[EPROD-1119] sync data from the evm canister in case no new blocks are generated from the primary url

Cargo.toml

@@ -650,14 +650,14 @@ tracy-client = "0.17.3"
 # Bitfinity Deps
 async-channel = "2"
 candid = "0.10"
-did = { git = "https://github.com/bitfinity-network/bitfinity-evm-sdk", package = "did", tag = "v0.40.x" }
+did = { git = "https://github.com/bitfinity-network/bitfinity-evm-sdk", package = "did", tag = "v0.42.x" }
 dirs = "5.0.1"
-ethereum-json-rpc-client = { git = "https://github.com/bitfinity-network/bitfinity-evm-sdk", package = "ethereum-json-rpc-client", tag = "v0.40.x", features = [
+ethereum-json-rpc-client = { git = "https://github.com/bitfinity-network/bitfinity-evm-sdk", package = "ethereum-json-rpc-client", tag = "v0.42.x", features = [
     "reqwest",
 ] }
 evm-canister-client = { git = "https://github.com/bitfinity-network/bitfinity-evm-sdk", package = "evm-canister-client", features = [
     "ic-agent-client",
-], tag = "v0.40.x" }
+], tag = "v0.42.x" }
 ic-cbor = "3"
 ic-certificate-verification = "3"
 ic-certification = "3"

bin/reth/src/commands/bitfinity_import.rs

@@ -28,7 +28,9 @@ use reth_provider::{
 };
 use reth_prune::PruneModes;
 use reth_stages::{
-    prelude::*, stages::{ExecutionStage, SenderRecoveryStage}, ExecutionStageThresholds, Pipeline, StageSet
+    prelude::*,
+    stages::{ExecutionStage, SenderRecoveryStage},
+    ExecutionStageThresholds, Pipeline, StageSet,
 };
 use reth_static_file::StaticFileProducer;
 use std::{path::PathBuf, sync::Arc, time::Duration};
@@ -142,6 +144,7 @@ impl BitfinityImportCommand {
             backup_url: self.bitfinity.backup_rpc_url.clone(),
             max_retries: self.bitfinity.max_retries,
             retry_delay: Duration::from_secs(self.bitfinity.retry_delay_secs),
+            max_block_age_secs: Duration::from_secs(self.bitfinity.max_block_age_secs),
         };
 
         let remote_client = Arc::new(
@@ -155,6 +158,7 @@ impl BitfinityImportCommand {
                     evmc_principal: self.bitfinity.evmc_principal.clone(),
                     ic_root_key: self.bitfinity.ic_root_key.clone(),
                 }),
+                self.bitfinity.check_evm_state_before_importing,
             )
             .await?,
         );

bin/reth/src/commands/bitfinity_reset_evm_state.rs

@@ -7,7 +7,7 @@ use std::sync::Arc;
 
 use alloy_rlp::{Decodable, Encodable};
 use clap::Parser;
-use did::evm_reset_state::EvmResetState;
+use did::evm_state::EvmResetState;
 use did::{AccountInfoMap, RawAccountInfo, H160, H256};
 use evm_canister_client::{CanisterClient, EvmCanisterClient, IcAgentClient};
 use reth_db::cursor::DbCursorRO;
@@ -107,7 +107,13 @@ impl BitfinityResetEvmStateCommand {
         max_request_bytes: usize,
         max_account_request_bytes: usize,
     ) -> Self {
-        Self { provider_factory, executor, parallel_requests: parallel_requests.max(1), max_request_bytes, max_account_request_bytes }
+        Self {
+            provider_factory,
+            executor,
+            parallel_requests: parallel_requests.max(1),
+            max_request_bytes,
+            max_account_request_bytes,
+        }
     }
 
     /// Execute the command

bin/reth/tests/commands/bitfinity_import_it.rs

@@ -3,10 +3,18 @@
 //! These tests requires a running EVM node or EVM block extractor node at the specified URL.
 //!
 
