Merge pull request #62 from bitfinity-network/feat/pow-hashing-validation

POW hash calculation

Author: ufoscout

Cargo.lock

@@ -665,3 +665,5 @@ ic-certificate-verification = "3"
 ic-certification = "3"
 hex = "0.4"
 lightspeed_scheduler = { version = "0.60.0", features = ["tracing"] }
+anyhow = "1"
+jsonrpc-core = "18.0.0"

Cargo.toml

@@ -110,6 +110,7 @@ lightspeed_scheduler = { workspace = true, features = ["tracing"] }
 tempfile.workspace = true
 
 # bitfinity dev dependencies
+alloy-genesis.workspace = true
 async-trait = { workspace = true }
 dirs.workspace = true
 ethereum-json-rpc-client = { workspace = true, features = ["reqwest"] }

bin/reth/Cargo.toml

@@ -228,10 +228,10 @@ impl BitfinityImportCommand {
         let config = self.rpc_config();
         let client = BitfinityEvmClient::client(config).await?;
 
-        let confirmator = BitfinityBlockConfirmation::new(client, provider_factory);
+        let confirmer = BitfinityBlockConfirmation::new(client, provider_factory);
         let blocks = remote_client.unsafe_blocks(block)?;
 
-        confirmator.confirm_blocks(&blocks).await
+        confirmer.confirm_blocks(&blocks).await
     }
 
     /// Imports the blocks up to the given block hash of the `remove_client`.

bin/reth/src/commands/bitfinity_import.rs

@@ -13,11 +13,16 @@ use super::{
 };
 use alloy_eips::BlockNumberOrTag;
 
+use did::H256;
 use ethereum_json_rpc_client::{reqwest::ReqwestClient, EthJsonRpcClient};
 
 use reth::commands::bitfinity_import::BitfinityImportCommand;
 use reth_provider::{BlockNumReader, BlockReader, BlockReaderIdExt};
+use reth_trie::StateRoot;
+use reth_trie_db::DatabaseStateRoot;
+use revm_primitives::{Address, U256};
 
+use std::sync::Arc;
 use std::time::Duration;
 
 #[tokio::test]
