Implement a reverse polish calculator for calldata arithmetic

This commit reorders the input file such that we have a definitions
section and an implementations section and such that the the order of
the items in both sections is the same.

Cargo.lock

@@ -3948,6 +3948,17 @@ dependencies = [
  "serde_stacker",
 ]
 
+[[package]]
+name = "revive-dt-common"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "futures",
+ "once_cell",
+ "tokio",
+ "tracing",
+]
+
 [[package]]
 name = "revive-dt-compiler"
 version = "0.1.0"
@@ -3982,6 +3993,7 @@ dependencies = [
  "clap",
  "indexmap 2.10.0",
  "rayon",
+ "revive-dt-common",
  "revive-dt-compiler",
  "revive-dt-config",
  "revive-dt-format",
@@ -4003,7 +4015,7 @@ dependencies = [
  "alloy-primitives",
  "alloy-sol-types",
  "anyhow",
- "revive-dt-node-interaction",
+ "revive-dt-common",
  "semver 1.0.26",
  "serde",
  "serde_json",
@@ -4016,7 +4028,9 @@ version = "0.1.0"
 dependencies = [
  "alloy",
  "anyhow",
+ "revive-dt-common",
  "revive-dt-config",
+ "revive-dt-format",
  "revive-dt-node-interaction",
  "serde",
  "serde_json",
@@ -4033,10 +4047,6 @@ version = "0.1.0"
 dependencies = [
  "alloy",
  "anyhow",
- "futures",
- "once_cell",
- "tokio",
- "tracing",
 ]
 
 [[package]]

Cargo.toml

@@ -11,6 +11,7 @@ repository = "https://github.com/paritytech/revive-differential-testing.git"
 rust-version = "1.85.0"
 
 [workspace.dependencies]
+revive-dt-common = { version = "0.1.0", path = "crates/common" }
 revive-dt-compiler = { version = "0.1.0", path = "crates/compiler" }
 revive-dt-config = { version = "0.1.0", path = "crates/config" }
 revive-dt-core = { version = "0.1.0", path = "crates/core" }

crates/common/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "revive-dt-common"
+description = "A library containing common concepts that other crates in the workspace can rely on"
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+edition.workspace = true
+repository.workspace = true
+rust-version.workspace = true
+
+[dependencies]
+anyhow = { workspace = true }
+futures = { workspace = true }
+tracing = { workspace = true }
+once_cell = { workspace = true }
+tokio = { workspace = true }

crates/common/src/concepts/blocking_executor.rs

@@ -23,7 +23,7 @@ use tracing::Instrument;
 /// executor to drive an async computation:
 ///
 /// ```rust
-/// use revive_dt_node_interaction::*;
+/// use revive_dt_common::concepts::*;
 ///
 /// fn blocking_function() {
 ///     let result = BlockingExecutor::execute(async move {
@@ -134,22 +134,17 @@ impl BlockingExecutor {
             }
         };
 
-        match result.map(|result| {
+        let result = match result {
-            *result
+            Ok(result) => result,
-                .downcast::<R>()
-                .expect("Type mismatch in the downcast")
-        }) {
-            Ok(result) => Ok(result),
             Err(error) => {
-                tracing::error!(
+                tracing::error!(?error, "An error occurred when running the async task");
-                    ?error,
+                anyhow::bail!("An error occurred when running the async task: {error:?}")
-                    "Failed to downcast the returned result into the expected type"
-                );
-                anyhow::bail!(
-                    "Failed to downcast the returned result into the expected type: {error:?}"
-                )
             }
-        }
+        };
+
+        Ok(*result
+            .downcast::<R>()
+            .expect("An error occurred when downcasting into R. This is a bug"))
     }
 }
 /// Represents the state of the async runtime. This runtime is designed to be a singleton runtime