+use super::bitfinity_node_it::{
+    eth_server::{EthImpl, EthServer},
+    mock_eth_server_start,
+};
 use super::utils::*;
 use alloy_eips::BlockNumberOrTag;
+
 use ethereum_json_rpc_client::{reqwest::ReqwestClient, EthJsonRpcClient};
+
+use reth::commands::bitfinity_import::BitfinityImportCommand;
 use reth_provider::{BlockNumReader, BlockReader, BlockReaderIdExt};
+
 use std::time::Duration;
 
 #[tokio::test]
@@ -134,3 +142,167 @@ async fn bitfinity_test_should_import_data_from_evm_with_backup_rpc_url() {
         assert_eq!(remote_block.state_root.0, local_block.state_root.0);
     }
 }
+
+#[tokio::test]
+async fn bitfinity_test_should_not_import_blocks_when_evm_is_disabled_and_check_evm_state_before_importing_is_true(
+) {
+    // Arrange
+    let _log = init_logs();
+
+    let eth_server = EthImpl::with_evm_state(did::evm_state::EvmGlobalState::Disabled);
+    let (_server, eth_server_address) =
+        mock_eth_server_start(EthServer::into_rpc(eth_server)).await;
+    let evm_datasource_url = format!("http://{}", eth_server_address);
+
+    let (_temp_dir, mut import_data) =
+        bitfinity_import_config_data(&evm_datasource_url, None, None).await.unwrap();
+    import_data.bitfinity_args.end_block = Some(10);
+    import_data.bitfinity_args.batch_size = 5;
+    import_data.bitfinity_args.max_fetch_blocks = 10;
+    import_data.bitfinity_args.check_evm_state_before_importing = true;
+
+    // Act - Try to import blocks
+    let import = BitfinityImportCommand::new(
+        None,
+        import_data.data_dir,
+        import_data.chain,
+        import_data.bitfinity_args,
+        import_data.provider_factory.clone(),
+        import_data.blockchain_db,
+    );
+    let (job_executor, _import_handle) = import.schedule_execution().await.unwrap();
+
+    // Allow some time for potential imports
+    tokio::time::sleep(Duration::from_secs(2)).await;
+    job_executor.stop(true).await.unwrap();
+
+    // Assert - No blocks should have been imported
+    let provider = import_data.provider_factory.provider().unwrap();
+    let last_block = provider.last_block_number().unwrap();
+    assert_eq!(last_block, 0, "Expected no blocks to be imported when staging mode is disabled");
+}
+
+#[tokio::test]
+async fn bitfinity_test_should_import_blocks_when_evm_is_enabled_and_check_evm_state_before_importing_is_true(
+) {
+    // Arrange
+    let _log = init_logs();
+
+    // Set up mock ETH server in disabled mode
+    let eth_server = EthImpl::with_evm_state(did::evm_state::EvmGlobalState::Enabled);
+    let (_server, eth_server_address) =
+        mock_eth_server_start(EthServer::into_rpc(eth_server)).await;
+    let evm_datasource_url = format!("http://{}", eth_server_address);
+
+    let (_temp_dir, mut import_data) =
+        bitfinity_import_config_data(&evm_datasource_url, None, None).await.unwrap();
+    import_data.bitfinity_args.end_block = Some(10);
+    import_data.bitfinity_args.batch_size = 5;
+    import_data.bitfinity_args.max_fetch_blocks = 10;
+    import_data.bitfinity_args.check_evm_state_before_importing = true;
+
+    // Act - Try to import blocks
+    let import = BitfinityImportCommand::new(
+        None,
+        import_data.data_dir,
+        import_data.chain,
+        import_data.bitfinity_args,
+        import_data.provider_factory.clone(),
+        import_data.blockchain_db,
+    );
+    let (job_executor, _import_handle) = import.schedule_execution().await.unwrap();
+
+    // Allow some time for potential imports
+    tokio::time::sleep(Duration::from_secs(2)).await;
+    job_executor.stop(true).await.unwrap();
+
+    // Assert
+    let provider = import_data.provider_factory.provider().unwrap();
+    let last_block = provider.last_block_number().unwrap();
+    assert_eq!(last_block, 10, "Expected 10 blocks to be imported when EVM is enabled");
+}
+
+#[tokio::test]
+async fn bitfinity_test_should_import_block_when_evm_is_enabled_and_check_evm_state_before_importing_is_false(
+) {
+    // Arrange
+    let _log = init_logs();
+
+    // Act
+    // Set up mock ETH server in disabled mode
+    let eth_server = EthImpl::with_evm_state(did::evm_state::EvmGlobalState::Enabled);
+    let (_server, eth_server_address) =
+        mock_eth_server_start(EthServer::into_rpc(eth_server)).await;
+    let evm_datasource_url = format!("http://{}", eth_server_address);
+
+    let (_temp_dir, mut import_data) =
+        bitfinity_import_config_data(&evm_datasource_url, None, None).await.unwrap();
+
+    import_data.bitfinity_args.end_block = Some(10);
+    import_data.bitfinity_args.batch_size = 5;
+    import_data.bitfinity_args.max_fetch_blocks = 10;
+    import_data.bitfinity_args.check_evm_state_before_importing = false;
+
+    // Act - Try to import blocks
+    let import = BitfinityImportCommand::new(
+        None,
+        import_data.data_dir,
+        import_data.chain,
+        import_data.bitfinity_args,
+        import_data.provider_factory.clone(),
+        import_data.blockchain_db,
+    );
+    let (job_executor, _import_handle) = import.schedule_execution().await.unwrap();
+
+    // Allow some time for potential imports
+    tokio::time::sleep(Duration::from_secs(2)).await;
+    job_executor.stop(true).await.unwrap();
+
+    // Assert
+    let provider = import_data.provider_factory.provider().unwrap();
+    let last_block = provider.last_block_number().unwrap();
+    assert_eq!(last_block, 10, "Expected 10 blocks to be imported when EVM is enabled");
+}
+
+#[tokio::test]
+async fn bitfinity_test_should_not_import_block_when_evm_is_staging_and_check_evm_state_before_importing_is_false(
+) {
+    // Arrange
+    let _log = init_logs();
+
+    // Set up mock ETH server in disabled mode
+    let eth_server =
+        EthImpl::with_evm_state(did::evm_state::EvmGlobalState::Staging { max_block_number: None });
+    let (_server, eth_server_address) =
+        mock_eth_server_start(EthServer::into_rpc(eth_server)).await;
+    let evm_datasource_url = format!("http://{}", eth_server_address);
+
+    // Act
+    let (_temp_dir, mut import_data) =
+        bitfinity_import_config_data(&evm_datasource_url, None, None).await.unwrap();
+
+    import_data.bitfinity_args.end_block = Some(10);
+    import_data.bitfinity_args.batch_size = 5;
+    import_data.bitfinity_args.max_fetch_blocks = 10;
+    import_data.bitfinity_args.check_evm_state_before_importing = true;
+
+    // Act
+    let import = BitfinityImportCommand::new(
+        None,
+        import_data.data_dir,
+        import_data.chain,
+        import_data.bitfinity_args,
+        import_data.provider_factory.clone(),
+        import_data.blockchain_db,
+    );
+    let (job_executor, _import_handle) = import.schedule_execution().await.unwrap();
+
+    // Allow some time for potential imports
+    tokio::time::sleep(Duration::from_secs(2)).await;
+    job_executor.stop(true).await.unwrap();
+
+    // Assert
+    let provider = import_data.provider_factory.provider().unwrap();
+    let last_block = provider.last_block_number().unwrap();
+    assert_eq!(last_block, 0, "Expected no blocks to be imported when EVM is staging");
+}