forked from ghostchain/ghost-node
		
	ability to avoid too big deviations between from_block and to_block
Signed-off-by: Uncle Stinky <uncle.stinky@ghostchain.io>
This commit is contained in:
		
							parent
							
								
									d5643472ee
								
							
						
					
					
						commit
						d8e934a98e
					
				
							
								
								
									
										4
									
								
								Cargo.lock
									
									
									
										generated
									
									
									
								
							
							
						
						
									
										4
									
								
								Cargo.lock
									
									
									
										generated
									
									
									
								
							@ -1186,7 +1186,7 @@ dependencies = [
 | 
			
		||||
 | 
			
		||||
[[package]]
 | 
			
		||||
name = "casper-runtime"
 | 
			
		||||
version = "3.5.23"
 | 
			
		||||
version = "3.5.24"
 | 
			
		||||
dependencies = [
 | 
			
		||||
 "casper-runtime-constants",
 | 
			
		||||
 "frame-benchmarking",
 | 
			
		||||
@ -3834,7 +3834,7 @@ dependencies = [
 | 
			
		||||
 | 
			
		||||
[[package]]
 | 
			
		||||
name = "ghost-slow-clap"
 | 
			
		||||
version = "0.3.27"
 | 
			
		||||
version = "0.3.28"
 | 
			
		||||
dependencies = [
 | 
			
		||||
 "frame-benchmarking",
 | 
			
		||||
 "frame-support",
 | 
			
		||||
 | 
			
		||||
@ -1,6 +1,6 @@
 | 
			
		||||
[package]
 | 
			
		||||
name = "ghost-slow-clap"
 | 
			
		||||
version = "0.3.27"
 | 
			
		||||
version = "0.3.28"
 | 
			
		||||
description = "Applause protocol for the EVM bridge"
 | 
			
		||||
license.workspace = true
 | 
			
		||||
authors.workspace = true
 | 
			
		||||
 | 
			
		||||
@ -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,
 | 
			
		||||
@ -717,12 +724,20 @@ impl<T: Config> Pallet<T> {
 | 
			
		||||
                            )?;
 | 
			
		||||
 | 
			
		||||
                            let finality_delay = network_data.finality_delay.unwrap_or_default();
 | 
			
		||||
                            let estimated_block = new_evm_block.saturating_sub(finality_delay);
 | 
			
		||||
                            let estimated_block = maybe_new_evm_block
 | 
			
		||||
                                .map(|new_evm_block| new_evm_block.saturating_sub(finality_delay))
 | 
			
		||||
                                .unwrap_or_default();
 | 
			
		||||
 | 
			
		||||
                            Ok(match maybe_block_range {
 | 
			
		||||
                                Some((from_block, to_block)) => match new_evm_block {
 | 
			
		||||
                                    0 => (to_block, to_block),
 | 
			
		||||
                                    _ => (from_block, estimated_block),
 | 
			
		||||
                                Some((from_block, to_block)) => match maybe_new_evm_block {
 | 
			
		||||
                                    Some(_) => match estimated_block.checked_sub(from_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 +763,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 +772,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 +814,7 @@ impl<T: Config> Pallet<T> {
 | 
			
		||||
                        .map_err(|_| OffchainErr::SubmitTransaction)?;
 | 
			
		||||
                }
 | 
			
		||||
 | 
			
		||||
                Ok(0u64)
 | 
			
		||||
                Ok(None)
 | 
			
		||||
            }
 | 
			
		||||
        }
 | 
			
		||||
    }
 | 
			
		||||
 | 
			
		||||
@ -24,7 +24,7 @@ fn prepare_evm_network(
 | 
			
		||||
        chain_name: "Ethereum".into(),
 | 
			
		||||
        default_endpoint: get_rpc_endpoint(),
 | 
			
		||||
        finality_delay: Some(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(())
 | 
			
		||||
    });
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
		Loading…
	
		Reference in New Issue
	
	Block a user