[WIP] Force telos state

Cargo.toml

@@ -601,7 +601,7 @@ reth-node-telos = { path = "crates/telos/node" }
 reth-telos-rpc = { path = "crates/telos/rpc" }
 reth-telos-primitives-traits = { path = "crates/telos/primitives-traits" }
 reth-telos-rpc-engine-api = { path = "crates/telos/rpc-engine-api" }
-antelope-client = { git = "https://github.com/telosnetwork/antelope-rs", branch = "development" }
+antelope-client = { git = "https://github.com/telosnetwork/antelope-rs", branch = "master" }
 
 [patch.crates-io]
 #alloy-consensus = { git = "https://github.com/alloy-rs/alloy", rev = "8c499409"}

crates/ethereum/evm/Cargo.toml

@@ -20,6 +20,7 @@ reth-revm.workspace = true
 reth-ethereum-consensus.workspace = true
 reth-prune-types.workspace = true
 reth-execution-types.workspace = true
+sha2.workspace = true
 
 # Ethereum
 revm-primitives.workspace = true

crates/ethereum/evm/src/execute.rs

@@ -38,6 +38,8 @@ use reth_telos_rpc_engine_api::compare::compare_state_diffs;
 use revm_primitives::{Address, Account, AccountInfo, AccountStatus, Bytecode, HashMap, KECCAK_EMPTY};
 #[cfg(feature = "telos")]
 use alloy_primitives::B256;
+#[cfg(feature = "telos")]
+use sha2::{Sha256, Digest};
 
 /// Provides executors to execute regular ethereum blocks
 #[derive(Debug, Clone)]
@@ -192,6 +194,7 @@ where
 
         // execute transactions
         let mut cumulative_gas_used = 0;
+        #[cfg(not(feature = "telos"))]
         let mut receipts = Vec::with_capacity(block.body.transactions.len());
         for (sender, transaction) in block.transactions_with_sender() {
             #[cfg(feature = "telos")]
@@ -233,6 +236,7 @@ where
             // append gas used
             cumulative_gas_used += result.gas_used();
 
+            #[cfg(not(feature = "telos"))]
             // Push transaction changeset and calculate header bloom filter for receipt.
             receipts.push(
                 #[allow(clippy::needless_update)] // side-effect of optimism fields
@@ -259,22 +263,31 @@ where
             new_addresses_using_create_iter.next();
         }
 
-        #[cfg(feature = "telos")] {
-        // Perform state diff comparision
-        let revm_state_diffs = evm.db_mut().transition_state.clone().unwrap_or_default().transitions;
-        let block_num = block.block.header.number;
-        println!(
-            "Compare: block {block_num} {}",
-            compare_state_diffs(
-                &mut evm,
-                revm_state_diffs,
-                unwrapped_telos_extra_fields.statediffs_account.unwrap_or_default(),
-                unwrapped_telos_extra_fields.statediffs_accountstate.unwrap_or_default(),
-                unwrapped_telos_extra_fields.new_addresses_using_create.unwrap_or_default(),
-                unwrapped_telos_extra_fields.new_addresses_using_openwallet.unwrap_or_default()
-            )
-        );
-        }
+        // #[cfg(feature = "telos")]
+        // {
+        //     // Perform state diff comparision
+        //     let revm_state_diffs = evm.db_mut().transition_state.clone().unwrap_or_default().transitions;
+        //     let block_num = block.block.header.number;
+        //     println!(
+        //         "Compare: block {block_num} {}",
+        //         compare_state_diffs(
+        //             &mut evm,
+        //             revm_state_diffs,
+        //             unwrapped_telos_extra_fields.statediffs_account.clone().unwrap_or_default(),
+        //             unwrapped_telos_extra_fields.statediffs_accountstate.clone().unwrap_or_default(),
+        //             unwrapped_telos_extra_fields.new_addresses_using_create.clone().unwrap_or_default(),
+        //             unwrapped_telos_extra_fields.new_addresses_using_openwallet.clone().unwrap_or_default(),
+        //             false
+        //         )
+        //     );
+        // }
+
+        #[cfg(feature = "telos")]
+        let receipts = if unwrapped_telos_extra_fields.receipts.is_some() {
+            unwrapped_telos_extra_fields.receipts.clone().unwrap()
+        } else {
+            vec![]
+        };
 
         let requests = if self.chain_spec.is_prague_active_at_timestamp(block.timestamp) {
             // Collect all EIP-6110 deposits
@@ -288,7 +301,44 @@ where
             vec![]
         };
 
