forked from ghostchain/ghost-node
		
	remove legacy release_delay and add block_distance for maximum block range for the eth_getLogs
Signed-off-by: Uncle Stretch <uncle.stretch@ghostchain.io>
This commit is contained in:
		
							parent
							
								
									39a6192d28
								
							
						
					
					
						commit
						671196ebac
					
				@ -1,6 +1,6 @@
 | 
			
		||||
[package]
 | 
			
		||||
name = "ghost-networks"
 | 
			
		||||
version = "0.1.6"
 | 
			
		||||
version = "0.1.7"
 | 
			
		||||
license.workspace = true
 | 
			
		||||
authors.workspace = true
 | 
			
		||||
edition.workspace = true
 | 
			
		||||
 | 
			
		||||
@ -31,7 +31,7 @@ fn prepare_network<T: Config>(
 | 
			
		||||
        gatekeeper,
 | 
			
		||||
        topic_name,
 | 
			
		||||
        finality_delay: Some(69),
 | 
			
		||||
        release_delay: Some(69),
 | 
			
		||||
        block_distance: 69,
 | 
			
		||||
        network_type: NetworkType::Evm,
 | 
			
		||||
        incoming_fee: 0,
 | 
			
		||||
        outgoing_fee: 0,
 | 
			
		||||
@ -120,16 +120,16 @@ benchmarks! {
 | 
			
		||||
        assert_ne!(GhostNetworks::<T>::networks(chain_id.clone()), prev_network);
 | 
			
		||||
    }
 | 
			
		||||
 | 
			
		||||
    update_network_release_delay {
 | 
			
		||||
        let delay = Some(1337);
 | 
			
		||||
    update_network_block_distance {
 | 
			
		||||
        let block_distance = 1337;
 | 
			
		||||
        let (chain_id, network) = prepare_network::<T>(1, 1);
 | 
			
		||||
        let authority = T::UpdateOrigin::try_successful_origin()
 | 
			
		||||
            .map_err(|_| BenchmarkError::Weightless)?;
 | 
			
		||||
        let prev_network = create_network::<T>(chain_id.clone(), network.clone())?;
 | 
			
		||||
    }: _<T::RuntimeOrigin>(authority, chain_id.clone(), delay)
 | 
			
		||||
    }: _<T::RuntimeOrigin>(authority, chain_id.clone(), block_distance)
 | 
			
		||||
    verify {
 | 
			
		||||
        assert_last_event::<T>(Event::NetworkReleaseDelayUpdated {
 | 
			
		||||
            chain_id: chain_id.clone(), release_delay: delay,
 | 
			
		||||
        assert_last_event::<T>(Event::NetworkBlockDistanceUpdated {
 | 
			
		||||
            chain_id: chain_id.clone(), block_distance,
 | 
			
		||||
        }.into());
 | 
			
		||||
        assert_ne!(GhostNetworks::<T>::networks(chain_id.clone()), prev_network);
 | 
			
		||||
    }
 | 
			
		||||
 | 
			
		||||
@ -55,8 +55,8 @@ pub struct NetworkData {
 | 
			
		||||
    pub gatekeeper: Vec<u8>,
 | 
			
		||||
    pub topic_name: Vec<u8>,
 | 
			
		||||
    pub finality_delay: Option<u64>,
 | 
			
		||||
    pub release_delay: Option<u64>,
 | 
			
		||||
    pub network_type: NetworkType,
 | 
			
		||||
    pub block_distance: u64,
 | 
			
		||||
    pub incoming_fee: u32,
 | 
			
		||||
    pub outgoing_fee: u32,
 | 
			
		||||
}
 | 
			
		||||
@ -158,7 +158,7 @@ pub mod module {
 | 
			
		||||
        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> },
 | 
			
		||||
        NetworkReleaseDelayUpdated { chain_id: T::NetworkId, release_delay: Option<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> },
 | 
			
		||||
        NetworkTopicNameUpdated { chain_id: T::NetworkId, topic_name: Vec<u8> },
 | 
			
		||||
@ -303,16 +303,16 @@ pub mod module {
 | 
			
		||||
        }
 | 
			
		||||
 | 
			
		||||
        #[pallet::call_index(4)]
 | 
			
		||||
        #[pallet::weight(T::WeightInfo::update_network_release_delay())]
 | 
			
		||||
        pub fn update_network_release_delay(
 | 
			
		||||
        #[pallet::weight(T::WeightInfo::update_network_block_distance())]
 | 
			
		||||
        pub fn update_network_block_distance(
 | 
			
		||||
            origin: OriginFor<T>,
 | 
			
		||||
            chain_id: T::NetworkId,
 | 
			
		||||
            release_delay: Option<u64>,
 | 
			
		||||
            block_distance: u64,
 | 
			
		||||
        ) -> DispatchResult {
 | 
			
		||||
            T::UpdateOrigin::ensure_origin_or_root(origin)?;
 | 
			
		||||
            Self::do_update_network_release_delay(
 | 
			
		||||
            Self::do_update_network_block_distance(
 | 
			
		||||
                chain_id,
 | 
			
		||||
                release_delay,
 | 
			
		||||
                block_distance,
 | 
			
		||||
            )
 | 
			
		||||
        }
 | 
			
		||||
 | 
			
		||||
@ -484,21 +484,21 @@ impl<T: Config> Pallet<T> {
 | 
			
		||||
        Ok(())
 | 
			
		||||
    }
 | 
			
		||||
 | 
			
		||||
    /// Update existent network default endpoint.
 | 
			
		||||
    pub fn do_update_network_release_delay(
 | 
			
		||||
    /// Update existent network default max distance between blocks.
 | 
			
		||||
    pub fn do_update_network_block_distance(
 | 
			
		||||
        chain_id: T::NetworkId,
 | 
			
		||||
        release_delay: Option<u64>,
 | 
			
		||||
        block_distance: u64,
 | 
			
		||||
    ) -> DispatchResult {
 | 
			
		||||
        Networks::<T>::try_mutate(&chain_id, |maybe_network| -> DispatchResult {
 | 
			
		||||
            ensure!(maybe_network.is_some(), Error::<T>::NetworkDoesNotExist);
 | 
			
		||||
            let net = maybe_network.as_mut().unwrap();
 | 
			
		||||
            net.release_delay = release_delay;
 | 
			
		||||
            net.block_distance = block_distance;
 | 
			
		||||
            *maybe_network = Some(net.clone());
 | 
			
		||||
            Ok(())
 | 
			
		||||
        })?;
 | 
			
		||||
        Self::deposit_event(Event::<T>::NetworkReleaseDelayUpdated {
 | 
			
		||||
        Self::deposit_event(Event::<T>::NetworkBlockDistanceUpdated {
 | 
			
		||||
            chain_id,
 | 
			
		||||
            release_delay,
 | 
			
		||||
            block_distance,
 | 
			
		||||
        });
 | 
			
		||||
        Ok(())
 | 
			
		||||
    }
 | 
			
		||||
 | 
			
		||||
@ -12,7 +12,7 @@ fn prepare_network_data() -> (u32, NetworkData) {
 | 
			
		||||
        chain_name: "Ethereum".into(),
 | 
			
		||||
        default_endpoint: "https:://some-endpoint.my-server.com/v1/my-super-secret-key".into(),
 | 
			
		||||
        finality_delay: Some(69),
 | 
			
		||||
        release_delay: Some(69),
 | 
			
		||||
        block_distance: 69,
 | 
			
		||||
        network_type: NetworkType::Evm,
 | 
			
		||||
        gatekeeper: b"0x1234567891234567891234567891234567891234".to_vec(),
 | 
			
		||||
        topic_name: b"0x12345678912345678912345678912345678912345678912345678912345678".to_vec(),
 | 
			
		||||
@ -137,21 +137,21 @@ fn could_update_network_finality_delay_from_authority_account() {
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
#[test]
 | 
			
		||||
fn could_update_network_release_delay_from_authority_account() {
 | 
			
		||||
fn could_update_network_block_distance_from_authority_account() {
 | 
			
		||||
    ExtBuilder::build()
 | 
			
		||||
        .execute_with(|| {
 | 
			
		||||
            let new_release_delay = Some(1337);
 | 
			
		||||
            let new_block_distance = 1337;
 | 
			
		||||
            let (chain_id, network) = prepare_network_data();
 | 
			
		||||
            register_and_check_network(chain_id, network.clone());
 | 
			
		||||
            assert_ok!(GhostNetworks::update_network_release_delay(
 | 
			
		||||
            assert_ok!(GhostNetworks::update_network_block_distance(
 | 
			
		||||
                    RuntimeOrigin::signed(UpdaterAccount::get()),
 | 
			
		||||
                    chain_id, new_release_delay));
 | 
			
		||||
                    chain_id, new_block_distance));
 | 
			
		||||
            System::assert_last_event(RuntimeEvent::GhostNetworks(
 | 
			
		||||
                    crate::Event::NetworkReleaseDelayUpdated {
 | 
			
		||||
                    crate::Event::NetworkBlockDistanceUpdated {
 | 
			
		||||
                        chain_id,
 | 
			
		||||
                        release_delay: new_release_delay }));
 | 
			
		||||
                        block_distance: new_block_distance }));
 | 
			
		||||
            let mut final_network = network.clone();
 | 
			
		||||
            final_network.release_delay = new_release_delay;
 | 
			
		||||
            final_network.block_distance = new_block_distance;
 | 
			
		||||
            assert_eq!(Networks::<Test>::get(chain_id), Some(final_network.clone()));
 | 
			
		||||
            assert_ne!(network, final_network);
 | 
			
		||||
        });
 | 
			
		||||
@ -333,18 +333,19 @@ fn could_not_update_network_release_delay_from_random_account() {
 | 
			
		||||
    ExtBuilder::build()
 | 
			
		||||
        .execute_with(|| {
 | 
			
		||||
            let (chain_id, network) = prepare_network_data();
 | 
			
		||||
            let block_distance = 1337;
 | 
			
		||||
            register_and_check_network(chain_id, network.clone());
 | 
			
		||||
            assert_err!(GhostNetworks::update_network_release_delay(
 | 
			
		||||
            assert_err!(GhostNetworks::update_network_block_distance(
 | 
			
		||||
                    RuntimeOrigin::signed(RegistererAccount::get()),
 | 
			
		||||
                    chain_id, Some(1337)),
 | 
			
		||||
                    chain_id, block_distance),
 | 
			
		||||
                    DispatchError::BadOrigin);
 | 
			
		||||
            assert_err!(GhostNetworks::update_network_release_delay(
 | 
			
		||||
            assert_err!(GhostNetworks::update_network_block_distance(
 | 
			
		||||
                    RuntimeOrigin::signed(RemoverAccount::get()),
 | 
			
		||||
                    chain_id, Some(1337)),
 | 
			
		||||
                    chain_id, block_distance),
 | 
			
		||||
                    DispatchError::BadOrigin);
 | 
			
		||||
            assert_err!(GhostNetworks::update_network_release_delay(
 | 
			
		||||
            assert_err!(GhostNetworks::update_network_block_distance(
 | 
			
		||||
                    RuntimeOrigin::signed(RandomAccount::get()),
 | 
			
		||||
                    chain_id, Some(1337)),
 | 
			
		||||
                    chain_id, block_distance),
 | 
			
		||||
                    DispatchError::BadOrigin);
 | 
			
		||||
            assert_eq!(Networks::<Test>::get(chain_id), Some(network));
 | 
			
		||||
        });
 | 
			
		||||
@ -508,9 +509,9 @@ fn could_not_update_release_delay_for_non_existent_network() {
 | 
			
		||||
        .execute_with(|| {
 | 
			
		||||
            let chain_id: u32 = 1;
 | 
			
		||||
            assert_eq!(Networks::<Test>::get(chain_id), None);
 | 
			
		||||
            assert_err!(GhostNetworks::update_network_release_delay(
 | 
			
		||||
            assert_err!(GhostNetworks::update_network_block_distance(
 | 
			
		||||
                    RuntimeOrigin::signed(UpdaterAccount::get()),
 | 
			
		||||
                    chain_id, Some(1337)),
 | 
			
		||||
                    chain_id, 1337),
 | 
			
		||||
                    crate::Error::<Test>::NetworkDoesNotExist);
 | 
			
		||||
            assert_eq!(Networks::<Test>::get(chain_id), None);
 | 
			
		||||
        });
 | 
			
		||||
 | 
			
		||||
@ -7,7 +7,7 @@
 | 
			
		||||
 | 
			
		||||
// Ghost Network is distributed in the hope that it will be useful,
 | 
			
		||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
 | 
			
		||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 | 
			
		||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 | 
			
		||||
// GNU General Public License for more details.
 | 
			
		||||
 | 
			
		||||
// You should have received a copy of the GNU General Public License
 | 
			
		||||
@ -15,14 +15,14 @@
 | 
			
		||||
 | 
			
		||||
//! Autogenerated weights for `ghost_networks`
 | 
			
		||||
//!
 | 
			
		||||
//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
 | 
			
		||||
//! DATE: 2023-11-29, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
 | 
			
		||||
//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0
 | 
			
		||||
//! DATE: 2025-06-18, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
 | 
			
		||||
//! WORST CASE MAP SIZE: `1000000`
 | 
			
		||||
//! HOSTNAME: `ghost`, CPU: `Intel(R) Core(TM) i3-2310M CPU @ 2.10GHz`
 | 
			
		||||
//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("casper-dev"), DB CACHE: 1024
 | 
			
		||||
//! HOSTNAME: `ghostown`, CPU: `Intel(R) Core(TM) i3-2310M CPU @ 2.10GHz`
 | 
			
		||||
//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("casper-dev")`, DB CACHE: 1024
 | 
			
		||||
 | 
			
		||||
// Executed Command:
 | 
			
		||||
// ./target/production/ghost
 | 
			
		||||
// ./target/release/ghost
 | 
			
		||||
// benchmark
 | 
			
		||||
// pallet
 | 
			
		||||
// --chain=casper-dev
 | 
			
		||||
@ -30,8 +30,8 @@
 | 
			
		||||
// --repeat=20
 | 
			
		||||
// --pallet=ghost_networks
 | 
			
		||||
// --extrinsic=*
 | 
			
		||||
// --execution=wasm
 | 
			
		||||
// --wasm-execution=compiled
 | 
			
		||||
// --heap-pages=4096
 | 
			
		||||
// --header=./file_header.txt
 | 
			
		||||
// --output=./runtime/casper/src/weights/ghost_networks.rs
 | 
			
		||||
 | 
			
		||||
@ -53,7 +53,7 @@ pub trait WeightInfo {
 | 
			
		||||
	fn update_network_name(n: u32, ) -> Weight;
 | 
			
		||||
	fn update_network_endpoint(n: u32, ) -> Weight;
 | 
			
		||||
	fn update_network_finality_delay() -> Weight;
 | 
			
		||||
	fn update_network_release_delay() -> Weight;
 | 
			
		||||
	fn update_network_block_distance() -> Weight;
 | 
			
		||||
	fn update_network_type() -> Weight;
 | 
			
		||||
	fn update_network_gatekeeper() -> Weight;
 | 
			
		||||
	fn update_network_topic_name() -> Weight;
 | 
			
		||||
@ -65,260 +65,290 @@ pub trait WeightInfo {
 | 
			
		||||
/// Weight for ghost_networks using the Substrate node and recommended hardware.
 | 
			
		||||
pub struct SubstrateWeight<T>(PhantomData<T>);
 | 
			
		||||
impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 | 
			
		||||
	/// Storage: GhostNetworks Networks (r:1 w:1)
 | 
			
		||||
	/// Proof Skipped: GhostNetworks Networks (max_values: None, max_size: None, mode: Measured)
 | 
			
		||||
	/// The range of component `n` is `[1, 20]`.
 | 
			
		||||
	/// The range of component `m` is `[1, 150]`.
 | 
			
		||||
	fn register_network(_n: u32, _m: u32, ) -> Weight {
 | 
			
		||||
	/// Storage: `GhostNetworks::Networks` (r:1 w:1)
 | 
			
		||||
	/// Proof: `GhostNetworks::Networks` (`max_values`: None, `max_size`: None, mode: `Measured`)
 | 
			
		||||
	/// The range of component `i` is `[1, 20]`.
 | 
			
		||||
	/// The range of component `j` is `[1, 150]`.
 | 
			
		||||
	fn register_network(i: u32, j: u32, ) -> Weight {
 | 
			
		||||
		// Proof Size summary in bytes:
 | 
			
		||||
		//  Measured:  `76`
 | 
			
		||||
		//  Estimated: `2551`
 | 
			
		||||
		// Minimum execution time: 32_086 nanoseconds.
 | 
			
		||||
		Weight::from_parts(33_092_855, 2551)
 | 
			
		||||
		//  Measured:  `109`
 | 
			
		||||
		//  Estimated: `3574`
 | 
			
		||||
		// Minimum execution time: 43_624_000 picoseconds.
 | 
			
		||||
		Weight::from_parts(44_945_690, 0)
 | 
			
		||||
			.saturating_add(Weight::from_parts(0, 3574))
 | 
			
		||||
			// Standard Error: 3_439
 | 
			
		||||
			.saturating_add(Weight::from_parts(15_557, 0).saturating_mul(i.into()))
 | 
			
		||||
			// Standard Error: 450
 | 
			
		||||
			.saturating_add(Weight::from_parts(3_508, 0).saturating_mul(j.into()))
 | 
			
		||||
			.saturating_add(T::DbWeight::get().reads(1))
 | 
			
		||||
			.saturating_add(T::DbWeight::get().writes(1))
 | 
			
		||||
	}
 | 
			
		||||
	/// Storage: GhostNetworks Networks (r:1 w:1)
 | 
			
		||||
	/// Proof Skipped: GhostNetworks Networks (max_values: None, max_size: None, mode: Measured)
 | 
			
		||||
	/// Storage: `GhostNetworks::Networks` (r:1 w:1)
 | 
			
		||||
	/// Proof: `GhostNetworks::Networks` (`max_values`: None, `max_size`: None, mode: `Measured`)
 | 
			
		||||
	/// The range of component `n` is `[1, 20]`.
 | 
			
		||||
	fn update_network_name(_n: u32, ) -> Weight {
 | 
			
		||||
		// Proof Size summary in bytes:
 | 
			
		||||
		//  Measured:  `141`
 | 
			
		||||
		//  Estimated: `2616`
 | 
			
		||||
		// Minimum execution time: 34_496 nanoseconds.
 | 
			
		||||
		Weight::from_parts(35_728_230, 2616)
 | 
			
		||||
			// Standard Error: 2_591
 | 
			
		||||
		//  Measured:  `294`
 | 
			
		||||
		//  Estimated: `3759`
 | 
			
		||||
		// Minimum execution time: 48_741_000 picoseconds.
 | 
			
		||||
		Weight::from_parts(50_426_703, 0)
 | 
			
		||||
			.saturating_add(Weight::from_parts(0, 3759))
 | 
			
		||||
			.saturating_add(T::DbWeight::get().reads(1))
 | 
			
		||||
			.saturating_add(T::DbWeight::get().writes(1))
 | 
			
		||||
	}
 | 
			
		||||
	/// Storage: GhostNetworks Networks (r:1 w:1)
 | 
			
		||||
	/// Proof Skipped: GhostNetworks Networks (max_values: None, max_size: None, mode: Measured)
 | 
			
		||||
	/// Storage: `GhostNetworks::Networks` (r:1 w:1)
 | 
			
		||||
	/// Proof: `GhostNetworks::Networks` (`max_values`: None, `max_size`: None, mode: `Measured`)
 | 
			
		||||
	/// The range of component `n` is `[1, 150]`.
 | 
			
		||||
	fn update_network_endpoint(_n: u32, ) -> Weight {
 | 
			
		||||
	fn update_network_endpoint(n: u32, ) -> Weight {
 | 
			
		||||
		// Proof Size summary in bytes:
 | 
			
		||||
		//  Measured:  `141`
 | 
			
		||||
		//  Estimated: `2616`
 | 
			
		||||
		// Minimum execution time: 34_666 nanoseconds.
 | 
			
		||||
		Weight::from_parts(35_959_961, 2616)
 | 
			
		||||
			// Standard Error: 381
 | 
			
		||||
		//  Measured:  `294`
 | 
			
		||||
		//  Estimated: `3759`
 | 
			
		||||
		// Minimum execution time: 49_090_000 picoseconds.
 | 
			
		||||
		Weight::from_parts(50_734_447, 0)
 | 
			
		||||
			.saturating_add(Weight::from_parts(0, 3759))
 | 
			
		||||
			// Standard Error: 863
 | 
			
		||||
			.saturating_add(Weight::from_parts(786, 0).saturating_mul(n.into()))
 | 
			
		||||
			.saturating_add(T::DbWeight::get().reads(1))
 | 
			
		||||
			.saturating_add(T::DbWeight::get().writes(1))
 | 
			
		||||
	}
 | 
			
		||||
	/// Storage: GhostNetworks Networks (r:1 w:1)
 | 
			
		||||
	/// Proof Skipped: GhostNetworks Networks (max_values: None, max_size: None, mode: Measured)
 | 
			
		||||
	/// Storage: `GhostNetworks::Networks` (r:1 w:1)
 | 
			
		||||
	/// Proof: `GhostNetworks::Networks` (`max_values`: None, `max_size`: None, mode: `Measured`)
 | 
			
		||||
	fn update_network_finality_delay() -> Weight {
 | 
			
		||||
		// Proof Size summary in bytes:
 | 
			
		||||
		//  Measured:  `141`
 | 
			
		||||
		//  Estimated: `2616`
 | 
			
		||||
		// Minimum execution time: 33_860 nanoseconds.
 | 
			
		||||
		Weight::from_parts(34_995_000, 2616)
 | 
			
		||||
		//  Measured:  `294`
 | 
			
		||||
		//  Estimated: `3759`
 | 
			
		||||
		// Minimum execution time: 48_107_000 picoseconds.
 | 
			
		||||
		Weight::from_parts(48_993_000, 0)
 | 
			
		||||
			.saturating_add(Weight::from_parts(0, 3759))
 | 
			
		||||
			.saturating_add(T::DbWeight::get().reads(1))
 | 
			
		||||
			.saturating_add(T::DbWeight::get().writes(1))
 | 
			
		||||
	}
 | 
			
		||||
	/// Storage: GhostNetworks Networks (r:1 w:1)
 | 
			
		||||
	/// Proof Skipped: GhostNetworks Networks (max_values: None, max_size: None, mode: Measured)
 | 
			
		||||
	fn update_network_release_delay() -> Weight {
 | 
			
		||||
	/// Storage: `GhostNetworks::Networks` (r:1 w:1)
 | 
			
		||||
	/// Proof: `GhostNetworks::Networks` (`max_values`: None, `max_size`: None, mode: `Measured`)
 | 
			
		||||
	fn update_network_block_distance() -> Weight {
 | 
			
		||||
		// Proof Size summary in bytes:
 | 
			
		||||
		//  Measured:  `141`
 | 
			
		||||
		//  Estimated: `2616`
 | 
			
		||||
		// Minimum execution time: 33_860 nanoseconds.
 | 
			
		||||
		Weight::from_parts(34_995_000, 2616)
 | 
			
		||||
		//  Measured:  `294`
 | 
			
		||||
		//  Estimated: `3759`
 | 
			
		||||
		// Minimum execution time: 48_277_000 picoseconds.
 | 
			
		||||
		Weight::from_parts(49_393_000, 0)
 | 
			
		||||
			.saturating_add(Weight::from_parts(0, 3759))
 | 
			
		||||
			.saturating_add(T::DbWeight::get().reads(1))
 | 
			
		||||
			.saturating_add(T::DbWeight::get().writes(1))
 | 
			
		||||
	}
 | 
			
		||||
	/// Storage: GhostNetworks Networks (r:1 w:1)
 | 
			
		||||
	/// Proof Skipped: GhostNetworks Networks (max_values: None, max_size: None, mode: Measured)
 | 
			
		||||
	/// Storage: `GhostNetworks::Networks` (r:1 w:1)
 | 
			
		||||
	/// Proof: `GhostNetworks::Networks` (`max_values`: None, `max_size`: None, mode: `Measured`)
 | 
			
		||||
	fn update_network_type() -> Weight {
 | 
			
		||||
		// Proof Size summary in bytes:
 | 
			
		||||
		//  Measured:  `141`
 | 
			
		||||
		//  Estimated: `2616`
 | 
			
		||||
		// Minimum execution time: 34_976 nanoseconds.
 | 
			
		||||
		Weight::from_parts(36_182_000, 2616)
 | 
			
		||||
		//  Measured:  `294`
 | 
			
		||||
		//  Estimated: `3759`
 | 
			
		||||
		// Minimum execution time: 47_642_000 picoseconds.
 | 
			
		||||
		Weight::from_parts(49_212_000, 0)
 | 
			
		||||
			.saturating_add(Weight::from_parts(0, 3759))
 | 
			
		||||
			.saturating_add(T::DbWeight::get().reads(1))
 | 
			
		||||
			.saturating_add(T::DbWeight::get().writes(1))
 | 
			
		||||
	}
 | 
			
		||||
	/// Storage: GhostNetworks Networks (r:1 w:1)
 | 
			
		||||
	/// Proof Skipped: GhostNetworks Networks (max_values: None, max_size: None, mode: Measured)
 | 
			
		||||
	/// Storage: `GhostNetworks::Networks` (r:1 w:1)
 | 
			
		||||
	/// Proof: `GhostNetworks::Networks` (`max_values`: None, `max_size`: None, mode: `Measured`)
 | 
			
		||||
	fn update_network_gatekeeper() -> Weight {
 | 
			
		||||
		// Proof Size summary in bytes:
 | 
			
		||||
		//  Measured:  `141`
 | 
			
		||||
		//  Estimated: `2616`
 | 
			
		||||
		// Minimum execution time: 34_768 nanoseconds.
 | 
			
		||||
		Weight::from_parts(35_580_000, 2616)
 | 
			
		||||
		//  Measured:  `294`
 | 
			
		||||
		//  Estimated: `3759`
 | 
			
		||||
		// Minimum execution time: 49_440_000 picoseconds.
 | 
			
		||||
		Weight::from_parts(50_315_000, 0)
 | 
			
		||||
			.saturating_add(Weight::from_parts(0, 3759))
 | 
			
		||||
			.saturating_add(T::DbWeight::get().reads(1))
 | 
			
		||||
			.saturating_add(T::DbWeight::get().writes(1))
 | 
			
		||||
	}
 | 
			
		||||
	/// Storage: GhostNetworks Networks (r:1 w:1)
 | 
			
		||||
	/// Proof Skipped: GhostNetworks Networks (max_values: None, max_size: None, mode: Measured)
 | 
			
		||||
	/// Storage: `GhostNetworks::Networks` (r:1 w:1)
 | 
			
		||||
	/// Proof: `GhostNetworks::Networks` (`max_values`: None, `max_size`: None, mode: `Measured`)
 | 
			
		||||
	fn update_network_topic_name() -> Weight {
 | 
			
		||||
		// Proof Size summary in bytes:
 | 
			
		||||
		//  Measured:  `141`
 | 
			
		||||
		//  Estimated: `2616`
 | 
			
		||||
		// Minimum execution time: 34_768 nanoseconds.
 | 
			
		||||
		Weight::from_parts(35_580_000, 2616)
 | 
			
		||||
		//  Measured:  `294`
 | 
			
		||||
		//  Estimated: `3759`
 | 
			
		||||
		// Minimum execution time: 49_469_000 picoseconds.
 | 
			
		||||
		Weight::from_parts(50_532_000, 0)
 | 
			
		||||
			.saturating_add(Weight::from_parts(0, 3759))
 | 
			
		||||
			.saturating_add(T::DbWeight::get().reads(1))
 | 
			
		||||
			.saturating_add(T::DbWeight::get().writes(1))
 | 
			
		||||
    }
 | 
			
		||||
	/// Storage: GhostNetworks Networks (r:1 w:1)
 | 
			
		||||
	/// Proof Skipped: GhostNetworks Networks (max_values: None, max_size: None, mode: Measured)
 | 
			
		||||
	}
 | 
			
		||||
	/// Storage: `GhostNetworks::Networks` (r:1 w:1)
 | 
			
		||||
	/// Proof: `GhostNetworks::Networks` (`max_values`: None, `max_size`: None, mode: `Measured`)
 | 
			
		||||
	fn update_incoming_network_fee() -> Weight {
 | 
			
		||||
		// Proof Size summary in bytes:
 | 
			
		||||
		//  Measured:  `141`
 | 
			
		||||
		//  Estimated: `2616`
 | 
			
		||||
		// Minimum execution time: 34_768 nanoseconds.
 | 
			
		||||
		Weight::from_parts(35_580_000, 2616)
 | 
			
		||||
		//  Measured:  `294`
 | 
			
		||||
		//  Estimated: `3759`
 | 
			
		||||
		// Minimum execution time: 47_858_000 picoseconds.
 | 
			
		||||
		Weight::from_parts(48_703_000, 0)
 | 
			
		||||
			.saturating_add(Weight::from_parts(0, 3759))
 | 
			
		||||
			.saturating_add(T::DbWeight::get().reads(1))
 | 
			
		||||
			.saturating_add(T::DbWeight::get().writes(1))
 | 
			
		||||
    }
 | 
			
		||||
	/// Storage: GhostNetworks Networks (r:1 w:1)
 | 
			
		||||
	/// Proof Skipped: GhostNetworks Networks (max_values: None, max_size: None, mode: Measured)
 | 
			
		||||
	}
 | 
			
		||||
	/// Storage: `GhostNetworks::Networks` (r:1 w:1)
 | 
			
		||||
	/// Proof: `GhostNetworks::Networks` (`max_values`: None, `max_size`: None, mode: `Measured`)
 | 
			
		||||
	fn update_outgoing_network_fee() -> Weight {
 | 
			
		||||
		// Proof Size summary in bytes:
 | 
			
		||||
		//  Measured:  `141`
 | 
			
		||||
		//  Estimated: `2616`
 | 
			
		||||
		// Minimum execution time: 34_768 nanoseconds.
 | 
			
		||||
		Weight::from_parts(35_580_000, 2616)
 | 
			
		||||
		//  Measured:  `294`
 | 
			
		||||
		//  Estimated: `3759`
 | 
			
		||||
		// Minimum execution time: 47_895_000 picoseconds.
 | 
			
		||||
		Weight::from_parts(49_230_000, 0)
 | 
			
		||||
			.saturating_add(Weight::from_parts(0, 3759))
 | 
			
		||||
			.saturating_add(T::DbWeight::get().reads(1))
 | 
			
		||||
			.saturating_add(T::DbWeight::get().writes(1))
 | 
			
		||||
    }
 | 
			
		||||
	/// Storage: GhostNetworks Networks (r:1 w:1)
 | 
			
		||||
	/// Proof Skipped: GhostNetworks Networks (max_values: None, max_size: None, mode: Measured)
 | 
			
		||||
	}
 | 
			
		||||
	/// Storage: `GhostNetworks::Networks` (r:1 w:1)
 | 
			
		||||
	/// Proof: `GhostNetworks::Networks` (`max_values`: None, `max_size`: None, mode: `Measured`)
 | 
			
		||||
	fn remove_network() -> Weight {
 | 
			
		||||
		// Proof Size summary in bytes:
 | 
			
		||||
		//  Measured:  `141`
 | 
			
		||||
		//  Estimated: `2616`
 | 
			
		||||
		// Minimum execution time: 33_336 nanoseconds.
 | 
			
		||||
		Weight::from_parts(34_609_000, 2616)
 | 
			
		||||
		//  Measured:  `294`
 | 
			
		||||
		//  Estimated: `3759`
 | 
			
		||||
		// Minimum execution time: 44_052_000 picoseconds.
 | 
			
		||||
		Weight::from_parts(44_612_000, 0)
 | 
			
		||||
			.saturating_add(Weight::from_parts(0, 3759))
 | 
			
		||||
			.saturating_add(T::DbWeight::get().reads(1))
 | 
			
		||||
			.saturating_add(T::DbWeight::get().writes(1))
 | 
			
		||||
	}
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
impl WeightInfo for () {
 | 
			
		||||
	/// Storage: GhostNetworks Networks (r:1 w:1)
 | 
			
		||||
	/// Proof Skipped: GhostNetworks Networks (max_values: None, max_size: None, mode: Measured)
 | 
			
		||||
	/// The range of component `n` is `[1, 20]`.
 | 
			
		||||
	/// The range of component `m` is `[1, 150]`.
 | 
			
		||||
	fn register_network(_n: u32, _m: u32, ) -> Weight {
 | 
			
		||||
	/// Storage: `GhostNetworks::Networks` (r:1 w:1)
 | 
			
		||||
	/// Proof: `GhostNetworks::Networks` (`max_values`: None, `max_size`: None, mode: `Measured`)
 | 
			
		||||
	/// The range of component `i` is `[1, 20]`.
 | 
			
		||||
	/// The range of component `j` is `[1, 150]`.
 | 
			
		||||
	fn register_network(i: u32, j: u32, ) -> Weight {
 | 
			
		||||
		// Proof Size summary in bytes:
 | 
			
		||||
		//  Measured:  `76`
 | 
			
		||||
		//  Estimated: `2551`
 | 
			
		||||
		// Minimum execution time: 32_086 nanoseconds.
 | 
			
		||||
		Weight::from_parts(33_092_855, 2551)
 | 
			
		||||
		//  Measured:  `109`
 | 
			
		||||
		//  Estimated: `3574`
 | 
			
		||||
		// Minimum execution time: 43_624_000 picoseconds.
 | 
			
		||||
		Weight::from_parts(44_945_690, 0)
 | 
			
		||||
			.saturating_add(Weight::from_parts(0, 3574))
 | 
			
		||||
			// Standard Error: 3_439
 | 
			
		||||
			.saturating_add(Weight::from_parts(15_557, 0).saturating_mul(i.into()))
 | 
			
		||||
			// Standard Error: 450
 | 
			
		||||
			.saturating_add(Weight::from_parts(3_508, 0).saturating_mul(j.into()))
 | 
			
		||||
			.saturating_add(RocksDbWeight::get().reads(1))
 | 
			
		||||
			.saturating_add(RocksDbWeight::get().writes(1))
 | 
			
		||||
	}
 | 
			
		||||
	/// Storage: GhostNetworks Networks (r:1 w:1)
 | 
			
		||||
	/// Proof Skipped: GhostNetworks Networks (max_values: None, max_size: None, mode: Measured)
 | 
			
		||||
	/// Storage: `GhostNetworks::Networks` (r:1 w:1)
 | 
			
		||||
	/// Proof: `GhostNetworks::Networks` (`max_values`: None, `max_size`: None, mode: `Measured`)
 | 
			
		||||
	/// The range of component `n` is `[1, 20]`.
 | 
			
		||||
	fn update_network_name(_n: u32, ) -> Weight {
 | 
			
		||||
		// Proof Size summary in bytes:
 | 
			
		||||
		//  Measured:  `141`
 | 
			
		||||
		//  Estimated: `2616`
 | 
			
		||||
		// Minimum execution time: 34_496 nanoseconds.
 | 
			
		||||
		Weight::from_parts(35_728_230, 2616)
 | 
			
		||||
			// Standard Error: 2_591
 | 
			
		||||
		//  Measured:  `294`
 | 
			
		||||
		//  Estimated: `3759`
 | 
			
		||||
		// Minimum execution time: 48_741_000 picoseconds.
 | 
			
		||||
		Weight::from_parts(50_426_703, 0)
 | 
			
		||||
			.saturating_add(Weight::from_parts(0, 3759))
 | 
			
		||||
			.saturating_add(RocksDbWeight::get().reads(1))
 | 
			
		||||
			.saturating_add(RocksDbWeight::get().writes(1))
 | 
			
		||||
	}
 | 
			
		||||
	/// Storage: GhostNetworks Networks (r:1 w:1)
 | 
			
		||||
	/// Proof Skipped: GhostNetworks Networks (max_values: None, max_size: None, mode: Measured)
 | 
			
		||||
	/// Storage: `GhostNetworks::Networks` (r:1 w:1)
 | 
			
		||||
	/// Proof: `GhostNetworks::Networks` (`max_values`: None, `max_size`: None, mode: `Measured`)
 | 
			
		||||
	/// The range of component `n` is `[1, 150]`.
 | 
			
		||||
	fn update_network_endpoint(_n: u32, ) -> Weight {
 | 
			
		||||
	fn update_network_endpoint(n: u32, ) -> Weight {
 | 
			
		||||
		// Proof Size summary in bytes:
 | 
			
		||||
		//  Measured:  `141`
 | 
			
		||||
		//  Estimated: `2616`
 | 
			
		||||
		// Minimum execution time: 34_666 nanoseconds.
 | 
			
		||||
		Weight::from_parts(35_959_961, 2616)
 | 
			
		||||
			// Standard Error: 381
 | 
			
		||||
		//  Measured:  `294`
 | 
			
		||||
		//  Estimated: `3759`
 | 
			
		||||
		// Minimum execution time: 49_090_000 picoseconds.
 | 
			
		||||
		Weight::from_parts(50_734_447, 0)
 | 
			
		||||
			.saturating_add(Weight::from_parts(0, 3759))
 | 
			
		||||
			// Standard Error: 863
 | 
			
		||||
			.saturating_add(Weight::from_parts(786, 0).saturating_mul(n.into()))
 | 
			
		||||
			.saturating_add(RocksDbWeight::get().reads(1))
 | 
			
		||||
			.saturating_add(RocksDbWeight::get().writes(1))
 | 
			
		||||
	}
 | 
			
		||||
	/// Storage: GhostNetworks Networks (r:1 w:1)
 | 
			
		||||
	/// Proof Skipped: GhostNetworks Networks (max_values: None, max_size: None, mode: Measured)
 | 
			
		||||
	/// Storage: `GhostNetworks::Networks` (r:1 w:1)
 | 
			
		||||
	/// Proof: `GhostNetworks::Networks` (`max_values`: None, `max_size`: None, mode: `Measured`)
 | 
			
		||||
	fn update_network_finality_delay() -> Weight {
 | 
			
		||||
		// Proof Size summary in bytes:
 | 
			
		||||
		//  Measured:  `141`
 | 
			
		||||
		//  Estimated: `2616`
 | 
			
		||||
		// Minimum execution time: 33_860 nanoseconds.
 | 
			
		||||
		Weight::from_parts(34_995_000, 2616)
 | 
			
		||||
		//  Measured:  `294`
 | 
			
		||||
		//  Estimated: `3759`
 | 
			
		||||
		// Minimum execution time: 48_107_000 picoseconds.
 | 
			
		||||
		Weight::from_parts(48_993_000, 0)
 | 
			
		||||
			.saturating_add(Weight::from_parts(0, 3759))
 | 
			
		||||
			.saturating_add(RocksDbWeight::get().reads(1))
 | 
			
		||||
			.saturating_add(RocksDbWeight::get().writes(1))
 | 
			
		||||
	}
 | 
			
		||||
	/// Storage: GhostNetworks Networks (r:1 w:1)
 | 
			
		||||
	/// Proof Skipped: GhostNetworks Networks (max_values: None, max_size: None, mode: Measured)
 | 
			
		||||
	fn update_network_release_delay() -> Weight {
 | 
			
		||||
	/// Storage: `GhostNetworks::Networks` (r:1 w:1)
 | 
			
		||||
	/// Proof: `GhostNetworks::Networks` (`max_values`: None, `max_size`: None, mode: `Measured`)
 | 
			
		||||
	fn update_network_block_distance() -> Weight {
 | 
			
		||||
		// Proof Size summary in bytes:
 | 
			
		||||
		//  Measured:  `141`
 | 
			
		||||
		//  Estimated: `2616`
 | 
			
		||||
		// Minimum execution time: 33_860 nanoseconds.
 | 
			
		||||
		Weight::from_parts(34_995_000, 2616)
 | 
			
		||||
		//  Measured:  `294`
 | 
			
		||||
		//  Estimated: `3759`
 | 
			
		||||
		// Minimum execution time: 48_277_000 picoseconds.
 | 
			
		||||
		Weight::from_parts(49_393_000, 0)
 | 
			
		||||
			.saturating_add(Weight::from_parts(0, 3759))
 | 
			
		||||
			.saturating_add(RocksDbWeight::get().reads(1))
 | 
			
		||||
			.saturating_add(RocksDbWeight::get().writes(1))
 | 
			
		||||
	}
 | 
			
		||||
	/// Storage: GhostNetworks Networks (r:1 w:1)
 | 
			
		||||
	/// Proof Skipped: GhostNetworks Networks (max_values: None, max_size: None, mode: Measured)
 | 
			
		||||
	/// Storage: `GhostNetworks::Networks` (r:1 w:1)
 | 
			
		||||
	/// Proof: `GhostNetworks::Networks` (`max_values`: None, `max_size`: None, mode: `Measured`)
 | 
			
		||||
	fn update_network_type() -> Weight {
 | 
			
		||||
		// Proof Size summary in bytes:
 | 
			
		||||
		//  Measured:  `141`
 | 
			
		||||
		//  Estimated: `2616`
 | 
			
		||||
		// Minimum execution time: 34_976 nanoseconds.
 | 
			
		||||
		Weight::from_parts(36_182_000, 2616)
 | 
			
		||||
		//  Measured:  `294`
 | 
			
		||||
		//  Estimated: `3759`
 | 
			
		||||
		// Minimum execution time: 47_642_000 picoseconds.
 | 
			
		||||
		Weight::from_parts(49_212_000, 0)
 | 
			
		||||
			.saturating_add(Weight::from_parts(0, 3759))
 | 
			
		||||
			.saturating_add(RocksDbWeight::get().reads(1))
 | 
			
		||||
			.saturating_add(RocksDbWeight::get().writes(1))
 | 
			
		||||
	}
 | 
			
		||||
	/// Storage: GhostNetworks Networks (r:1 w:1)
 | 
			
		||||
	/// Proof Skipped: GhostNetworks Networks (max_values: None, max_size: None, mode: Measured)
 | 
			
		||||
	/// Storage: `GhostNetworks::Networks` (r:1 w:1)
 | 
			
		||||
	/// Proof: `GhostNetworks::Networks` (`max_values`: None, `max_size`: None, mode: `Measured`)
 | 
			
		||||
	fn update_network_gatekeeper() -> Weight {
 | 
			
		||||
		// Proof Size summary in bytes:
 | 
			
		||||
		//  Measured:  `141`
 | 
			
		||||
		//  Estimated: `2616`
 | 
			
		||||
		// Minimum execution time: 34_768 nanoseconds.
 | 
			
		||||
		Weight::from_parts(35_580_000, 2616)
 | 
			
		||||
		//  Measured:  `294`
 | 
			
		||||
		//  Estimated: `3759`
 | 
			
		||||
		// Minimum execution time: 49_440_000 picoseconds.
 | 
			
		||||
		Weight::from_parts(50_315_000, 0)
 | 
			
		||||
			.saturating_add(Weight::from_parts(0, 3759))
 | 
			
		||||
			.saturating_add(RocksDbWeight::get().reads(1))
 | 
			
		||||
			.saturating_add(RocksDbWeight::get().writes(1))
 | 
			
		||||
	}
 | 
			
		||||
	/// Storage: GhostNetworks Networks (r:1 w:1)
 | 
			
		||||
	/// Proof Skipped: GhostNetworks Networks (max_values: None, max_size: None, mode: Measured)
 | 
			
		||||
	/// Storage: `GhostNetworks::Networks` (r:1 w:1)
 | 
			
		||||
	/// Proof: `GhostNetworks::Networks` (`max_values`: None, `max_size`: None, mode: `Measured`)
 | 
			
		||||
	fn update_network_topic_name() -> Weight {
 | 
			
		||||
		// Proof Size summary in bytes:
 | 
			
		||||
		//  Measured:  `141`
 | 
			
		||||
		//  Estimated: `2616`
 | 
			
		||||
		// Minimum execution time: 34_768 nanoseconds.
 | 
			
		||||
		Weight::from_parts(35_580_000, 2616)
 | 
			
		||||
		//  Measured:  `294`
 | 
			
		||||
		//  Estimated: `3759`
 | 
			
		||||
		// Minimum execution time: 49_469_000 picoseconds.
 | 
			
		||||
		Weight::from_parts(50_532_000, 0)
 | 
			
		||||
			.saturating_add(Weight::from_parts(0, 3759))
 | 
			
		||||
			.saturating_add(RocksDbWeight::get().reads(1))
 | 
			
		||||
			.saturating_add(RocksDbWeight::get().writes(1))
 | 
			
		||||
    }
 | 
			
		||||
	/// Storage: GhostNetworks Networks (r:1 w:1)
 | 
			
		||||
	/// Proof Skipped: GhostNetworks Networks (max_values: None, max_size: None, mode: Measured)
 | 
			
		||||
	}
 | 
			
		||||
	/// Storage: `GhostNetworks::Networks` (r:1 w:1)
 | 
			
		||||
	/// Proof: `GhostNetworks::Networks` (`max_values`: None, `max_size`: None, mode: `Measured`)
 | 
			
		||||
	fn update_incoming_network_fee() -> Weight {
 | 
			
		||||
		// Proof Size summary in bytes:
 | 
			
		||||
		//  Measured:  `141`
 | 
			
		||||
		//  Estimated: `2616`
 | 
			
		||||
		// Minimum execution time: 34_768 nanoseconds.
 | 
			
		||||
		Weight::from_parts(35_580_000, 2616)
 | 
			
		||||
		//  Measured:  `294`
 | 
			
		||||
		//  Estimated: `3759`
 | 
			
		||||
		// Minimum execution time: 47_858_000 picoseconds.
 | 
			
		||||
		Weight::from_parts(48_703_000, 0)
 | 
			
		||||
			.saturating_add(Weight::from_parts(0, 3759))
 | 
			
		||||
			.saturating_add(RocksDbWeight::get().reads(1))
 | 
			
		||||
			.saturating_add(RocksDbWeight::get().writes(1))
 | 
			
		||||
    }
 | 
			
		||||
	/// Storage: GhostNetworks Networks (r:1 w:1)
 | 
			
		||||
	/// Proof Skipped: GhostNetworks Networks (max_values: None, max_size: None, mode: Measured)
 | 
			
		||||
	}
 | 
			
		||||
	/// Storage: `GhostNetworks::Networks` (r:1 w:1)
 | 
			
		||||
	/// Proof: `GhostNetworks::Networks` (`max_values`: None, `max_size`: None, mode: `Measured`)
 | 
			
		||||
	fn update_outgoing_network_fee() -> Weight {
 | 
			
		||||
		// Proof Size summary in bytes:
 | 
			
		||||
		//  Measured:  `141`
 | 
			
		||||
		//  Estimated: `2616`
 | 
			
		||||
		// Minimum execution time: 34_768 nanoseconds.
 | 
			
		||||
		Weight::from_parts(35_580_000, 2616)
 | 
			
		||||
		//  Measured:  `294`
 | 
			
		||||
		//  Estimated: `3759`
 | 
			
		||||
		// Minimum execution time: 47_895_000 picoseconds.
 | 
			
		||||
		Weight::from_parts(49_230_000, 0)
 | 
			
		||||
			.saturating_add(Weight::from_parts(0, 3759))
 | 
			
		||||
			.saturating_add(RocksDbWeight::get().reads(1))
 | 
			
		||||
			.saturating_add(RocksDbWeight::get().writes(1))
 | 
			
		||||
    }
 | 
			
		||||
	/// Storage: GhostNetworks Networks (r:1 w:1)
 | 
			
		||||
	/// Proof Skipped: GhostNetworks Networks (max_values: None, max_size: None, mode: Measured)
 | 
			
		||||
	}
 | 
			
		||||
	/// Storage: `GhostNetworks::Networks` (r:1 w:1)
 | 
			
		||||
	/// Proof: `GhostNetworks::Networks` (`max_values`: None, `max_size`: None, mode: `Measured`)
 | 
			
		||||
	fn remove_network() -> Weight {
 | 
			
		||||
		// Proof Size summary in bytes:
 | 
			
		||||
		//  Measured:  `141`
 | 
			
		||||
		//  Estimated: `2616`
 | 
			
		||||
		// Minimum execution time: 33_336 nanoseconds.
 | 
			
		||||
		Weight::from_parts(34_609_000, 2616)
 | 
			
		||||
		//  Measured:  `294`
 | 
			
		||||
		//  Estimated: `3759`
 | 
			
		||||
		// Minimum execution time: 44_052_000 picoseconds.
 | 
			
		||||
		Weight::from_parts(44_612_000, 0)
 | 
			
		||||
			.saturating_add(Weight::from_parts(0, 3759))
 | 
			
		||||
			.saturating_add(RocksDbWeight::get().reads(1))
 | 
			
		||||
			.saturating_add(RocksDbWeight::get().writes(1))
 | 
			
		||||
	}
 | 
			
		||||
 | 
			
		||||
		Loading…
	
		Reference in New Issue
	
	Block a user