update chain specification because of finality delay non-option type

Signed-off-by: Uncle Stretch <uncle.stretch@ghostchain.io>

Cargo.lock

@@ -1186,7 +1186,7 @@ dependencies = [
 
 [[package]]
 name = "casper-runtime"
-version = "3.5.23"
+version = "3.5.24"
 dependencies = [
  "casper-runtime-constants",
  "frame-benchmarking",
@@ -3648,7 +3648,7 @@ dependencies = [
 
 [[package]]
 name = "ghost-networks"
-version = "0.1.7"
+version = "0.1.8"
 dependencies = [
  "frame-benchmarking",
  "frame-support",
@@ -3834,7 +3834,7 @@ dependencies = [
 
 [[package]]
 name = "ghost-slow-clap"
-version = "0.3.27"
+version = "0.3.28"
 dependencies = [
  "frame-benchmarking",
  "frame-support",

Cargo.toml

@@ -17,7 +17,7 @@ homepage.workspace = true
 [workspace.package]
 license = "GPL-3.0-only"
 authors = ["571nky", "57r37ch", "f4750"]
-version = "0.7.198"
+version = "0.7.199"
 edition = "2021"
 homepage = "https://ghostchain.io"
 repository = "https://git.ghostchain.io/ghostchain/ghost-node"

pallets/networks/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ghost-networks"
-version = "0.1.7"
+version = "0.1.8"
 license.workspace = true
 authors.workspace = true
 edition.workspace = true

pallets/networks/src/benchmarking.rs

@@ -30,9 +30,9 @@ fn prepare_network<T: Config>(
         default_endpoint: sp_std::vec![0x69; m as usize],
         gatekeeper,
         topic_name,
-        finality_delay: Some(69),
-        block_distance: 69,
         network_type: NetworkType::Evm,
+        finality_delay: 69,
+        block_distance: 69,
         incoming_fee: 0,
         outgoing_fee: 0,
     };
@@ -107,7 +107,7 @@ benchmarks! {
     }
 
     update_network_finality_delay {
-        let delay = Some(1337);
+        let delay = 1337;
         let (chain_id, network) = prepare_network::<T>(1, 1);
         let authority = T::UpdateOrigin::try_successful_origin()
             .map_err(|_| BenchmarkError::Weightless)?;

pallets/networks/src/lib.rs

@@ -54,8 +54,8 @@ pub struct NetworkData {
     pub default_endpoint: Vec<u8>,
     pub gatekeeper: Vec<u8>,
     pub topic_name: Vec<u8>,
-    pub finality_delay: Option<u64>,
     pub network_type: NetworkType,
+    pub finality_delay: u64,
     pub block_distance: u64,
     pub incoming_fee: u32,
     pub outgoing_fee: u32,
@@ -157,7 +157,7 @@ pub mod module {
         NetworkRegistered { chain_id: T::NetworkId, network: NetworkData },
         NetworkNameUpdated { chain_id: T::NetworkId, chain_name: Vec<u8> },
         NetworkEndpointUpdated { chain_id: T::NetworkId, default_endpoint: Vec<u8> },
-        NetworkFinalityDelayUpdated { chain_id: T::NetworkId, finality_delay: Option<u64> },
+        NetworkFinalityDelayUpdated { chain_id: T::NetworkId, finality_delay: u64 },
         NetworkBlockDistanceUpdated { chain_id: T::NetworkId, block_distance: u64 },
         NetworkTypeUpdated { chain_id: T::NetworkId, network_type: NetworkType },
         NetworkGatekeeperUpdated { chain_id: T::NetworkId, gatekeeper: Vec<u8> },
@@ -293,7 +293,7 @@ pub mod module {
         pub fn update_network_finality_delay(
             origin: OriginFor<T>,
             chain_id: T::NetworkId,
-            finality_delay: Option<u64>,
+            finality_delay: u64,
         ) -> DispatchResult {
             T::UpdateOrigin::ensure_origin_or_root(origin)?;
             Self::do_update_network_finality_delay(
@@ -468,7 +468,7 @@ impl<T: Config> Pallet<T> {
     /// Update existent network default endpoint.
     pub fn do_update_network_finality_delay(
         chain_id: T::NetworkId,
-        finality_delay: Option<u64>,
+        finality_delay: u64,
     ) -> DispatchResult {
         Networks::<T>::try_mutate(&chain_id, |maybe_network| -> DispatchResult {
             ensure!(maybe_network.is_some(), Error::<T>::NetworkDoesNotExist);

pallets/networks/src/tests.rs

@@ -11,7 +11,7 @@ fn prepare_network_data() -> (u32, NetworkData) {
     (1u32, NetworkData {
         chain_name: "Ethereum".into(),
         default_endpoint: "https:://some-endpoint.my-server.com/v1/my-super-secret-key".into(),
-        finality_delay: Some(69),
+        finality_delay: 69,
         block_distance: 69,
         network_type: NetworkType::Evm,
         gatekeeper: b"0x1234567891234567891234567891234567891234".to_vec(),
@@ -119,7 +119,7 @@ fn could_update_network_endpoint_from_authority_account() {
 fn could_update_network_finality_delay_from_authority_account() {
     ExtBuilder::build()
         .execute_with(|| {
-            let new_finality_delay = Some(1337);
+            let new_finality_delay = 1337;
             let (chain_id, network) = prepare_network_data();
             register_and_check_network(chain_id, network.clone());
             assert_ok!(GhostNetworks::update_network_finality_delay(
@@ -311,18 +311,19 @@ fn could_not_update_network_finality_delay_from_random_account() {
     ExtBuilder::build()
         .execute_with(|| {
             let (chain_id, network) = prepare_network_data();
+            let finality_delay = 1337;
             register_and_check_network(chain_id, network.clone());
             assert_err!(GhostNetworks::update_network_finality_delay(
                     RuntimeOrigin::signed(RegistererAccount::get()),
-                    chain_id, Some(1337)),
+                    chain_id, finality_delay),
                     DispatchError::BadOrigin);
             assert_err!(GhostNetworks::update_network_finality_delay(
                     RuntimeOrigin::signed(RemoverAccount::get()),
-                    chain_id, Some(1337)),
+                    chain_id, finality_delay),
                     DispatchError::BadOrigin);
             assert_err!(GhostNetworks::update_network_finality_delay(
                     RuntimeOrigin::signed(RandomAccount::get()),
-                    chain_id, Some(1337)),
+                    chain_id, finality_delay),
                     DispatchError::BadOrigin);
             assert_eq!(Networks::<Test>::get(chain_id), Some(network));
         });
@@ -497,7 +498,7 @@ fn could_not_update_finality_delay_for_non_existent_network() {
             assert_eq!(Networks::<Test>::get(chain_id), None);
             assert_err!(GhostNetworks::update_network_finality_delay(
                     RuntimeOrigin::signed(UpdaterAccount::get()),
-                    chain_id, Some(1337)),
+                    chain_id, 1337),
                     crate::Error::<Test>::NetworkDoesNotExist);
             assert_eq!(Networks::<Test>::get(chain_id), None);
         });

pallets/slow-clap/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ghost-slow-clap"
-version = "0.3.27"
+version = "0.3.29"
 description = "Applause protocol for the EVM bridge"
 license.workspace = true
 authors.workspace = true

pallets/slow-clap/src/lib.rs

@@ -687,6 +687,7 @@ impl<T: Config> Pallet<T> {
         let network_id_encoded = network_id.encode();
 
         let block_number_key = Self::create_storage_key(b"block-", &network_id_encoded);
+        let block_distance_key = Self::create_storage_key(b"block-distance-", &network_id_encoded);
         let endpoint_key = Self::create_storage_key(b"endpoint-", &network_id_encoded);
 
         let rpc_endpoint = StorageValueRef::persistent(&endpoint_key)
@@ -695,6 +696,12 @@ impl<T: Config> Pallet<T> {
             .flatten()
             .unwrap_or(network_data.default_endpoint.clone());
 
+        let max_block_distance = StorageValueRef::persistent(&block_distance_key)
+            .get()
+            .ok()
+            .flatten()
+            .unwrap_or(network_data.block_distance);
+
         let mutation_result = StorageValueRef::persistent(&block_number_key).mutate(|result_block_range: Result<Option<(u64, u64)>, StorageRetrievalError>| {
             match result_block_range {
                 Ok(maybe_block_range) => {
@@ -708,7 +715,7 @@ impl<T: Config> Pallet<T> {
 
                     match network_data.network_type {
                         NetworkType::Evm => {
-                            let new_evm_block = Self::apply_evm_response(
+                            let maybe_new_evm_block = Self::apply_evm_response(
                                 &response_bytes,
                                 authority_index,
                                 authority_key,
@@ -716,13 +723,20 @@ impl<T: Config> Pallet<T> {
                                 network_id
                             )?;
 
-                            let finality_delay = network_data.finality_delay.unwrap_or_default();
+                            let estimated_block = maybe_new_evm_block
-                            let estimated_block = new_evm_block.saturating_sub(finality_delay);
+                                .map(|new_evm_block| new_evm_block.saturating_sub(network_data.finality_delay))
+                                .unwrap_or_default();
 
                             Ok(match maybe_block_range {
-                                Some((from_block, to_block)) => match new_evm_block {
+                                Some((from_block, to_block)) => match maybe_new_evm_block {
-                                    0 => (to_block, to_block),
+                                    Some(_) => match estimated_block.checked_sub(from_block) {
-                                    _ => (from_block, estimated_block),
+                                        Some(current_distance) if current_distance < max_block_distance =>
+                                            (from_block, estimated_block),
+                                        _ => (from_block, from_block
+                                                .saturating_add(max_block_distance)
+                                                .min(estimated_block)),
+                                    },
+                                    None => (to_block, to_block),
                                 },
                                 None => (estimated_block, estimated_block),
                             })
@@ -748,7 +762,7 @@ impl<T: Config> Pallet<T> {
         authority_key: T::AuthorityId,
         session_index: SessionIndex,
         network_id: NetworkIdOf<T>
-    ) -> OffchainResult<T, u64> {
+    ) -> OffchainResult<T, Option<u64>> {
         match Self::parse_evm_response(&response_bytes)? {
             EvmResponseType::BlockNumber(new_evm_block) => {
                 log::info!(
@@ -757,7 +771,7 @@ impl<T: Config> Pallet<T> {
                     new_evm_block,
                     network_id,
                 );
-                Ok(new_evm_block)
+                Ok(Some(new_evm_block))
             },
             EvmResponseType::TransactionLogs(evm_logs) => {
                 let claps: Vec<_> = evm_logs
@@ -799,7 +813,7 @@ impl<T: Config> Pallet<T> {
                         .map_err(|_| OffchainErr::SubmitTransaction)?;
                 }
 
-                Ok(0u64)
+                Ok(None)
             }
         }
     }

pallets/slow-clap/src/tests.rs

@@ -23,8 +23,8 @@ fn prepare_evm_network(
     let network_data = NetworkData {
         chain_name: "Ethereum".into(),
         default_endpoint: get_rpc_endpoint(),
-        finality_delay: Some(69),
+        finality_delay: 69,
-        release_delay: Some(69),
+        block_distance: 69,
         network_type: ghost_networks::NetworkType::Evm,
         gatekeeper: get_gatekeeper(),
         topic_name: get_topic_name(),
@@ -197,9 +197,9 @@ fn should_make_http_call_and_parse_block_number() {
 
         let request_body = SlowClap::prepare_request_body_for_latest_block(&network_data);
         let raw_response = SlowClap::fetch_from_remote(&rpc_endpoint, &request_body)?;
-        let evm_block_number = SlowClap::apply_evm_response(&raw_response, 69, Default::default(), 420, 1)?;
+        let maybe_evm_block_number = SlowClap::apply_evm_response(&raw_response, 69, Default::default(), 420, 1)?;
 
-        assert_eq!(evm_block_number, 20335745);
+        assert_eq!(maybe_evm_block_number, Some(20335745));
         Ok(())
     });
 }
@@ -234,7 +234,7 @@ fn should_make_http_call_and_parse_logs() {
             EvmResponseType::TransactionLogs(evm_logs) => assert_eq!(evm_logs.len(), 2),
         }
 
-        let evm_block_number = SlowClap::apply_evm_response(
+        let maybe_evm_block_number = SlowClap::apply_evm_response(
             &raw_response,
             1,
             UintAuthorityId::from(2),
@@ -242,7 +242,7 @@ fn should_make_http_call_and_parse_logs() {
             network_id,
         )?;
 
-        assert_eq!(evm_block_number, 0);
+        assert_eq!(maybe_evm_block_number, None);
         Ok(())
     });
 }

service/src/chain_spec.rs

@@ -177,7 +177,7 @@ fn casper_testnet_evm_networks() -> Vec<(u32, Vec<u8>)> {
         (1, ghost_networks::NetworkData { 
             chain_name: "ethereum-mainnet".into(), 
             default_endpoint: "https://nd-422-757-666.p2pify.com/0a9d79d93fb2f4a4b1e04695da2b77a7/".into(),
-            finality_delay: Some(40u64),
+            finality_delay: 40u64,
             block_distance: 50u64,
             network_type: ghost_networks::NetworkType::Evm,
             gatekeeper: "0x4d224452801aced8b2f0aebe155379bb5d594381".into(),
@@ -188,7 +188,7 @@ fn casper_testnet_evm_networks() -> Vec<(u32, Vec<u8>)> {
         (56, ghost_networks::NetworkData { 
             chain_name: "bnb-mainnet".into(), 
             default_endpoint: "https://bsc-mainnet.core.chainstack.com/35848e183f3e3303c8cfeacbea831cab/".into(),
-            finality_delay: Some(20u64),
+            finality_delay: 20u64,
             block_distance: 50u64,
             network_type: ghost_networks::NetworkType::Evm,
             gatekeeper: "0x0E09FaBB73Bd3Ade0a17ECC321fD13a19e81cE82".into(),