@@ -208,7 +203,9 @@ mod test {
     fn panics_in_futures_are_caught() {
         // Act
         let result = BlockingExecutor::execute(async move {
-            panic!("This is a panic!");
+            panic!(
+                "If this panic causes, well, a panic, then this is an issue. If it's caught then all good!"
+            );
             0xFFu8
         });
 

crates/common/src/concepts/mod.rs

@@ -0,0 +1,3 @@
+mod blocking_executor;
+
+pub use blocking_executor::*;

crates/common/src/iterators/mod.rs

@@ -0,0 +1,3 @@
+mod files_with_extension_iterator;
+
+pub use files_with_extension_iterator::*;

crates/common/src/lib.rs

@@ -0,0 +1,6 @@
+//! This crate provides common concepts, functionality, types, macros, and more that other crates in
+//! the workspace can benefit from.
+
+pub mod concepts;
+pub mod iterators;
+pub mod macros;

crates/common/src/macros/define_wrapper_type.rs

@@ -12,11 +12,9 @@
 /// pub struct CaseId(usize);
 /// ```
 ///
-/// And would also implement a number of methods on this type making it easier
+/// And would also implement a number of methods on this type making it easier to use.
-/// to use.
 ///
-/// These wrapper types become very useful as they make the code a lot easier
+/// These wrapper types become very useful as they make the code a lot easier to read.
-/// to read.
 ///
 /// Take the following as an example:
 ///
@@ -26,33 +24,31 @@
 /// }
 /// ```
 ///
-/// In the above code it's hard to understand what the various types refer to or
+/// In the above code it's hard to understand what the various types refer to or what to expect them
-/// what to expect them to contain.
+/// to contain.
 ///
-/// With these wrapper types we're able to create code that's self-documenting
+/// With these wrapper types we're able to create code that's self-documenting in that the types
-/// in that the types tell us what the code is referring to. The above code is
+/// tell us what the code is referring to. The above code is transformed into
-/// transformed into
 ///
 /// ```rust,ignore
 /// struct State {
 ///     contracts: HashMap<CaseId, HashMap<ContractName, ContractByteCode>>
 /// }
 /// ```
+///
+/// Note that we follow the same syntax for defining wrapper structs but we do not permit the use of
+/// generics.
 #[macro_export]
 macro_rules! define_wrapper_type {
     (
         $(#[$meta: meta])*
-        $ident: ident($ty: ty) $(;)?
+        $vis:vis struct $ident: ident($ty: ty);
     ) => {
         $(#[$meta])*
-        pub struct $ident($ty);
+        $vis struct $ident($ty);
 
         impl $ident {
-            pub fn new(value: $ty) -> Self {
+            pub fn new(value: impl Into<$ty>) -> Self {
-                Self(value)
-            }
-
-            pub fn new_from<T: Into<$ty>>(value: T) -> Self {
                 Self(value.into())
             }
 
@@ -104,3 +100,7 @@ macro_rules! define_wrapper_type {
         }
     };
 }
+
+/// Technically not needed but this allows for the macro to be found in the `macros` module of the
+/// crate in addition to being found in the root of the crate.
+pub use define_wrapper_type;

crates/common/src/macros/mod.rs

@@ -0,0 +1,3 @@
+mod define_wrapper_type;
+
+pub use define_wrapper_type::*;

crates/core/Cargo.toml

@@ -13,6 +13,7 @@ name = "retester"
 path = "src/main.rs"
 
 [dependencies]
+revive-dt-common = { workspace = true }
 revive-dt-compiler = { workspace = true }
 revive-dt-config = { workspace = true }
 revive-dt-format = { workspace = true }

crates/core/src/driver/mod.rs

@@ -1,6 +1,7 @@
 //! The test driver handles the compilation and execution of the test cases.
 
 use std::collections::HashMap;
+use std::fmt::Debug;
 use std::marker::PhantomData;
 
 use alloy::json_abi::JsonAbi;
@@ -19,6 +20,9 @@ use alloy::{
 };
 use anyhow::Context;
 use indexmap::IndexMap;
+use serde_json::Value;
+
+use revive_dt_common::iterators::FilesWithExtensionIterator;
 use revive_dt_compiler::{Compiler, SolidityCompiler};
 use revive_dt_config::Arguments;
 use revive_dt_format::case::CaseIdx;
@@ -29,11 +33,8 @@ use revive_dt_node::Node;
 use revive_dt_node_interaction::EthereumNode;
 use revive_dt_report::reporter::{CompilationTask, Report, Span};
 use revive_solc_json_interface::SolcStandardJsonOutput;
-use serde_json::Value;
-use std::fmt::Debug;
 
 use crate::Platform;
-use crate::common::*;
 
 pub struct State<'a, T: Platform> {
     /// The configuration that the framework was started with.
@@ -508,7 +509,7 @@ where
                     .iter()
                     .zip(actual_event.topics())
                 {
-                    let expected = Calldata::Compound(vec![expected.clone()]);
+                    let expected = Calldata::new_compound([expected]);
                     if !expected.is_equivalent(
                         &actual.0,
                         deployed_contracts,
@@ -717,7 +718,7 @@ where
                 );
                 let _guard = tracing_span.enter();
 
-                let case_idx = CaseIdx::new_from(case_idx);
+                let case_idx = CaseIdx::new(case_idx);
 
                 // For inputs if one of the inputs fail we move on to the next case (we do not move
                 // on to the next input as it doesn't make sense. It depends on the previous one).

crates/core/src/lib.rs

@@ -5,17 +5,17 @@
 
 use revive_dt_compiler::{SolidityCompiler, revive_resolc, solc};
 use revive_dt_config::TestingPlatform;
+use revive_dt_format::traits::ResolverApi;
 use revive_dt_node::{Node, geth, kitchensink::KitchensinkNode};
 use revive_dt_node_interaction::EthereumNode;
 
-pub mod common;
 pub mod driver;
 
 /// One platform can be tested differentially against another.
 ///
 /// For this we need a blockchain node implementation and a compiler.
 pub trait Platform {
-    type Blockchain: EthereumNode + Node;
+    type Blockchain: EthereumNode + Node + ResolverApi;
     type Compiler: SolidityCompiler;
 
     /// Returns the matching [TestingPlatform] of the [revive_dt_config::Arguments].

crates/format/Cargo.toml

@@ -9,7 +9,7 @@ repository.workspace = true
 rust-version.workspace = true
 
 [dependencies]
-revive-dt-node-interaction = { workspace = true }
+revive-dt-common = { workspace = true }
 
 alloy = { workspace = true }
 alloy-primitives = { workspace = true }

crates/format/src/case.rs

@@ -1,7 +1,8 @@
 use serde::Deserialize;
 
+use revive_dt_common::macros::define_wrapper_type;
+
 use crate::{
-    define_wrapper_type,
     input::{Expected, Input},
     mode::Mode,
 };
@@ -45,5 +46,5 @@ impl Case {
 define_wrapper_type!(
     /// A wrapper type for the index of test cases found in metadata file.
     #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-    CaseIdx(usize);
+    pub struct CaseIdx(usize);
 );

crates/format/src/lib.rs

@@ -3,6 +3,6 @@
 pub mod case;
 pub mod corpus;
 pub mod input;
-pub mod macros;
 pub mod metadata;
 pub mod mode;
+pub mod traits;

crates/format/src/metadata.rs

@@ -9,9 +9,10 @@ use std::{
 
 use serde::{Deserialize, Serialize};
 
+use revive_dt_common::macros::define_wrapper_type;
+
 use crate::{
     case::Case,
-    define_wrapper_type,
     mode::{Mode, SolcMode},
 };
 
@@ -192,10 +193,10 @@ impl Metadata {
                 metadata.file_path = Some(path.to_path_buf());
                 metadata.contracts = Some(
                     [(
-                        ContractInstance::new_from("test"),
+                        ContractInstance::new("test"),
                         ContractPathAndIdentifier {
                             contract_source_path: path.to_path_buf(),
-                            contract_ident: ContractIdent::new_from("Test"),
+                            contract_ident: ContractIdent::new("Test"),
                         },
                     )]
                     .into(),
@@ -217,18 +218,22 @@ define_wrapper_type!(
     /// Represents a contract instance found a metadata file.
     ///
     /// Typically, this is used as the key to the "contracts" field of metadata files.
-    #[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+    #[derive(
+        Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize,
+    )]
     #[serde(transparent)]
-    ContractInstance(String);
+    pub struct ContractInstance(String);
 );
 
 define_wrapper_type!(
     /// Represents a contract identifier found a metadata file.
     ///
     /// A contract identifier is the name of the contract in the source code.
-    #[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+    #[derive(
+        Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize,
+    )]
     #[serde(transparent)]
-    ContractIdent(String);
+    pub struct ContractIdent(String);
 );
 
 /// Represents an identifier used for contracts.

crates/format/src/traits.rs

@@ -0,0 +1,30 @@
+use alloy::eips::BlockNumberOrTag;
+use alloy::primitives::{Address, BlockHash, BlockNumber, BlockTimestamp, ChainId, U256};
+use anyhow::Result;
+
+/// A trait of the interface are required to implement to be used by the resolution logic that this
+/// crate implements to go from string calldata and into the bytes calldata.
+pub trait ResolverApi {
+    /// Returns the ID of the chain that the node is on.
+    fn chain_id(&self) -> Result<ChainId>;
+
+    // TODO: This is currently a u128 due to Kitchensink needing more than 64 bits for its gas limit
+    // when we implement the changes to the gas we need to adjust this to be a u64.
+    /// Returns the gas limit of the specified block.
+    fn block_gas_limit(&self, number: BlockNumberOrTag) -> Result<u128>;
+
+    /// Returns the coinbase of the specified block.
+    fn block_coinbase(&self, number: BlockNumberOrTag) -> Result<Address>;
+
+    /// Returns the difficulty of the specified block.
+    fn block_difficulty(&self, number: BlockNumberOrTag) -> Result<U256>;
+
+    /// Returns the hash of the specified block.
+    fn block_hash(&self, number: BlockNumberOrTag) -> Result<BlockHash>;
+
+    /// Returns the timestamp of the specified block,
+    fn block_timestamp(&self, number: BlockNumberOrTag) -> Result<BlockTimestamp>;
+
+    /// Returns the number of the last block.
+    fn last_block_number(&self) -> Result<BlockNumber>;
+}

crates/node-interaction/Cargo.toml

@@ -11,7 +11,3 @@ rust-version.workspace = true
 [dependencies]
 alloy = { workspace = true }
 anyhow = { workspace = true }
-futures = { workspace = true }
-tracing = { workspace = true }
-once_cell = { workspace = true }
-tokio = { workspace = true }

crates/node-interaction/src/lib.rs

@@ -1,14 +1,9 @@
 //! This crate implements all node interactions.
 
-use alloy::eips::BlockNumberOrTag;
-use alloy::primitives::{Address, BlockHash, BlockNumber, BlockTimestamp, ChainId, U256};
 use alloy::rpc::types::trace::geth::{DiffMode, GethDebugTracingOptions, GethTrace};
 use alloy::rpc::types::{TransactionReceipt, TransactionRequest};
 use anyhow::Result;
 
-mod blocking_executor;
-pub use blocking_executor::*;
-
 /// An interface for all interactions with Ethereum compatible nodes.
 pub trait EthereumNode {
     /// Execute the [TransactionRequest] and return a [TransactionReceipt].
@@ -23,27 +18,4 @@ pub trait EthereumNode {
 
     /// Returns the state diff of the transaction hash in the [TransactionReceipt].
     fn state_diff(&self, receipt: &TransactionReceipt) -> Result<DiffMode>;
-
-    /// Returns the ID of the chain that the node is on.
-    fn chain_id(&self) -> Result<ChainId>;
-
-    // TODO: This is currently a u128 due to Kitchensink needing more than 64 bits for its gas limit
-    // when we implement the changes to the gas we need to adjust this to be a u64.
-    /// Returns the gas limit of the specified block.
-    fn block_gas_limit(&self, number: BlockNumberOrTag) -> Result<u128>;
-
-    /// Returns the coinbase of the specified block.
-    fn block_coinbase(&self, number: BlockNumberOrTag) -> Result<Address>;
-
-    /// Returns the difficulty of the specified block.
-    fn block_difficulty(&self, number: BlockNumberOrTag) -> Result<U256>;
-
-    /// Returns the hash of the specified block.
-    fn block_hash(&self, number: BlockNumberOrTag) -> Result<BlockHash>;
-
-    /// Returns the timestamp of the specified block,
-    fn block_timestamp(&self, number: BlockNumberOrTag) -> Result<BlockTimestamp>;
-
-    /// Returns the number of the last block.
-    fn last_block_number(&self) -> Result<BlockNumber>;
 }

crates/node/Cargo.toml

@@ -14,8 +14,10 @@ alloy = { workspace = true }
 tracing = { workspace = true }
 tokio = { workspace = true }
 
-revive-dt-node-interaction = { workspace = true }
+revive-dt-common = { workspace = true }
 revive-dt-config = { workspace = true }
+revive-dt-format = { workspace = true }
+revive-dt-node-interaction = { workspace = true }
 
 serde = { workspace = true }
 serde_json = { workspace = true }

crates/node/src/constants.rs

@@ -1,5 +1,5 @@
 /// This constant defines how much Wei accounts are pre-seeded with in genesis.
 ///
-/// We use [`u128::MAX`] here which means that accounts will be given 2^128 - 1 WEI which is
+/// Note: After changing this number, check that the tests for kitchensink work as we encountered
-/// (2^128 - 1) / 10^18 ETH.
+/// some issues with different values of the initial balance on Kitchensink.
-pub const INITIAL_BALANCE: u128 = u128::MAX;
+pub const INITIAL_BALANCE: u128 = 10u128.pow(37);

crates/node/src/geth.rs

@@ -25,8 +25,10 @@ use alloy::{
     },
     signers::local::PrivateKeySigner,
 };
+use revive_dt_common::concepts::BlockingExecutor;
 use revive_dt_config::Arguments;
-use revive_dt_node_interaction::{BlockingExecutor, EthereumNode};
+use revive_dt_format::traits::ResolverApi;
+use revive_dt_node_interaction::EthereumNode;
 use tracing::Level;
 
 use crate::{Node, common::FallbackGasFiller, constants::INITIAL_BALANCE};
@@ -74,6 +76,8 @@ impl Instance {
     const GETH_STDOUT_LOG_FILE_NAME: &str = "node_stdout.log";
     const GETH_STDERR_LOG_FILE_NAME: &str = "node_stderr.log";
 
+    const TRANSACTION_INDEXING_ERROR: &str = "transaction indexing is in progress";
+
     /// Create the node directory and call `geth init` to configure the genesis.
     #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
     fn init(&mut self, genesis: String) -> anyhow::Result<&mut Self> {
@@ -84,6 +88,8 @@ impl Instance {
         for signer_address in
             <EthereumWallet as NetworkWallet<Ethereum>>::signer_addresses(&self.wallet)
         {
+            // Note, the use of the entry API here means that we only modify the entries for any
+            // account that is not in the `alloc` field of the genesis state.
             genesis
                 .alloc
                 .entry(signer_address)
@@ -265,57 +271,45 @@ impl EthereumNode for Instance {
             // it eventually works, but we only do that if the error we get back is the "transaction
             // indexing is in progress" error or if the receipt is None.
             //
-            // At the moment we do not allow for the 60 seconds to be modified and we take it as
+            // Getting the transaction indexed and taking a receipt can take a long time especially
-            // being an implementation detail that's invisible to anything outside of this module.
+            // when a lot of transactions are being submitted to the node. Thus, while initially we
-            //
+            // only allowed for 60 seconds of waiting with a 1 second delay in polling, we need to
-            // We allow a total of 60 retries for getting the receipt with one second between each
+            // allow for a larger wait time. Therefore, in here we allow for 5 minutes of waiting
-            // retry and the next which means that we allow for a total of 60 seconds of waiting
+            // with exponential backoff each time we attempt to get the receipt and find that it's
-            // before we consider that we're unable to get the transaction receipt.
+            // not available.
             let mut retries = 0;
+            let mut total_wait_duration = Duration::from_secs(0);
+            let max_allowed_wait_duration = Duration::from_secs(5 * 60);
             loop {
+                if total_wait_duration >= max_allowed_wait_duration {
+                    tracing::error!(
+                        ?total_wait_duration,
+                        ?max_allowed_wait_duration,
+                        retry_count = retries,
+                        "Failed to get receipt after polling for it"
+                    );
+                    anyhow::bail!(
+                        "Polled for receipt for {total_wait_duration:?} but failed to get it"
+                    );
+                }
+
                 match provider.get_transaction_receipt(*transaction_hash).await {
-                    Ok(Some(receipt)) => {
+                    Ok(Some(receipt)) => break Ok(receipt),
-                        tracing::info!("Obtained the transaction receipt");
+                    Ok(None) => {}
-                        break Ok(receipt);
-                    }
-                    Ok(None) => {
-                        if retries == 60 {
-                            tracing::error!(
-                                "Polled for transaction receipt for 60 seconds but failed to get it"
-                            );
-                            break Err(anyhow::anyhow!("Failed to get the transaction receipt"));
-                        } else {
-                            tracing::trace!(
-                                retries,
-                                "Sleeping for 1 second and trying to get the receipt again"
-                            );
-                            retries += 1;
-                            tokio::time::sleep(std::time::Duration::from_secs(1)).await;
-                            continue;
-                        }
-                    }
                     Err(error) => {
                         let error_string = error.to_string();
-                        if error_string.contains("transaction indexing is in progress") {
+                        if !error_string.contains(Self::TRANSACTION_INDEXING_ERROR) {
-                            if retries == 60 {
-                                tracing::error!(
-                                    "Polled for transaction receipt for 60 seconds but failed to get it"
-                                );
-                                break Err(error.into());
-                            } else {
-                                tracing::trace!(
-                                    retries,
-                                    "Sleeping for 1 second and trying to get the receipt again"
-                                );
-                                retries += 1;
-                                tokio::time::sleep(std::time::Duration::from_secs(1)).await;
-                                continue;
-                            }
-                        } else {
                             break Err(error.into());
                         }
                     }
-                }
+                };
+
+                let next_wait_duration = Duration::from_secs(2u64.pow(retries))
+                    .min(max_allowed_wait_duration - total_wait_duration);
+                total_wait_duration += next_wait_duration;
+                retries += 1;
+
+                tokio::time::sleep(next_wait_duration).await;
             }
         })?
     }
@@ -351,7 +345,9 @@ impl EthereumNode for Instance {
             _ => anyhow::bail!("expected a diff mode trace"),
         }
     }
+}
 
+impl ResolverApi for Instance {
     #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
     fn chain_id(&self) -> anyhow::Result<alloy::primitives::ChainId> {
         let provider = self.provider();

crates/node/src/kitchensink.rs

@@ -30,14 +30,16 @@ use alloy::{
     },
     signers::local::PrivateKeySigner,
 };
+use revive_dt_format::traits::ResolverApi;
 use serde::{Deserialize, Serialize};
 use serde_json::{Value as JsonValue, json};
 use sp_core::crypto::Ss58Codec;
 use sp_runtime::AccountId32;
 use tracing::Level;
 
+use revive_dt_common::concepts::BlockingExecutor;
 use revive_dt_config::Arguments;
-use revive_dt_node_interaction::{BlockingExecutor, EthereumNode};
+use revive_dt_node_interaction::EthereumNode;
 
 use crate::{Node, common::FallbackGasFiller, constants::INITIAL_BALANCE};
 
@@ -131,6 +133,8 @@ impl KitchensinkNode {
             for signer_address in
                 <EthereumWallet as NetworkWallet<Ethereum>>::signer_addresses(&self.wallet)
             {
+                // Note, the use of the entry API here means that we only modify the entries for any
+                // account that is not in the `alloc` field of the genesis state.
                 genesis
                     .alloc
                     .entry(signer_address)
@@ -422,7 +426,9 @@ impl EthereumNode for KitchensinkNode {
             _ => anyhow::bail!("expected a diff mode trace"),
         }
     }
+}
 
+impl ResolverApi for KitchensinkNode {
     #[tracing::instrument(skip_all, fields(geth_node_id = self.id))]
     fn chain_id(&self) -> anyhow::Result<alloy::primitives::ChainId> {
         let provider = self.provider();

genesis.json

@@ -33,9 +33,5 @@
     "mixhash": "0x0000000000000000000000000000000000000000000000000000000000000000",
     "parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
     "timestamp": "0x00",
-    "alloc": {
+    "alloc": {}
-        "90F8bf6A479f320ead074411a4B0e7944Ea8c9C1": {
-            "balance": "10000000000000000000000"
-        }
-    }
 }