@@ -374,7 +379,15 @@ async fn bitfinity_test_should_confirm_and_import_unsafe_blocks() {
     const UNSAFE_BLOCKS: u64 = 3;
     const MAX_BLOCKS: u64 = 10;
 
-    let mut eth_server = EthImpl::new_with_max_block(MAX_BLOCKS);
+    let genesis_balances =
+        vec![(Address::from_slice(&[0u8; 20]).into(), U256::from(1_000_000_u64))];
+
+    let state_root = compute_state_root(&genesis_balances);
+
+    let mut eth_server = EthImpl::new_with_max_block(MAX_BLOCKS)
+        .with_genesis_balances(genesis_balances)
+        .with_state_root(state_root.into());
+
     let bf_evm_server = eth_server.bf_impl(UNSAFE_BLOCKS);
 
     let (_server, eth_server_address) = mock_multi_server_start([
@@ -422,8 +435,14 @@ async fn bitfinity_test_should_import_until_last_confirmed() {
     const UNSAFE_BLOCKS: u64 = 3;
     const MAX_BLOCKS: u64 = 10;
     const CONFIRM_UNTIL: u64 = 8;
+    let genesis_balances =
+        vec![(Address::from_slice(&[0u8; 20]).into(), U256::from(1_000_000_u64))];
 
-    let mut eth_server = EthImpl::new_with_max_block(MAX_BLOCKS);
+    let state_root = compute_state_root(&genesis_balances);
+
+    let mut eth_server = EthImpl::new_with_max_block(MAX_BLOCKS)
+        .with_genesis_balances(genesis_balances)
+        .with_state_root(state_root.into());
     let mut bf_evm_server = eth_server.bf_impl(UNSAFE_BLOCKS);
     bf_evm_server.confirm_until = CONFIRM_UNTIL;
 
@@ -463,3 +482,39 @@ async fn bitfinity_test_should_import_until_last_confirmed() {
     let last_imported_block = provider.last_block_number().unwrap();
     assert_eq!(last_imported_block, CONFIRM_UNTIL);
 }
+
+/// Compute state root for genesis Balances
+fn compute_state_root(genesis_balances: &[(Address, U256)]) -> H256 {
+    use alloy_genesis::Genesis;
+    use alloy_genesis::GenesisAccount;
+    use reth_chainspec::ChainSpec;
+    use reth_db_common::init::init_genesis;
+    use reth_provider::test_utils::create_test_provider_factory_with_chain_spec;
+
+    let chain_spec = Arc::new(ChainSpec {
+        chain: 1_u64.into(),
+        genesis: Genesis {
+            alloc: genesis_balances
+                .iter()
+                .map(|(address, balance)| {
+                    (*address, GenesisAccount { balance: *balance, ..Default::default() })
+                })
+                .collect(),
+            ..Default::default()
+        },
+        hardforks: Default::default(),
+        genesis_hash: Default::default(),
+        paris_block_and_final_difficulty: None,
+        deposit_contract: None,
+        ..Default::default()
+    });
+
+    let factory = create_test_provider_factory_with_chain_spec(chain_spec);
+    init_genesis(&factory).unwrap();
+
+    let provider = factory.provider().unwrap();
+
+    let tx = provider.tx_ref();
+
+    StateRoot::from_tx(tx).root().unwrap().into()
+}

bin/reth/tests/commands/bitfinity_import_it.rs

@@ -118,7 +118,7 @@ async fn bitfinity_test_node_forward_eth_get_genesis_balances() {
     // Arrange
     let _log = init_logs();
 
-    let eth_server = EthImpl::with_genesis_balances(vec![
+    let eth_server = EthImpl::new().with_genesis_balances(vec![
         (Address::from_slice(&[1u8; 20]), U256::from(10)),
         (Address::from_slice(&[2u8; 20]), U256::from(20)),
         (Address::from_slice(&[3u8; 20]), U256::from(30)),
@@ -156,7 +156,7 @@ async fn bitfinity_test_node_forward_ic_get_genesis_balances() {
     // Arrange
     let _log = init_logs();
 
-    let eth_server = EthImpl::with_genesis_balances(vec![
+    let eth_server = EthImpl::new().with_genesis_balances(vec![
         (Address::from_slice(&[1u8; 20]), U256::from(10)),
         (Address::from_slice(&[2u8; 20]), U256::from(20)),
         (Address::from_slice(&[3u8; 20]), U256::from(30)),
@@ -347,7 +347,9 @@ pub async fn mock_eth_server_start(methods: impl Into<Methods>) -> (ServerHandle
 }
 
 /// Starts a local mock server that combines methods from different sources.
-pub async fn mock_multi_server_start(methods: impl IntoIterator<Item = Methods>) -> (ServerHandle, SocketAddr) {
+pub async fn mock_multi_server_start(
+    methods: impl IntoIterator<Item = Methods>,
+) -> (ServerHandle, SocketAddr) {
     let addr = SocketAddr::from(([127, 0, 0, 1], 0));
     let server = Server::builder().build(addr).await.unwrap();
 
@@ -373,6 +375,7 @@ pub mod eth_server {
     use did::{keccak, BlockConfirmationData, BlockConfirmationResult, BlockNumber, H256, U64};
     use ethereum_json_rpc_client::CertifiedResult;
     use jsonrpsee::{core::RpcResult, proc_macros::rpc};
+
     use reth_trie::EMPTY_ROOT_HASH;
     use revm_primitives::{Address, B256, U256};
 
@@ -424,7 +427,10 @@ pub mod eth_server {
     trait BfEvm {
         /// Send block confirmation request.
         #[method(name = "sendConfirmBlock")]
-        async fn confirm_block(&self, data: BlockConfirmationData) -> RpcResult<BlockConfirmationResult>;
+        async fn confirm_block(
+            &self,
+            data: BlockConfirmationData,
+        ) -> RpcResult<BlockConfirmationResult>;
     }
 
     /// Eth server implementation for local testing
@@ -447,6 +453,8 @@ pub mod eth_server {
         pub genesis_balances: Vec<(Address, U256)>,
         /// Unsafe blocks count
         pub unsafe_blocks_count: u64,
+        /// Custom state root hash
+        pub custom_state_root: H256,
     }
 
     impl EthImpl {
@@ -483,6 +491,7 @@ pub mod eth_server {
                 block_task,
                 genesis_balances: vec![],
                 unsafe_blocks_count: 0,
+                custom_state_root: EMPTY_ROOT_HASH.into(),
             }
         }
 
@@ -494,18 +503,21 @@ pub mod eth_server {
         }
 
         /// Set the genesis balances
-        pub fn with_genesis_balances(balances: Vec<(Address, U256)>) -> Self {
-            let mut instance = Self::new();
-            instance.genesis_balances = balances;
-            instance
+        pub fn with_genesis_balances(mut self, balances: Vec<(Address, U256)>) -> Self {
+            self.genesis_balances = balances;
+            self
+        }
+
+        /// Set a custom state root hash
+        pub fn with_state_root(mut self, state_root: did::H256) -> Self {
+            self.custom_state_root = state_root;
+            self
         }
 
         /// Returns an implementation of Bitfinity EVM canister API
         pub fn bf_impl(&mut self, unsafe_blocks_count: u64) -> BfEvmImpl {
             self.unsafe_blocks_count = unsafe_blocks_count;
-            BfEvmImpl {
-                confirm_until: u64::MAX,
-            }
+            BfEvmImpl { confirm_until: u64::MAX }
         }
     }
 
@@ -550,7 +562,7 @@ pub mod eth_server {
                 timestamp: did::U256::from(1234567890_u64 + block_num),
                 gas_limit: did::U256::from(30_000_000_u64),
                 base_fee_per_gas: Some(did::U256::from(7_u64)),
-                state_root: EMPTY_ROOT_HASH.into(),
+                state_root: self.custom_state_root.clone(),
                 receipts_root: EMPTY_RECEIPTS.into(),
                 transactions_root: EMPTY_TRANSACTIONS.into(),
                 parent_hash: if block_num == 0 {
@@ -625,7 +637,10 @@ pub mod eth_server {
 
     #[async_trait::async_trait]
     impl BfEvmServer for BfEvmImpl {
-        async fn confirm_block(&self, data: BlockConfirmationData) -> RpcResult<BlockConfirmationResult> {
+        async fn confirm_block(
+            &self,
+            data: BlockConfirmationData,
+        ) -> RpcResult<BlockConfirmationResult> {
             if data.block_number > self.confirm_until {
                 Ok(BlockConfirmationResult::NotConfirmed)
             } else {

bin/reth/tests/commands/bitfinity_node_it.rs

@@ -26,13 +26,14 @@ reth-engine-tree.workspace = true
 reth-evm.workspace = true
 reth-evm-ethereum.workspace = true
 reth-node-types.workspace = true
-reth-provider.workspace = true
+reth-provider = { workspace = true, features = ["test-utils"] }
 reth-primitives.workspace = true
 reth-primitives-traits.workspace = true
 reth-revm.workspace = true
 reth-trie.workspace = true
 reth-trie-db.workspace = true
 tracing.workspace = true
+reth-rpc-eth-types.workspace = true
 
 [dev-dependencies]
 alloy-consensus.workspace = true
@@ -45,3 +46,9 @@ reth-db-common.workspace = true
 tokio.workspace = true
 serde.workspace = true
 tempfile.workspace = true
+reth-testing-utils.workspace = true
+reth-ethereum-engine-primitives.workspace = true
+anyhow.workspace = true
+jsonrpc-core.workspace = true
+serde_json.workspace = true
+alloy-network.workspace = true