-        Ok(EthExecuteOutput { receipts, requests, gas_used: cumulative_gas_used })
+        // #[cfg(feature = "telos")]
+        // {
+        //     let mut addr_to_accstate: HashMap<Address, HashMap<U256, EvmStorageSlot>> = HashMap::new();
+
+        //     for sdiff_accstate in unwrapped_telos_extra_fields.clone().statediffs_accountstate.unwrap_or(vec![]) {
+        //         if !addr_to_accstate.contains_key(&sdiff_accstate.address) {
+        //             addr_to_accstate.insert(sdiff_accstate.address, HashMap::new());
+        //         }
+        //         let mut acc_storage = addr_to_accstate.get_mut(&sdiff_accstate.address).unwrap();
+        //         acc_storage.insert(sdiff_accstate.key, EvmStorageSlot { original_value: Default::default(), present_value: sdiff_accstate.value, is_cold: false });
+        //     }
+
+        //     let mut state: HashMap<Address, Account> = HashMap::new();
+
+        //     for sdiff_acc in unwrapped_telos_extra_fields.clone().statediffs_account.unwrap_or(vec![]) {
+        //         state.insert(
+        //             sdiff_acc.address,
+        //             Account {
+        //                 info: AccountInfo {
+        //                     balance: sdiff_acc.balance,
+        //                     nonce: sdiff_acc.nonce,
+        //                     code_hash: B256::from(Sha256::digest(sdiff_acc.code.as_ref()).as_ref()),
+        //                     code: Some(Bytecode::LegacyRaw(sdiff_acc.code)),
+        //                 },
+        //                 storage: addr_to_accstate.get(&sdiff_acc.address).unwrap_or(&HashMap::new()).clone(),
+        //                 status: AccountStatus::Touched | AccountStatus::LoadedAsNotExisting,
+        //             }
+        //         );
+        //     }
+
+        //     evm.db_mut().commit(state);
+        // }
+
+        Ok(EthExecuteOutput {
+            receipts,
+            requests,
+            gas_used: cumulative_gas_used
+        })
     }
 }
 
@@ -366,7 +416,12 @@ where
         let env = self.evm_env_for_block(&block.header, total_difficulty);
         let output = {
             let evm = self.executor.evm_config.evm_with_env(&mut self.state, env);
-            self.executor.execute_state_transitions(block, evm, #[cfg(feature = "telos")] telos_extra_fields)
+            self.executor.execute_state_transitions(
+                block,
+                evm,
+                #[cfg(feature = "telos")]
+                    telos_extra_fields
+            )
         }?;
 
         // 3. apply post execution changes

crates/telos/bin/Cargo.toml

@@ -16,6 +16,8 @@ reth-chainspec.workspace = true
 reth-provider.workspace = true
 reth-node-telos.workspace = true
 reth-telos-rpc.workspace = true
+reth-db.workspace = true
+alloy-primitives.workspace = true
 
 
 clap = { workspace = true, features = ["derive", "env"] }

crates/telos/bin/src/main.rs

@@ -4,17 +4,24 @@
 static ALLOC: reth_cli_util::allocator::Allocator = reth_cli_util::allocator::new_allocator();
 
 use clap::Parser;
+use tracing::{error, info, warn};
 use reth::args::utils::EthereumChainSpecParser;
 use reth_node_builder::{engine_tree_config::TreeConfig, EngineNodeLauncher};
 use reth::cli::Cli;
 use reth_node_telos::{TelosArgs, TelosNode};
 use reth_node_telos::node::TelosAddOns;
 use reth_provider::providers::BlockchainProvider2;
 use reth_telos_rpc::TelosClient;
+use reth::primitives::BlockId;
+use reth::rpc::types::BlockNumberOrTag;
+use reth_provider::{DatabaseProviderFactory, StateProviderFactory};
+use reth_db::{PlainAccountState, PlainStorageState};
 
 
 #[cfg(feature = "telos")]
 fn main() {
+    use reth_provider::BlockNumReader;
+
     reth_cli_util::sigsegv_handler::install();
 
     // Enable backtraces unless a RUST_BACKTRACE value has already been explicitly provided.
@@ -45,6 +52,10 @@ fn main() {
                 handle.node_exit_future.await
             },
             false => {
+                let two_way_storage_compare = telos_args.two_way_storage_compare.clone();
+                let telos_rpc = telos_args.telos_endpoint.clone();
+                let block_delta = telos_args.block_delta.clone();
+
                 let handle = builder
                     .node(TelosNode::new(telos_args.clone()))
                     .extend_rpc_modules(move |ctx| {
@@ -59,6 +70,36 @@ fn main() {
                     .launch()
                     .await?;
 
+                match two_way_storage_compare {
+                    true => {
+                        if telos_rpc.is_none() {
+                            warn!("Telos RPC Endpoint is not specified, skipping two-way storage compare");
+                        } else if block_delta.is_none() {
+                            warn!("Block delta is not specified, skipping two-way storage compare");
+                        } else {
+                            info!("Fetching account and accountstate from Telos native RPC (Can take a long time)...");
+
+                            let (account_table, accountstate_table, block_number) = reth_node_telos::two_way_storage_compare::get_telos_tables(telos_rpc.unwrap().as_str(), block_delta.unwrap()).await;
+
+                            if block_number.as_u64().unwrap() <= handle.node.provider.best_block_number().unwrap() {
+                                info!("Two-way comparing state (Reth vs. Telos) at height: {:?}", block_number);
+
+                                let state_at_specific_height = handle.node.provider.state_by_block_id(BlockId::Number(BlockNumberOrTag::Number(block_number.as_u64().unwrap()))).unwrap();
+                                let plain_account_state = handle.node.provider.database_provider_ro().unwrap().table::<PlainAccountState>().unwrap();
+                                let plain_storage_state = handle.node.provider.database_provider_ro().unwrap().table::<PlainStorageState>().unwrap();
+
+                                let match_counter = reth_node_telos::two_way_storage_compare::two_side_state_compare(account_table, accountstate_table, state_at_specific_height, plain_account_state, plain_storage_state).await;
+                                match_counter.print();
+
+                                info!("Comparing done");
+                            } else {
+                                error!("Nodeos is ahead of reth, failed to compare state");
+                            }
+                        }
+                    }
+                    _ => {}
+                }
+
                 handle.node_exit_future.await
             }
         }

crates/telos/node/Cargo.toml

@@ -34,6 +34,9 @@ reth-stages.workspace = true
 reth-telos-rpc.workspace = true
 reth-tracing.workspace = true
 reth-transaction-pool.workspace = true
+reth-telos-rpc-engine-api.workspace = true
+alloy-primitives.workspace = true
+reth-db.workspace = true
 
 clap.workspace = true
 serde = { workspace = true, features = ["derive"] }

crates/telos/node/src/args.rs

@@ -45,6 +45,14 @@ pub struct TelosArgs {
     /// a batch of downloaded blocks.
     #[arg(long = "engine.max-execute-block-batch-size", requires = "experimental", default_value_t = DEFAULT_MAX_EXECUTE_BLOCK_BATCH_SIZE)]
     pub max_execute_block_batch_size: usize,
+
+    /// Enable Two-way storage compare between reth and telos
+    #[arg(long = "telos.two_way_storage_compare", default_value = "false")]
+    pub two_way_storage_compare: bool,
+
+    /// Block delta between native and EVM
+    #[arg(long = "telos.block_delta")]
+    pub block_delta: Option<u32>,
 }
 
 impl From<TelosArgs> for TelosClientArgs {

crates/telos/node/src/lib.rs

@@ -11,6 +11,7 @@
 
 pub mod args;
 pub mod node;
+pub mod two_way_storage_compare;
 
 pub use crate::args::TelosArgs;
 pub use crate::node::TelosNode;