From 4e92752b59bacad3f65e515d95b24d8c2e53cb45 Mon Sep 17 00:00:00 2001 From: felixfaisal Date: Mon, 12 Aug 2024 07:17:40 +0000 Subject: [PATCH 01/21] feat: add paseo runtime --- Cargo.toml | 2 + Makefile | 8 + node/Cargo.toml | 4 + node/res/genesis_info/paseo.json | 47 + node/src/chain_specs/mod.rs | 1 + node/src/chain_specs/paseo.rs | 261 +++ node/src/command.rs | 15 + runtime/paseo/Cargo.toml | 322 +++ runtime/paseo/build.rs | 25 + runtime/paseo/src/asset_config.rs | 103 + runtime/paseo/src/constants.rs | 32 + runtime/paseo/src/lib.rs | 2003 +++++++++++++++++ runtime/paseo/src/migration/P9100.rs | 301 +++ runtime/paseo/src/migration/P9130.rs | 208 ++ .../P9190/balances_transaction_payment.rs | 311 +++ .../src/migration/P9190/bridge_related.rs | 300 +++ runtime/paseo/src/migration/P9190/mod.rs | 6 + .../src/migration/P9190/parachain_staking.rs | 626 ++++++ .../paseo/src/migration/P9191/fix_balances.rs | 89 + .../src/migration/P9191/migrate_bounty.rs | 159 ++ .../src/migration/P9191/migrate_democracy.rs | 511 +++++ .../src/migration/P9191/migrate_identity.rs | 209 ++ .../src/migration/P9191/migrate_multisig.rs | 91 + .../src/migration/P9191/migrate_preimage.rs | 163 ++ .../src/migration/P9191/migrate_proxy.rs | 265 +++ .../src/migration/P9191/migrate_treasury.rs | 208 ++ .../src/migration/P9191/migrate_vesting.rs | 172 ++ runtime/paseo/src/migration/P9191/mod.rs | 33 + runtime/paseo/src/migration/P9192.rs | 164 ++ runtime/paseo/src/migration/migration.md | 40 + runtime/paseo/src/migration/mod.rs | 1 + runtime/paseo/src/precompiles.rs | 151 ++ runtime/paseo/src/tests/base_call_filter.rs | 24 + runtime/paseo/src/tests/mod.rs | 43 + runtime/paseo/src/tests/orml_xcm.rs | 74 + .../src/weights/cumulus_pallet_xcmp_queue.rs | 76 + runtime/paseo/src/weights/frame_system.rs | 132 ++ runtime/paseo/src/weights/mod.rs | 42 + .../paseo/src/weights/pallet_asset_manager.rs | 126 ++ runtime/paseo/src/weights/pallet_balances.rs | 152 ++ runtime/paseo/src/weights/pallet_bridge.rs | 163 ++ .../src/weights/pallet_bridge_transfer.rs | 69 + .../paseo/src/weights/pallet_collective.rs | 304 +++ runtime/paseo/src/weights/pallet_democracy.rs | 527 +++++ runtime/paseo/src/weights/pallet_evm.rs | 58 + .../src/weights/pallet_extrinsic_filter.rs | 90 + runtime/paseo/src/weights/pallet_identity.rs | 199 ++ .../src/weights/pallet_identity_management.rs | 163 ++ .../paseo/src/weights/pallet_membership.rs | 206 ++ runtime/paseo/src/weights/pallet_multisig.rs | 164 ++ .../src/weights/pallet_parachain_staking.rs | 718 ++++++ runtime/paseo/src/weights/pallet_preimage.rs | 217 ++ runtime/paseo/src/weights/pallet_proxy.rs | 225 ++ runtime/paseo/src/weights/pallet_scheduler.rs | 206 ++ runtime/paseo/src/weights/pallet_session.rs | 80 + runtime/paseo/src/weights/pallet_teebag.rs | 261 +++ runtime/paseo/src/weights/pallet_timestamp.rs | 76 + runtime/paseo/src/weights/pallet_treasury.rs | 153 ++ runtime/paseo/src/weights/pallet_utility.rs | 101 + .../paseo/src/weights/pallet_vc_management.rs | 178 ++ runtime/paseo/src/xcm_config.rs | 356 +++ scripts/launch-local-binary.sh | 2 +- 62 files changed, 12015 insertions(+), 1 deletion(-) create mode 100644 node/res/genesis_info/paseo.json create mode 100644 node/src/chain_specs/paseo.rs create mode 100644 runtime/paseo/Cargo.toml create mode 100644 runtime/paseo/build.rs create mode 100644 runtime/paseo/src/asset_config.rs create mode 100644 runtime/paseo/src/constants.rs create mode 100644 runtime/paseo/src/lib.rs create mode 100644 runtime/paseo/src/migration/P9100.rs create mode 100644 runtime/paseo/src/migration/P9130.rs create mode 100644 runtime/paseo/src/migration/P9190/balances_transaction_payment.rs create mode 100644 runtime/paseo/src/migration/P9190/bridge_related.rs create mode 100644 runtime/paseo/src/migration/P9190/mod.rs create mode 100644 runtime/paseo/src/migration/P9190/parachain_staking.rs create mode 100644 runtime/paseo/src/migration/P9191/fix_balances.rs create mode 100644 runtime/paseo/src/migration/P9191/migrate_bounty.rs create mode 100644 runtime/paseo/src/migration/P9191/migrate_democracy.rs create mode 100644 runtime/paseo/src/migration/P9191/migrate_identity.rs create mode 100644 runtime/paseo/src/migration/P9191/migrate_multisig.rs create mode 100644 runtime/paseo/src/migration/P9191/migrate_preimage.rs create mode 100644 runtime/paseo/src/migration/P9191/migrate_proxy.rs create mode 100644 runtime/paseo/src/migration/P9191/migrate_treasury.rs create mode 100644 runtime/paseo/src/migration/P9191/migrate_vesting.rs create mode 100644 runtime/paseo/src/migration/P9191/mod.rs create mode 100644 runtime/paseo/src/migration/P9192.rs create mode 100644 runtime/paseo/src/migration/migration.md create mode 100644 runtime/paseo/src/migration/mod.rs create mode 100644 runtime/paseo/src/precompiles.rs create mode 100644 runtime/paseo/src/tests/base_call_filter.rs create mode 100644 runtime/paseo/src/tests/mod.rs create mode 100644 runtime/paseo/src/tests/orml_xcm.rs create mode 100644 runtime/paseo/src/weights/cumulus_pallet_xcmp_queue.rs create mode 100644 runtime/paseo/src/weights/frame_system.rs create mode 100644 runtime/paseo/src/weights/mod.rs create mode 100644 runtime/paseo/src/weights/pallet_asset_manager.rs create mode 100644 runtime/paseo/src/weights/pallet_balances.rs create mode 100644 runtime/paseo/src/weights/pallet_bridge.rs create mode 100644 runtime/paseo/src/weights/pallet_bridge_transfer.rs create mode 100644 runtime/paseo/src/weights/pallet_collective.rs create mode 100644 runtime/paseo/src/weights/pallet_democracy.rs create mode 100644 runtime/paseo/src/weights/pallet_evm.rs create mode 100644 runtime/paseo/src/weights/pallet_extrinsic_filter.rs create mode 100644 runtime/paseo/src/weights/pallet_identity.rs create mode 100644 runtime/paseo/src/weights/pallet_identity_management.rs create mode 100644 runtime/paseo/src/weights/pallet_membership.rs create mode 100644 runtime/paseo/src/weights/pallet_multisig.rs create mode 100644 runtime/paseo/src/weights/pallet_parachain_staking.rs create mode 100644 runtime/paseo/src/weights/pallet_preimage.rs create mode 100644 runtime/paseo/src/weights/pallet_proxy.rs create mode 100644 runtime/paseo/src/weights/pallet_scheduler.rs create mode 100644 runtime/paseo/src/weights/pallet_session.rs create mode 100644 runtime/paseo/src/weights/pallet_teebag.rs create mode 100644 runtime/paseo/src/weights/pallet_timestamp.rs create mode 100644 runtime/paseo/src/weights/pallet_treasury.rs create mode 100644 runtime/paseo/src/weights/pallet_utility.rs create mode 100644 runtime/paseo/src/weights/pallet_vc_management.rs create mode 100644 runtime/paseo/src/xcm_config.rs diff --git a/Cargo.toml b/Cargo.toml index f1d3112594..ab4eacf2b9 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -25,6 +25,7 @@ members = [ 'runtime/litentry', 'runtime/litmus', 'runtime/rococo', + 'runtime/paseo', 'runtime/common', 'worker-pallets/parentchain', ] @@ -250,6 +251,7 @@ runtime-common = { path = "runtime/common", default-features = false } litentry-parachain-runtime = { path = "runtime/litentry", default-features = false } litmus-parachain-runtime = { path = "runtime/litmus", default-features = false } rococo-parachain-runtime = { path = "runtime/rococo", default-features = false } +paseo-parachain-runtime = { path = "runtime/paseo", default-features = false } pallet-account-fix = { path = "pallets/account-fix", default-features = false } pallet-asset-manager = { path = "pallets/xcm-asset-manager", default-features = false } pallet-assets-handler = { path = "pallets/assets-handler", default-features = false } diff --git a/Makefile b/Makefile index eceb6931e3..875b5f5954 100644 --- a/Makefile +++ b/Makefile @@ -46,6 +46,10 @@ build-runtime-litmus: build-runtime-rococo: cargo build --locked -p $(call pkgid, rococo-parachain-runtime) --release +.PHONY: build-runtime-paseo ## Build paseo release runtime +build-runtime-paseo: + cargo build --locked -p $(call pkgid, paseo-parachain-runtime) --release + .PHONY: srtool-build-wasm-litentry ## Build litentry wasm with srtools srtool-build-wasm-litentry: @./scripts/build-wasm.sh litentry @@ -108,6 +112,10 @@ launch-binary-litmus: launch-binary-rococo: @./scripts/launch-local-binary.sh rococo +.PHONY: launch-binary-paseo ## Launch a local rococo-parachain network with binaries +launch-binary-paseo: + @./scripts/launch-local-binary.sh paseo + .PHONY: launch-custom-binary-rococo ## Launch a local rococo-parachain network with binary already built under target files launch-custom-binary-rococo: @./scripts/launch-local-custom-binary.sh rococo diff --git a/node/Cargo.toml b/node/Cargo.toml index a867ac54f3..907b88bfb0 100644 --- a/node/Cargo.toml +++ b/node/Cargo.toml @@ -94,6 +94,7 @@ try-runtime-cli = { workspace = true } core-primitives = { workspace = true, features = ["std"] } litentry-parachain-runtime = { workspace = true, features = ["std"] } litmus-parachain-runtime = { workspace = true, features = ["std"] } +paseo-parachain-runtime = { workspace = true, features = ["std"] } rococo-parachain-runtime = { workspace = true, features = ["std"] } [build-dependencies] @@ -105,11 +106,13 @@ fast-runtime = [ "litentry-parachain-runtime/fast-runtime", "litmus-parachain-runtime/fast-runtime", "rococo-parachain-runtime/fast-runtime", + "paseo-parachain-runtime/fast-runtime", ] runtime-benchmarks = [ "litentry-parachain-runtime/runtime-benchmarks", "litmus-parachain-runtime/runtime-benchmarks", "rococo-parachain-runtime/runtime-benchmarks", + "paseo-parachain-runtime/runtime-benchmarks", "polkadot-service/runtime-benchmarks", "polkadot-cli/runtime-benchmarks", ] @@ -117,6 +120,7 @@ try-runtime = [ "litentry-parachain-runtime/try-runtime", "litmus-parachain-runtime/try-runtime", "rococo-parachain-runtime/try-runtime", + "paseo-parachain-runtime/try-runtime", "polkadot-service/try-runtime", "polkadot-cli/try-runtime", ] diff --git a/node/res/genesis_info/paseo.json b/node/res/genesis_info/paseo.json new file mode 100644 index 0000000000..8b34c2427c --- /dev/null +++ b/node/res/genesis_info/paseo.json @@ -0,0 +1,47 @@ +{ + "rootKey": "jcMcexZDWw6PUEeSEXAcGppmyy1mSzSvgHCmge6jYYmVma2Y7", + "invulnerables": [ + [ + "jcRVUU8svEMTtwJjX1HzySNrrVEHVnoAdNAmhnbM8ub5dfbM9", + "jcSmq9jXyvZWwJQY6cqf7fCAbnFpesph35H3iqKPgSexTLbCr" + ], + [ + "jcSQcu5RXtWXKPN78zJogNyqsff1j4ffgoJ2njNcDbZ3qNEh5", + "jcQ9fNkocehtVvSa9deQr36bnJWt656EQdN3zDgSgP7dgX2kr" + ] + ], + "candidacyBond": "16000000000000000000", + "endowedAccounts": [ + [ + "jcRVUU8svEMTtwJjX1HzySNrrVEHVnoAdNAmhnbM8ub5dfbM9", + "1000000000000000000000" + ], + [ + "jcSQcu5RXtWXKPN78zJogNyqsff1j4ffgoJ2njNcDbZ3qNEh5", + "1000000000000000000000" + ], + [ + "jcMcexZDWw6PUEeSEXAcGppmyy1mSzSvgHCmge6jYYmVma2Y7", + "1000000000000000000000" + ], + [ + "jcS2wD5jDwouCqVABGCZhVjKQQm3ZHxMYTabySfT3Pygzck9W", + "1000000000000000000000" + ] + ], + "council": [ + "jcRVUU8svEMTtwJjX1HzySNrrVEHVnoAdNAmhnbM8ub5dfbM9", + "jcSQcu5RXtWXKPN78zJogNyqsff1j4ffgoJ2njNcDbZ3qNEh5" + ], + "technicalCommittee": [ + "jcRVUU8svEMTtwJjX1HzySNrrVEHVnoAdNAmhnbM8ub5dfbM9", + "jcSQcu5RXtWXKPN78zJogNyqsff1j4ffgoJ2njNcDbZ3qNEh5" + ], + "developerCommittee": [ + "jcRVUU8svEMTtwJjX1HzySNrrVEHVnoAdNAmhnbM8ub5dfbM9", + "jcSQcu5RXtWXKPN78zJogNyqsff1j4ffgoJ2njNcDbZ3qNEh5" + ], + "telemetryEndpoints": [ + "wss://telemetry.polkadot.io/submit/" + ] +} diff --git a/node/src/chain_specs/mod.rs b/node/src/chain_specs/mod.rs index 5d8e532105..a7871d4192 100644 --- a/node/src/chain_specs/mod.rs +++ b/node/src/chain_specs/mod.rs @@ -26,6 +26,7 @@ use sp_runtime::traits::{IdentifyAccount, Verify}; pub mod litentry; pub mod litmus; +pub mod paseo; pub mod rococo; // This is a default chain spec using litentry genesis config diff --git a/node/src/chain_specs/paseo.rs b/node/src/chain_specs/paseo.rs new file mode 100644 index 0000000000..8a0d40234f --- /dev/null +++ b/node/src/chain_specs/paseo.rs @@ -0,0 +1,261 @@ +// Copyright 2020-2024 Trust Computing GmbH. +// This file is part of Litentry. +// +// Litentry is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Litentry 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 +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Litentry. If not, see . + +use super::*; +use cumulus_primitives_core::ParaId; +use paseo_parachain_runtime::{ + AccountId, AuraId, Balance, BalancesConfig, BitacrossConfig, CouncilMembershipConfig, + DeveloperCommitteeMembershipConfig, GenesisConfig, ParachainInfoConfig, ParachainStakingConfig, + PolkadotXcmConfig, SessionConfig, SudoConfig, SystemConfig, TechnicalCommitteeMembershipConfig, + TeebagConfig, TeebagOperationalMode, VCManagementConfig, UNIT, WASM_BINARY, +}; +use sc_service::ChainType; +use sc_telemetry::TelemetryEndpoints; +use serde::Deserialize; +use sp_core::sr25519; + +const DEFAULT_PARA_ID: u32 = 2106; + +/// Specialized `ChainSpec` for the normal parachain runtime. +pub type ChainSpec = sc_service::GenericChainSpec; + +/// The default XCM version to set in genesis config. +const SAFE_XCM_VERSION: u32 = xcm::prelude::XCM_VERSION; + +/// Get default parachain properties for Rococo which will be filled into chain spec +/// Currently, we use 131 as the SS58Prefix (same as Litmus) +fn default_parachain_properties() -> Option { + parachain_properties("LIT", 18, 131) +} + +const DEFAULT_ENDOWED_ACCOUNT_BALANCE: Balance = 1000 * UNIT; + +/// GenesisInfo struct to store the parsed genesis_info JSON +#[derive(Deserialize, Debug, Clone)] +#[serde(rename_all = "camelCase")] +struct GenesisInfo { + root_key: AccountId, + invulnerables: Vec<(AccountId, AuraId)>, + endowed_accounts: Vec<(AccountId, String)>, + council: Vec, + technical_committee: Vec, + developer_committee: Vec, + boot_nodes: Vec, + telemetry_endpoints: Vec, +} + +pub fn get_chain_spec_dev(is_standalone: bool) -> ChainSpec { + let id = if is_standalone { "standalone" } else { "litentry-paseo-dev" }; + ChainSpec::from_genesis( + "Litentry-paseo-dev", + id, + ChainType::Development, + move || { + generate_genesis( + get_account_id_from_seed::("Alice"), + vec![( + get_account_id_from_seed::("Alice"), + get_collator_keys_from_seed("Alice"), + )], + vec![ + ( + get_account_id_from_seed::("Alice"), + DEFAULT_ENDOWED_ACCOUNT_BALANCE, + ), + ( + get_account_id_from_seed::("Bob"), + DEFAULT_ENDOWED_ACCOUNT_BALANCE, + ), + ( + get_account_id_from_seed::("Charlie"), + DEFAULT_ENDOWED_ACCOUNT_BALANCE, + ), + ( + get_account_id_from_seed::("Eve"), + DEFAULT_ENDOWED_ACCOUNT_BALANCE, + ), + ], + vec![ + get_account_id_from_seed::("Alice"), + get_account_id_from_seed::("Bob"), + ], + vec![get_account_id_from_seed::("Alice")], + vec![get_account_id_from_seed::("Alice")], + DEFAULT_PARA_ID.into(), + ) + }, + Vec::new(), + None, + Some("litentry-paseo"), + None, + default_parachain_properties(), + Extensions { relay_chain: "rococo-local".into(), para_id: DEFAULT_PARA_ID }, + ) +} + +pub fn get_chain_spec_staging() -> ChainSpec { + // Staging keys are derivative keys based on a single master secret phrase: + // + // root: $SECRET + // account: $SECRET//collator// + // aura: $SECRET//collator////aura + get_chain_spec_from_genesis_info( + include_bytes!("../../res/genesis_info/staging.json"), + "Litentry-paseo-staging", + "litentry-paseo-staging", + ChainType::Local, + "rococo-local".into(), + DEFAULT_PARA_ID.into(), + ) +} + +pub fn get_chain_spec_prod() -> ChainSpec { + get_chain_spec_from_genesis_info( + include_bytes!("../../res/genesis_info/paseo.json"), + "Litentry-paseo", + "litentry-paseo", + ChainType::Live, + "paseo".into(), + DEFAULT_PARA_ID.into(), + ) +} + +/// Private function to get a ChainSpec from a `genesis_info_json_file`, +/// used in both staging and prod env. +fn get_chain_spec_from_genesis_info( + genesis_info_bytes: &[u8], + name: &str, + id: &str, + chain_type: ChainType, + relay_chain_name: String, + para_id: ParaId, +) -> ChainSpec { + let genesis_info: GenesisInfo = + serde_json::from_slice(genesis_info_bytes).expect("Invalid GenesisInfo; qed."); + + let boot_nodes = genesis_info.boot_nodes.clone(); + let telemetry_endpoints = genesis_info.telemetry_endpoints.clone(); + + ChainSpec::from_genesis( + name, + id, + chain_type, + move || { + use std::str::FromStr; + let genesis_info_cloned = genesis_info.clone(); + generate_genesis( + genesis_info_cloned.root_key, + genesis_info_cloned.invulnerables, + genesis_info_cloned + .endowed_accounts + .into_iter() + .map(|(k, b)| (k, u128::from_str(&b).expect("Bad endowed balance; qed."))) + .collect(), + genesis_info_cloned.council, + genesis_info_cloned.technical_committee, + genesis_info_cloned.developer_committee, + para_id, + ) + }, + boot_nodes + .into_iter() + .map(|k| k.parse().expect("Wrong bootnode format; qed.")) + .collect(), + Some( + TelemetryEndpoints::new( + telemetry_endpoints + .into_iter() + .map(|k| (k, 0)) // 0 is verbose level + .collect(), + ) + .expect("Invalid telemetry URL; qed."), + ), + Some("litentry-paseo"), + None, + default_parachain_properties(), + Extensions { relay_chain: relay_chain_name, para_id: para_id.into() }, + ) +} + +fn generate_genesis( + root_key: AccountId, + invulnerables: Vec<(AccountId, AuraId)>, + endowed_accounts: Vec<(AccountId, Balance)>, + council_members: Vec, + technical_committee_members: Vec, + developer_committee_members: Vec, + id: ParaId, +) -> GenesisConfig { + GenesisConfig { + system: SystemConfig { + code: WASM_BINARY.expect("WASM binary was not build, please build it!").to_vec(), + }, + balances: BalancesConfig { balances: endowed_accounts }, + sudo: SudoConfig { key: Some(root_key.clone()) }, + parachain_info: ParachainInfoConfig { parachain_id: id }, + parachain_staking: ParachainStakingConfig { + candidates: invulnerables.iter().cloned().map(|(acc, _)| (acc, 50 * UNIT)).collect(), + ..Default::default() + }, + session: SessionConfig { + keys: invulnerables + .iter() + .cloned() + .map(|(acc, aura)| { + ( + acc.clone(), // account id + acc, // validator id + paseo_parachain_runtime::SessionKeys { aura }, // session keys + ) + }) + .collect(), + }, + democracy: Default::default(), + council: Default::default(), + council_membership: CouncilMembershipConfig { + members: council_members.try_into().expect("error convert to BoundedVec"), + phantom: Default::default(), + }, + technical_committee: Default::default(), + technical_committee_membership: TechnicalCommitteeMembershipConfig { + members: technical_committee_members.try_into().expect("error convert to BoundedVec"), + phantom: Default::default(), + }, + developer_committee: Default::default(), + developer_committee_membership: DeveloperCommitteeMembershipConfig { + members: developer_committee_members.try_into().expect("error convert to BoundedVec"), + phantom: Default::default(), + }, + treasury: Default::default(), + vesting: Default::default(), + aura: Default::default(), + aura_ext: Default::default(), + parachain_system: Default::default(), + polkadot_xcm: PolkadotXcmConfig { safe_xcm_version: Some(SAFE_XCM_VERSION) }, + vc_management: VCManagementConfig { admin: Some(root_key.clone()) }, + transaction_payment: Default::default(), + assets: Default::default(), + ethereum: Default::default(), + evm: Default::default(), + teebag: TeebagConfig { + allow_sgx_debug_mode: true, + admin: Some(root_key.clone()), + mode: TeebagOperationalMode::Development, + }, + bitacross: BitacrossConfig { admin: Some(root_key) }, + score_staking: Default::default(), + } +} diff --git a/node/src/command.rs b/node/src/command.rs index 1c84479896..4d8a2b9c34 100644 --- a/node/src/command.rs +++ b/node/src/command.rs @@ -40,6 +40,7 @@ trait IdentifyChain { fn is_litentry(&self) -> bool; fn is_litmus(&self) -> bool; fn is_rococo(&self) -> bool; + fn is_paseo(&self) -> bool; fn is_dev(&self) -> bool; fn is_standalone(&self) -> bool; } @@ -57,6 +58,9 @@ impl IdentifyChain for dyn sc_service::ChainSpec { fn is_rococo(&self) -> bool { self.id().starts_with("litentry-rococo") } + fn is_paseo(&self) -> bool { + self.id().starts_with("litentry-paseo") + } fn is_dev(&self) -> bool { self.id().ends_with("dev") } @@ -75,6 +79,9 @@ impl IdentifyChain for T { fn is_rococo(&self) -> bool { ::is_rococo(self) } + fn is_paseo(&self) -> bool { + ::is_paseo(self) + } fn is_dev(&self) -> bool { ::is_dev(self) } @@ -106,10 +113,18 @@ fn load_spec(id: &str) -> std::result::Result, St "rococo" => Box::new(chain_specs::rococo::ChainSpec::from_json_bytes( &include_bytes!("../res/chain_specs/rococo.json")[..], )?), + // Paseo + "paseo-dev" => Box::new(chain_specs::paseo::get_chain_spec_dev(false)), + "paseo-staging" => Box::new(chain_specs::paseo::get_chain_spec_staging()), + "paseo" => Box::new(chain_specs::paseo::ChainSpec::from_json_bytes( + &include_bytes!("../res/chain_specs/rococo.json")[..], + )?), // Generate res/chain_specs/litentry.json "generate-litentry" => Box::new(chain_specs::litentry::get_chain_spec_prod()), // Generate res/chain_specs/litmus.json "generate-litmus" => Box::new(chain_specs::litmus::get_chain_spec_prod()), + // Generate res/chain_specs/paseo.json + "generate-paseo" => Box::new(chain_specs::paseo::get_chain_spec_prod()), // Generate res/chain_specs/rococo.json // Deprecated: for rococo we are using a new chain spec which was restored from an old state // see https://github.com/paritytech/subport/issues/337#issuecomment-1137882912 diff --git a/runtime/paseo/Cargo.toml b/runtime/paseo/Cargo.toml new file mode 100644 index 0000000000..74c22fd776 --- /dev/null +++ b/runtime/paseo/Cargo.toml @@ -0,0 +1,322 @@ +[package] +authors = ["Trust Computing GmbH "] +edition = '2021' +name = 'paseo-parachain-runtime' +version = '0.1.0' + +[dependencies] +hex-literal = { workspace = true } +log = { workspace = true } +num_enum = { workspace = true } +parity-scale-codec = { workspace = true } +scale-info = { workspace = true } + +sp-api = { workspace = true } +sp-block-builder = { workspace = true } +sp-consensus-aura = { workspace = true } +sp-core = { workspace = true } +sp-inherents = { workspace = true } +sp-io = { workspace = true } +sp-offchain = { workspace = true } +sp-runtime = { workspace = true } +sp-session = { workspace = true } +sp-std = { workspace = true } +sp-transaction-pool = { workspace = true } +sp-version = { workspace = true } + +frame-executive = { workspace = true } +frame-support = { workspace = true } +frame-system = { workspace = true } +frame-system-rpc-runtime-api = { workspace = true } +frame-try-runtime = { workspace = true, optional = true } + +pallet-aura = { workspace = true } +pallet-authorship = { workspace = true } +pallet-balances = { workspace = true } +pallet-bounties = { workspace = true } +pallet-collective = { workspace = true } +pallet-democracy = { workspace = true } +pallet-identity = { workspace = true } +pallet-membership = { workspace = true } +pallet-multisig = { workspace = true } +pallet-preimage = { workspace = true } +pallet-proxy = { workspace = true } +pallet-scheduler = { workspace = true } +pallet-session = { workspace = true } +pallet-sudo = { workspace = true } +pallet-timestamp = { workspace = true } +pallet-tips = { workspace = true } +pallet-transaction-payment = { workspace = true } +pallet-transaction-payment-rpc-runtime-api = { workspace = true } +pallet-treasury = { workspace = true } +pallet-utility = { workspace = true } +pallet-vesting = { workspace = true } + +cumulus-pallet-aura-ext = { workspace = true } +cumulus-pallet-dmp-queue = { workspace = true } +cumulus-pallet-parachain-system = { workspace = true } +cumulus-pallet-xcm = { workspace = true } +cumulus-pallet-xcmp-queue = { workspace = true } +cumulus-primitives-core = { workspace = true } +cumulus-primitives-timestamp = { workspace = true } +cumulus-primitives-utility = { workspace = true } +parachain-info = { workspace = true } + +pallet-xcm = { workspace = true } +polkadot-parachain = { workspace = true } +xcm = { workspace = true } +xcm-builder = { workspace = true } +xcm-executor = { workspace = true } + +orml-traits = { workspace = true } +orml-xtokens = { workspace = true } + +cumulus-pallet-session-benchmarking = { workspace = true, optional = true } +frame-benchmarking = { workspace = true, optional = true } +frame-system-benchmarking = { workspace = true, optional = true } + +core-primitives = { workspace = true } +pallet-account-fix = { workspace = true } +pallet-asset-manager = { workspace = true } +pallet-assets = { workspace = true } +pallet-assets-handler = { workspace = true } +pallet-bitacross = { workspace = true } +pallet-bridge = { workspace = true } +pallet-bridge-transfer = { workspace = true } +pallet-evm-assertions = { workspace = true } +pallet-extrinsic-filter = { workspace = true } +pallet-group = { workspace = true } +pallet-identity-management = { workspace = true } +pallet-parachain-staking = { workspace = true } +pallet-score-staking = { workspace = true } +pallet-teebag = { workspace = true } +pallet-vc-management = { workspace = true } +runtime-common = { workspace = true } + +fp-evm = { workspace = true } +fp-rpc = { workspace = true } +fp-self-contained = { workspace = true } +pallet-ethereum = { workspace = true } +pallet-evm = { workspace = true } +pallet-evm-precompile-assets-erc20 = { workspace = true } +pallet-evm-precompile-blake2 = { workspace = true } +pallet-evm-precompile-bn128 = { workspace = true } +pallet-evm-precompile-dispatch = { workspace = true } +pallet-evm-precompile-ed25519 = { workspace = true } +pallet-evm-precompile-modexp = { workspace = true } +pallet-evm-precompile-sha3fips = { workspace = true } +pallet-evm-precompile-simple = { workspace = true } + +pallet-evm-precompile-bridge-transfer = { workspace = true } +pallet-evm-precompile-parachain-staking = { workspace = true } +pallet-evm-precompile-score-staking = { workspace = true } + +moonbeam-evm-tracer = { workspace = true } +moonbeam-rpc-primitives-debug = { workspace = true } +moonbeam-rpc-primitives-txpool = { workspace = true } +precompile-utils = { workspace = true } + +[dev-dependencies] +cumulus-primitives-parachain-inherent = { workspace = true, features = ["std"] } +polkadot-primitives = { workspace = true, features = ["std"] } +polkadot-runtime-parachains = { workspace = true, features = ["std"] } +runtime-common = { workspace = true, features = ["tests"] } +sp-state-machine = { workspace = true, features = ["std"] } +xcm-simulator = { workspace = true } + +[build-dependencies] +substrate-wasm-builder = { workspace = true } + +[features] +default = ["std"] +fast-runtime = [] +runtime-benchmarks = [ + "cumulus-pallet-session-benchmarking/runtime-benchmarks", + "frame-benchmarking/runtime-benchmarks", + "frame-support/runtime-benchmarks", + "frame-system-benchmarking/runtime-benchmarks", + "frame-system/runtime-benchmarks", + "pallet-asset-manager/runtime-benchmarks", + "pallet-assets-handler/runtime-benchmarks", + "pallet-balances/runtime-benchmarks", + "pallet-bounties/runtime-benchmarks", + "pallet-collective/runtime-benchmarks", + "pallet-democracy/runtime-benchmarks", + "pallet-ethereum/runtime-benchmarks", + "pallet-evm/runtime-benchmarks", + "pallet-identity/runtime-benchmarks", + "pallet-membership/runtime-benchmarks", + "pallet-multisig/runtime-benchmarks", + "pallet-parachain-staking/runtime-benchmarks", + "pallet-preimage/runtime-benchmarks", + "pallet-proxy/runtime-benchmarks", + "pallet-scheduler/runtime-benchmarks", + "pallet-timestamp/runtime-benchmarks", + "pallet-tips/runtime-benchmarks", + "pallet-treasury/runtime-benchmarks", + "pallet-utility/runtime-benchmarks", + "pallet-xcm/runtime-benchmarks", + "runtime-common/runtime-benchmarks", + "sp-runtime/runtime-benchmarks", + "xcm-builder/runtime-benchmarks", + "pallet-bridge/runtime-benchmarks", + "pallet-bridge-transfer/runtime-benchmarks", + "pallet-extrinsic-filter/runtime-benchmarks", + "cumulus-pallet-xcmp-queue/runtime-benchmarks", + "pallet-group/runtime-benchmarks", + "pallet-identity-management/runtime-benchmarks", + "pallet-teebag/runtime-benchmarks", + "pallet-vc-management/runtime-benchmarks", + "pallet-account-fix/runtime-benchmarks", + "pallet-score-staking/runtime-benchmarks", +] +std = [ + "parity-scale-codec/std", + "log/std", + "scale-info/std", + "sp-api/std", + "sp-block-builder/std", + "sp-consensus-aura/std", + "sp-core/std", + "sp-inherents/std", + "sp-io/std", + "sp-offchain/std", + "sp-runtime/std", + "sp-session/std", + "sp-std/std", + "sp-transaction-pool/std", + "sp-version/std", + "frame-executive/std", + "frame-support/std", + "frame-system/std", + "frame-try-runtime?/std", + "frame-system-rpc-runtime-api/std", + "orml-traits/std", + "orml-xtokens/std", + "pallet-asset-manager/std", + "pallet-assets/std", + "pallet-assets-handler/std", + "pallet-aura/std", + "pallet-authorship/std", + "pallet-balances/std", + "pallet-bounties/std", + "pallet-collective/std", + "pallet-democracy/std", + "pallet-ethereum/std", + "pallet-evm/std", + "pallet-evm-precompile-assets-erc20/std", + "pallet-evm-precompile-blake2/std", + "pallet-evm-precompile-simple/std", + "pallet-evm-precompile-bn128/std", + "pallet-evm-precompile-dispatch/std", + "pallet-evm-precompile-ed25519/std", + "pallet-evm-precompile-modexp/std", + "pallet-evm-precompile-sha3fips/std", + "pallet-evm-precompile-bridge-transfer/std", + "pallet-evm-precompile-parachain-staking/std", + "pallet-evm-precompile-score-staking/std", + "pallet-identity/std", + "pallet-membership/std", + "pallet-multisig/std", + "pallet-parachain-staking/std", + "pallet-preimage/std", + "pallet-proxy/std", + "pallet-scheduler/std", + "pallet-session/std", + "pallet-sudo/std", + "pallet-timestamp/std", + "pallet-tips/std", + "pallet-transaction-payment/std", + "pallet-transaction-payment-rpc-runtime-api/std", + "pallet-treasury/std", + "pallet-utility/std", + "pallet-vesting/std", + "core-primitives/std", + "cumulus-pallet-aura-ext/std", + "cumulus-pallet-dmp-queue/std", + "cumulus-pallet-parachain-system/std", + "cumulus-pallet-xcm/std", + "cumulus-pallet-xcmp-queue/std", + "cumulus-primitives-core/std", + "cumulus-primitives-utility/std", + "cumulus-primitives-timestamp/std", + "parachain-info/std", + "pallet-xcm/std", + "polkadot-parachain/std", + "xcm/std", + "xcm-builder/std", + "xcm-executor/std", + "fp-evm/std", + "fp-rpc/std", + "fp-self-contained/std", + "frame-benchmarking?/std", + "frame-system-benchmarking?/std", + 'runtime-common/std', + "pallet-bridge/std", + "pallet-bridge-transfer/std", + "pallet-extrinsic-filter/std", + "pallet-group/std", + "pallet-identity-management/std", + "pallet-score-staking/std", + "pallet-teebag/std", + "pallet-vc-management/std", + "pallet-account-fix/std", + "moonbeam-evm-tracer/std", + "moonbeam-rpc-primitives-debug/std", + "moonbeam-rpc-primitives-txpool/std", + "pallet-bitacross/std", + "precompile-utils/std", +] +try-runtime = [ + "cumulus-pallet-aura-ext/try-runtime", + "cumulus-pallet-dmp-queue/try-runtime", + "cumulus-pallet-parachain-system/try-runtime", + "cumulus-pallet-xcm/try-runtime", + "cumulus-pallet-xcmp-queue/try-runtime", + "fp-self-contained/try-runtime", + "frame-executive/try-runtime", + "frame-support/try-runtime", + "frame-system/try-runtime", + "frame-try-runtime", + "orml-xtokens/try-runtime", + "pallet-account-fix/try-runtime", + "pallet-asset-manager/try-runtime", + "pallet-assets/try-runtime", + "pallet-assets-handler/try-runtime", + "pallet-aura/try-runtime", + "pallet-authorship/try-runtime", + "pallet-balances/try-runtime", + "pallet-bitacross/try-runtime", + "pallet-bounties/try-runtime", + "pallet-bridge/try-runtime", + "pallet-bridge-transfer/try-runtime", + "pallet-collective/try-runtime", + "pallet-democracy/try-runtime", + "pallet-ethereum/try-runtime", + "pallet-evm/try-runtime", + "pallet-evm-assertions/try-runtime", + "pallet-identity/try-runtime", + "pallet-extrinsic-filter/try-runtime", + "pallet-identity/try-runtime", + "pallet-group/try-runtime", + "pallet-identity-management/try-runtime", + "pallet-membership/try-runtime", + "pallet-multisig/try-runtime", + "pallet-parachain-staking/try-runtime", + "pallet-preimage/try-runtime", + "pallet-proxy/try-runtime", + "pallet-scheduler/try-runtime", + "pallet-score-staking/try-runtime", + "pallet-session/try-runtime", + "pallet-sudo/try-runtime", + "pallet-teebag/try-runtime", + "pallet-timestamp/try-runtime", + "pallet-tips/try-runtime", + "pallet-transaction-payment/try-runtime", + "pallet-treasury/try-runtime", + "pallet-utility/try-runtime", + "pallet-vc-management/try-runtime", + "pallet-vesting/try-runtime", + "pallet-xcm/try-runtime", + "parachain-info/try-runtime", +] diff --git a/runtime/paseo/build.rs b/runtime/paseo/build.rs new file mode 100644 index 0000000000..3ccbec6b26 --- /dev/null +++ b/runtime/paseo/build.rs @@ -0,0 +1,25 @@ +// Copyright 2020-2024 Trust Computing GmbH. +// This file is part of Litentry. +// +// Litentry is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Litentry 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 +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Litentry. If not, see . + +use substrate_wasm_builder::WasmBuilder; + +fn main() { + WasmBuilder::new() + .with_current_project() + .export_heap_base() + .import_memory() + .build() +} diff --git a/runtime/paseo/src/asset_config.rs b/runtime/paseo/src/asset_config.rs new file mode 100644 index 0000000000..b86fd07517 --- /dev/null +++ b/runtime/paseo/src/asset_config.rs @@ -0,0 +1,103 @@ +use super::{ + weights, AccountId, AssetId, Balance, Balances, Runtime, RuntimeEvent, TreasuryPalletId, +}; +use crate::{constants::currency::deposit, precompiles::ASSET_PRECOMPILE_ADDRESS_PREFIX}; +use frame_support::{ + parameter_types, + traits::{AsEnsureOriginWithArg, ConstU32, NeverEnsureOrigin}, +}; +use frame_system::EnsureRoot; +use pallet_evm_precompile_assets_erc20::AddressToAssetId; +use parity_scale_codec::Compact; +use runtime_common::{ + currency::{DOLLARS, EXISTENTIAL_DEPOSIT}, + xcm_impl::CurrencyId, + EnsureRootOrHalfCouncil, +}; +use sp_core::{ConstU128, H160}; +use sp_runtime::traits::AccountIdConversion; +use sp_std::prelude::*; + +pub fn get_all_module_accounts() -> Vec { + // Add whitelist here, usually this is the system account like treasury + vec![] +} + +parameter_types! { + pub LitTreasuryAccount: AccountId = TreasuryPalletId::get().into_account_truncating(); +} + +parameter_types! { + pub const AssetDeposit: Balance = 1 * DOLLARS; + pub const AssetsStringLimit: u32 = 50; + /// Key = 32 bytes, Value = 36 bytes (32+1+1+1+1) + // https://github.com/paritytech/substrate/blob/069917b/frame/assets/src/lib.rs#L257L271 + pub const MetadataDepositBase: Balance = deposit(1, 68); + pub const MetadataDepositPerByte: Balance = deposit(0, 1); + pub const AssetAccountDeposit: Balance = deposit(1, 18); +} + +impl AddressToAssetId for Runtime { + fn address_to_asset_id(address: H160) -> Option { + let mut data = [0u8; 16]; + let address_bytes: [u8; 20] = address.into(); + if ASSET_PRECOMPILE_ADDRESS_PREFIX.eq(&address_bytes[0..4]) { + data.copy_from_slice(&address_bytes[4..20]); + Some(u128::from_be_bytes(data)) + } else { + None + } + } + + fn asset_id_to_address(asset_id: AssetId) -> H160 { + let mut data = [0u8; 20]; + data[0..4].copy_from_slice(ASSET_PRECOMPILE_ADDRESS_PREFIX); + data[4..20].copy_from_slice(&asset_id.to_be_bytes()); + H160::from(data) + } +} + +pub struct AssetsBenchmarkHelper; +#[cfg(feature = "runtime-benchmarks")] +impl> pallet_assets::BenchmarkHelper + for AssetsBenchmarkHelper +{ + fn create_asset_id_parameter(id: u32) -> AssetIdParameter { + AssetId::from(id).into() + } +} + +impl pallet_assets::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type Balance = Balance; + type AssetId = AssetId; + type Currency = Balances; + // TODO: We do not allow creating by regular users before pallet_asset_manager fully adopted + // P-937 + type CreateOrigin = AsEnsureOriginWithArg>; + type ForceOrigin = EnsureRoot; + type AssetDeposit = AssetDeposit; + type MetadataDepositBase = MetadataDepositBase; + type MetadataDepositPerByte = MetadataDepositPerByte; + type AssetAccountDeposit = AssetAccountDeposit; + type ApprovalDeposit = ConstU128<{ EXISTENTIAL_DEPOSIT }>; + type StringLimit = AssetsStringLimit; + type Freezer = (); + type Extra = (); + type WeightInfo = pallet_assets::weights::SubstrateWeight; + type RemoveItemsLimit = ConstU32<1000>; + type AssetIdParameter = Compact; + type CallbackHandle = (); + #[cfg(feature = "runtime-benchmarks")] + type BenchmarkHelper = AssetsBenchmarkHelper; +} + +impl pallet_asset_manager::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type Balance = Balance; + type AssetId = AssetId; + type ForeignAssetType = CurrencyId; + type ForeignAssetModifierOrigin = EnsureRootOrHalfCouncil; + type Currency = Balances; + type WeightInfo = weights::pallet_asset_manager::WeightInfo; +} diff --git a/runtime/paseo/src/constants.rs b/runtime/paseo/src/constants.rs new file mode 100644 index 0000000000..b24f3ddb51 --- /dev/null +++ b/runtime/paseo/src/constants.rs @@ -0,0 +1,32 @@ +// Copyright 2020-2024 Trust Computing GmbH. +// This file is part of Litentry. +// +// Litentry is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Litentry 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 +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Litentry. If not, see . + +/// Money matters. +pub mod currency { + use crate::Balance; + use runtime_common::currency::{DOLLARS, MILLICENTS}; + + // Linear ratio of transaction fee distribution + // It is recommended to set sum of ratio to 100, yet only decimal loss is concerned. + pub const TREASURY_PROPORTION: u32 = 40u32; + pub const AUTHOR_PROPORTION: u32 = 0u32; + pub const BURNED_PROPORTION: u32 = 60u32; + + /// Function used in some fee configurations + pub const fn deposit(items: u32, bytes: u32) -> Balance { + items as Balance * DOLLARS + (bytes as Balance) * 100 * MILLICENTS + } +} diff --git a/runtime/paseo/src/lib.rs b/runtime/paseo/src/lib.rs new file mode 100644 index 0000000000..7b3ae824c8 --- /dev/null +++ b/runtime/paseo/src/lib.rs @@ -0,0 +1,2003 @@ +// Copyright 2020-2024 Trust Computing GmbH. +// This file is part of Litentry. +// +// Litentry is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Litentry 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 +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Litentry. If not, see . + +#![cfg_attr(not(feature = "std"), no_std)] +#![allow(clippy::identity_op)] +#![allow(clippy::items_after_test_module)] +// `construct_runtime!` does a lot of recursion and requires us to increase the limit to 256. +#![recursion_limit = "512"] + +#[cfg(feature = "runtime-benchmarks")] +#[macro_use] +extern crate frame_benchmarking; + +use cumulus_pallet_parachain_system::RelayNumberStrictlyIncreases; +use frame_support::{ + construct_runtime, parameter_types, + traits::{ + ConstU128, ConstU32, ConstU64, ConstU8, Contains, ContainsLengthBound, EnsureOrigin, + Everything, FindAuthor, InstanceFilter, OnFinalize, SortedMembers, WithdrawReasons, + }, + weights::{constants::RocksDbWeight, ConstantMultiplier, Weight}, + ConsensusEngineId, PalletId, RuntimeDebug, +}; +use frame_system::EnsureRoot; +use hex_literal::hex; +use parity_scale_codec::{Decode, Encode, MaxEncodedLen}; + +use runtime_common::EnsureEnclaveSigner; +// for TEE +pub use pallet_balances::Call as BalancesCall; +pub use pallet_teebag::{self, OperationalMode as TeebagOperationalMode}; + +use sp_api::impl_runtime_apis; +pub use sp_consensus_aura::sr25519::AuthorityId as AuraId; +use sp_core::{crypto::KeyTypeId, OpaqueMetadata, H160, H256, U256}; +#[cfg(any(feature = "std", test))] +pub use sp_runtime::BuildStorage; +use sp_runtime::{ + create_runtime_str, generic, impl_opaque_keys, + traits::{ + AccountIdConversion, AccountIdLookup, BlakeTwo256, Block as BlockT, ConvertInto, + DispatchInfoOf, Dispatchable, PostDispatchInfoOf, UniqueSaturatedInto, + }, + transaction_validity::{TransactionSource, TransactionValidity, TransactionValidityError}, + ApplyExtrinsicResult, +}; +pub use sp_runtime::{MultiAddress, Perbill, Percent, Permill}; +use sp_std::prelude::*; +#[cfg(feature = "std")] +use sp_version::NativeVersion; +use sp_version::RuntimeVersion; +// XCM Imports +use xcm_executor::XcmExecutor; + +pub use constants::currency::deposit; +pub use core_primitives::{ + opaque, AccountId, Amount, AssetId, Balance, BlockNumber, Hash, Header, Index, Signature, DAYS, + HOURS, MINUTES, SLOT_DURATION, +}; +pub use runtime_common::currency::*; + +use runtime_common::{ + impl_runtime_transaction_payment_fees, prod_or_fast, BlockHashCount, BlockLength, + CouncilInstance, CouncilMembershipInstance, DeveloperCommitteeInstance, + DeveloperCommitteeMembershipInstance, EnsureRootOrAllCouncil, + EnsureRootOrAllTechnicalCommittee, EnsureRootOrHalfCouncil, EnsureRootOrHalfTechnicalCommittee, + EnsureRootOrTwoThirdsCouncil, EnsureRootOrTwoThirdsTechnicalCommittee, + IMPExtrinsicWhitelistInstance, NegativeImbalance, RuntimeBlockWeights, SlowAdjustingFeeUpdate, + TechnicalCommitteeInstance, TechnicalCommitteeMembershipInstance, + VCMPExtrinsicWhitelistInstance, MAXIMUM_BLOCK_WEIGHT, NORMAL_DISPATCH_RATIO, WEIGHT_PER_GAS, + WEIGHT_TO_FEE_FACTOR, +}; +use xcm_config::{XcmConfig, XcmOriginToTransactDispatchOrigin}; + +use pallet_ethereum::{Call::transact, PostLogContent, TransactionStatus}; +use pallet_evm::{ + EVMCurrencyAdapter, FeeCalculator, GasWeightMapping, + OnChargeEVMTransaction as OnChargeEVMTransactionT, Runner, +}; +// Make the WASM binary available. +#[cfg(feature = "std")] +include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs")); + +pub mod asset_config; +pub mod constants; +pub mod precompiles; + +pub mod migration; + +#[cfg(test)] +mod tests; +pub mod weights; +pub mod xcm_config; + +pub use precompiles::RococoNetworkPrecompiles; +pub type Precompiles = RococoNetworkPrecompiles; + +#[derive(Clone)] +pub struct TransactionConverter; + +impl fp_rpc::ConvertTransaction for TransactionConverter { + fn convert_transaction(&self, transaction: pallet_ethereum::Transaction) -> UncheckedExtrinsic { + UncheckedExtrinsic::new_unsigned( + pallet_ethereum::Call::::transact { transaction }.into(), + ) + } +} + +impl fp_rpc::ConvertTransaction for TransactionConverter { + fn convert_transaction( + &self, + transaction: pallet_ethereum::Transaction, + ) -> opaque::UncheckedExtrinsic { + let extrinsic = UncheckedExtrinsic::new_unsigned( + pallet_ethereum::Call::::transact { transaction }.into(), + ); + let encoded = extrinsic.encode(); + opaque::UncheckedExtrinsic::decode(&mut &encoded[..]) + .expect("Encoded extrinsic is always valid") + } +} + +/// The address format for describing accounts. +pub type Address = MultiAddress; + +/// Block type as expected by this runtime. +pub type Block = generic::Block; + +/// A Block signed with a Justification +pub type SignedBlock = generic::SignedBlock; + +/// BlockId type as expected by this runtime. +pub type BlockId = generic::BlockId; + +/// The SignedExtension to the basic transaction logic. +pub type SignedExtra = ( + frame_system::CheckNonZeroSender, + frame_system::CheckSpecVersion, + frame_system::CheckTxVersion, + frame_system::CheckGenesis, + frame_system::CheckEra, + frame_system::CheckNonce, + frame_system::CheckWeight, + pallet_transaction_payment::ChargeTransactionPayment, +); + +/// Unchecked extrinsic type as expected by this runtime. +pub type UncheckedExtrinsic = + fp_self_contained::UncheckedExtrinsic; +/// Extrinsic type that has already been checked. +pub type CheckedExtrinsic = + fp_self_contained::CheckedExtrinsic; + +/// Executive: handles dispatch to the various modules. +pub type Executive = frame_executive::Executive< + Runtime, + Block, + frame_system::ChainContext, + Runtime, + // see https://github.com/paritytech/substrate/pull/10043 + // + // With this type the hooks of pallets will be executed + // in the order that they are declared in `construct_runtime!` + // it was reverse order before. + // See the comment before collation related pallets too. + AllPalletsWithSystem, +>; + +impl fp_self_contained::SelfContainedCall for RuntimeCall { + type SignedInfo = H160; + + fn is_self_contained(&self) -> bool { + match self { + RuntimeCall::Ethereum(call) => call.is_self_contained(), + _ => false, + } + } + + fn check_self_contained(&self) -> Option> { + match self { + RuntimeCall::Ethereum(call) => call.check_self_contained(), + _ => None, + } + } + + fn validate_self_contained( + &self, + info: &Self::SignedInfo, + dispatch_info: &DispatchInfoOf, + len: usize, + ) -> Option { + match self { + RuntimeCall::Ethereum(call) => call.validate_self_contained(info, dispatch_info, len), + _ => None, + } + } + + fn pre_dispatch_self_contained( + &self, + info: &Self::SignedInfo, + dispatch_info: &DispatchInfoOf, + len: usize, + ) -> Option> { + match self { + RuntimeCall::Ethereum(call) => + call.pre_dispatch_self_contained(info, dispatch_info, len), + _ => None, + } + } + + fn apply_self_contained( + self, + info: Self::SignedInfo, + ) -> Option>> { + match self { + call @ RuntimeCall::Ethereum(pallet_ethereum::Call::transact { .. }) => + Some(call.dispatch(RuntimeOrigin::from( + pallet_ethereum::RawOrigin::EthereumTransaction(info), + ))), + _ => None, + } + } +} + +impl_opaque_keys! { + pub struct SessionKeys { + pub aura: Aura, + } +} + +/// This runtime version. +#[sp_version::runtime_version] +pub const VERSION: RuntimeVersion = RuntimeVersion { + // Note: + // It's important to match `rococo-parachain-runtime`, which is runtime pkg name + spec_name: create_runtime_str!("rococo-parachain"), + impl_name: create_runtime_str!("rococo-parachain"), + authoring_version: 1, + // same versioning-mechanism as polkadot: use last digit for minor updates + spec_version: 9193, + impl_version: 0, + apis: RUNTIME_API_VERSIONS, + transaction_version: 1, + state_version: 0, +}; + +/// A timestamp: milliseconds since the unix epoch. +pub type Moment = u64; + +/// The version information used to identify this runtime when compiled natively. +#[cfg(feature = "std")] +pub fn native_version() -> NativeVersion { + NativeVersion { runtime_version: VERSION, can_author_with: Default::default() } +} + +parameter_types! { + pub const Version: RuntimeVersion = VERSION; + + // using generic substrate prefix + pub const SS58Prefix: u16 = 42; +} + +impl frame_system::Config for Runtime { + /// The identifier used to distinguish between accounts. + type AccountId = AccountId; + /// The aggregated dispatch type that is available for extrinsics. + type RuntimeCall = RuntimeCall; + /// The lookup mechanism to get account ID from whatever is passed in dispatchers. + type Lookup = AccountIdLookup; + /// The index type for storing how many extrinsics an account has signed. + type Index = Index; + /// The index type for blocks. + type BlockNumber = BlockNumber; + /// The type for hashing blocks and tries. + type Hash = Hash; + /// The hashing algorithm used. + type Hashing = BlakeTwo256; + /// The header type. + type Header = generic::Header; + /// The ubiquitous event type. + type RuntimeEvent = RuntimeEvent; + /// The ubiquitous origin type. + type RuntimeOrigin = RuntimeOrigin; + /// Maximum number of block number to block hash mappings to keep (oldest pruned first). + type BlockHashCount = BlockHashCount; + /// Runtime version. + type Version = Version; + /// Converts a module to an index of this module in the runtime. + type PalletInfo = PalletInfo; + /// The data to be stored in an account. + type AccountData = pallet_balances::AccountData; + /// What to do if a new account is created. + type OnNewAccount = (); + /// What to do if an account is fully reaped from the system. + type OnKilledAccount = (); + /// The weight of database operations that the runtime can invoke. + type DbWeight = RocksDbWeight; + /// The basic call filter to use in dispatchable. + type BaseCallFilter = BaseCallFilter; + /// Weight information for the extrinsics of this pallet. + type SystemWeightInfo = weights::frame_system::WeightInfo; + /// Block & extrinsics weights: base values and limits. + type BlockWeights = RuntimeBlockWeights; + /// The maximum length of a block (in bytes). + type BlockLength = BlockLength; + /// This is used as an identifier of the chain. 42 is the generic substrate prefix. + type SS58Prefix = SS58Prefix; + /// The action to take on a Runtime Upgrade + type OnSetCode = cumulus_pallet_parachain_system::ParachainSetCode; + type MaxConsumers = frame_support::traits::ConstU32<16>; +} + +parameter_types! { + // One storage item; key size is 32; value is size 4+4+16+32 bytes = 56 bytes. + pub const DepositBase: Balance = deposit(1, 88); + // Additional storage item size of 32 bytes. + pub const DepositFactor: Balance = deposit(0, 32); +} + +impl pallet_multisig::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type RuntimeCall = RuntimeCall; + type Currency = Balances; + type DepositBase = DepositBase; + type DepositFactor = DepositFactor; + type MaxSignatories = ConstU32<100>; + type WeightInfo = weights::pallet_multisig::WeightInfo; +} + +/// The type used to represent the kinds of proxying allowed. +#[derive( + Copy, + Clone, + Eq, + PartialEq, + Ord, + PartialOrd, + Encode, + Decode, + RuntimeDebug, + MaxEncodedLen, + scale_info::TypeInfo, +)] +pub enum ProxyType { + /// Fully permissioned proxy. Can execute any call on behalf of _proxied_. + #[codec(index = 0)] + Any, + /// Can execute any call that does not transfer funds, including asset transfers. + #[codec(index = 1)] + NonTransfer, + /// Proxy with the ability to reject time-delay proxy announcements. + #[codec(index = 2)] + CancelProxy, + /// Collator selection proxy. Can execute calls related to collator selection mechanism. + #[codec(index = 3)] + Collator, + /// Governance + #[codec(index = 4)] + Governance, +} + +impl Default for ProxyType { + fn default() -> Self { + Self::Any + } +} + +impl InstanceFilter for ProxyType { + fn filter(&self, c: &RuntimeCall) -> bool { + match self { + ProxyType::Any => true, + ProxyType::NonTransfer => !matches!( + c, + RuntimeCall::Balances(..) | + RuntimeCall::Vesting(pallet_vesting::Call::vested_transfer { .. }) + ), + ProxyType::CancelProxy => matches!( + c, + RuntimeCall::Proxy(pallet_proxy::Call::reject_announcement { .. }) | + RuntimeCall::Utility(..) | + RuntimeCall::Multisig(..) + ), + ProxyType::Collator => matches!( + c, + RuntimeCall::ParachainStaking(..) | + RuntimeCall::Utility(..) | + RuntimeCall::Multisig(..) + ), + ProxyType::Governance => matches!( + c, + RuntimeCall::Democracy(..) | + RuntimeCall::Council(..) | + RuntimeCall::TechnicalCommittee(..) | + RuntimeCall::Treasury(..) | + RuntimeCall::DeveloperCommittee(..) + ), + } + } + fn is_superset(&self, o: &Self) -> bool { + match (self, o) { + (x, y) if x == y => true, + (ProxyType::Any, _) => true, + (_, ProxyType::Any) => false, + (ProxyType::NonTransfer, _) => true, + _ => false, + } + } +} + +parameter_types! { + // One storage item; key size 32, value size 8; . + pub const ProxyDepositBase: Balance = deposit(1, 8); + // Additional storage item size of 33 bytes. + pub const ProxyDepositFactor: Balance = deposit(0, 33); + pub const AnnouncementDepositBase: Balance = deposit(1, 8); + pub const AnnouncementDepositFactor: Balance = deposit(0, 66); +} + +impl pallet_proxy::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type RuntimeCall = RuntimeCall; + type Currency = Balances; + type ProxyType = ProxyType; + type ProxyDepositBase = ProxyDepositBase; + type ProxyDepositFactor = ProxyDepositFactor; + type MaxProxies = ConstU32<32>; + type WeightInfo = weights::pallet_proxy::WeightInfo; + type MaxPending = ConstU32<32>; + type CallHasher = BlakeTwo256; + type AnnouncementDepositBase = AnnouncementDepositBase; + type AnnouncementDepositFactor = AnnouncementDepositFactor; +} + +impl pallet_timestamp::Config for Runtime { + /// A timestamp: milliseconds since the unix epoch. + type Moment = Moment; + type OnTimestampSet = (); + type MinimumPeriod = ConstU64<{ SLOT_DURATION / 2 }>; + type WeightInfo = weights::pallet_timestamp::WeightInfo; +} + +impl pallet_authorship::Config for Runtime { + type FindAuthor = pallet_session::FindAccountFromAuthorIndex; + type EventHandler = (ParachainStaking,); +} + +parameter_types! { + pub MaximumSchedulerWeight: Weight = Perbill::from_percent(80) * + RuntimeBlockWeights::get().max_block; +} + +impl pallet_scheduler::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type RuntimeOrigin = RuntimeOrigin; + type PalletsOrigin = OriginCaller; + type RuntimeCall = RuntimeCall; + type MaximumWeight = MaximumSchedulerWeight; + type ScheduleOrigin = EnsureRootOrAllCouncil; + type MaxScheduledPerBlock = ConstU32<50>; + type WeightInfo = weights::pallet_scheduler::WeightInfo; + type OriginPrivilegeCmp = frame_support::traits::EqualPrivilegeOnly; + type Preimages = Preimage; +} + +parameter_types! { + pub const PreimageMaxSize: u32 = 4096 * 1024; + pub const PreimageBaseDeposit: Balance = 1 * DOLLARS; +} + +impl pallet_preimage::Config for Runtime { + type WeightInfo = weights::pallet_preimage::WeightInfo; + type RuntimeEvent = RuntimeEvent; + type Currency = Balances; + type ManagerOrigin = EnsureRootOrAllCouncil; + type BaseDeposit = PreimageBaseDeposit; + type ByteDeposit = PreimageByteDeposit; +} + +parameter_types! { + pub const ExistentialDeposit: Balance = EXISTENTIAL_DEPOSIT; +} + +impl pallet_balances::Config for Runtime { + /// The type for recording an account's balance. + type Balance = Balance; + /// The ubiquitous event type. + type RuntimeEvent = RuntimeEvent; + type DustRemoval = (); + type ExistentialDeposit = ExistentialDeposit; + type AccountStore = System; + type WeightInfo = weights::pallet_balances::WeightInfo; + type MaxLocks = ConstU32<50>; + type MaxReserves = ConstU32<50>; + type ReserveIdentifier = [u8; 8]; + type HoldIdentifier = (); + type FreezeIdentifier = (); + type MaxHolds = (); + type MaxFreezes = (); +} + +impl pallet_utility::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type RuntimeCall = RuntimeCall; + type PalletsOrigin = OriginCaller; + type WeightInfo = weights::pallet_utility::WeightInfo; +} + +parameter_types! { + pub const TransactionByteFee: Balance = WEIGHT_TO_FEE_FACTOR; // 10^6 + pub const WeightToFeeFactor: Balance = WEIGHT_TO_FEE_FACTOR; // 10^6 +} +impl_runtime_transaction_payment_fees!(constants); + +impl pallet_transaction_payment::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type OnChargeTransaction = + pallet_transaction_payment::CurrencyAdapter>; + type WeightToFee = ConstantMultiplier; + type LengthToFee = ConstantMultiplier; + type FeeMultiplierUpdate = SlowAdjustingFeeUpdate; + type OperationalFeeMultiplier = ConstU8<5>; +} + +parameter_types! { + pub LaunchPeriod: BlockNumber = prod_or_fast!(10 * MINUTES, 5 * MINUTES, "ROCOCO_LAUNCHPERIOD"); + pub VotingPeriod: BlockNumber = prod_or_fast!(10 * MINUTES, 5 * MINUTES, "ROCOCO_VOTINGPERIOD"); + pub FastTrackVotingPeriod: BlockNumber = prod_or_fast!(8 * MINUTES, 2 * MINUTES, "ROCOCO_FASTTRACKVOTINGPERIOD"); + pub const InstantAllowed: bool = true; + pub const MinimumDeposit: Balance = 100 * DOLLARS; + pub EnactmentPeriod: BlockNumber = prod_or_fast!(5 * MINUTES, 2 * MINUTES, "ROCOCO_ENACTMENTPERIOD"); + pub CooloffPeriod: BlockNumber = prod_or_fast!(10 * MINUTES, 2 * MINUTES, "ROCOCO_COOLOFFPERIOD"); + pub const PreimageByteDeposit: Balance = deposit(0, 1); +} + +impl pallet_democracy::Config for Runtime { + type Preimages = Preimage; + type RuntimeEvent = RuntimeEvent; + type Currency = Balances; + type EnactmentPeriod = EnactmentPeriod; + type LaunchPeriod = LaunchPeriod; + type VotingPeriod = VotingPeriod; + type VoteLockingPeriod = EnactmentPeriod; // Same as EnactmentPeriod + type MinimumDeposit = MinimumDeposit; + /// A straight majority of the council can decide what their next motion is. + type ExternalOrigin = EnsureRootOrHalfCouncil; + /// A super-majority can have the next scheduled referendum be a straight majority-carries vote. + type ExternalMajorityOrigin = EnsureRootOrTwoThirdsCouncil; + /// A unanimous council can have the next scheduled referendum be a straight default-carries + /// (NTB) vote. + type ExternalDefaultOrigin = EnsureRootOrAllCouncil; + /// Two thirds of the technical committee can have an ExternalMajority/ExternalDefault vote + /// be tabled immediately and with a shorter voting/enactment period. + type FastTrackOrigin = EnsureRootOrTwoThirdsTechnicalCommittee; + type InstantOrigin = EnsureRootOrAllTechnicalCommittee; + type InstantAllowed = InstantAllowed; + type FastTrackVotingPeriod = FastTrackVotingPeriod; + // To cancel a proposal which has been passed, 2/3 of the council must agree to it. + type CancellationOrigin = EnsureRootOrTwoThirdsCouncil; + // To cancel a proposal before it has been passed, the technical committee must be unanimous or + // Root must agree. + type CancelProposalOrigin = EnsureRootOrAllTechnicalCommittee; + type BlacklistOrigin = EnsureRootOrAllCouncil; + // Any single technical committee member may veto a coming council proposal, however they can + // only do it once and it lasts only for the cool-off period. + type VetoOrigin = pallet_collective::EnsureMember; + type CooloffPeriod = CooloffPeriod; + type Slash = Treasury; + type Scheduler = Scheduler; + type PalletsOrigin = OriginCaller; + type MaxVotes = ConstU32<100>; + type WeightInfo = weights::pallet_democracy::WeightInfo; + type MaxProposals = ConstU32<100>; + type MaxDeposits = ConstU32<100>; + type MaxBlacklisted = ConstU32<100>; + type SubmitOrigin = frame_system::EnsureSigned; +} + +parameter_types! { + pub const CouncilMotionDuration: BlockNumber = 3 * DAYS; + pub const CouncilDefaultMaxMembers: u32 = 100; + pub MaxProposalWeight: Weight = Perbill::from_percent(50) * RuntimeBlockWeights::get().max_block; +} + +impl pallet_collective::Config for Runtime { + type RuntimeOrigin = RuntimeOrigin; + type Proposal = RuntimeCall; + type RuntimeEvent = RuntimeEvent; + type MotionDuration = CouncilMotionDuration; + type MaxProposals = ConstU32<100>; + type MaxMembers = CouncilDefaultMaxMembers; + type DefaultVote = pallet_collective::PrimeDefaultVote; + type WeightInfo = weights::pallet_collective::WeightInfo; + type SetMembersOrigin = EnsureRoot; + type MaxProposalWeight = MaxProposalWeight; +} + +impl pallet_membership::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type AddOrigin = EnsureRootOrTwoThirdsCouncil; + type RemoveOrigin = EnsureRootOrTwoThirdsCouncil; + type SwapOrigin = EnsureRootOrTwoThirdsCouncil; + type ResetOrigin = EnsureRootOrTwoThirdsCouncil; + type PrimeOrigin = EnsureRootOrTwoThirdsCouncil; + type MembershipInitialized = Council; + type MembershipChanged = Council; + type MaxMembers = CouncilDefaultMaxMembers; + type WeightInfo = weights::pallet_membership::WeightInfo; +} + +parameter_types! { + pub const TechnicalMotionDuration: BlockNumber = 3 * DAYS; +} + +impl pallet_collective::Config for Runtime { + type RuntimeOrigin = RuntimeOrigin; + type Proposal = RuntimeCall; + type RuntimeEvent = RuntimeEvent; + type MotionDuration = TechnicalMotionDuration; + type MaxProposals = ConstU32<100>; + type MaxMembers = CouncilDefaultMaxMembers; + type DefaultVote = pallet_collective::PrimeDefaultVote; + type WeightInfo = weights::pallet_collective::WeightInfo; + type SetMembersOrigin = EnsureRoot; + type MaxProposalWeight = MaxProposalWeight; +} + +impl pallet_membership::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type AddOrigin = EnsureRootOrTwoThirdsCouncil; + type RemoveOrigin = EnsureRootOrTwoThirdsCouncil; + type SwapOrigin = EnsureRootOrTwoThirdsCouncil; + type ResetOrigin = EnsureRootOrTwoThirdsCouncil; + type PrimeOrigin = EnsureRootOrTwoThirdsCouncil; + type MembershipInitialized = TechnicalCommittee; + type MembershipChanged = TechnicalCommittee; + type MaxMembers = CouncilDefaultMaxMembers; + type WeightInfo = weights::pallet_membership::WeightInfo; +} + +impl pallet_collective::Config for Runtime { + type RuntimeOrigin = RuntimeOrigin; + type Proposal = RuntimeCall; + type RuntimeEvent = RuntimeEvent; + type MotionDuration = TechnicalMotionDuration; + type MaxProposals = ConstU32<100>; + type MaxMembers = CouncilDefaultMaxMembers; + type DefaultVote = pallet_collective::PrimeDefaultVote; + type WeightInfo = weights::pallet_collective::WeightInfo; + type SetMembersOrigin = EnsureRoot; + type MaxProposalWeight = MaxProposalWeight; +} + +impl pallet_membership::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type AddOrigin = EnsureRootOrTwoThirdsCouncil; + type RemoveOrigin = EnsureRootOrTwoThirdsCouncil; + type SwapOrigin = EnsureRootOrTwoThirdsCouncil; + type ResetOrigin = EnsureRootOrTwoThirdsCouncil; + type PrimeOrigin = EnsureRootOrTwoThirdsCouncil; + type MembershipInitialized = DeveloperCommittee; + type MembershipChanged = DeveloperCommittee; + type MaxMembers = CouncilDefaultMaxMembers; + type WeightInfo = weights::pallet_membership::WeightInfo; +} + +parameter_types! { + pub const ProposalBond: Permill = Permill::from_percent(5); + pub const ProposalBondMinimum: Balance = 1 * DOLLARS; + pub const ProposalBondMaximum: Balance = 20 * DOLLARS; + pub SpendPeriod: BlockNumber = prod_or_fast!(10 * MINUTES, 2 * MINUTES, "ROCOCO_SPENDPERIOD"); + pub const Burn: Permill = Permill::from_percent(0); + pub const TreasuryPalletId: PalletId = PalletId(*b"py/trsry"); + + pub const TipCountdown: BlockNumber = DAYS; + pub const TipFindersFee: Percent = Percent::from_percent(5); + pub TipReportDepositBase: Balance = deposit(1, 0); + pub BountyDepositBase: Balance = deposit(1, 0); + pub const BountyDepositPayoutDelay: BlockNumber = 4 * DAYS; + pub const BountyUpdatePeriod: BlockNumber = 35 * DAYS; + pub const CuratorDepositMultiplier: Permill = Permill::from_percent(50); + pub CuratorDepositMin: Balance = DOLLARS; + pub CuratorDepositMax: Balance = 100 * DOLLARS; + pub BountyValueMinimum: Balance = 5 * DOLLARS; + pub DataDepositPerByte: Balance = deposit(0, 1); + pub const MaximumReasonLength: u32 = 8192; +} + +pub struct EnsureRootOrTwoThirdsCouncilWrapper; +impl EnsureOrigin for EnsureRootOrTwoThirdsCouncilWrapper { + type Success = Balance; + fn try_origin(o: RuntimeOrigin) -> Result { + match EnsureRootOrTwoThirdsCouncil::try_origin(o) { + Ok(_) => Ok(Balance::max_value()), + Err(o) => Err(o), + } + } + #[cfg(feature = "runtime-benchmarks")] + fn try_successful_origin() -> Result { + Ok(RuntimeOrigin::root()) + } +} + +impl pallet_treasury::Config for Runtime { + type PalletId = TreasuryPalletId; + type Currency = Balances; + type ApproveOrigin = EnsureRootOrTwoThirdsCouncil; + type RejectOrigin = EnsureRootOrHalfCouncil; + type RuntimeEvent = RuntimeEvent; + type OnSlash = Treasury; + type ProposalBond = ProposalBond; + type ProposalBondMinimum = ProposalBondMinimum; + type ProposalBondMaximum = ProposalBondMaximum; + // Once passed, at most all is allowed to be spent + type SpendOrigin = EnsureRootOrTwoThirdsCouncilWrapper; + type SpendPeriod = SpendPeriod; + type Burn = Burn; + type BurnDestination = (); + // Rcococo bounty enabled + type SpendFunds = Bounties; + type WeightInfo = weights::pallet_treasury::WeightInfo; + type MaxApprovals = ConstU32<100>; +} + +pub struct CouncilProvider; +impl SortedMembers for CouncilProvider { + fn contains(who: &AccountId) -> bool { + Council::is_member(who) + } + + fn sorted_members() -> Vec { + Council::members() + } + + #[cfg(feature = "runtime-benchmarks")] + fn add(_: &AccountId) { + unimplemented!() + } +} + +impl ContainsLengthBound for CouncilProvider { + fn max_len() -> usize { + CouncilDefaultMaxMembers::get() as usize + } + fn min_len() -> usize { + 0 + } +} + +impl pallet_bounties::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type BountyDepositBase = BountyDepositBase; + type BountyDepositPayoutDelay = BountyDepositPayoutDelay; + type BountyUpdatePeriod = BountyUpdatePeriod; + type BountyValueMinimum = BountyValueMinimum; + type CuratorDepositMultiplier = CuratorDepositMultiplier; + type CuratorDepositMin = CuratorDepositMin; + type CuratorDepositMax = CuratorDepositMax; + type DataDepositPerByte = DataDepositPerByte; + type MaximumReasonLength = MaximumReasonLength; + type WeightInfo = (); + type ChildBountyManager = (); +} + +impl pallet_tips::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type DataDepositPerByte = DataDepositPerByte; + type MaximumReasonLength = MaximumReasonLength; + type Tippers = CouncilProvider; + type TipCountdown = TipCountdown; + type TipFindersFee = TipFindersFee; + type TipReportDepositBase = TipReportDepositBase; + type WeightInfo = (); +} + +impl pallet_identity::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type Currency = Balances; + // Add one item in storage and take 258 bytes + type BasicDeposit = ConstU128<{ deposit(1, 258) }>; + // Not add any item to the storage but takes 66 bytes + type FieldDeposit = ConstU128<{ deposit(0, 66) }>; + // Add one item in storage and take 53 bytes + type SubAccountDeposit = ConstU128<{ deposit(1, 53) }>; + type MaxSubAccounts = ConstU32<100>; + type MaxAdditionalFields = ConstU32<100>; + type MaxRegistrars = ConstU32<20>; + type Slashed = Treasury; + type ForceOrigin = EnsureRootOrHalfCouncil; + type RegistrarOrigin = EnsureRootOrHalfCouncil; + type WeightInfo = weights::pallet_identity::WeightInfo; +} + +impl pallet_sudo::Config for Runtime { + type RuntimeCall = RuntimeCall; + type RuntimeEvent = RuntimeEvent; +} + +impl pallet_account_fix::Config for Runtime { + type Currency = Balances; + type BurnOrigin = EnsureRootOrTwoThirdsTechnicalCommittee; +} + +parameter_types! { + pub const ReservedXcmpWeight: Weight = MAXIMUM_BLOCK_WEIGHT.saturating_div(4); + pub const ReservedDmpWeight: Weight = MAXIMUM_BLOCK_WEIGHT.saturating_div(4); +} + +impl cumulus_pallet_parachain_system::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type OnSystemEvent = (); + type SelfParaId = parachain_info::Pallet; + type DmpMessageHandler = DmpQueue; + type ReservedDmpWeight = ReservedDmpWeight; + type OutboundXcmpMessageSource = XcmpQueue; + type XcmpMessageHandler = XcmpQueue; + type ReservedXcmpWeight = ReservedXcmpWeight; + type CheckAssociatedRelayNumber = RelayNumberStrictlyIncreases; +} + +impl parachain_info::Config for Runtime {} + +impl cumulus_pallet_aura_ext::Config for Runtime {} + +impl cumulus_pallet_xcmp_queue::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type XcmExecutor = XcmExecutor; + type ChannelInfo = ParachainSystem; + // We use pallet_xcm to confirm the version of xcm + type VersionWrapper = PolkadotXcm; + type ExecuteOverweightOrigin = EnsureRootOrAllCouncil; + type ControllerOrigin = EnsureRootOrAllCouncil; + type ControllerOriginConverter = XcmOriginToTransactDispatchOrigin; + type WeightInfo = weights::cumulus_pallet_xcmp_queue::WeightInfo; + type PriceForSiblingDelivery = (); +} + +impl cumulus_pallet_dmp_queue::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type XcmExecutor = XcmExecutor; + type ExecuteOverweightOrigin = EnsureRootOrAllCouncil; +} + +parameter_types! { + pub const Offset: u32 = 0; +} + +impl pallet_session::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type ValidatorId = ::AccountId; + // we don't have stash and controller, thus we don't need the convert as well. + type ValidatorIdOf = ConvertInto; + type ShouldEndSession = ParachainStaking; + type NextSessionRotation = ParachainStaking; + type SessionManager = ParachainStaking; + // Essentially just Aura, but lets be pedantic. + type SessionHandler = ::KeyTypeIdProviders; + type Keys = SessionKeys; + type WeightInfo = weights::pallet_session::WeightInfo; +} + +impl pallet_aura::Config for Runtime { + type AuthorityId = AuraId; + type DisabledValidators = (); + type MaxAuthorities = ConstU32<100_000>; +} + +parameter_types! { + /// Default fixed percent a collator takes off the top of due rewards + pub const DefaultCollatorCommission: Perbill = Perbill::from_percent(0); + /// Default percent of inflation set aside for parachain bond every round + pub const DefaultParachainBondReservePercent: Percent = Percent::from_percent(0); + pub const MinCollatorStk: Balance = 50 * DOLLARS; + pub const MinCandidateStk: Balance = 50 * DOLLARS; + pub const MinDelegation: Balance = 50 * DOLLARS; + pub const MinDelegatorStk: Balance = 50 * DOLLARS; +} + +impl pallet_parachain_staking::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type Currency = Balances; + type MonetaryGovernanceOrigin = EnsureRootOrAllCouncil; + /// Minimum round length is 2 minutes (10 * 12 second block times) + type MinBlocksPerRound = ConstU32<{ prod_or_fast!(2 * MINUTES, 2) }>; + /// Blocks per round + type DefaultBlocksPerRound = ConstU32<{ prod_or_fast!(2 * MINUTES, 2) }>; + /// Rounds before the collator leaving the candidates request can be executed + type LeaveCandidatesDelay = ConstU32<{ prod_or_fast!(28, 1) }>; + /// Rounds before the candidate bond increase/decrease can be executed + type CandidateBondLessDelay = ConstU32<{ prod_or_fast!(28, 1) }>; + /// Rounds before the delegator exit can be executed + type LeaveDelegatorsDelay = ConstU32<{ prod_or_fast!(28, 1) }>; + /// Rounds before the delegator revocation can be executed + type RevokeDelegationDelay = ConstU32<{ prod_or_fast!(28, 1) }>; + /// Rounds before the delegator bond increase/decrease can be executed + type DelegationBondLessDelay = ConstU32<{ prod_or_fast!(28, 1) }>; + /// Rounds before the reward is paid + type RewardPaymentDelay = ConstU32<2>; + /// Minimum collators selected per round, default at genesis and minimum forever after + type MinSelectedCandidates = ConstU32<1>; + /// Maximum top delegations per candidate + type MaxTopDelegationsPerCandidate = ConstU32<1000>; + /// Maximum bottom delegations per candidate + type MaxBottomDelegationsPerCandidate = ConstU32<200>; + /// Maximum delegations per delegator + type MaxDelegationsPerDelegator = ConstU32<100>; + type DefaultCollatorCommission = DefaultCollatorCommission; + type DefaultParachainBondReservePercent = DefaultParachainBondReservePercent; + /// Minimum stake required to become a collator + type MinCollatorStk = MinCollatorStk; + /// Minimum stake required to be reserved to be a candidate + type MinCandidateStk = MinCandidateStk; + /// Minimum stake required to be reserved to be a delegator + type MinDelegation = MinDelegation; + /// Minimum stake required to be reserved to be a delegator + type MinDelegatorStk = MinDelegatorStk; + type OnCollatorPayout = (); + type OnNewRound = (); + type WeightInfo = weights::pallet_parachain_staking::WeightInfo; + type IssuanceAdapter = AssetsHandler; +} + +parameter_types! { + pub const MinVestedTransfer: Balance = 10 * CENTS; + pub UnvestedFundsAllowedWithdrawReasons: WithdrawReasons = + WithdrawReasons::except(WithdrawReasons::TRANSFER | WithdrawReasons::RESERVE); +} + +impl pallet_vesting::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type Currency = Balances; + type BlockNumberToBalance = ConvertInto; + type MinVestedTransfer = MinVestedTransfer; + type WeightInfo = (); + // `VestingInfo` encode length is 36bytes. 28 schedules gets encoded as 1009 bytes, which is the + // highest number of schedules that encodes less than 2^10. + const MAX_VESTING_SCHEDULES: u32 = 28; + type UnvestedFundsAllowedWithdrawReasons = UnvestedFundsAllowedWithdrawReasons; +} + +parameter_types! { + pub const BridgeChainId: u8 = 3; + pub const ProposalLifetime: BlockNumber = 50400; // ~7 days + pub TreasuryAccount: AccountId = TreasuryPalletId::get().into_account_truncating(); +} + +impl pallet_bridge::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type BridgeCommitteeOrigin = EnsureRootOrHalfCouncil; + type Proposal = RuntimeCall; + type BridgeChainId = BridgeChainId; + type Balance = Balance; + type ProposalLifetime = ProposalLifetime; + type WeightInfo = weights::pallet_bridge::WeightInfo; +} + +parameter_types! { + pub const MaximumIssuance: Balance = 20_000_000 * DOLLARS; + // Ethereum LIT total issuance in parachain decimal form + pub const ExternalTotalIssuance: Balance = 100_000_000 * DOLLARS; + // bridge::derive_resource_id(1, &bridge::hashing::blake2_128(b"LIT")); + pub const NativeTokenResourceId: [u8; 32] = hex!("00000000000000000000000000000063a7e2be78898ba83824b0c0cc8dfb6001"); +} + +pub struct TransferAssetsAnyone; +impl SortedMembers for TransferAssetsAnyone { + fn sorted_members() -> Vec { + vec![] + } + + fn contains(_who: &AccountId) -> bool { + true + } + + #[cfg(feature = "runtime-benchmarks")] + fn add(_: &AccountId) { + unimplemented!() + } +} + +impl pallet_bridge_transfer::Config for Runtime { + type BridgeHandler = AssetsHandler; + type BridgeOrigin = pallet_bridge::EnsureBridge; + type TransferAssetsMembers = TransferAssetsAnyone; + type WeightInfo = weights::pallet_bridge_transfer::WeightInfo; +} + +impl pallet_assets_handler::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type TreasuryAccount = TreasuryAccount; + type SetMaximumIssuanceOrigin = EnsureRootOrHalfCouncil; + type DefaultMaximumIssuance = MaximumIssuance; + type ExternalTotalIssuance = ExternalTotalIssuance; +} + +impl pallet_extrinsic_filter::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type UpdateOrigin = EnsureRootOrHalfTechnicalCommittee; + type NormalModeFilter = NormalModeFilter; + type SafeModeFilter = SafeModeFilter; + type TestModeFilter = Everything; + type WeightInfo = weights::pallet_extrinsic_filter::WeightInfo; +} + +parameter_types! { + pub const MomentsPerDay: Moment = 86_400_000; // [ms/d] +} + +impl pallet_teebag::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type MomentsPerDay = MomentsPerDay; + type SetAdminOrigin = EnsureRootOrHalfCouncil; + type MaxEnclaveIdentifier = ConstU32<3>; + type MaxAuthorizedEnclave = ConstU32<5>; + type WeightInfo = weights::pallet_teebag::WeightInfo; +} + +impl pallet_identity_management::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type WeightInfo = (); + type TEECallOrigin = EnsureEnclaveSigner; + type DelegateeAdminOrigin = EnsureRootOrAllCouncil; + type ExtrinsicWhitelistOrigin = IMPExtrinsicWhitelist; + type MaxOIDCClientRedirectUris = ConstU32<10>; +} + +impl pallet_bitacross::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type TEECallOrigin = EnsureEnclaveSigner; + type SetAdminOrigin = EnsureRootOrAllCouncil; +} + +impl pallet_evm_assertions::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type AssertionId = H160; + type ContractDevOrigin = pallet_collective::EnsureMember; + type TEECallOrigin = EnsureEnclaveSigner; +} + +impl pallet_group::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type GroupManagerOrigin = EnsureRootOrAllCouncil; +} + +impl pallet_vc_management::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type WeightInfo = weights::pallet_vc_management::WeightInfo; + type TEECallOrigin = EnsureEnclaveSigner; + type SetAdminOrigin = EnsureRootOrHalfCouncil; + type DelegateeAdminOrigin = EnsureRootOrAllCouncil; + type ExtrinsicWhitelistOrigin = VCMPExtrinsicWhitelist; +} + +impl pallet_group::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type GroupManagerOrigin = EnsureRootOrAllCouncil; +} + +// For OnChargeEVMTransaction implementation +type CurrencyAccountId = ::AccountId; +type BalanceFor = + <::Currency as Currency>>::Balance; +type PositiveImbalanceFor = + <::Currency as Currency>>::PositiveImbalance; +type NegativeImbalanceFor = + <::Currency as Currency>>::NegativeImbalance; +pub struct OnChargeEVMTransaction(sp_std::marker::PhantomData); +impl OnChargeEVMTransactionT for OnChargeEVMTransaction +where + T: pallet_evm::Config, + PositiveImbalanceFor: Imbalance, Opposite = NegativeImbalanceFor>, + NegativeImbalanceFor: Imbalance, Opposite = PositiveImbalanceFor>, + OU: OnUnbalanced>, + U256: UniqueSaturatedInto>, +{ + type LiquidityInfo = Option>; + + fn withdraw_fee(who: &H160, fee: U256) -> Result> { + EVMCurrencyAdapter::<::Currency, ()>::withdraw_fee(who, fee) + } + + fn correct_and_deposit_fee( + who: &H160, + corrected_fee: U256, + base_fee: U256, + already_withdrawn: Self::LiquidityInfo, + ) -> Self::LiquidityInfo { + ::Currency, OU> as OnChargeEVMTransactionT< + T, + >>::correct_and_deposit_fee(who, corrected_fee, base_fee, already_withdrawn) + } + // This is the only difference of OnChargeEVMTransaction regarding EVMCurrencyAdapter + // We can use parachain TransactionPayment logic to handle evm tip + fn pay_priority_fee(tip: Self::LiquidityInfo) { + if let Some(tip) = tip { + OU::on_unbalanced(tip); + } + } +} + +pub struct TransactionPaymentAsGasPrice; +impl FeeCalculator for TransactionPaymentAsGasPrice { + fn min_gas_price() -> (U256, Weight) { + // We do not want to involve Transaction Payment Multiplier here + // It will biased normal transfer (base weight is not biased by Multiplier) too much for + // Ethereum tx + // This is hardcoded ConstantMultiplier, WeightToFeeFactor = + // MILLICENTS / 10 + let weight_to_fee: u128 = WEIGHT_TO_FEE_FACTOR; + let min_gas_price = weight_to_fee.saturating_mul(WEIGHT_PER_GAS as u128); + (min_gas_price.into(), ::DbWeight::get().reads(1)) + } +} + +parameter_types! { + pub WeightPerGas: Weight = Weight::from_parts(WEIGHT_PER_GAS, 0); + // It will be the best if we can implement this in a more professional way + pub ChainId: u64 = 2106u64; + pub BlockGasLimit: U256 = U256::from( + NORMAL_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT.ref_time() / WEIGHT_PER_GAS + ); + pub PrecompilesValue: Precompiles = RococoNetworkPrecompiles::<_>::new(); + // BlockGasLimit / MAX_POV_SIZE + pub GasLimitPovSizeRatio: u64 = 4; +} + +pub struct FindAuthorTruncated(sp_std::marker::PhantomData); +impl FindAuthor for FindAuthorTruncated +where + pallet_aura::Pallet: FindAuthor, +{ + fn find_author<'a, I>(digests: I) -> Option + where + I: 'a + IntoIterator, + { + if let Some(author_index) = pallet_aura::Pallet::::find_author(digests) { + let authority_id = + >::authorities()[author_index as usize].clone(); + return Some(H160::from_slice(&authority_id.encode()[4..24])) + } + + None + } +} + +impl pallet_evm::Config for Runtime { + type FeeCalculator = TransactionPaymentAsGasPrice; + type GasWeightMapping = pallet_evm::FixedGasWeightMapping; + type WeightPerGas = WeightPerGas; + type BlockHashMapping = pallet_ethereum::EthereumBlockHashMapping; + type CallOrigin = pallet_evm::EnsureAddressTruncated; + type WithdrawOrigin = pallet_evm::EnsureAddressTruncated; + // From evm address to parachain address + type AddressMapping = pallet_evm::HashedAddressMapping; + type Currency = Balances; + type RuntimeEvent = RuntimeEvent; + type Runner = pallet_evm::runner::stack::Runner; + type PrecompilesType = Precompiles; + type PrecompilesValue = PrecompilesValue; + type ChainId = ChainId; + type OnChargeTransaction = OnChargeEVMTransaction>; + type BlockGasLimit = BlockGasLimit; + type Timestamp = Timestamp; + type OnCreate = (); + type FindAuthor = FindAuthorTruncated; + // BlockGasLimit / MAX_POV_SIZE + type GasLimitPovSizeRatio = GasLimitPovSizeRatio; + type WeightInfo = weights::pallet_evm::WeightInfo; +} + +parameter_types! { + pub const PostBlockAndTxnHashes: PostLogContent = PostLogContent::BlockAndTxnHashes; +} + +impl pallet_ethereum::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type StateRoot = pallet_ethereum::IntermediateStateRoot; + type PostLogContent = PostBlockAndTxnHashes; + // Maximum length (in bytes) of revert message to include in Executed event + type ExtraDataLength = ConstU32<30>; +} + +parameter_types! { + pub const DefaultYearlyInflation: Perbill = Perbill::from_perthousand(5); +} + +pub struct IdentityAccountIdConvert; + +impl pallet_score_staking::AccountIdConvert for IdentityAccountIdConvert { + fn convert(account: AccountId) -> ::AccountId { + account + } +} + +impl pallet_score_staking::Config for Runtime { + type Currency = Balances; + type RuntimeEvent = RuntimeEvent; + type AccountIdConvert = IdentityAccountIdConvert; + type AdminOrigin = EnsureRootOrHalfCouncil; + type YearlyIssuance = ConstU128<{ 100_000_000 * UNIT }>; + type YearlyInflation = DefaultYearlyInflation; + type MaxScoreUserCount = ConstU32<1_000_000>; +} + +impl runtime_common::BaseRuntimeRequirements for Runtime {} +impl runtime_common::ParaRuntimeRequirements for Runtime {} + +construct_runtime! { + pub enum Runtime where + Block = Block, + NodeBlock = opaque::Block, + UncheckedExtrinsic = UncheckedExtrinsic, + { + // Core + System: frame_system = 0, + Timestamp: pallet_timestamp = 1, + Scheduler: pallet_scheduler = 2, + Utility: pallet_utility = 3, + Multisig: pallet_multisig = 4, + Proxy: pallet_proxy = 5, + Preimage: pallet_preimage = 6, + + // Token related + Balances: pallet_balances = 10, + Vesting: pallet_vesting = 11, + TransactionPayment: pallet_transaction_payment = 12, + Treasury: pallet_treasury = 13, + + // Governance + Democracy: pallet_democracy = 21, + Council: pallet_collective:: = 22, + CouncilMembership: pallet_membership:: = 23, + TechnicalCommittee: pallet_collective:: = 24, + TechnicalCommitteeMembership: pallet_membership:: = 25, + Bounties: pallet_bounties = 26, + Tips: pallet_tips = 27, + ParachainIdentity: pallet_identity = 28, + + // Parachain + ParachainSystem: cumulus_pallet_parachain_system = 30, + ParachainInfo: parachain_info = 31, + + // Collator support + // About the order of these 5 pallets, the comment in cumulus seems to be outdated. + // + // The main thing is Authorship looks for the block author (T::FindAuthor::find_author) + // in its `on_initialize` hook -> Session::find_author, where Session::validators() is enquired. + // Meanwhile Session could modify the validators storage in its `on_initialize` hook. If Session + // comes after Authorship, the changes on validators() will only take effect in the next block. + // + // I assume it's the desired behavior though or it doesn't really matter. + // + // also see the comment above `AllPalletsWithSystem` and + // https://github.com/litentry/litentry-parachain/issues/336 + Authorship: pallet_authorship = 40, + //41 is for old CollatorSelection, replaced by ParachainSTaking + Session: pallet_session = 42, + Aura: pallet_aura = 43, + AuraExt: cumulus_pallet_aura_ext = 44, + ParachainStaking: pallet_parachain_staking = 45, + + // XCM helpers + XcmpQueue: cumulus_pallet_xcmp_queue = 50, + PolkadotXcm: pallet_xcm = 51, + CumulusXcm: cumulus_pallet_xcm = 52, + DmpQueue: cumulus_pallet_dmp_queue = 53, + XTokens: orml_xtokens = 54, + // 55 is saved for old pallet: Tokens: orml_tokens + Assets: pallet_assets = 56, + + // Rococo pallets + ChainBridge: pallet_bridge = 60, + BridgeTransfer: pallet_bridge_transfer = 61, + ExtrinsicFilter: pallet_extrinsic_filter = 63, + IdentityManagement: pallet_identity_management = 64, + AssetManager: pallet_asset_manager = 65, + VCManagement: pallet_vc_management = 66, + IMPExtrinsicWhitelist: pallet_group:: = 67, + VCMPExtrinsicWhitelist: pallet_group:: = 68, + Bitacross: pallet_bitacross = 70, + EvmAssertions: pallet_evm_assertions = 71, + + // Developer council + DeveloperCommittee: pallet_collective:: = 73, + DeveloperCommitteeMembership: pallet_membership:: = 74, + ScoreStaking: pallet_score_staking = 75, + + // New Bridge Added + AssetsHandler: pallet_assets_handler = 76, + + // TEE + Teebag: pallet_teebag = 93, + + // Frontier + EVM: pallet_evm = 120, + Ethereum: pallet_ethereum = 121, + + // TMP + AccountFix: pallet_account_fix = 254, + Sudo: pallet_sudo = 255, + } +} + +pub struct BaseCallFilter; +impl Contains for BaseCallFilter { + fn contains(call: &RuntimeCall) -> bool { + if matches!( + call, + RuntimeCall::Sudo(_) | + RuntimeCall::System(_) | + RuntimeCall::Timestamp(_) | + RuntimeCall::ParachainSystem(_) | + RuntimeCall::ExtrinsicFilter(_) | + RuntimeCall::Multisig(_) | + RuntimeCall::Council(_) | + RuntimeCall::CouncilMembership(_) | + RuntimeCall::TechnicalCommittee(_) | + RuntimeCall::TechnicalCommitteeMembership(_) | + RuntimeCall::Utility(_) | + // Temp: should be removed after the one-time burn + RuntimeCall::AccountFix(pallet_account_fix::Call::burn { .. }) + ) { + // always allow core calls + return true + } + + pallet_extrinsic_filter::Pallet::::contains(call) + } +} + +pub struct SafeModeFilter; +impl Contains for SafeModeFilter { + fn contains(_call: &RuntimeCall) -> bool { + false + } +} + +pub struct NormalModeFilter; +impl Contains for NormalModeFilter { + fn contains(call: &RuntimeCall) -> bool { + matches!( + call, + // Vesting::vest + RuntimeCall::Vesting(pallet_vesting::Call::vest { .. }) | + // ChainBridge + RuntimeCall::ChainBridge(_) | + // Bounties + RuntimeCall::Bounties(_) | + // BridgeTransfer + RuntimeCall::BridgeTransfer(_) | + // XTokens::transfer for normal users + RuntimeCall::XTokens(orml_xtokens::Call::transfer { .. }) | + // collective + RuntimeCall::DeveloperCommittee(_) | + // memberships + RuntimeCall::CouncilMembership(_) | + RuntimeCall::TechnicalCommitteeMembership(_) | + RuntimeCall::DeveloperCommitteeMembership(_) | + // democracy, we don't subdivide the calls, so we allow public proposals + RuntimeCall::Democracy(_) | + // Preimage + RuntimeCall::Preimage(_) | + // Identity + RuntimeCall::ParachainIdentity(_) | + // Utility + RuntimeCall::Utility(_) | + // Seesion + RuntimeCall::Session(_) | + // Balance + RuntimeCall::Balances(_) | + // IMP and VCMP + RuntimeCall::IdentityManagement(_) | + RuntimeCall::VCManagement(_) | + // TEE pallets + RuntimeCall::Teebag(_) | + // ParachainStaking; Only the collator part + RuntimeCall::ParachainStaking(pallet_parachain_staking::Call::join_candidates { .. }) | + RuntimeCall::ParachainStaking(pallet_parachain_staking::Call::schedule_leave_candidates { .. }) | + RuntimeCall::ParachainStaking(pallet_parachain_staking::Call::execute_leave_candidates { .. }) | + RuntimeCall::ParachainStaking(pallet_parachain_staking::Call::cancel_leave_candidates { .. }) | + RuntimeCall::ParachainStaking(pallet_parachain_staking::Call::go_offline { .. }) | + RuntimeCall::ParachainStaking(pallet_parachain_staking::Call::go_online { .. }) | + RuntimeCall::ParachainStaking(pallet_parachain_staking::Call::candidate_bond_more { .. }) | + RuntimeCall::ParachainStaking(pallet_parachain_staking::Call::schedule_candidate_bond_less { .. }) | + RuntimeCall::ParachainStaking(pallet_parachain_staking::Call::execute_candidate_bond_less { .. }) | + RuntimeCall::ParachainStaking(pallet_parachain_staking::Call::cancel_candidate_bond_less { .. }) | + // Group + RuntimeCall::IMPExtrinsicWhitelist(_) | + RuntimeCall::VCMPExtrinsicWhitelist(_) | + // EVM + // Substrate EVM extrinsic not allowed + // So no EVM pallet + RuntimeCall::Ethereum(_) | + // AccountFix + RuntimeCall::AccountFix(_) | + RuntimeCall::Bitacross(_) | + RuntimeCall::EvmAssertions(_) | + RuntimeCall::ScoreStaking(_) + ) + } +} + +#[cfg(feature = "runtime-benchmarks")] +mod benches { + define_benchmarks!( + [frame_system, SystemBench::] + [pallet_asset_manager, AssetManager] + [pallet_balances, Balances] + [pallet_timestamp, Timestamp] + [pallet_utility, Utility] + [pallet_treasury, Treasury] + [pallet_democracy, Democracy] + [pallet_collective, Council] + [pallet_proxy, Proxy] + [pallet_membership, CouncilMembership] + [pallet_multisig, Multisig] + [paleet_evm, EVM] + [pallet_extrinsic_filter, ExtrinsicFilter] + [pallet_scheduler, Scheduler] + [pallet_preimage, Preimage] + [pallet_session, SessionBench::] + [pallet_parachain_staking, ParachainStaking] + [cumulus_pallet_xcmp_queue, XcmpQueue] + [pallet_identity_management, IdentityManagement] + [pallet_vc_management, VCManagement] + [pallet_bridge,ChainBridge] + [pallet_bridge_transfer,BridgeTransfer] + [pallet_teebag, Teebag] + ); +} + +impl_runtime_apis! { + impl sp_api::Core for Runtime { + fn version() -> RuntimeVersion { + VERSION + } + + fn execute_block(block: Block) { + Executive::execute_block(block); + } + + fn initialize_block(header: &::Header) { + Executive::initialize_block(header) + } + } + + impl sp_api::Metadata for Runtime { + fn metadata() -> OpaqueMetadata { + OpaqueMetadata::new(Runtime::metadata().into()) + } + + fn metadata_at_version(version: u32) -> Option { + Runtime::metadata_at_version(version) + } + + fn metadata_versions() -> sp_std::vec::Vec { + Runtime::metadata_versions() + } + } + + impl sp_block_builder::BlockBuilder for Runtime { + fn apply_extrinsic( + extrinsic: ::Extrinsic, + ) -> ApplyExtrinsicResult { + Executive::apply_extrinsic(extrinsic) + } + + fn finalize_block() -> ::Header { + Executive::finalize_block() + } + + fn inherent_extrinsics(data: sp_inherents::InherentData) -> Vec<::Extrinsic> { + data.create_extrinsics() + } + + fn check_inherents(block: Block, data: sp_inherents::InherentData) -> sp_inherents::CheckInherentsResult { + data.check_extrinsics(&block) + } + } + + impl sp_transaction_pool::runtime_api::TaggedTransactionQueue for Runtime { + fn validate_transaction( + source: TransactionSource, + tx: ::Extrinsic, + block_hash: ::Hash, + ) -> TransactionValidity { + Executive::validate_transaction(source, tx, block_hash) + } + } + + impl sp_offchain::OffchainWorkerApi for Runtime { + fn offchain_worker(header: &::Header) { + Executive::offchain_worker(header) + } + } + + impl sp_session::SessionKeys for Runtime { + fn decode_session_keys( + encoded: Vec, + ) -> Option, KeyTypeId)>> { + SessionKeys::decode_into_raw_public_keys(&encoded) + } + + fn generate_session_keys(seed: Option>) -> Vec { + SessionKeys::generate(seed) + } + } + + impl sp_consensus_aura::AuraApi for Runtime { + fn slot_duration() -> sp_consensus_aura::SlotDuration { + sp_consensus_aura::SlotDuration::from_millis(Aura::slot_duration()) + } + + fn authorities() -> Vec { + Aura::authorities().into_inner() + } + } + + impl frame_system_rpc_runtime_api::AccountNonceApi for Runtime { + fn account_nonce(account: AccountId) -> Index { + System::account_nonce(account) + } + } + + impl pallet_transaction_payment_rpc_runtime_api::TransactionPaymentApi for Runtime { + fn query_info( + uxt: ::Extrinsic, + len: u32, + ) -> pallet_transaction_payment_rpc_runtime_api::RuntimeDispatchInfo { + TransactionPayment::query_info(uxt, len) + } + fn query_fee_details( + uxt: ::Extrinsic, + len: u32, + ) -> pallet_transaction_payment::FeeDetails { + TransactionPayment::query_fee_details(uxt, len) + } + fn query_weight_to_fee(weight: Weight) -> Balance { + TransactionPayment::weight_to_fee(weight) + } + fn query_length_to_fee(length: u32) -> Balance { + TransactionPayment::length_to_fee(length) + } + } + + impl cumulus_primitives_core::CollectCollationInfo for Runtime { + fn collect_collation_info(header: &::Header) -> cumulus_primitives_core::CollationInfo { + ParachainSystem::collect_collation_info(header) + } + } + + impl fp_rpc::EthereumRuntimeRPCApi for Runtime { + fn chain_id() -> u64 { + ::ChainId::get() + } + + fn account_basic(address: H160) -> pallet_evm::Account { + let (account, _) = EVM::account_basic(&address); + account + } + + fn gas_price() -> U256 { + let (gas_price, _) = ::FeeCalculator::min_gas_price(); + gas_price + } + + fn account_code_at(address: H160) -> Vec { + pallet_evm::AccountCodes::::get(address) + } + + fn author() -> H160 { + >::find_author() + } + + fn storage_at(address: H160, index: U256) -> H256 { + let mut tmp = [0u8; 32]; + index.to_big_endian(&mut tmp); + pallet_evm::AccountStorages::::get(address, H256::from_slice(&tmp[..])) + } + + fn call( + from: H160, + to: H160, + data: Vec, + value: U256, + gas_limit: U256, + max_fee_per_gas: Option, + max_priority_fee_per_gas: Option, + nonce: Option, + estimate: bool, + access_list: Option)>>, + ) -> Result { + let config = if estimate { + let mut config = ::config().clone(); + config.estimate = true; + Some(config) + } else { + None + }; + + let is_transactional = false; + let validate = true; + + // Reused approach from Moonbeam since Frontier implementation doesn't support this + let mut estimated_transaction_len = data.len() + + // to: 20 + // from: 20 + // value: 32 + // gas_limit: 32 + // nonce: 32 + // 1 byte transaction action variant + // chain id 8 bytes + // 65 bytes signature + 210; + if max_fee_per_gas.is_some() { + estimated_transaction_len += 32; + } + if max_priority_fee_per_gas.is_some() { + estimated_transaction_len += 32; + } + if access_list.is_some() { + estimated_transaction_len += access_list.encoded_size(); + } + + let gas_limit = gas_limit.min(u64::MAX.into()).low_u64(); + let without_base_extrinsic_weight = true; + + let (weight_limit, proof_size_base_cost) = + match ::GasWeightMapping::gas_to_weight( + gas_limit, + without_base_extrinsic_weight + ) { + weight_limit if weight_limit.proof_size() > 0 => { + (Some(weight_limit), Some(estimated_transaction_len as u64)) + } + _ => (None, None), + }; + + ::Runner::call( + from, + to, + data, + value, + gas_limit.unique_saturated_into(), + max_fee_per_gas, + max_priority_fee_per_gas, + nonce, + Vec::new(), + is_transactional, + validate, + weight_limit, + proof_size_base_cost, + config + .as_ref() + .unwrap_or_else(|| ::config()), + ) + .map_err(|err| err.error.into()) + } + + fn create( + from: H160, + data: Vec, + value: U256, + gas_limit: U256, + max_fee_per_gas: Option, + max_priority_fee_per_gas: Option, + nonce: Option, + estimate: bool, + access_list: Option)>>, + ) -> Result { + let config = if estimate { + let mut config = ::config().clone(); + config.estimate = true; + Some(config) + } else { + None + }; + + let is_transactional = false; + let validate = true; + + // Reused approach from Moonbeam since Frontier implementation doesn't support this + let mut estimated_transaction_len = data.len() + + // to: 20 + // from: 20 + // value: 32 + // gas_limit: 32 + // nonce: 32 + // 1 byte transaction action variant + // chain id 8 bytes + // 65 bytes signature + 210; + if max_fee_per_gas.is_some() { + estimated_transaction_len += 32; + } + if max_priority_fee_per_gas.is_some() { + estimated_transaction_len += 32; + } + if access_list.is_some() { + estimated_transaction_len += access_list.encoded_size(); + } + + let gas_limit = gas_limit.min(u64::MAX.into()).low_u64(); + let without_base_extrinsic_weight = true; + + let (weight_limit, proof_size_base_cost) = + match ::GasWeightMapping::gas_to_weight( + gas_limit, + without_base_extrinsic_weight + ) { + weight_limit if weight_limit.proof_size() > 0 => { + (Some(weight_limit), Some(estimated_transaction_len as u64)) + } + _ => (None, None), + }; + + #[allow(clippy::or_fun_call)] // suggestion not helpful here + ::Runner::create( + from, + data, + value, + gas_limit.unique_saturated_into(), + max_fee_per_gas, + max_priority_fee_per_gas, + nonce, + Vec::new(), + is_transactional, + validate, + weight_limit, + proof_size_base_cost, + config + .as_ref() + .unwrap_or(::config()), + ) + .map_err(|err| err.error.into()) + } + + fn current_transaction_statuses() -> Option> { + pallet_ethereum::CurrentTransactionStatuses::::get() + } + + fn current_block() -> Option { + pallet_ethereum::CurrentBlock::::get() + } + + fn current_receipts() -> Option> { + pallet_ethereum::CurrentReceipts::::get() + } + + fn current_all() -> ( + Option, + Option>, + Option> + ) { + ( + pallet_ethereum::CurrentBlock::::get(), + pallet_ethereum::CurrentReceipts::::get(), + pallet_ethereum::CurrentTransactionStatuses::::get() + ) + } + + fn extrinsic_filter( + xts: Vec<::Extrinsic>, + ) -> Vec { + xts.into_iter().filter_map(|xt| match xt.0.function { + RuntimeCall::Ethereum(transact { transaction }) => Some(transaction), + _ => None + }).collect::>() + } + + fn elasticity() -> Option { + None + } + + fn gas_limit_multiplier_support() {} + + fn pending_block( + xts: Vec<::Extrinsic>, + ) -> (Option, Option>) { + for ext in xts.into_iter() { + let _ = Executive::apply_extrinsic(ext); + } + + Ethereum::on_finalize(System::block_number() + 1); + + ( + pallet_ethereum::CurrentBlock::::get(), + pallet_ethereum::CurrentTransactionStatuses::::get() + ) + } + } + + impl fp_rpc::ConvertTransactionRuntimeApi for Runtime { + fn convert_transaction(transaction: pallet_ethereum::Transaction) -> ::Extrinsic { + UncheckedExtrinsic::new_unsigned( + pallet_ethereum::Call::::transact { transaction }.into(), + ) + } + } + + impl moonbeam_rpc_primitives_debug::DebugRuntimeApi for Runtime { + fn trace_transaction( + extrinsics: Vec<::Extrinsic>, + traced_transaction: &pallet_ethereum::Transaction, + ) -> Result< + (), + sp_runtime::DispatchError, + > { + use moonbeam_evm_tracer::tracer::EvmTracer; + + // Apply the a subset of extrinsics: all the substrate-specific or ethereum + // transactions that preceded the requested transaction. + for ext in extrinsics.into_iter() { + let _ = match &ext.0.function { + RuntimeCall::Ethereum(pallet_ethereum::Call::transact { transaction }) => { + if transaction == traced_transaction { + EvmTracer::new().trace(|| Executive::apply_extrinsic(ext)); + return Ok(()); + } else { + Executive::apply_extrinsic(ext) + } + } + _ => Executive::apply_extrinsic(ext), + }; + } + Err(sp_runtime::DispatchError::Other( + "Failed to find Ethereum transaction among the extrinsics.", + )) + } + + fn trace_block( + extrinsics: Vec<::Extrinsic>, + known_transactions: Vec, + ) -> Result< + (), + sp_runtime::DispatchError, + > { + use moonbeam_evm_tracer::tracer::EvmTracer; + + let mut config = ::config().clone(); + config.estimate = true; + + // Apply all extrinsics. Ethereum extrinsics are traced. + for ext in extrinsics.into_iter() { + match &ext.0.function { + RuntimeCall::Ethereum(pallet_ethereum::Call::transact { transaction }) => { + if known_transactions.contains(&transaction.hash()) { + // Each known extrinsic is a new call stack. + EvmTracer::emit_new(); + EvmTracer::new().trace(|| Executive::apply_extrinsic(ext)); + } else { + let _ = Executive::apply_extrinsic(ext); + } + } + _ => { + let _ = Executive::apply_extrinsic(ext); + } + }; + } + + Ok(()) + } + } + + impl moonbeam_rpc_primitives_txpool::TxPoolRuntimeApi for Runtime { + fn extrinsic_filter( + xts_ready: Vec<::Extrinsic>, + xts_future: Vec<::Extrinsic>, + ) -> moonbeam_rpc_primitives_txpool::TxPoolResponse { + moonbeam_rpc_primitives_txpool::TxPoolResponse { + ready: xts_ready + .into_iter() + .filter_map(|xt| match xt.0.function { + RuntimeCall::Ethereum(pallet_ethereum::Call::transact { transaction }) => Some(transaction), + _ => None, + }) + .collect(), + future: xts_future + .into_iter() + .filter_map(|xt| match xt.0.function { + RuntimeCall::Ethereum(pallet_ethereum::Call::transact { transaction }) => Some(transaction), + _ => None, + }) + .collect(), + } + } + } + + #[cfg(feature = "try-runtime")] + impl frame_try_runtime::TryRuntime for Runtime { + fn on_runtime_upgrade(checks: frame_try_runtime::UpgradeCheckSelect) -> (Weight, Weight) { + // NOTE: intentional unwrap: we don't want to propagate the error backwards, and want to + // have a backtrace here. If any of the pre/post migration checks fail, we shall stop + // right here and right now. + log::info!("try-runtime::on_runtime_upgrade rococo."); + let weight = Executive::try_runtime_upgrade(checks).unwrap(); + (weight, RuntimeBlockWeights::get().max_block) + } + + fn execute_block(block: Block, state_root_check: bool,signature_check: bool, select: frame_try_runtime::TryStateSelect) -> Weight { + log::info!( + target: "runtime::Rococo", "try-runtime: executing block #{} ({:?}) / root checks: {:?} / sanity-checks: {:?}", + block.header.number, + block.header.hash(), + state_root_check, + select, + ); + Executive::try_execute_block(block, state_root_check, signature_check,select).expect("try_execute_block failed") + } + } + + #[cfg(feature = "runtime-benchmarks")] + impl frame_benchmarking::Benchmark for Runtime { + fn benchmark_metadata(extra: bool) -> ( + Vec, + Vec, + ) { + use frame_benchmarking::{Benchmarking, BenchmarkList}; + use frame_support::traits::StorageInfoTrait; + use frame_system_benchmarking::Pallet as SystemBench; + use cumulus_pallet_session_benchmarking::Pallet as SessionBench; + + let mut list = Vec::::new(); + list_benchmarks!(list, extra); + + let storage_info = AllPalletsWithSystem::storage_info(); + (list, storage_info) + } + + fn dispatch_benchmark( + config: frame_benchmarking::BenchmarkConfig + ) -> Result, sp_runtime::RuntimeString> { + use frame_benchmarking::{Benchmarking, BenchmarkBatch, TrackedStorageKey}; + + use frame_system_benchmarking::Pallet as SystemBench; + impl frame_system_benchmarking::Config for Runtime {} + + use cumulus_pallet_session_benchmarking::Pallet as SessionBench; + impl cumulus_pallet_session_benchmarking::Config for Runtime {} + + let whitelist: Vec = vec![ + // Block Number + hex!("26aa394eea5630e07c48ae0c9558cef702a5c1b19ab7a04f536c519aca4983ac").to_vec().into(), + // Total Issuance + hex!("c2261276cc9d1f8598ea4b6a74b15c2f57c875e4cff74148e4628f264b974c80").to_vec().into(), + // Execution Phase + hex!("26aa394eea5630e07c48ae0c9558cef7ff553b5a9862a516939d82b3d3d8661a").to_vec().into(), + // Event Count + hex!("26aa394eea5630e07c48ae0c9558cef70a98fdbe9ce6c55837576c60c7af3850").to_vec().into(), + // System Events + hex!("26aa394eea5630e07c48ae0c9558cef780d41e5e16056765bc8461851072c9d7").to_vec().into(), + ]; + + let mut batches = Vec::::new(); + let params = (&config, &whitelist); + add_benchmarks!(params, batches); + + if batches.is_empty() { return Err("Benchmark not found for this pallet.".into()) } + Ok(batches) + } + } +} + +struct CheckInherents; + +impl cumulus_pallet_parachain_system::CheckInherents for CheckInherents { + fn check_inherents( + block: &Block, + relay_state_proof: &cumulus_pallet_parachain_system::RelayChainStateProof, + ) -> sp_inherents::CheckInherentsResult { + let relay_chain_slot = relay_state_proof + .read_slot() + .expect("Could not read the relay chain slot from the proof"); + + let inherent_data = + cumulus_primitives_timestamp::InherentDataProvider::from_relay_chain_slot_and_duration( + relay_chain_slot, + sp_std::time::Duration::from_secs(6), + ) + .create_inherent_data() + .expect("Could not create the timestamp inherent data"); + + inherent_data.check_extrinsics(block) + } +} + +cumulus_pallet_parachain_system::register_validate_block! { + Runtime = Runtime, + BlockExecutor = cumulus_pallet_aura_ext::BlockExecutor::, + CheckInherents = CheckInherents, +} diff --git a/runtime/paseo/src/migration/P9100.rs b/runtime/paseo/src/migration/P9100.rs new file mode 100644 index 0000000000..3765266c0f --- /dev/null +++ b/runtime/paseo/src/migration/P9100.rs @@ -0,0 +1,301 @@ +// Copyright 2020-2021 Trust Computing GmbH. +// This file is part of Litentry. +// +// Litentry is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Litentry 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 +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Litentry. If not, see . +use frame_support::{ + inherent::Vec, + pallet_prelude::*, + storage::storage_prefix, + traits::{Currency, Get, OnRuntimeUpgrade}, + StorageHasher, Twox128, +}; +use pallet_parachain_staking::BalanceOf; +use sp_runtime::{traits::Zero, Perbill}; +use sp_std::marker::PhantomData; + +pub struct MigrateCollatorSelectionIntoParachainStaking(PhantomData); +impl OnRuntimeUpgrade for MigrateCollatorSelectionIntoParachainStaking +where + T: pallet_parachain_staking::Config + pallet_bridge_transfer::Config, + ::Event: From>, +{ + #[cfg(feature = "try-runtime")] + fn pre_upgrade() -> Result<(), &'static str> { + use frame_support::traits::OnRuntimeUpgradeHelpersExt; + use core_primitives::AccountId; + + log::info!("Pre check pallet CollatorSelection exists"); + // Get Invulnerables address from CollatorSelection + // WARN: We do not care about any Candidates storage, as we forbid any general transaction + // by sudo and so no info there in practice + let invulnerables = frame_support::storage::migration::get_storage_value::>( + b"CollatorSelection", + b"Invulnerables", + b"", + ) + .expect("Storage query fails: CollatorSelection Invulnerables"); + + if invulnerables.is_empty() { + return Err("CollatorSelection empty") + }; + let invulnerables_len: u32 = invulnerables.len().try_into().unwrap_or(0); + assert!( + invulnerables_len >= + ::MinSelectedCandidates::get(), + "Need More Initial Candidates" + ); + + // Set the temporary storage for post upgrade check + Self::set_temp_storage(invulnerables, "invulnerables"); + + // Ensure ParachainStaking is Empty + assert!( + !frame_support::storage::migration::have_storage_value( + b"ParachainStaking", + b"SelectedCandidates", + b"", + ), + "ParachainStaking SelectedCandidates Storage Already Exist" + ); + + assert!( + !frame_support::storage::migration::have_storage_value( + b"ParachainStaking", + b"CandidatePool", + b"", + ), + "ParachainStaking CandidatePool Storage Already Exist" + ); + + assert!( + !frame_support::storage::migration::have_storage_value( + b"ParachainStaking", + b"Total", + b"", + ), + "ParachainStaking Total Storage Already Exist" + ); + Ok(()) + } + + fn on_runtime_upgrade() -> frame_support::weights::Weight { + use sp_io::KillStorageResult; + let mut invulnerables = frame_support::storage::migration::get_storage_value::< + Vec<::AccountId>, + >(b"CollatorSelection", b"Invulnerables", b"") + .expect("Storage query fails: CollatorSelection Invulnerables"); + invulnerables.sort(); + + let invulnerables_len: u32 = invulnerables.len().try_into().unwrap_or(0); + assert!( + invulnerables_len >= + ::MinSelectedCandidates::get(), + "Need More Initial Candidates" + ); + + // Add whitelist Storage + frame_support::storage::migration::put_storage_value::< + Vec<::AccountId>, + >(b"ParachainStaking", b"Candidates", b"", invulnerables.clone()); + + let mut candidate_count = 0u32; + // Get the minimum collator stake amount + let min_collator_stk = ::MinCollatorStk::get(); + // Initialize the candidates + for candidate in invulnerables { + assert!( + ::Currency::free_balance(&candidate) >= + min_collator_stk, + "Account does not have enough balance to bond as a candidate." + ); + + if let Err(error) = >::join_candidates( + ::Origin::from(Some(candidate.clone()).into()), + min_collator_stk, + ) { + log::warn!("Join candidates failed in genesis with error {:?}", error); + } else { + candidate_count = candidate_count.saturating_add(1u32); + } + } + + assert!(candidate_count > 0, "No valid candidates"); + + // Reproduce the genesis build + // Initialize the rest setup of parachain-staking + // After runtimeUpgrade, we should: + // (1) Set the inflation by set_inflation + // (2) Set collator commission by set_collator_commission + // (3) Set parachain bond config by parachset_parachain_bond_account + // (4) Set total selected candidates to minimum config set_total_selected + // (5) Choose top TotalSelected collator candidates + // (6) Refresh round if it is during runtimeUpgrade + // (7) Snapshot total staked (through select_top_candidates) + // (8) NewRound Event Deposit + + // Inflation config as Default, so do nothing + // ... + // Set collator commission to default config + frame_support::storage::migration::put_storage_value::( + b"ParachainStaking", + b"CollatorCommission", + b"", + ::DefaultCollatorCommission::get(), + ); + // Set parachain bond config to default config + frame_support::storage::migration::put_storage_value::< + pallet_parachain_staking::ParachainBondConfig<::AccountId>, + >( + b"ParachainStaking", + b"ParachainBondInfo", + b"", + pallet_parachain_staking::ParachainBondConfig { + // must be set soon; if not => due inflation will be sent to some weird place + account: ::AccountId::decode( + &mut sp_runtime::traits::TrailingZeroInput::zeroes(), + ) + .expect("infinite length input; no invalid inputs for type; qed"), + percent: + ::DefaultParachainBondReservePercent::get( + ), + }, + ); + + // // Set total selected candidates to minimum config + frame_support::storage::migration::put_storage_value::( + b"ParachainStaking", + b"TotalSelected", + b"", + candidate_count, + ); + // Choose top TotalSelected collator candidates + // WARNING/TODO: We change the private into public of select_top_candidates function in + // pallet. We should change it back in next runtime upgrade for safety. + let (v_count, _, total_staked) = + >::select_top_candidates(1u32); + + // Start Round 1 at Block 0 + let round: pallet_parachain_staking::RoundInfo<::BlockNumber> = + pallet_parachain_staking::RoundInfo::new( + 1u32, + 0u32.into(), + ::DefaultBlocksPerRound::get(), + ); + frame_support::storage::migration::put_storage_value::< + pallet_parachain_staking::RoundInfo<::BlockNumber>, + >(b"ParachainStaking", b"Round", b"", round); + + // // Snapshot total stake + // The code below is supposed to behave same as: + // >::insert(1u32, >::get()) + let val = frame_support::storage::migration::get_storage_value::>( + b"ParachainStaking", + b"Total", + b"", + ); + let storage_prefix = storage_prefix(b"ParachainStaking", b"Staked"); + let key_hashed = 1u32.using_encoded(Twox64Concat::hash); + let mut final_key = Vec::with_capacity(storage_prefix.len() + key_hashed.len()); + final_key.extend_from_slice(&storage_prefix); + final_key.extend_from_slice(key_hashed.as_ref()); + frame_support::storage::unhashed::put(final_key.as_ref(), &val); + + // Deposit NewRound event at RuntimeUpgrade + >::deposit_event(pallet_parachain_staking::Event::NewRound { + starting_block: ::BlockNumber::zero(), + round: 1u32, + selected_collators_number: v_count, + total_balance: total_staked, + }); + + // Remove CollatorSelection Storage + // TODO: Very Weak safety + let entries: u64 = 4 + 6142; + let _res: KillStorageResult = frame_support::storage::unhashed::clear_prefix( + &Twox128::hash(b"CollatorSelection"), + Some(entries.try_into().unwrap()), + None, + ) + .into(); + ::DbWeight::get().writes(entries) + } + + #[cfg(feature = "try-runtime")] + fn post_upgrade() -> Result<(), &'static str> { + use frame_support::traits::OnRuntimeUpgradeHelpersExt; + use core_primitives::AccountId; + use sp_io::KillStorageResult; + + log::info!("Post check CollatorSelection"); + let res: KillStorageResult = frame_support::storage::unhashed::clear_prefix( + &Twox128::hash(b"CollatorSelection"), + Some(0), + None, + ) + .into(); + + match res { + KillStorageResult::AllRemoved(0) | KillStorageResult::SomeRemaining(0) => {}, + KillStorageResult::AllRemoved(n) | KillStorageResult::SomeRemaining(n) => { + log::error!("Remaining entries: {:?}", n); + return Err("CollatorSelection not removed") + }, + }; + + assert!( + frame_support::storage::migration::have_storage_value( + b"ParachainStaking", + b"CandidatePool", + b"", + ), + "ParachainStaking CandidatePool Storage not migrate properly" + ); + + assert!( + frame_support::storage::migration::have_storage_value( + b"ParachainStaking", + b"Total", + b"", + ), + "ParachainStaking Total Storage not migrate properly" + ); + + // Check the Selected Candidates info + let mut selected_candidates = frame_support::storage::migration::get_storage_value::< + Vec, + >(b"ParachainStaking", b"SelectedCandidates", b"") + .expect("Storage query fails: ParachainStaking SelectedCandidates"); + selected_candidates.sort(); + let mut invulnerables: Vec = + Self::get_temp_storage("invulnerables").expect("qed"); + invulnerables.sort(); + + assert!(selected_candidates == invulnerables, "candidates not migrate properly"); + + // Check the Round info + let round_info = frame_support::storage::migration::get_storage_value::< + pallet_parachain_staking::RoundInfo, + >(b"ParachainStaking", b"Round", b"") + .expect("Storage query fails: ParachainStaking Round"); + + let expected_round_info = pallet_parachain_staking::RoundInfo::::new( + 1u32, + 0u32.into(), + ::DefaultBlocksPerRound::get(), + ); + assert!(round_info == expected_round_info, "round info not migrate properly"); + + Ok(()) + } +} diff --git a/runtime/paseo/src/migration/P9130.rs b/runtime/paseo/src/migration/P9130.rs new file mode 100644 index 0000000000..dae4fb4e22 --- /dev/null +++ b/runtime/paseo/src/migration/P9130.rs @@ -0,0 +1,208 @@ +// Copyright 2020-2021 Trust Computing GmbH. +// This file is part of Litentry. +// +// Litentry is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Litentry 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 +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Litentry. If not, see . +#![allow(deprecated)] +#![allow(clippy::type_complexity)] +use frame_support::{ + storage, + traits::{Get, OnRuntimeUpgrade}, +}; +use pallet_parachain_staking::{ + AtStake, BalanceOf, BondWithAutoCompound, CollatorSnapshot, Round, RoundIndex, +}; +use sp_runtime::Percent; +use sp_std::{marker::PhantomData, prelude::*, vec::Vec}; + +use parity_scale_codec::{Decode, Encode}; +extern crate alloc; +#[cfg(feature = "try-runtime")] +use alloc::{format, string::ToString}; +#[cfg(feature = "try-runtime")] +use scale_info::prelude::string::String; +#[cfg(feature = "try-runtime")] +use sp_std::{collections::btree_map::BTreeMap, vec}; + +mod deprecated { + use super::*; + use frame_support::RuntimeDebug; + use pallet_parachain_staking::Bond; + use scale_info::TypeInfo; + // CollatorSnapshot + #[deprecated(note = "use CollatorSnapshot with BondWithAutoCompound delegations")] + #[derive(Encode, Decode, RuntimeDebug, TypeInfo)] + /// Snapshot of collator state at the start of the round for which they are selected + pub struct CollatorSnapshot { + /// The total value locked by the collator. + pub bond: Balance, + + /// The rewardable delegations. This list is a subset of total delegators, where certain + /// delegators are adjusted based on their scheduled + /// [DelegationChange::Revoke] or [DelegationChange::Decrease] action. + pub delegations: Vec>, + + /// The total counted value locked for the collator, including the self bond + total staked + /// by top delegators. + pub total: Balance, + } + + impl PartialEq for CollatorSnapshot { + fn eq(&self, other: &Self) -> bool { + let must_be_true = self.bond == other.bond && self.total == other.total; + if !must_be_true { + return false + } + for (Bond { owner: o1, amount: a1 }, Bond { owner: o2, amount: a2 }) in + self.delegations.iter().zip(other.delegations.iter()) + { + if o1 != o2 || a1 != a2 { + return false + } + } + true + } + } + + impl Default for CollatorSnapshot { + fn default() -> CollatorSnapshot { + CollatorSnapshot { bond: B::default(), delegations: Vec::new(), total: B::default() } + } + } +} +use deprecated::CollatorSnapshot as OldCollatorSnapshot; +pub struct MigrateAtStakeAutoCompound(PhantomData); +impl MigrateAtStakeAutoCompound { + /// Get keys for the `AtStake` storage for the rounds up to `RewardPaymentDelay` rounds ago. + /// We migrate only the last unpaid rounds due to the presence of stale entries in `AtStake` + /// which significantly increase the PoV size. + fn unpaid_rounds_keys() -> impl Iterator)> { + let current_round = >::get().current; + let max_unpaid_round = current_round.saturating_sub(T::RewardPaymentDelay::get()); + (max_unpaid_round..=current_round).into_iter().flat_map(|round| { + >::iter_key_prefix(round).map(move |candidate| { + let key = >::hashed_key_for(round, candidate.clone()); + (round, candidate, key) + }) + }) + } +} +impl OnRuntimeUpgrade for MigrateAtStakeAutoCompound +where + T: pallet_parachain_staking::Config, +{ + #[cfg(feature = "try-runtime")] + fn pre_upgrade() -> Result, &'static str> { + let mut num_to_update = 0u32; + let mut rounds_candidates: Vec<(RoundIndex, T::AccountId)> = vec![]; + let mut state_map: BTreeMap = BTreeMap::new(); + + for (round, candidate, key) in Self::unpaid_rounds_keys() { + let state: OldCollatorSnapshot> = + storage::unhashed::get(&key).expect("unable to decode value"); + + num_to_update = num_to_update.saturating_add(1); + rounds_candidates.push((round, candidate.clone())); + let mut delegation_str = vec![]; + for d in state.delegations { + delegation_str + .push(format!("owner={:?}_amount={:?}_autoCompound=0%", d.owner, d.amount)); + } + state_map.insert( + (*format!("round_{:?}_candidate_{:?}", round, candidate)).to_string(), + format!( + "bond={:?}_total={:?}_delegations={:?}", + state.bond, state.total, delegation_str + ), + ); + } + + rounds_candidates.sort(); + Ok((state_map, rounds_candidates, num_to_update).encode()) + } + + fn on_runtime_upgrade() -> frame_support::weights::Weight { + log::info!( + target: "MigrateAtStakeAutoCompound", + "running migration to add auto-compound values" + ); + let mut reads = 0u64; + let mut writes = 0u64; + for (round, candidate, key) in Self::unpaid_rounds_keys() { + let old_state: OldCollatorSnapshot> = + storage::unhashed::get(&key).expect("unable to decode value"); + reads = reads.saturating_add(1); + writes = writes.saturating_add(1); + log::info!( + target: "MigrateAtStakeAutoCompound", + "migration from old format round {:?}, candidate {:?}", round, candidate + ); + let new_state = CollatorSnapshot { + bond: old_state.bond, + delegations: old_state + .delegations + .into_iter() + .map(|d| BondWithAutoCompound { + owner: d.owner, + amount: d.amount, + auto_compound: Percent::zero(), + }) + .collect(), + total: old_state.total, + }; + storage::unhashed::put(&key, &new_state); + } + + T::DbWeight::get().reads_writes(reads, writes) + } + + #[cfg(feature = "try-runtime")] + fn post_upgrade(state: Vec) -> Result<(), &'static str> { + let (state_map, rounds_candidates_received, num_updated_received): ( + BTreeMap, + Vec<(RoundIndex, T::AccountId)>, + u32, + ) = Decode::decode(&mut &state[..]).expect("pre_upgrade provides a valid state; qed"); + + let mut num_updated = 0u32; + let mut rounds_candidates = vec![]; + for (round, candidate, _) in Self::unpaid_rounds_keys() { + let state = >::get(round, &candidate); + num_updated = num_updated.saturating_add(1); + rounds_candidates.push((round, candidate.clone())); + let mut delegation_str = vec![]; + for d in state.delegations { + delegation_str.push(format!( + "owner={:?}_amount={:?}_autoCompound={:?}", + d.owner, d.amount, d.auto_compound + )); + } + assert_eq!( + Some(&format!( + "bond={:?}_total={:?}_delegations={:?}", + state.bond, state.total, delegation_str + )), + state_map + .get(&((*format!("round_{:?}_candidate_{:?}", round, candidate)).to_string())), + "incorrect delegations migration for round_{:?}_candidate_{:?}", + round, + candidate, + ); + } + + rounds_candidates.sort(); + assert_eq!(rounds_candidates, rounds_candidates_received); + assert_eq!(num_updated, num_updated_received); + Ok(()) + } +} diff --git a/runtime/paseo/src/migration/P9190/balances_transaction_payment.rs b/runtime/paseo/src/migration/P9190/balances_transaction_payment.rs new file mode 100644 index 0000000000..f1d4caed2b --- /dev/null +++ b/runtime/paseo/src/migration/P9190/balances_transaction_payment.rs @@ -0,0 +1,311 @@ +// Copyright 2020-2024 Trust Computing GmbH. +// This file is part of Litentry. +// +// Litentry is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Litentry 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 +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Litentry. If not, see . +#![allow(clippy::type_complexity)] + +use frame_support::{ + migration::storage_key_iter, + pallet_prelude::*, + traits::{Get, OnRuntimeUpgrade}, + Blake2_128Concat, WeakBoundedVec, +}; +use frame_system::{Account, AccountInfo}; +use pallet_balances::{ + Account as BAccount, AccountData, BalanceLock, Freezes, Holds, InactiveIssuance, Locks, + Reserves, TotalIssuance, +}; +use sp_std::{marker::PhantomData, vec::Vec}; + +pub const DECIMAL_CONVERTOR: u128 = 1_000_000u128; + +#[cfg(feature = "try-runtime")] +use parity_scale_codec::Encode; +#[cfg(feature = "try-runtime")] +use sp_std::collections::btree_map::BTreeMap; +use storage::migration::get_storage_value; + +// Replace Frame System Storage for Decimal Change from 12 to 18 +// Replace Balances Storage for Decimal Change from 12 to 18 +pub struct ReplaceBalancesRelatedStorage(PhantomData); +impl ReplaceBalancesRelatedStorage +where + T: frame_system::Config> + + pallet_balances::Config, +{ + pub fn replace_frame_system_account_storage() -> frame_support::weights::Weight { + // The storage of Account for pallet balances is in frame_system pallet + log::info!( + target: "ReplaceBalancesRelatedStorage", + "running migration to Frame System Account" + ); + let pallet_prefix: &[u8] = b"System"; + let storage_item_prefix: &[u8] = b"Account"; + let mut weight: Weight = frame_support::weights::Weight::zero(); + + for (account, mut account_info) in storage_key_iter::< + T::AccountId, + AccountInfo, + Blake2_128Concat, + >(pallet_prefix, storage_item_prefix) + .drain() + { + account_info.data.free = account_info.data.free.saturating_mul(DECIMAL_CONVERTOR); + account_info.data.reserved = + account_info.data.reserved.saturating_mul(DECIMAL_CONVERTOR); + // Runtime migration is wrong at first. The below code has been mistakenly applied to + // online rococo account_info.data.frozen = + // account_info.data.reserved.saturating_mul(DECIMAL_CONVERTOR); + account_info.data.frozen = account_info.data.frozen.saturating_mul(DECIMAL_CONVERTOR); + + >::insert(&account, account_info); + weight += T::DbWeight::get().reads_writes(1, 1); + } + weight + } + pub fn repalce_balances_total_issuance_storage() -> frame_support::weights::Weight { + log::info!( + target: "ReplaceBalancesRelatedStorage", + "running migration to Balances TotalIssuance" + ); + let pallet_prefix: &[u8] = b"Balances"; + let storage_item_prefix: &[u8] = b"TotalIssuance"; + let stored_data = get_storage_value::(pallet_prefix, storage_item_prefix, b"") + .expect("Storage query fails: Balances TotalIssuance"); + >::put(stored_data.saturating_mul(DECIMAL_CONVERTOR)); + let weight = T::DbWeight::get(); + frame_support::weights::Weight::from_parts(0, weight.write + weight.read) + } + pub fn repalce_balances_inactive_issuance_storage() -> frame_support::weights::Weight { + log::info!( + target: "ReplaceBalancesRelatedStorage", + "running migration to Balances InactiveIssuance" + ); + let pallet_prefix: &[u8] = b"Balances"; + let storage_item_prefix: &[u8] = b"InactiveIssuance"; + let stored_data = get_storage_value::(pallet_prefix, storage_item_prefix, b"") + .expect("Storage query fails: Balances InactiveIssuance"); + >::put(stored_data.saturating_mul(DECIMAL_CONVERTOR)); + let weight = T::DbWeight::get(); + frame_support::weights::Weight::from_parts(0, weight.write + weight.read) + } + pub fn replace_balances_locks_storage() -> frame_support::weights::Weight { + log::info!( + target: "ReplaceBalancesRelatedStorage", + "running checking to Balances Locks" + ); + let pallet_prefix: &[u8] = b"Balances"; + let storage_item_prefix: &[u8] = b"Locks"; + let mut weight: Weight = frame_support::weights::Weight::zero(); + + for (account, mut locks) in storage_key_iter::< + T::AccountId, + WeakBoundedVec, T::MaxLocks>, + Blake2_128Concat, + >(pallet_prefix, storage_item_prefix) + .drain() + { + let new_locks: &mut WeakBoundedVec, T::MaxLocks> = &mut locks; + for balance_lock in new_locks.into_iter() { + balance_lock.amount = balance_lock.amount.saturating_mul(DECIMAL_CONVERTOR); + } + >::insert(&account, new_locks); + weight += T::DbWeight::get().reads_writes(1, 1); + } + + weight + } +} + +#[cfg(feature = "try-runtime")] +impl ReplaceBalancesRelatedStorage +where + T: frame_system::Config> + + pallet_balances::Config, +{ + pub fn pre_upgrade_frame_system_account_storage() -> Result, &'static str> { + let result: BTreeMap>> = + >::iter() + .map(|(account, state)| { + let mut new_account: AccountInfo> = state; + new_account.data.free = new_account.data.free.saturating_mul(DECIMAL_CONVERTOR); + new_account.data.reserved = + new_account.data.reserved.saturating_mul(DECIMAL_CONVERTOR); + new_account.data.frozen = + new_account.data.frozen.saturating_mul(DECIMAL_CONVERTOR); + + (account, new_account) + }) + .collect(); + Ok(result.encode()) + } + pub fn post_upgrade_frame_system_account_storage(state: Vec) -> Result<(), &'static str> { + let expected_state = + BTreeMap::>>::decode( + &mut &state[..], + ) + .map_err(|_| "Failed to decode AccountInfo")?; + for (account, actual_result) in >::iter() { + let expected_result: AccountInfo> = + expected_state.get(&account).ok_or("Not Expected AccountInfo")?.clone(); + assert_eq!(expected_result, actual_result); + } + Ok(()) + } + pub fn pre_upgrade_balances_total_issuance_storage() -> Result, &'static str> { + Ok(>::get().saturating_mul(DECIMAL_CONVERTOR).encode()) + } + pub fn post_upgrade_balances_total_issuance_storage( + state: Vec, + ) -> Result<(), &'static str> { + let expected_state = + u128::decode(&mut &state[..]).map_err(|_| "Failed to decode Total Balance")?; + let actual_state = >::get(); + assert_eq!(expected_state, actual_state); + Ok(()) + } + pub fn pre_upgrade_balances_inactive_issuance_storage() -> Result, &'static str> { + Ok(>::get().saturating_mul(DECIMAL_CONVERTOR).encode()) + } + pub fn post_upgrade_balances_inactive_issuance_storage( + state: Vec, + ) -> Result<(), &'static str> { + let expected_state = + u128::decode(&mut &state[..]).map_err(|_| "Failed to decode Total Balance")?; + let actual_state = >::get(); + assert_eq!(expected_state, actual_state); + Ok(()) + } + pub fn pre_upgrade_balances_account_check() -> Result, &'static str> { + assert!(>::iter().next().is_none()); + Ok(Vec::::new()) + } + pub fn post_upgrade_balances_account_check(_state: Vec) -> Result<(), &'static str> { + assert!(>::iter().next().is_none()); + Ok(()) + } + pub fn pre_upgrade_balances_locks_storage() -> Result, &'static str> { + let result: BTreeMap>> = >::iter() + .map(|(account, state)| { + let mut new_locks: Vec> = state.into_inner(); + for balance_lock in new_locks.iter_mut() { + balance_lock.amount = balance_lock.amount.saturating_mul(DECIMAL_CONVERTOR); + } + (account, new_locks) + }) + .collect(); + Ok(result.encode()) + } + pub fn post_upgrade_balances_locks_storage(state: Vec) -> Result<(), &'static str> { + let expected_state = + BTreeMap::>>::decode(&mut &state[..]) + .map_err(|_| "Failed to decode Locks")?; + for (account, actual_result) in >::iter() { + let expected_result: Vec> = + expected_state.get(&account).ok_or("Not Expected Locks")?.clone(); + assert_eq!(expected_result.encode(), actual_result.into_inner().encode()); + } + Ok(()) + } + pub fn pre_upgrade_balances_reserves_check() -> Result, &'static str> { + assert!(>::iter().next().is_none()); + Ok(Vec::::new()) + } + pub fn post_upgrade_balances_reserves_check(_state: Vec) -> Result<(), &'static str> { + assert!(>::iter().next().is_none()); + Ok(()) + } + pub fn pre_upgrade_balances_holds_check() -> Result, &'static str> { + assert!(>::iter().next().is_none()); + Ok(Vec::::new()) + } + pub fn post_upgrade_balances_holds_check(_state: Vec) -> Result<(), &'static str> { + assert!(>::iter().next().is_none()); + Ok(()) + } + pub fn pre_upgrade_balances_freezes_check() -> Result, &'static str> { + assert!(>::iter().next().is_none()); + Ok(Vec::::new()) + } + pub fn post_upgrade_balances_freezes_check(_state: Vec) -> Result<(), &'static str> { + assert!(>::iter().next().is_none()); + Ok(()) + } +} + +impl OnRuntimeUpgrade for ReplaceBalancesRelatedStorage +where + T: frame_system::Config> + + pallet_balances::Config, +{ + #[cfg(feature = "try-runtime")] + fn pre_upgrade() -> Result, &'static str> { + let frame_system_account_vec = Self::pre_upgrade_frame_system_account_storage()?; + let balances_total_issuance_vec = Self::pre_upgrade_balances_total_issuance_storage()?; + let balances_inactive_issuance_vec = + Self::pre_upgrade_balances_inactive_issuance_storage()?; + + let _ = Self::pre_upgrade_balances_account_check()?; + + let balances_locks_vec = Self::pre_upgrade_balances_locks_storage()?; + + let _ = Self::pre_upgrade_balances_reserves_check()?; + let _ = Self::pre_upgrade_balances_holds_check()?; + let _ = Self::pre_upgrade_balances_freezes_check()?; + + Ok(( + frame_system_account_vec, + balances_total_issuance_vec, + balances_inactive_issuance_vec, + balances_locks_vec, + ) + .encode()) + } + + fn on_runtime_upgrade() -> frame_support::weights::Weight { + let mut weight = frame_support::weights::Weight::from_parts(0, 0); + // The storage of pallet balances is in frame_system pallet + weight += Self::replace_frame_system_account_storage(); + weight += Self::repalce_balances_total_issuance_storage(); + weight += Self::repalce_balances_inactive_issuance_storage(); + + // The storage of Account for pallet balances is in frame_system pallet + // Should be empty + + weight += Self::replace_balances_locks_storage(); + + // The storage of Reserves/Holds/Freezes for pallet balances is in frame_system pallet + // Should be empty + + weight + } + + #[cfg(feature = "try-runtime")] + fn post_upgrade(state: Vec) -> Result<(), &'static str> { + let pre_vec: (Vec, Vec, Vec, Vec) = + Decode::decode(&mut &state[..]).map_err(|_| "Failed to decode Tuple")?; + Self::post_upgrade_frame_system_account_storage(pre_vec.0)?; + Self::post_upgrade_balances_total_issuance_storage(pre_vec.1)?; + Self::post_upgrade_balances_inactive_issuance_storage(pre_vec.2)?; + + Self::post_upgrade_balances_account_check(Vec::::new())?; + + Self::post_upgrade_balances_locks_storage(pre_vec.3)?; + + Self::post_upgrade_balances_reserves_check(Vec::::new())?; + Self::post_upgrade_balances_holds_check(Vec::::new())?; + Self::post_upgrade_balances_freezes_check(Vec::::new())?; + Ok(()) + } +} diff --git a/runtime/paseo/src/migration/P9190/bridge_related.rs b/runtime/paseo/src/migration/P9190/bridge_related.rs new file mode 100644 index 0000000000..69192a8398 --- /dev/null +++ b/runtime/paseo/src/migration/P9190/bridge_related.rs @@ -0,0 +1,300 @@ +// Copyright 2020-2024 Trust Computing GmbH. +// This file is part of Litentry. +// +// Litentry is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Litentry 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 +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Litentry. If not, see . +#![allow(clippy::type_complexity)] + +use frame_support::{ + migration::{clear_storage_prefix, storage_key_iter}, + pallet_prelude::*, + traits::{Get, OnRuntimeUpgrade}, + Blake2_256, Twox64Concat, +}; +use pallet_assets_handler::{AssetInfo, ExternalBalances, MaximumIssuance, ResourceToAssetInfo}; +use pallet_balances::AccountData; +use pallet_bridge::{BridgeChainId, ResourceId}; +use sp_std::{marker::PhantomData, vec::Vec}; + +pub const DECIMAL_CONVERTOR: u128 = 1_000_000u128; + +use hex_literal::hex; +#[cfg(feature = "try-runtime")] +use parity_scale_codec::Encode; +use storage::migration::get_storage_value; + +mod old { + use super::*; + #[frame_support::storage_alias] + pub type BridgeBalances = StorageDoubleMap< + pallet_bridge_transfer::Pallet, + Twox64Concat, + ResourceId, + Twox64Concat, + ::AccountId, + u128, + >; + + #[frame_support::storage_alias] + pub type Resources = + StorageMap, Blake2_256, ResourceId, Vec>; + + #[frame_support::storage_alias] + pub type BridgeFee = + StorageMap, Twox64Concat, BridgeChainId, u128>; +} + +pub const NATIVE_TOKEN_RESOURCE_ID: [u8; 32] = + hex!("00000000000000000000000000000063a7e2be78898ba83824b0c0cc8dfb6001"); +// Hard coded key of NATIVE_TOKEN_RESOURCE_ID +pub const BLAKE2_256_KEY: [u8; 32] = + hex!("560cf5c8bfa0719141e0d1b33ae9fec279c53682ce13220d526ad79cccc8aead"); + +// Replace Frame System Storage for Decimal Change from 12 to 18 +// Replace Balances Storage for Decimal Change from 12 to 18 +pub struct ReplaceBridgeRelatedStorage(PhantomData); +impl ReplaceBridgeRelatedStorage +where + T: frame_system::Config> + + pallet_assets::Config + + pallet_assets_handler::Config + + pallet_balances::Config + + pallet_bridge::Config + + pallet_bridge_transfer::Config, +{ + pub fn relocate_resource_fee_storage() -> frame_support::weights::Weight { + log::info!( + target: "ReplaceBridgeRelatedStorage", + "running migration to Bridge Resources/Bridge Fee" + ); + + // We get only one resource registed + // Which is native tokrn + // Resources Storage is using Blake2_256 + // So we can not reverse it out + // Must hardcode back in + let pallet_prefix: &[u8] = b"ChainBridge"; + let storage_item_prefix_resources: &[u8] = b"Resources"; + let _ = clear_storage_prefix(pallet_prefix, storage_item_prefix_resources, &[], None, None); + // Must hardcode back in + let resource_id: ResourceId = NATIVE_TOKEN_RESOURCE_ID; + + // This is fee for native token + // There should be only 1 item + let storage_item_prefix_fee: &[u8] = b"BridgeFee"; + let stored_data_fee: Vec<_> = storage_key_iter::( + pallet_prefix, + storage_item_prefix_fee, + ) + .collect(); + let _ = clear_storage_prefix(pallet_prefix, storage_item_prefix_fee, &[], None, None); + + // Replace into new storage of AssetsHandler + let fee: u128 = stored_data_fee[0].1.saturating_mul(DECIMAL_CONVERTOR); + let asset_info: AssetInfo = AssetInfo { + fee, + asset: None, // None for native token Asset Id + }; + >::insert(resource_id, asset_info); + + let weight = T::DbWeight::get(); + frame_support::weights::Weight::from_parts(0, 2 * (weight.write + weight.read)) + } + pub fn delete_bridge_balances_storage() -> frame_support::weights::Weight { + log::info!( + target: "ReplaceBridgeRelatedStorage", + "running migration to Bridge Transfer Bridge Balances" + ); + + let result = old::BridgeBalances::::clear(u32::MAX, None); + + let weight = T::DbWeight::get(); + frame_support::weights::Weight::from_parts( + 0, + u64::from(result.unique).saturating_mul(weight.write + weight.read), + ) + } + pub fn relocate_external_balance_storage() -> frame_support::weights::Weight { + log::info!( + target: "ReplaceBridgeRelatedStorage", + "running migration to ExternalBalances" + ); + let pallet_prefix: &[u8] = b"BridgeTransfer"; + let storage_item_prefix: &[u8] = b"ExternalBalances"; + let stored_data = get_storage_value::(pallet_prefix, storage_item_prefix, b"") + .expect("Storage query fails: BridgeTransfer ExternalBalances"); + let _ = clear_storage_prefix(pallet_prefix, storage_item_prefix, &[], None, None); + + >::put(stored_data.saturating_mul(DECIMAL_CONVERTOR)); + let weight = T::DbWeight::get(); + frame_support::weights::Weight::from_parts(0, weight.write + weight.read) + } + pub fn relocate_maximum_issuance_storage() -> frame_support::weights::Weight { + log::info!( + target: "ReplaceBridgeRelatedStorage", + "running migration to MaximumIssuance" + ); + let pallet_prefix: &[u8] = b"BridgeTransfer"; + let storage_item_prefix: &[u8] = b"MaximumIssuance"; + let stored_data = get_storage_value::(pallet_prefix, storage_item_prefix, b"") + .expect("Storage query fails: BridgeTransfer MaximumIssuance"); + let _ = clear_storage_prefix(pallet_prefix, storage_item_prefix, &[], None, None); + + >::put(stored_data.saturating_mul(DECIMAL_CONVERTOR)); + let weight = T::DbWeight::get(); + frame_support::weights::Weight::from_parts(0, weight.write + weight.read) + } +} + +#[cfg(feature = "try-runtime")] +impl ReplaceBridgeRelatedStorage +where + T: frame_system::Config> + + pallet_assets::Config + + pallet_assets_handler::Config + + pallet_balances::Config + + pallet_bridge::Config + + pallet_bridge_transfer::Config, +{ + pub fn pre_upgrade_resource_fee_storage() -> Result, &'static str> { + assert_eq!(old::Resources::::get(NATIVE_TOKEN_RESOURCE_ID), Some(b"aaaaaa?".to_vec())); + + let mut fee_iter = old::BridgeFee::::iter(); + // Just For Reference + // Ethereum: chain_id=0 + // substrate_Litmus: chain_id=1 + // substrate_Litentry:chain_id=2 + // Rinkeby: chain_id=4 + // substrate_Rococo:chain_id=3 + // substrate_Stage: chain_id=5 + // Goerli: chain_id=6 + assert_eq!(fee_iter.next(), Some((4u8, 1_000_000_000_000u128))); + + assert_eq!(fee_iter.next(), Some((97u8, 1u128))); + assert_eq!(fee_iter.next(), Some((6u8, 1_000_000_000_000u128))); + assert_eq!(fee_iter.next(), Some((99u8, 1_000_000_000_000u128))); + assert!(fee_iter.next().is_none()); + + Ok(Vec::new()) + } + pub fn post_upgrade_resource_fee_storage(_state: Vec) -> Result<(), &'static str> { + assert_eq!(old::Resources::::get(NATIVE_TOKEN_RESOURCE_ID), None); + + let mut fee_iter = old::BridgeFee::::iter(); + assert_eq!(fee_iter.next(), None); + + // Check AssetsHandler Storage + let mut new_resource_fee_iter = >::iter(); + let expected_asset_info = AssetInfo { + // The first one get migrated + fee: 1_000_000_000_000u128.saturating_mul(DECIMAL_CONVERTOR), + asset: None, + }; + assert_eq!( + new_resource_fee_iter.next(), + Some((NATIVE_TOKEN_RESOURCE_ID, expected_asset_info)) + ); + Ok(()) + } + pub fn pre_upgrade_bridge_balances_storage() -> Result, &'static str> { + Ok(Vec::new()) + } + pub fn post_upgrade_bridge_balances_storage(_state: Vec) -> Result<(), &'static str> { + assert!(old::BridgeBalances::::iter().next().is_none()); + Ok(()) + } + pub fn pre_upgrade_external_balance_storage() -> Result, &'static str> { + let pallet_prefix: &[u8] = b"BridgeTransfer"; + let storage_item_prefix: &[u8] = b"ExternalBalances"; + let stored_data = get_storage_value::(pallet_prefix, storage_item_prefix, b"") + .expect("Storage query fails: BridgeTransfer ExternalBalances"); + Ok(stored_data.saturating_mul(DECIMAL_CONVERTOR).encode()) + } + pub fn post_upgrade_external_balance_storage(state: Vec) -> Result<(), &'static str> { + let expected_state = u128::decode(&mut &state[..]) + .map_err(|_| "Failed to decode BridgeTransfer ExternalBalances")?; + + let pallet_prefix: &[u8] = b"AssetsHandler"; + let storage_item_prefix: &[u8] = b"ExternalBalances"; + let actual_state = get_storage_value::(pallet_prefix, storage_item_prefix, b"") + .expect("Storage query fails: BridgeTransfer ExternalBalances"); + assert_eq!(expected_state, actual_state); + Ok(()) + } + pub fn pre_upgrade_maximum_issuance_storage() -> Result, &'static str> { + let pallet_prefix: &[u8] = b"BridgeTransfer"; + let storage_item_prefix: &[u8] = b"MaximumIssuance"; + let stored_data = get_storage_value::(pallet_prefix, storage_item_prefix, b"") + .expect("Storage query fails: BridgeTransfer MaximumIssuance"); + Ok(stored_data.saturating_mul(DECIMAL_CONVERTOR).encode()) + } + pub fn post_upgrade_maximum_issuance_storage(state: Vec) -> Result<(), &'static str> { + let expected_state = u128::decode(&mut &state[..]) + .map_err(|_| "Failed to decode BridgeTransfer MaximumIssuance")?; + + let pallet_prefix: &[u8] = b"AssetsHandler"; + let storage_item_prefix: &[u8] = b"MaximumIssuance"; + let actual_state = get_storage_value::(pallet_prefix, storage_item_prefix, b"") + .expect("Storage query fails: BridgeTransfer MaximumIssuance"); + assert_eq!(expected_state, actual_state); + Ok(()) + } +} + +impl OnRuntimeUpgrade for ReplaceBridgeRelatedStorage +where + T: frame_system::Config> + + pallet_assets::Config + + pallet_assets_handler::Config + + pallet_balances::Config + + pallet_bridge::Config + + pallet_bridge_transfer::Config, +{ + #[cfg(feature = "try-runtime")] + fn pre_upgrade() -> Result, &'static str> { + let _ = Self::pre_upgrade_resource_fee_storage()?; + let _ = Self::pre_upgrade_bridge_balances_storage()?; + + let external_balances_vec = Self::pre_upgrade_external_balance_storage()?; + let maximum_issuance_vec = Self::pre_upgrade_maximum_issuance_storage()?; + + Ok((external_balances_vec, maximum_issuance_vec).encode()) + } + + fn on_runtime_upgrade() -> frame_support::weights::Weight { + let mut weight = frame_support::weights::Weight::from_parts(0, 0); + + // Replace Old Bridge's Resources, BridgeFee with AssetsHandler's ResourceToAssetInfo + weight += Self::relocate_resource_fee_storage(); + // Delete BridgeTransfer's Bridge Balances Storage + weight += Self::delete_bridge_balances_storage(); + + weight += Self::relocate_external_balance_storage(); + weight += Self::relocate_maximum_issuance_storage(); + weight + } + + #[cfg(feature = "try-runtime")] + fn post_upgrade(state: Vec) -> Result<(), &'static str> { + let pre_vec: (Vec, Vec) = + Decode::decode(&mut &state[..]).map_err(|_| "Failed to decode Tuple")?; + + Self::post_upgrade_resource_fee_storage(Vec::::new())?; + Self::post_upgrade_bridge_balances_storage(Vec::::new())?; + + Self::post_upgrade_external_balance_storage(pre_vec.0)?; + Self::post_upgrade_maximum_issuance_storage(pre_vec.1)?; + + Ok(()) + } +} diff --git a/runtime/paseo/src/migration/P9190/mod.rs b/runtime/paseo/src/migration/P9190/mod.rs new file mode 100644 index 0000000000..bd5e6a22bc --- /dev/null +++ b/runtime/paseo/src/migration/P9190/mod.rs @@ -0,0 +1,6 @@ +pub mod bridge_related; +pub use bridge_related::ReplaceBridgeRelatedStorage; +pub mod parachain_staking; +pub use parachain_staking::ReplaceParachainStakingStorage; +pub mod balances_transaction_payment; +pub use balances_transaction_payment::ReplaceBalancesRelatedStorage; diff --git a/runtime/paseo/src/migration/P9190/parachain_staking.rs b/runtime/paseo/src/migration/P9190/parachain_staking.rs new file mode 100644 index 0000000000..2de502e2c0 --- /dev/null +++ b/runtime/paseo/src/migration/P9190/parachain_staking.rs @@ -0,0 +1,626 @@ +// Copyright 2020-2024 Trust Computing GmbH. +// This file is part of Litentry. +// +// Litentry is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Litentry 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 +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Litentry. If not, see . +#![allow(clippy::type_complexity)] + +use frame_support::{ + migration::storage_key_iter, + pallet_prelude::*, + traits::{Get, OnRuntimeUpgrade}, + Blake2_128Concat, Twox64Concat, +}; +use sp_runtime::Saturating; +use sp_std::{convert::From, marker::PhantomData, vec::Vec}; + +use pallet_parachain_staking::{ + set::OrderedSet, BalanceOf, Bond, BottomDelegations, CandidateInfo, CandidateMetadata, + CandidatePool, DelayedPayout, DelayedPayouts, DelegationAction, DelegationScheduledRequests, + Delegations, Delegator, DelegatorState, ScheduledRequest, Staked, TopDelegations, Total, +}; +pub const DECIMAL_CONVERTOR: u128 = 1_000_000u128; + +#[cfg(feature = "try-runtime")] +use parity_scale_codec::Encode; +#[cfg(feature = "try-runtime")] +use sp_std::collections::btree_map::BTreeMap; +use storage::migration::get_storage_value; + +// Replace Parachain Staking Storage for Decimal Change from 12 to 18 +pub struct ReplaceParachainStakingStorage(PhantomData); +impl ReplaceParachainStakingStorage +where + BalanceOf: From, +{ + pub fn replace_delegator_state_storage() -> frame_support::weights::Weight { + log::info!( + target: "ReplaceParachainStakingStorage", + "running migration to ParachainStaking DelegatorState" + ); + let pallet_prefix: &[u8] = b"ParachainStaking"; + let storage_item_prefix: &[u8] = b"DelegatorState"; + let mut weight: Weight = frame_support::weights::Weight::zero(); + + for (account, mut delegator) in storage_key_iter::< + T::AccountId, + Delegator>, + Twox64Concat, + >(pallet_prefix, storage_item_prefix) + .drain() + { + delegator.total = delegator.total.saturating_mul(DECIMAL_CONVERTOR.into()); + delegator.less_total = delegator.less_total.saturating_mul(DECIMAL_CONVERTOR.into()); + let mut sorted_inner_vector = delegator.delegations.0; + for elem in sorted_inner_vector.iter_mut() { + elem.amount = elem.amount.saturating_mul(DECIMAL_CONVERTOR.into()); + } + delegator.delegations = OrderedSet::from(sorted_inner_vector); + + >::insert(&account, delegator); + weight += T::DbWeight::get().reads_writes(1, 1); + } + + weight + } + + pub fn replace_candidate_info_storage() -> frame_support::weights::Weight { + log::info!( + target: "ReplaceParachainStakingStorage", + "running migration to ParachainStaking CandidateInfo" + ); + let pallet_prefix: &[u8] = b"ParachainStaking"; + let storage_item_prefix: &[u8] = b"CandidateInfo"; + let mut weight: Weight = frame_support::weights::Weight::zero(); + + for (account, mut metadata) in storage_key_iter::< + T::AccountId, + CandidateMetadata>, + Twox64Concat, + >(pallet_prefix, storage_item_prefix) + .drain() + { + metadata.bond = metadata.bond.saturating_mul(DECIMAL_CONVERTOR.into()); + metadata.total_counted = + metadata.total_counted.saturating_mul(DECIMAL_CONVERTOR.into()); + metadata.lowest_top_delegation_amount = + metadata.lowest_top_delegation_amount.saturating_mul(DECIMAL_CONVERTOR.into()); + metadata.highest_bottom_delegation_amount = metadata + .highest_bottom_delegation_amount + .saturating_mul(DECIMAL_CONVERTOR.into()); + metadata.lowest_bottom_delegation_amount = metadata + .lowest_bottom_delegation_amount + .saturating_mul(DECIMAL_CONVERTOR.into()); + + if let Some(mut i) = metadata.request { + i.amount = i.amount.saturating_mul(DECIMAL_CONVERTOR.into()); + } + >::insert(&account, metadata); + weight += T::DbWeight::get().reads_writes(1, 1); + } + + weight + } + + pub fn replace_delegation_scheduled_requests_storage() -> frame_support::weights::Weight { + log::info!( + target: "ReplaceParachainStakingStorage", + "running migration to ParachainStaking DelegationScheduledRequests" + ); + let pallet_prefix: &[u8] = b"ParachainStaking"; + let storage_item_prefix: &[u8] = b"DelegationScheduledRequests"; + let mut weight: Weight = frame_support::weights::Weight::zero(); + + for (account, mut scheduled_requests) in storage_key_iter::< + T::AccountId, + Vec>>, + Blake2_128Concat, + >(pallet_prefix, storage_item_prefix) + .drain() + { + for scheduled_request in scheduled_requests.iter_mut() { + match scheduled_request.action { + DelegationAction::Revoke(n) => { + scheduled_request.action = + DelegationAction::Revoke(n.saturating_mul(DECIMAL_CONVERTOR.into())); + }, + DelegationAction::Decrease(n) => { + scheduled_request.action = + DelegationAction::Decrease(n.saturating_mul(DECIMAL_CONVERTOR.into())); + }, + } + } + >::insert(&account, scheduled_requests); + weight += T::DbWeight::get().reads_writes(1, 1); + } + weight + } + + pub fn replace_top_delegations_storage() -> frame_support::weights::Weight { + log::info!( + target: "ReplaceParachainStakingStorage", + "running migration to ParachainStaking TopDelegations" + ); + let pallet_prefix: &[u8] = b"ParachainStaking"; + let storage_item_prefix: &[u8] = b"TopDelegations"; + let mut weight: Weight = frame_support::weights::Weight::zero(); + + for (account, mut delegations) in storage_key_iter::< + T::AccountId, + Delegations>, + Twox64Concat, + >(pallet_prefix, storage_item_prefix) + .drain() + { + for delegation_bond in delegations.delegations.iter_mut() { + delegation_bond.amount = + delegation_bond.amount.saturating_mul(DECIMAL_CONVERTOR.into()); + } + + >::insert(&account, delegations); + weight += T::DbWeight::get().reads_writes(1, 1); + } + weight + } + + pub fn replace_bottom_delegations_storage() -> frame_support::weights::Weight { + log::info!( + target: "ReplaceParachainStakingStorage", + "running migration to ParachainStaking BottomDelegations" + ); + let pallet_prefix: &[u8] = b"ParachainStaking"; + let storage_item_prefix: &[u8] = b"BottomDelegations"; + let mut weight: Weight = frame_support::weights::Weight::zero(); + + for (account, mut delegations) in storage_key_iter::< + T::AccountId, + Delegations>, + Twox64Concat, + >(pallet_prefix, storage_item_prefix) + .drain() + { + for delegation_bond in delegations.delegations.iter_mut() { + delegation_bond.amount = + delegation_bond.amount.saturating_mul(DECIMAL_CONVERTOR.into()); + } + + >::insert(&account, delegations); + weight += T::DbWeight::get().reads_writes(1, 1); + } + + weight + } + + pub fn replace_total_storage() -> frame_support::weights::Weight { + log::info!( + target: "ReplaceParachainStakingStorage", + "running migration to ParachainStaking Total" + ); + let pallet_prefix: &[u8] = b"ParachainStaking"; + let storage_item_prefix: &[u8] = b"Total"; + let stored_data = + get_storage_value::>(pallet_prefix, storage_item_prefix, b"") + .expect("Storage query fails: ParachainStaking Total"); + >::put(stored_data.saturating_mul(DECIMAL_CONVERTOR.into())); + let weight = T::DbWeight::get(); + frame_support::weights::Weight::from_parts(0, weight.write + weight.read) + } + + pub fn replace_candidate_pool_storage() -> frame_support::weights::Weight { + log::info!( + target: "ReplaceParachainStakingStorage", + "running migration to ParachainStaking CandidatePool" + ); + let pallet_prefix: &[u8] = b"ParachainStaking"; + let storage_item_prefix: &[u8] = b"CandidatePool"; + let mut stored_data = get_storage_value::>>>( + pallet_prefix, + storage_item_prefix, + b"", + ) + .expect("Storage query fails: ParachainStaking CandidatePool"); + for bond in stored_data.0.iter_mut() { + bond.amount = bond.amount.saturating_mul(DECIMAL_CONVERTOR.into()); + } + >::put(stored_data); + let weight = T::DbWeight::get(); + frame_support::weights::Weight::from_parts(0, weight.write + weight.read) + } + + pub fn replace_delayed_payouts_storage() -> frame_support::weights::Weight { + log::info!( + target: "ReplaceParachainStakingStorage", + "running migration to ParachainStaking DelayedPayouts" + ); + let pallet_prefix: &[u8] = b"ParachainStaking"; + let storage_item_prefix: &[u8] = b"DelayedPayouts"; + let mut weight: Weight = frame_support::weights::Weight::zero(); + + for (round, mut delayed_payout) in storage_key_iter::< + u32, + DelayedPayout>, + Twox64Concat, + >(pallet_prefix, storage_item_prefix) + .drain() + { + delayed_payout.round_issuance = + delayed_payout.round_issuance.saturating_mul(DECIMAL_CONVERTOR.into()); + delayed_payout.total_staking_reward = + delayed_payout.total_staking_reward.saturating_mul(DECIMAL_CONVERTOR.into()); + + >::insert(round, delayed_payout); + weight += T::DbWeight::get().reads_writes(1, 1); + } + weight + } + + pub fn replace_staked_storage() -> frame_support::weights::Weight { + log::info!( + target: "ReplaceParachainStakingStorage", + "running migration to ParachainStaking Staked" + ); + let pallet_prefix: &[u8] = b"ParachainStaking"; + let storage_item_prefix: &[u8] = b"Staked"; + + let mut weight: Weight = frame_support::weights::Weight::zero(); + + for (round, staked) in + storage_key_iter::, Twox64Concat>(pallet_prefix, storage_item_prefix) + .drain() + { + >::insert(round, staked.saturating_mul(DECIMAL_CONVERTOR.into())); + weight += T::DbWeight::get().reads_writes(1, 1); + } + weight + } +} + +#[cfg(feature = "try-runtime")] +impl ReplaceParachainStakingStorage +where + BalanceOf: From, +{ + pub fn pre_upgrade_delegator_state_storage() -> Result, &'static str> { + let result: BTreeMap>> = + >::iter() + .map(|(account, state)| { + let mut new_delegator: Delegator> = state; + new_delegator.total = + new_delegator.total.saturating_mul(DECIMAL_CONVERTOR.into()); + new_delegator.less_total = + new_delegator.less_total.saturating_mul(DECIMAL_CONVERTOR.into()); + let mut sorted_inner_vector = new_delegator.delegations.0; + for elem in sorted_inner_vector.iter_mut() { + elem.amount = elem.amount.saturating_mul(DECIMAL_CONVERTOR.into()); + } + new_delegator.delegations = OrderedSet::from(sorted_inner_vector); + + (account, new_delegator) + }) + .collect(); + Ok(result.encode()) + } + pub fn post_upgrade_delegator_state_storage(state: Vec) -> Result<(), &'static str> { + let expected_state = + BTreeMap::>>::decode( + &mut &state[..], + ) + .map_err(|_| "Failed to decode Delegator")?; + for (account, actual_result) in >::iter() { + let expected_result: Delegator> = + expected_state.get(&account).ok_or("Not Expected Delegator")?.clone(); + assert_eq!(expected_result, actual_result); + } + Ok(()) + } + pub fn pre_upgrade_candidate_info_storage() -> Result, &'static str> { + let result: BTreeMap>> = + >::iter() + .map(|(account, state)| { + let mut new_metadata: CandidateMetadata> = state; + new_metadata.bond = new_metadata.bond.saturating_mul(DECIMAL_CONVERTOR.into()); + new_metadata.total_counted = + new_metadata.total_counted.saturating_mul(DECIMAL_CONVERTOR.into()); + new_metadata.lowest_top_delegation_amount = new_metadata + .lowest_top_delegation_amount + .saturating_mul(DECIMAL_CONVERTOR.into()); + new_metadata.highest_bottom_delegation_amount = new_metadata + .highest_bottom_delegation_amount + .saturating_mul(DECIMAL_CONVERTOR.into()); + new_metadata.lowest_bottom_delegation_amount = new_metadata + .lowest_bottom_delegation_amount + .saturating_mul(DECIMAL_CONVERTOR.into()); + + if let Some(mut i) = new_metadata.request { + i.amount = i.amount.saturating_mul(DECIMAL_CONVERTOR.into()); + } + + (account, new_metadata) + }) + .collect(); + Ok(result.encode()) + } + pub fn post_upgrade_candidate_info_storage(state: Vec) -> Result<(), &'static str> { + let expected_state = + BTreeMap::>>::decode(&mut &state[..]) + .map_err(|_| "Failed to decode CandidateMetadata")?; + for (account, actual_result) in >::iter() { + let expected_result: CandidateMetadata> = + expected_state.get(&account).ok_or("Not Expected CandidateMetadata")?.clone(); + // Can not compare CandidateMetadata so compare its encode + assert_eq!(expected_result.encode(), actual_result.encode()); + } + Ok(()) + } + pub fn pre_upgrade_delegation_scheduled_requests_storage() -> Result, &'static str> { + let result: BTreeMap>>> = + >::iter() + .map(|(account, state)| { + let mut new_scheduled_requests: Vec< + ScheduledRequest>, + > = state; + for scheduled_request in new_scheduled_requests.iter_mut() { + match scheduled_request.action { + DelegationAction::Revoke(n) => { + scheduled_request.action = DelegationAction::Revoke( + n.saturating_mul(DECIMAL_CONVERTOR.into()), + ); + }, + DelegationAction::Decrease(n) => { + scheduled_request.action = DelegationAction::Decrease( + n.saturating_mul(DECIMAL_CONVERTOR.into()), + ); + }, + } + } + + (account, new_scheduled_requests) + }) + .collect(); + Ok(result.encode()) + } + pub fn post_upgrade_delegation_scheduled_requests_storage( + state: Vec, + ) -> Result<(), &'static str> { + let expected_state = BTreeMap::< + T::AccountId, + Vec>>, + >::decode(&mut &state[..]) + .map_err(|_| "Failed to decode Vec")?; + for (account, actual_result) in >::iter() { + let expected_result: Vec>> = expected_state + .get(&account) + .ok_or("Not Expected Vec")? + .clone(); + // Can not compare Vec so compare its encode + assert_eq!(expected_result.encode(), actual_result.encode()); + } + Ok(()) + } + pub fn pre_upgrade_top_delegations_storage() -> Result, &'static str> { + let result: BTreeMap>> = + >::iter() + .map(|(account, state)| { + let mut new_delegations: Delegations> = state; + + for delegation_bond in new_delegations.delegations.iter_mut() { + delegation_bond.amount = + delegation_bond.amount.saturating_mul(DECIMAL_CONVERTOR.into()); + } + + (account, new_delegations) + }) + .collect(); + Ok(result.encode()) + } + pub fn post_upgrade_top_delegations_storage(state: Vec) -> Result<(), &'static str> { + let expected_state = + BTreeMap::>>::decode( + &mut &state[..], + ) + .map_err(|_| "Failed to decode Delegations")?; + for (account, actual_result) in >::iter() { + let expected_result: Delegations> = + expected_state.get(&account).ok_or("Not Expected Delegations")?.clone(); + assert_eq!(expected_result.encode(), actual_result.encode()); + } + Ok(()) + } + pub fn pre_upgrade_bottom_delegations_storage() -> Result, &'static str> { + let result: BTreeMap>> = + >::iter() + .map(|(account, state)| { + let mut new_delegations: Delegations> = state; + + for delegation_bond in new_delegations.delegations.iter_mut() { + delegation_bond.amount = + delegation_bond.amount.saturating_mul(DECIMAL_CONVERTOR.into()); + } + + (account, new_delegations) + }) + .collect(); + Ok(result.encode()) + } + pub fn post_upgrade_bottom_delegations_storage(state: Vec) -> Result<(), &'static str> { + let expected_state = + BTreeMap::>>::decode( + &mut &state[..], + ) + .map_err(|_| "Failed to decode Delegations")?; + for (account, actual_result) in >::iter() { + let expected_result: Delegations> = + expected_state.get(&account).ok_or("Not Expected Delegations")?.clone(); + assert_eq!(expected_result.encode(), actual_result.encode()); + } + Ok(()) + } + pub fn pre_upgrade_total_storage() -> Result, &'static str> { + Ok(>::get().saturating_mul(DECIMAL_CONVERTOR.into()).encode()) + } + pub fn post_upgrade_total_storage(state: Vec) -> Result<(), &'static str> { + let expected_state = BalanceOf::::decode(&mut &state[..]) + .map_err(|_| "Failed to decode Total Balance")?; + let actual_state = >::get(); + assert_eq!(expected_state, actual_state); + Ok(()) + } + pub fn pre_upgrade_candidate_pool_storage() -> Result, &'static str> { + let result: BTreeMap> = >::get() + .0 + .iter() + .map(|bond| { + let mut new_bond: Bond> = bond.clone(); + new_bond.amount = new_bond.amount.saturating_mul(DECIMAL_CONVERTOR.into()); + (new_bond.owner, new_bond.amount) + }) + .collect(); + Ok(result.encode()) + } + pub fn post_upgrade_candidate_pool_storage(state: Vec) -> Result<(), &'static str> { + let expected_state = BTreeMap::>::decode(&mut &state[..]) + .map_err(|_| "Failed to decode Candidate Pool Bond (owner, amount)")?; + let actual_state: BTreeMap> = >::get() + .0 + .iter() + .map(|bond| (bond.owner.clone(), bond.amount)) + .collect(); + assert_eq!(expected_state.encode(), actual_state.encode()); + Ok(()) + } + pub fn pre_upgrade_delayed_payouts_storage() -> Result, &'static str> { + let result: BTreeMap>> = >::iter() + .map(|(round, state)| { + let mut new_delayed_payout: DelayedPayout> = state; + + new_delayed_payout.round_issuance = + new_delayed_payout.round_issuance.saturating_mul(DECIMAL_CONVERTOR.into()); + new_delayed_payout.total_staking_reward = new_delayed_payout + .total_staking_reward + .saturating_mul(DECIMAL_CONVERTOR.into()); + + (round, new_delayed_payout) + }) + .collect(); + Ok(result.encode()) + } + pub fn post_upgrade_delayed_payouts_storage(state: Vec) -> Result<(), &'static str> { + let expected_state = BTreeMap::>>::decode(&mut &state[..]) + .map_err(|_| "Failed to decode Delayed Payouts")?; + for (round, actual_result) in >::iter() { + let expected_result: DelayedPayout> = + expected_state.get(&round).ok_or("Not Expected DelayedPayout")?.clone(); + assert_eq!(expected_result.encode(), actual_result.encode()); + } + Ok(()) + } + pub fn pre_upgrade_staked_storage() -> Result, &'static str> { + let result: BTreeMap> = >::iter() + .map(|(round, state)| { + let new_staked: BalanceOf = state; + (round, new_staked.saturating_mul(DECIMAL_CONVERTOR.into())) + }) + .collect(); + Ok(result.encode()) + } + pub fn post_upgrade_staked_storage(state: Vec) -> Result<(), &'static str> { + let expected_state = BTreeMap::>::decode(&mut &state[..]) + .map_err(|_| "Failed to decode Staked")?; + for (round, actual_result) in >::iter() { + let expected_result: BalanceOf = + *expected_state.get(&round).ok_or("Not Expected DelayedPayout")?; + assert_eq!(expected_result.encode(), actual_result.encode()); + } + Ok(()) + } +} + +impl OnRuntimeUpgrade for ReplaceParachainStakingStorage +where + T: frame_system::Config + pallet_parachain_staking::Config, + BalanceOf: From, +{ + #[cfg(feature = "try-runtime")] + fn pre_upgrade() -> Result, &'static str> { + let delegator_state_vec = Self::pre_upgrade_delegator_state_storage()?; + let candidate_info_vec = Self::pre_upgrade_candidate_info_storage()?; + let delegation_scheduled_requests_vec = + Self::pre_upgrade_delegation_scheduled_requests_storage()?; + let top_delegations_vec = Self::pre_upgrade_top_delegations_storage()?; + let bottom_delegations_vec = Self::pre_upgrade_bottom_delegations_storage()?; + let total_vec = Self::pre_upgrade_total_storage()?; + let candidate_pool_vec = Self::pre_upgrade_candidate_pool_storage()?; + let delayed_payouts_vec = Self::pre_upgrade_delayed_payouts_storage()?; + let staked_vec = Self::pre_upgrade_staked_storage()?; + Ok(( + delegator_state_vec, + candidate_info_vec, + delegation_scheduled_requests_vec, + top_delegations_vec, + bottom_delegations_vec, + total_vec, + candidate_pool_vec, + delayed_payouts_vec, + staked_vec, + ) + .encode()) + } + + fn on_runtime_upgrade() -> frame_support::weights::Weight { + let mut weight = frame_support::weights::Weight::from_parts(0, 0); + weight += Self::replace_delegator_state_storage(); + weight += Self::replace_candidate_info_storage(); + weight += Self::replace_delegation_scheduled_requests_storage(); + weight += Self::replace_top_delegations_storage(); + weight += Self::replace_bottom_delegations_storage(); + weight += Self::replace_total_storage(); + weight += Self::replace_candidate_pool_storage(); + + // No need for AtStake Migration since this is a snapshot, everything is good as long as it + // will not change proportion AtStake + + weight += Self::replace_delayed_payouts_storage(); + // Staked Storage holds limited amount of recent rounds only, should not cause large PoV + weight += Self::replace_staked_storage(); + + // No need since all balance related config is Zero + // InflationConfig + + weight + } + + #[cfg(feature = "try-runtime")] + fn post_upgrade(state: Vec) -> Result<(), &'static str> { + let pre_vec: ( + Vec, + Vec, + Vec, + Vec, + Vec, + Vec, + Vec, + Vec, + Vec, + ) = Decode::decode(&mut &state[..]).map_err(|_| "Failed to decode Tuple")?; + Self::post_upgrade_delegator_state_storage(pre_vec.0)?; + Self::post_upgrade_candidate_info_storage(pre_vec.1)?; + Self::post_upgrade_delegation_scheduled_requests_storage(pre_vec.2)?; + Self::post_upgrade_top_delegations_storage(pre_vec.3)?; + Self::post_upgrade_bottom_delegations_storage(pre_vec.4)?; + Self::post_upgrade_total_storage(pre_vec.5)?; + Self::post_upgrade_candidate_pool_storage(pre_vec.6)?; + Self::post_upgrade_delayed_payouts_storage(pre_vec.7)?; + Self::post_upgrade_staked_storage(pre_vec.8)?; + Ok(()) + } +} diff --git a/runtime/paseo/src/migration/P9191/fix_balances.rs b/runtime/paseo/src/migration/P9191/fix_balances.rs new file mode 100644 index 0000000000..f0c352b099 --- /dev/null +++ b/runtime/paseo/src/migration/P9191/fix_balances.rs @@ -0,0 +1,89 @@ +// Copyright 2020-2024 Trust Computing GmbH. +// This file is part of Litentry. +// +// Litentry is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Litentry 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 +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Litentry. If not, see . +#![allow(clippy::type_complexity)] + +use frame_support::{ + migration::storage_key_iter, + pallet_prelude::*, + traits::{Get, OnRuntimeUpgrade}, +}; +use frame_system::{Account, AccountInfo}; +use pallet_balances::AccountData; +use sp_std::{marker::PhantomData, vec::Vec}; + +#[cfg(feature = "try-runtime")] +use sp_std::collections::btree_map::BTreeMap; + +// Force System Balances Storage frozen amount to 0 +pub struct ForceFixAccountFrozenStorage(PhantomData); +impl OnRuntimeUpgrade for ForceFixAccountFrozenStorage +where + T: frame_system::Config> + + pallet_balances::Config, +{ + #[cfg(feature = "try-runtime")] + fn pre_upgrade() -> Result, &'static str> { + let result: BTreeMap>> = + >::iter() + .map(|(account, state)| { + let mut new_account: AccountInfo> = state; + new_account.data.frozen = 0u128; + + (account, new_account) + }) + .collect(); + Ok(result.encode()) + } + + fn on_runtime_upgrade() -> frame_support::weights::Weight { + // The storage of Account for pallet balances is in frame_system pallet + log::info!( + target: "ReplaceBalancesRelatedStorage", + "running migration to Frame System Account" + ); + let pallet_prefix: &[u8] = b"System"; + let storage_item_prefix: &[u8] = b"Account"; + let mut weight: Weight = frame_support::weights::Weight::zero(); + + for (account, mut account_info) in storage_key_iter::< + T::AccountId, + AccountInfo, + Blake2_128Concat, + >(pallet_prefix, storage_item_prefix) + .drain() + { + account_info.data.frozen = 0u128; + >::insert(&account, account_info); + weight += T::DbWeight::get().reads_writes(1, 1); + } + weight + } + + #[cfg(feature = "try-runtime")] + fn post_upgrade(state: Vec) -> Result<(), &'static str> { + let expected_state = + BTreeMap::>>::decode( + &mut &state[..], + ) + .map_err(|_| "Failed to decode AccountInfo")?; + for (account, actual_result) in >::iter() { + let expected_result: AccountInfo> = + expected_state.get(&account).ok_or("Not Expected AccountInfo")?.clone(); + assert_eq!(expected_result, actual_result); + } + Ok(()) + } +} diff --git a/runtime/paseo/src/migration/P9191/migrate_bounty.rs b/runtime/paseo/src/migration/P9191/migrate_bounty.rs new file mode 100644 index 0000000000..bf6e73c0bd --- /dev/null +++ b/runtime/paseo/src/migration/P9191/migrate_bounty.rs @@ -0,0 +1,159 @@ +// Copyright 2020-2024 Trust Computing GmbH. +// This file is part of Litentry. +// +// Litentry is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Litentry 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 +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Litentry. If not, see . +use frame_support::traits::{Get, OnRuntimeUpgrade}; +use sp_std::{marker::PhantomData, vec::Vec}; + +use frame_support::{migration::storage_key_iter, pallet_prelude::*, Twox64Concat}; +use frame_system::pallet_prelude::BlockNumberFor; +use pallet_bounties::{Bounties, BountyIndex, BountyStatus}; +use pallet_treasury::BalanceOf; +use parity_scale_codec::EncodeLike; +use sp_runtime::Saturating; + +pub const DECIMAL_CONVERTOR: u128 = 1_000_000u128; + +// We are creating the exact same struct from the bounties pallet because the fields are private in +// the upstream code +#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen)] +pub struct Bounty { + /// The account proposing it. + pub proposer: AccountId, + /// The (total) amount that should be paid if the bounty is rewarded. + pub value: Balance, + /// The curator fee. Included in value. + pub fee: Balance, + /// The deposit of curator. + pub curator_deposit: Balance, + /// The amount held on deposit (reserved) for making this proposal. + pub bond: Balance, + /// The status of this bounty. + pub status: BountyStatus, +} + +// This is important when we want to insert into the storage item +impl + EncodeLike> + for Bounty +where + AccountId: EncodeLike, + Balance: EncodeLike, + BlockNumber: EncodeLike, +{ +} + +pub struct ReplacePalletBountyStorage(PhantomData<(T, I)>); +impl OnRuntimeUpgrade for ReplacePalletBountyStorage +where + T: pallet_bounties::Config + pallet_treasury::Config, + BalanceOf: EncodeLike> + From, +{ + #[cfg(feature = "try-runtime")] + fn pre_upgrade() -> Result, &'static str> { + let pallet_prefix: &[u8] = b"Bounties"; + let storage_item_prefix: &[u8] = b"Bounties"; + let stored_data: Vec<_> = storage_key_iter::< + BountyIndex, + Bounty, BlockNumberFor>, + Twox64Concat, + >(pallet_prefix, storage_item_prefix) + .collect(); + + let result: Vec<_> = stored_data + .into_iter() + .map(|(bounty_index, bounty)| { + let mut new_bounty = bounty; + new_bounty.value = new_bounty.value.saturating_mul(DECIMAL_CONVERTOR.into()); + new_bounty.fee = new_bounty.fee.saturating_mul(DECIMAL_CONVERTOR.into()); + new_bounty.curator_deposit = + new_bounty.curator_deposit.saturating_mul(DECIMAL_CONVERTOR.into()); + new_bounty.bond = new_bounty.bond.saturating_mul(DECIMAL_CONVERTOR.into()); + + (bounty_index, new_bounty) + }) + .collect(); + + log::info!( + target: "ReplacePalletBountyStorage", + "Finished performing pre upgrade checks" + ); + + Ok(result.encode()) + } + + fn on_runtime_upgrade() -> frame_support::weights::Weight { + log::info!( + target: "ReplacePalletBountyStorage", + "running migration to Bounties Bounties Storage Item" + ); + let pallet_prefix: &[u8] = b"Bounties"; + let storage_item_prefix: &[u8] = b"Bounties"; + let mut weight: Weight = frame_support::weights::Weight::zero(); + + for (bounty_index, mut bounty) in storage_key_iter::< + BountyIndex, + Bounty, BlockNumberFor>, + Twox64Concat, + >(pallet_prefix, storage_item_prefix) + .drain() + { + bounty.value = bounty.value.saturating_mul(DECIMAL_CONVERTOR.into()); + bounty.fee = bounty.fee.saturating_mul(DECIMAL_CONVERTOR.into()); + bounty.curator_deposit = + bounty.curator_deposit.saturating_mul(DECIMAL_CONVERTOR.into()); + bounty.bond = bounty.bond.saturating_mul(DECIMAL_CONVERTOR.into()); + + >::insert(bounty_index, bounty); + + weight += T::DbWeight::get().reads_writes(1, 1); + } + + log::info!( + target: "ReplacePalletBountyStorage", + "Finished performing storage migrations" + ); + + weight + } + + #[cfg(feature = "try-runtime")] + fn post_upgrade(state: Vec) -> Result<(), &'static str> { + let expected_result = Vec::<( + BountyIndex, + Bounty, BlockNumberFor>, + )>::decode(&mut &state[..]) + .map_err(|_| "Failed to decode Bounties")?; + + let pallet_prefix: &[u8] = b"Bounties"; + let storage_item_prefix: &[u8] = b"Bounties"; + let actual_result: Vec<_> = storage_key_iter::< + BountyIndex, + Bounty, BlockNumberFor>, + Twox64Concat, + >(pallet_prefix, storage_item_prefix) + .collect(); + + for x in 0..actual_result.len() { + assert_eq!(actual_result[x], expected_result[x]) + } + + log::info!( + target: "ReplacePalletBountyStorage", + "Finished performing post upgrade checks" + ); + + Ok(()) + } +} diff --git a/runtime/paseo/src/migration/P9191/migrate_democracy.rs b/runtime/paseo/src/migration/P9191/migrate_democracy.rs new file mode 100644 index 0000000000..d087105548 --- /dev/null +++ b/runtime/paseo/src/migration/P9191/migrate_democracy.rs @@ -0,0 +1,511 @@ +// Copyright 2020-2024 Trust Computing GmbH. +// This file is part of Litentry. +// +// Litentry is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Litentry 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 +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Litentry. If not, see . +use frame_support::traits::{Get, OnRuntimeUpgrade}; +use pallet_democracy::{ + AccountVote, BoundedCallOf, Conviction, Delegations, DepositOf, PropIndex, ReferendumIndex, + ReferendumInfo, ReferendumInfoOf, ReferendumStatus, Tally, VotingOf, +}; +use sp_std::{marker::PhantomData, vec::Vec}; + +use frame_support::{ + migration::storage_key_iter, pallet_prelude::*, traits::Currency, Twox64Concat, +}; +use frame_system::pallet_prelude::BlockNumberFor; +use parity_scale_codec::EncodeLike; +use sp_runtime::Saturating; + +type BalanceOf = <::Currency as Currency< + ::AccountId, +>>::Balance; + +pub const DECIMAL_CONVERTOR: u128 = 1_000_000u128; + +/// A "prior" lock, i.e. a lock for some now-forgotten reason. +#[derive( + Encode, + MaxEncodedLen, + Decode, + Default, + Copy, + Clone, + Eq, + PartialEq, + Ord, + PartialOrd, + RuntimeDebug, + TypeInfo, +)] +pub struct PriorLock(BlockNumber, Balance); + +#[derive(Clone, Encode, Decode, Eq, MaxEncodedLen, PartialEq, RuntimeDebug, TypeInfo)] +#[codec(mel_bound(skip_type_params(MaxVotes)))] +#[scale_info(skip_type_params(MaxVotes))] +pub enum Voting> { + /// The account is voting directly. `delegations` is the total amount of post-conviction voting + /// weight that it controls from those that have delegated to it. + Direct { + /// The current votes of the account. + votes: BoundedVec<(ReferendumIndex, AccountVote), MaxVotes>, + /// The total amount of delegations that this account has received. + delegations: Delegations, + /// Any pre-existing locks from past voting/delegating activity. + prior: PriorLock, + }, + /// The account is delegating `balance` of its balance to a `target` account with `conviction`. + Delegating { + balance: Balance, + target: AccountId, + conviction: Conviction, + /// The total amount of delegations that this account has received. + delegations: Delegations, + /// Any pre-existing locks from past voting/delegating activity. + prior: PriorLock, + }, +} + +/// Const doesn't implement partialeq trait, so we have to check manually +#[cfg(feature = "try-runtime")] +fn are_voting_instances_equal>( + a: &Voting, + b: &Voting, +) -> bool +where + Balance: PartialEq, + AccountId: PartialEq, + BlockNumber: PartialEq, +{ + match (a, b) { + ( + Voting::Direct { votes: votes_a, delegations: delegations_a, prior: prior_a }, + Voting::Direct { votes: votes_b, delegations: delegations_b, prior: prior_b }, + ) => votes_a == votes_b && delegations_a == delegations_b && prior_a == prior_b, + + ( + Voting::Delegating { + balance: balance_a, + target: target_a, + conviction: conviction_a, + delegations: delegations_a, + prior: prior_a, + }, + Voting::Delegating { + balance: balance_b, + target: target_b, + conviction: conviction_b, + delegations: delegations_b, + prior: prior_b, + }, + ) => + balance_a == balance_b && + target_a == target_b && + conviction_a == conviction_b && + delegations_a == delegations_b && + prior_a == prior_b, + + _ => false, + } +} + +// This is important when we want to insert into the storage item +impl + EncodeLike> + for Voting +where + AccountId: EncodeLike, + Balance: EncodeLike, + BlockNumber: EncodeLike, + MaxVotes: Get, +{ +} + +pub struct ReplaceDemocracyStorage(PhantomData); +impl ReplaceDemocracyStorage +where + BalanceOf: From, +{ + fn replace_deposit_of_storage() -> frame_support::weights::Weight { + log::info!( + target: "ReplaceDemocracyStorage", + "running migration to Democracy DepositOf Storage Item" + ); + let pallet_prefix: &[u8] = b"Democracy"; + let storage_item_prefix: &[u8] = b"DepositOf"; + let mut weight: Weight = frame_support::weights::Weight::zero(); + + for (prop_index, mut value) in storage_key_iter::< + PropIndex, + (BoundedVec, BalanceOf), + Twox64Concat, + >(pallet_prefix, storage_item_prefix) + .drain() + { + value.1 = value.1.saturating_mul(DECIMAL_CONVERTOR.into()); + + >::insert(prop_index, value); + + weight += T::DbWeight::get().reads_writes(1, 1); + } + + weight + } + + fn replace_referendum_info_of_storage() -> frame_support::weights::Weight { + log::info!( + target: "ReplaceDemocracyStorage", + "running migration to Democracy ReferendumInfoOf Storage Item" + ); + let pallet_prefix: &[u8] = b"Democracy"; + let storage_item_prefix: &[u8] = b"ReferenceInfoOf"; + + let mut weight: Weight = frame_support::weights::Weight::zero(); + for (ref_index, ref_info) in storage_key_iter::< + ReferendumIndex, + ReferendumInfo, BalanceOf>, + Twox64Concat, + >(pallet_prefix, storage_item_prefix) + .drain() + { + let new_ref_info = match ref_info { + ReferendumInfo::Finished { approved, end } => + ReferendumInfo::Finished { approved, end }, + ReferendumInfo::Ongoing(ref_status) => ReferendumInfo::Ongoing(ReferendumStatus { + end: ref_status.end, + proposal: ref_status.proposal, + threshold: ref_status.threshold, + delay: ref_status.delay, + tally: Tally { + ayes: ref_status.tally.ayes.saturating_mul(DECIMAL_CONVERTOR.into()), + nays: ref_status.tally.nays.saturating_mul(DECIMAL_CONVERTOR.into()), + turnout: ref_status.tally.turnout.saturating_mul(DECIMAL_CONVERTOR.into()), + }, + }), + }; + + >::insert(ref_index, new_ref_info); + + weight += T::DbWeight::get().reads_writes(1, 1); + } + + weight + } + + fn replace_voting_of_storage() -> frame_support::weights::Weight { + log::info!( + target: "ReplaceDemocracyStorage", + "running migration to Democracy VotingOf Storage Item" + ); + let pallet_prefix: &[u8] = b"Democracy"; + let storage_item_prefix: &[u8] = b"VotingOf"; + let mut weight: Weight = frame_support::weights::Weight::zero(); + + for (who, voting) in storage_key_iter::< + T::AccountId, + Voting, T::AccountId, BlockNumberFor, T::MaxVotes>, + Twox64Concat, + >(pallet_prefix, storage_item_prefix) + .drain() + { + let new_voting = match voting { + Voting::Delegating { balance, target, conviction, delegations, prior } => { + let new_balance = balance.saturating_mul(DECIMAL_CONVERTOR.into()); + let new_delegation = Delegations { + votes: delegations.votes.saturating_mul(DECIMAL_CONVERTOR.into()), + capital: delegations.capital.saturating_mul(DECIMAL_CONVERTOR.into()), + }; + let new_prior_locks = + PriorLock(prior.0, prior.1.saturating_mul(DECIMAL_CONVERTOR.into())); + Voting::Delegating { + balance: new_balance, + target, + conviction, + delegations: new_delegation, + prior: new_prior_locks, + } + }, + Voting::Direct { votes, delegations, prior } => { + let new_votes: Vec<_> = votes + .into_iter() + .map(|(id, vote)| { + let new_vote = match vote { + AccountVote::Split { aye, nay } => AccountVote::Split { + aye: aye.saturating_mul(DECIMAL_CONVERTOR.into()), + nay: nay.saturating_mul(DECIMAL_CONVERTOR.into()), + }, + AccountVote::Standard { vote, balance } => AccountVote::Standard { + vote, + balance: balance.saturating_mul(DECIMAL_CONVERTOR.into()), + }, + }; + (id, new_vote) + }) + .collect(); + + // This unwrap cannot fail since it is the same BoundedVec + let bounded_new_votes: BoundedVec< + (u32, AccountVote>), + T::MaxVotes, + > = new_votes.try_into().unwrap(); + + let new_delegation = Delegations { + votes: delegations.votes.saturating_mul(DECIMAL_CONVERTOR.into()), + capital: delegations.capital.saturating_mul(DECIMAL_CONVERTOR.into()), + }; + let new_prior_locks = + PriorLock(prior.0, prior.1.saturating_mul(DECIMAL_CONVERTOR.into())); + + Voting::Direct { + votes: bounded_new_votes, + delegations: new_delegation, + prior: new_prior_locks, + } + }, + }; + >::insert(who, new_voting); + + weight += T::DbWeight::get().reads_writes(1, 1); + } + + weight + } +} + +#[cfg(feature = "try-runtime")] +impl ReplaceDemocracyStorage +where + BalanceOf: From, +{ + fn pre_upgrade_deposit_of_storage() -> Result, &'static str> { + let result: Vec<_> = >::iter() + .map(|(prop_index, value)| { + let mut new_value = value; + new_value.1 = new_value.1.saturating_mul(DECIMAL_CONVERTOR.into()); + + (prop_index, new_value) + }) + .collect(); + Ok(result.encode()) + } + + fn post_upgrade_deposit_of_storage(state: Vec) -> Result<(), &'static str> { + let expected_result = Vec::<( + PropIndex, + (BoundedVec, BalanceOf), + )>::decode(&mut &state[..]) + .map_err(|_| "Failed to decode Bounties")?; + + let actual_result: Vec<_> = + >::iter().map(|(prop_index, value)| (prop_index, value)).collect(); + + for x in 0..actual_result.len() { + assert_eq!(actual_result[x], expected_result[x]) + } + + Ok(()) + } + + fn pre_upgrade_referendum_info_of_storage() -> Result, &'static str> { + let result: Vec<_> = >::iter() + .map(|(ref_index, ref_info)| { + let new_ref_info = match ref_info { + ReferendumInfo::Finished { approved, end } => + ReferendumInfo::Finished { approved, end }, + ReferendumInfo::Ongoing(ref_status) => + ReferendumInfo::Ongoing(ReferendumStatus { + end: ref_status.end, + proposal: ref_status.proposal, + threshold: ref_status.threshold, + delay: ref_status.delay, + tally: Tally { + ayes: ref_status + .tally + .ayes + .saturating_mul(DECIMAL_CONVERTOR.into()), + nays: ref_status + .tally + .nays + .saturating_mul(DECIMAL_CONVERTOR.into()), + turnout: ref_status + .tally + .turnout + .saturating_mul(DECIMAL_CONVERTOR.into()), + }, + }), + }; + + (ref_index, new_ref_info) + }) + .collect(); + Ok(result.encode()) + } + + fn post_upgrade_referendum_info_of_storage(state: Vec) -> Result<(), &'static str> { + let expected_result = Vec::<( + ReferendumIndex, + ReferendumInfo, BalanceOf>, + )>::decode(&mut &state[..]) + .map_err(|_| "Failed to decode Bounties")?; + + let actual_result: Vec<_> = >::iter() + .map(|(ref_index, ref_info)| (ref_index, ref_info)) + .collect(); + for x in 0..actual_result.len() { + assert_eq!(actual_result[x], expected_result[x]) + } + Ok(()) + } + + fn pre_upgrade_voting_of_storage() -> Result, &'static str> { + let pallet_prefix: &[u8] = b"Democracy"; + let storage_item_prefix: &[u8] = b"VotingOf"; + let stored_data: Vec<_> = storage_key_iter::< + T::AccountId, + Voting, T::AccountId, BlockNumberFor, T::MaxVotes>, + Twox64Concat, + >(pallet_prefix, storage_item_prefix) + .collect(); + + let result: Vec<_> = stored_data + .into_iter() + .map(|(who, voting)| { + let new_voting = match voting { + Voting::Delegating { balance, target, conviction, delegations, prior } => { + let new_balance = balance.saturating_mul(DECIMAL_CONVERTOR.into()); + let new_delegation = Delegations { + votes: delegations.votes.saturating_mul(DECIMAL_CONVERTOR.into()), + capital: delegations.capital.saturating_mul(DECIMAL_CONVERTOR.into()), + }; + let new_prior_locks = + PriorLock(prior.0, prior.1.saturating_mul(DECIMAL_CONVERTOR.into())); + Voting::Delegating { + balance: new_balance, + target, + conviction, + delegations: new_delegation, + prior: new_prior_locks, + } + }, + Voting::Direct { votes, delegations, prior } => { + let new_votes: Vec<_> = votes + .into_iter() + .map(|(id, vote)| { + let new_vote = match vote { + AccountVote::Split { aye, nay } => AccountVote::Split { + aye: aye.saturating_mul(DECIMAL_CONVERTOR.into()), + nay: nay.saturating_mul(DECIMAL_CONVERTOR.into()), + }, + AccountVote::Standard { vote, balance } => + AccountVote::Standard { + vote, + balance: balance + .saturating_mul(DECIMAL_CONVERTOR.into()), + }, + }; + (id, new_vote) + }) + .collect(); + + let bounded_new_votes: BoundedVec< + (u32, AccountVote>), + T::MaxVotes, + > = new_votes.try_into().unwrap(); + + let new_delegation = Delegations { + votes: delegations.votes.saturating_mul(DECIMAL_CONVERTOR.into()), + capital: delegations.capital.saturating_mul(DECIMAL_CONVERTOR.into()), + }; + let new_prior_locks = + PriorLock(prior.0, prior.1.saturating_mul(DECIMAL_CONVERTOR.into())); + + Voting::Direct { + votes: bounded_new_votes, + delegations: new_delegation, + prior: new_prior_locks, + } + }, + }; + (who, new_voting) + }) + .collect(); + + Ok(result.encode()) + } + + fn post_upgrade_voting_of_storage(state: Vec) -> Result<(), &'static str> { + let expected_result = Vec::<( + T::AccountId, + Voting, T::AccountId, BlockNumberFor, T::MaxVotes>, + )>::decode(&mut &state[..]) + .map_err(|_| "Failed to decode Bounties")?; + + let pallet_prefix: &[u8] = b"Democracy"; + let storage_item_prefix: &[u8] = b"VotingOf"; + let actual_result: Vec<_> = storage_key_iter::< + T::AccountId, + Voting, T::AccountId, BlockNumberFor, T::MaxVotes>, + Twox64Concat, + >(pallet_prefix, storage_item_prefix) + .collect(); + + for x in 0..actual_result.len() { + assert_eq!(actual_result[x].0, expected_result[x].0); + let result = are_voting_instances_equal::< + BalanceOf, + T::AccountId, + BlockNumberFor, + T::MaxVotes, + >(&actual_result[x].1, &expected_result[x].1); + assert!(result); + } + + Ok(()) + } +} + +impl OnRuntimeUpgrade for ReplaceDemocracyStorage +where + BalanceOf: From, +{ + #[cfg(feature = "try-runtime")] + fn pre_upgrade() -> Result, &'static str> { + let deposit_of_state_vec = Self::pre_upgrade_deposit_of_storage()?; + let referendum_info_of_state_vec = Self::pre_upgrade_referendum_info_of_storage()?; + let voting_of_state_vec = Self::pre_upgrade_voting_of_storage()?; + + log::info!(target: "ReplaceDemocracyStorage", "Finished performing pre upgrade checks"); + Ok((deposit_of_state_vec, referendum_info_of_state_vec, voting_of_state_vec).encode()) + } + + fn on_runtime_upgrade() -> frame_support::weights::Weight { + let mut weight = frame_support::weights::Weight::from_parts(0, 0); + weight += Self::replace_deposit_of_storage(); + weight += Self::replace_referendum_info_of_storage(); + weight += Self::replace_voting_of_storage(); + + log::info!(target: "ReplaceDemocracyStorage", "Finished performing storage migrations"); + weight + } + + #[cfg(feature = "try-runtime")] + fn post_upgrade(state: Vec) -> Result<(), &'static str> { + let pre_vec: (Vec, Vec, Vec) = + Decode::decode(&mut &state[..]).map_err(|_| "Failed to decode Tuple")?; + Self::post_upgrade_deposit_of_storage(pre_vec.0)?; + Self::post_upgrade_referendum_info_of_storage(pre_vec.1)?; + Self::post_upgrade_voting_of_storage(pre_vec.2)?; + log::info!(target: "ReplaceDemocracyStorage", "Finished performing post upgrade checks"); + Ok(()) + } +} diff --git a/runtime/paseo/src/migration/P9191/migrate_identity.rs b/runtime/paseo/src/migration/P9191/migrate_identity.rs new file mode 100644 index 0000000000..c0bf3eee82 --- /dev/null +++ b/runtime/paseo/src/migration/P9191/migrate_identity.rs @@ -0,0 +1,209 @@ +// Copyright 2020-2024 Trust Computing GmbH. +// This file is part of Litentry. +// +// Litentry is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Litentry 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 +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Litentry. If not, see . +#![allow(clippy::type_complexity)] + +use frame_support::{ + migration::storage_key_iter, + pallet_prelude::*, + traits::{Currency, Get, OnRuntimeUpgrade}, + Twox64Concat, +}; +use sp_std::{marker::PhantomData, vec::Vec}; + +#[cfg(feature = "try-runtime")] +use parity_scale_codec::{Decode, Encode}; + +use pallet_identity::{RegistrarInfo, Registration}; +use storage::migration::get_storage_value; +type BalanceOf = <::Currency as Currency< + ::AccountId, +>>::Balance; + +// Replace Parachain Staking Storage for Decimal Change from 12 to 18 +pub struct ReplacePalletIdentityStorage(PhantomData); + +impl ReplacePalletIdentityStorage +where + T: pallet_identity::Config, +{ + // pallet_identity + pub fn check_identityof_storage() -> frame_support::weights::Weight { + log::info!( + target: "ReplacePalletIdentityStorage", + "Running check to ParachainIdentity IdentityOf" + ); + let pallet_prefix: &[u8] = b"ParachainIdentity"; + let storage_item_prefix: &[u8] = b"IdentityOf"; + + assert!(storage_key_iter::< + T::AccountId, + Registration, T::MaxRegistrars, T::MaxAdditionalFields>, + Twox64Concat, + >(pallet_prefix, storage_item_prefix) + .next() + .is_none()); + let weight = T::DbWeight::get(); + frame_support::weights::Weight::from_parts(0, weight.read) + } + + pub fn check_subsof_storage() -> frame_support::weights::Weight { + log::info!( + target: "ReplacePalletIdentityStorage", + "Running check to ParachainIdentity SubsOf" + ); + let pallet_prefix: &[u8] = b"ParachainIdentity"; + let storage_item_prefix: &[u8] = b"SubsOf"; + + assert!(storage_key_iter::< + T::AccountId, + Registration, T::MaxRegistrars, T::MaxAdditionalFields>, + Twox64Concat, + >(pallet_prefix, storage_item_prefix) + .next() + .is_none()); + let weight = T::DbWeight::get(); + frame_support::weights::Weight::from_parts(0, weight.read) + } + + pub fn check_registrars_storage() -> frame_support::weights::Weight { + log::info!( + target: "ReplacePalletIdentityStorage", + "Running check to ParachainIdentity Registrars" + ); + let pallet_prefix: &[u8] = b"ParachainIdentity"; + let storage_item_prefix: &[u8] = b"Registrars"; + + assert!(get_storage_value::< + BoundedVec, T::AccountId>>, T::MaxRegistrars>, + >(pallet_prefix, storage_item_prefix, b"") + .is_none()); + + let weight = T::DbWeight::get(); + frame_support::weights::Weight::from_parts(0, weight.read) + } +} + +#[cfg(feature = "try-runtime")] +impl ReplacePalletIdentityStorage +where + T: pallet_identity::Config, +{ + // pallet_identity + pub fn pre_upgrade_identityof_storage() -> Result, &'static str> { + let pallet_prefix: &[u8] = b"ParachainIdentity"; + let storage_item_prefix: &[u8] = b"IdentityOf"; + + assert!(storage_key_iter::< + T::AccountId, + Registration, T::MaxRegistrars, T::MaxAdditionalFields>, + Twox64Concat, + >(pallet_prefix, storage_item_prefix) + .next() + .is_none()); + Ok(Vec::::new()) + } + pub fn post_upgrade_identityof_storage(_state: Vec) -> Result<(), &'static str> { + let pallet_prefix: &[u8] = b"ParachainIdentity"; + let storage_item_prefix: &[u8] = b"IdentityOf"; + + assert!(storage_key_iter::< + T::AccountId, + Registration, T::MaxRegistrars, T::MaxAdditionalFields>, + Twox64Concat, + >(pallet_prefix, storage_item_prefix) + .next() + .is_none()); + Ok(()) + } + pub fn pre_upgrade_subsof_storage() -> Result, &'static str> { + let pallet_prefix: &[u8] = b"ParachainIdentity"; + let storage_item_prefix: &[u8] = b"SubsOf"; + + assert!(storage_key_iter::< + T::AccountId, + Registration, T::MaxRegistrars, T::MaxAdditionalFields>, + Twox64Concat, + >(pallet_prefix, storage_item_prefix) + .next() + .is_none()); + Ok(Vec::::new()) + } + pub fn post_upgrade_subsof_storage(_state: Vec) -> Result<(), &'static str> { + let pallet_prefix: &[u8] = b"ParachainIdentity"; + let storage_item_prefix: &[u8] = b"SubsOf"; + + assert!(storage_key_iter::< + T::AccountId, + Registration, T::MaxRegistrars, T::MaxAdditionalFields>, + Twox64Concat, + >(pallet_prefix, storage_item_prefix) + .next() + .is_none()); + + Ok(()) + } + pub fn pre_upgrade_registrars_storage() -> Result, &'static str> { + let pallet_prefix: &[u8] = b"ParachainIdentity"; + let storage_item_prefix: &[u8] = b"Registrars"; + + assert!(get_storage_value::< + BoundedVec, T::AccountId>>, T::MaxRegistrars>, + >(pallet_prefix, storage_item_prefix, b"") + .is_none()); + Ok(Vec::::new()) + } + pub fn post_upgrade_registrars_storage(_state: Vec) -> Result<(), &'static str> { + let pallet_prefix: &[u8] = b"ParachainIdentity"; + let storage_item_prefix: &[u8] = b"Registrars"; + + assert!(get_storage_value::< + BoundedVec, T::AccountId>>, T::MaxRegistrars>, + >(pallet_prefix, storage_item_prefix, b"") + .is_none()); + Ok(()) + } +} + +impl OnRuntimeUpgrade for ReplacePalletIdentityStorage +where + T: frame_system::Config + pallet_identity::Config, +{ + #[cfg(feature = "try-runtime")] + fn pre_upgrade() -> Result, &'static str> { + // pallet_identity + let identityof_vec = Self::pre_upgrade_identityof_storage()?; + let subsof_vec = Self::pre_upgrade_subsof_storage()?; + let registrars_vec = Self::pre_upgrade_registrars_storage()?; + + Ok((identityof_vec, subsof_vec, registrars_vec).encode()) + } + + fn on_runtime_upgrade() -> frame_support::weights::Weight { + frame_support::weights::Weight::zero() + } + + #[cfg(feature = "try-runtime")] + fn post_upgrade(state: Vec) -> Result<(), &'static str> { + let pre_vec: (Vec, Vec, Vec) = + Decode::decode(&mut &state[..]).map_err(|_| "Failed to decode Tuple")?; + // pallet_identity + Self::post_upgrade_identityof_storage(pre_vec.0)?; + Self::post_upgrade_subsof_storage(pre_vec.1)?; + Self::post_upgrade_registrars_storage(pre_vec.2)?; + + Ok(()) + } +} diff --git a/runtime/paseo/src/migration/P9191/migrate_multisig.rs b/runtime/paseo/src/migration/P9191/migrate_multisig.rs new file mode 100644 index 0000000000..50209a08fa --- /dev/null +++ b/runtime/paseo/src/migration/P9191/migrate_multisig.rs @@ -0,0 +1,91 @@ +// Copyright 2020-2024 Trust Computing GmbH. +// This file is part of Litentry. +// +// Litentry is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Litentry 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 +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Litentry. If not, see . +#![allow(clippy::type_complexity)] + +use frame_support::{ + pallet_prelude::*, + traits::{Get, OnRuntimeUpgrade}, +}; +use sp_std::{marker::PhantomData, vec::Vec}; + +#[cfg(feature = "try-runtime")] +use parity_scale_codec::Encode; + +use pallet_multisig::Multisigs; + +// Replace Parachain Staking Storage for Decimal Change from 12 to 18 +pub struct ReplacePalletMultisigStorage(PhantomData); + +impl ReplacePalletMultisigStorage +where + T: pallet_multisig::Config, +{ + // pallet_multisig + pub fn check_multisig_multisigs_storage() -> frame_support::weights::Weight { + log::info!( + target: "ReplacePalletMultisigStorage", + "Running checking to Multisig - Multisigs" + ); + + assert!(Multisigs::::iter().next().is_none()); + + let weight = T::DbWeight::get(); + frame_support::weights::Weight::from_parts(0, weight.read) + } +} + +#[cfg(feature = "try-runtime")] +impl ReplacePalletMultisigStorage +where + T: pallet_multisig::Config, +{ + pub fn pre_upgrade_multisig_multisigs_storage() -> Result, &'static str> { + assert!(Multisigs::::iter().next().is_none()); + Ok(Vec::::new()) + } + + pub fn post_upgrade_multisig_multisigs_storage(_state: Vec) -> Result<(), &'static str> { + assert!(Multisigs::::iter().next().is_none()); + Ok(()) + } +} + +impl OnRuntimeUpgrade for ReplacePalletMultisigStorage +where + T: frame_system::Config + pallet_multisig::Config, +{ + #[cfg(feature = "try-runtime")] + fn pre_upgrade() -> Result, &'static str> { + // pallet_multisig + let multisigs_vec = Self::pre_upgrade_multisig_multisigs_storage()?; + + Ok((multisigs_vec,).encode()) + } + + fn on_runtime_upgrade() -> frame_support::weights::Weight { + frame_support::weights::Weight::zero() + } + + #[cfg(feature = "try-runtime")] + fn post_upgrade(state: Vec) -> Result<(), &'static str> { + let pre_vec: (Vec,) = + Decode::decode(&mut &state[..]).map_err(|_| "Failed to decode Tuple")?; + + // pallet_multisig + Self::post_upgrade_multisig_multisigs_storage(pre_vec.0)?; + Ok(()) + } +} diff --git a/runtime/paseo/src/migration/P9191/migrate_preimage.rs b/runtime/paseo/src/migration/P9191/migrate_preimage.rs new file mode 100644 index 0000000000..8fb4b9d2b8 --- /dev/null +++ b/runtime/paseo/src/migration/P9191/migrate_preimage.rs @@ -0,0 +1,163 @@ +// Copyright 2020-2024 Trust Computing GmbH. +// This file is part of Litentry. +// +// Litentry is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Litentry 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 +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Litentry. If not, see . +use frame_support::{ + pallet_prelude::*, + traits::{Get, OnRuntimeUpgrade}, + Identity, +}; +use pallet_preimage::RequestStatus; +use sp_std::{marker::PhantomData, vec::Vec}; + +use frame_support::migration::{put_storage_value, storage_key_iter}; +use pallet_treasury::BalanceOf; +#[cfg(feature = "try-runtime")] +use parity_scale_codec::{Decode, Encode}; +use sp_runtime::Saturating; + +pub const DECIMAL_CONVERTOR: u128 = 1_000_000u128; + +pub struct ReplacePreImageStorage(PhantomData); +impl OnRuntimeUpgrade for ReplacePreImageStorage +where + T: pallet_preimage::Config + pallet_treasury::Config, + BalanceOf: From, +{ + #[cfg(feature = "try-runtime")] + fn pre_upgrade() -> Result, &'static str> { + let pallet_prefix: &[u8] = b"Preimage"; + let storage_item_prefix: &[u8] = b"StatusFor"; + let stored_data: Vec<_> = storage_key_iter::< + T::Hash, + RequestStatus>, + Identity, + >(pallet_prefix, storage_item_prefix) + .collect(); + + let result: Vec<_> = stored_data + .into_iter() + .map(|(hash, status)| { + let new_status = match status { + RequestStatus::Requested { deposit, count, len } => { + if let Some((account, balance)) = deposit { + RequestStatus::Requested { + deposit: Some(( + account, + balance.saturating_mul(DECIMAL_CONVERTOR.into()), + )), + count, + len, + } + } else { + RequestStatus::Requested { deposit, count, len } + } + }, + RequestStatus::Unrequested { deposit, len } => RequestStatus::Unrequested { + deposit: (deposit.0, deposit.1.saturating_mul(DECIMAL_CONVERTOR.into())), + len, + }, + }; + + (hash, new_status) + }) + .collect(); + + log::info!( + target: "ReplacePreImageStorage", + "Finished performing pre upgrade checks" + ); + + Ok(result.encode()) + } + + fn on_runtime_upgrade() -> frame_support::weights::Weight { + log::info!( + target: "ReplacePreImageStorage", + "running migration to Preimage StatusFor Storage Item" + ); + let pallet_prefix: &[u8] = b"Preimage"; + let storage_item_prefix: &[u8] = b"StatusFor"; + let mut weight: Weight = frame_support::weights::Weight::zero(); + + for (hash, status) in storage_key_iter::< + T::Hash, + RequestStatus>, + Identity, + >(pallet_prefix, storage_item_prefix) + .drain() + { + let new_status = match status { + RequestStatus::Requested { deposit, count, len } => { + if let Some((account, balance)) = deposit { + RequestStatus::Requested { + deposit: Some(( + account, + balance.saturating_mul(DECIMAL_CONVERTOR.into()), + )), + count, + len, + } + } else { + RequestStatus::Requested { deposit, count, len } + } + }, + RequestStatus::Unrequested { deposit, len } => RequestStatus::Unrequested { + deposit: (deposit.0, deposit.1.saturating_mul(DECIMAL_CONVERTOR.into())), + len, + }, + }; + + // The storage item is using Identity so we don't need to do addtitional hashing and can + // directly put into storage + put_storage_value::>>( + pallet_prefix, + storage_item_prefix, + hash.as_ref(), + new_status, + ); + + weight += T::DbWeight::get().reads_writes(1, 1); + } + + weight + } + + #[cfg(feature = "try-runtime")] + fn post_upgrade(state: Vec) -> Result<(), &'static str> { + let expected_result = + Vec::<(T::Hash, RequestStatus>)>::decode(&mut &state[..]) + .map_err(|_| "Failed to decode Bounties")?; + + let pallet_prefix: &[u8] = b"Preimage"; + let storage_item_prefix: &[u8] = b"StatusFor"; + let actual_result: Vec<_> = storage_key_iter::< + T::Hash, + RequestStatus>, + Identity, + >(pallet_prefix, storage_item_prefix) + .collect(); + + for x in 0..actual_result.len() { + assert_eq!(actual_result[x], expected_result[x]) + } + + log::info!( + target: "ReplacePreImageStorage", + "Finished performing post upgrade checks" + ); + + Ok(()) + } +} diff --git a/runtime/paseo/src/migration/P9191/migrate_proxy.rs b/runtime/paseo/src/migration/P9191/migrate_proxy.rs new file mode 100644 index 0000000000..c5be78ebdc --- /dev/null +++ b/runtime/paseo/src/migration/P9191/migrate_proxy.rs @@ -0,0 +1,265 @@ +// Copyright 2020-2024 Trust Computing GmbH. +// This file is part of Litentry. +// +// Litentry is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Litentry 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 +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Litentry. If not, see . +#![allow(clippy::type_complexity)] + +use frame_support::{ + migration::storage_key_iter, + pallet_prelude::*, + traits::{Currency, Get, OnRuntimeUpgrade}, + Twox64Concat, +}; +use sp_runtime::{traits::Hash, Saturating}; +use sp_std::{marker::PhantomData, vec::Vec}; + +pub const DECIMAL_CONVERTOR: u32 = 1_000_000; + +#[cfg(feature = "try-runtime")] +use parity_scale_codec::Encode; +#[cfg(feature = "try-runtime")] +use sp_std::collections::btree_map::BTreeMap; + +use pallet_proxy::{Announcement, Announcements, Proxies, ProxyDefinition}; +type BalanceOf = <::Currency as Currency< + ::AccountId, +>>::Balance; + +type CallHashOf = <::CallHasher as Hash>::Output; + +pub struct ReplacePalletProxyStorage(PhantomData); + +impl ReplacePalletProxyStorage +where + T: pallet_proxy::Config, +{ + // pallet_proxy + pub fn replace_proxy_proxies_storage() -> frame_support::weights::Weight { + log::info!( + target: "ReplacePalletProxyStorage", + "Running migration to Proxy - Proxies" + ); + + let mut weight = frame_support::weights::Weight::zero(); + + let pallet_prefix: &[u8] = b"Proxy"; + let storage_item_prefix: &[u8] = b"Proxies"; + + for (account, (proxies, amount)) in storage_key_iter::< + T::AccountId, + ( + BoundedVec< + ProxyDefinition, + T::MaxProxies, + >, + BalanceOf, + ), + Twox64Concat, + >(pallet_prefix, storage_item_prefix) + .drain() + { + let new_amount = amount.saturating_mul(DECIMAL_CONVERTOR.into()); + >::insert(account, (proxies, new_amount)); + + weight += T::DbWeight::get().reads_writes(1, 1); + } + + weight + } + + pub fn replace_proxy_announcements_storage() -> frame_support::weights::Weight { + log::info!( + target: "ReplacePalletProxyStorage", + "Running migration to Proxy - Announcements" + ); + + let mut weight = frame_support::weights::Weight::zero(); + + let pallet_prefix: &[u8] = b"Proxy"; + let storage_item_prefix: &[u8] = b"Announcements"; + + for (account, (announcements, amount)) in storage_key_iter::< + T::AccountId, + ( + BoundedVec< + Announcement, T::BlockNumber>, + T::MaxPending, + >, + BalanceOf, + ), + Twox64Concat, + >(pallet_prefix, storage_item_prefix) + .drain() + { + let new_amount = amount.saturating_mul(DECIMAL_CONVERTOR.into()); + >::insert(account, (announcements, new_amount)); + + weight += T::DbWeight::get().reads_writes(1, 1); + } + + weight + } +} + +#[cfg(feature = "try-runtime")] +impl ReplacePalletProxyStorage +where + T: pallet_proxy::Config, +{ + // pallet_proxy + pub fn pre_upgrade_proxy_proxies_storage() -> Result, &'static str> { + let result: BTreeMap< + T::AccountId, + ( + BoundedVec< + ProxyDefinition, + T::MaxProxies, + >, + BalanceOf, + ), + > = >::iter() + .map(|(account, (proxies, amount))| { + let new_amount = amount.saturating_mul(DECIMAL_CONVERTOR.into()); + (account, (proxies, new_amount)) + }) + .collect(); + Ok(result.encode()) + } + + pub fn post_upgrade_proxy_proxies_storage(state: Vec) -> Result<(), &'static str> { + let expected_state = BTreeMap::< + T::AccountId, + ( + BoundedVec< + ProxyDefinition, + T::MaxProxies, + >, + BalanceOf, + ), + >::decode(&mut &state[..]) + .map_err(|_| "Failed to decode BoundedVec")?; + for (account, actual_result) in >::iter() { + let expected_result: ( + BoundedVec< + ProxyDefinition, + T::MaxProxies, + >, + BalanceOf, + ) = expected_state + .get(&account) + .ok_or("Not Expected BoundedVec")? + .clone(); + assert_eq!(expected_result.encode(), actual_result.encode()); + } + Ok(()) + } + + pub fn pre_upgrade_proxy_announcements_storage() -> Result, &'static str> { + let result: BTreeMap< + T::AccountId, + ( + BoundedVec< + Announcement, T::BlockNumber>, + T::MaxPending, + >, + BalanceOf, + ), + > = >::iter() + .map(|(account, (announcements, amount))| { + let new_amount = amount.saturating_mul(DECIMAL_CONVERTOR.into()); + (account, (announcements, new_amount)) + }) + .collect(); + Ok(result.encode()) + } + + pub fn post_upgrade_proxy_announcements_storage(state: Vec) -> Result<(), &'static str> { + let expected_state = BTreeMap::< + T::AccountId, + ( + BoundedVec< + Announcement, T::BlockNumber>, + T::MaxPending, + >, + BalanceOf, + ), + >::decode(&mut &state[..]) + .map_err(|_| "Failed to decode BoundedVec")?; + for (account, actual_result) in >::iter() { + let expected_result: ( + BoundedVec< + Announcement, T::BlockNumber>, + T::MaxPending, + >, + BalanceOf, + ) = expected_state + .get(&account) + .ok_or("Not Expected BoundedVec")? + .clone(); + assert_eq!(expected_result.encode(), actual_result.encode()); + } + Ok(()) + } +} + +impl OnRuntimeUpgrade for ReplacePalletProxyStorage +where + T: pallet_proxy::Config, +{ + #[cfg(feature = "try-runtime")] + fn pre_upgrade() -> Result, &'static str> { + // pallet_proxy + let proxies_vec = Self::pre_upgrade_proxy_proxies_storage()?; + let announcements_vec = Self::pre_upgrade_proxy_announcements_storage()?; + + log::info!( + target: "ReplacePalletProxyStorage", + "Finished performing Proxy pre upgrade checks" + ); + + Ok((proxies_vec, announcements_vec).encode()) + } + + fn on_runtime_upgrade() -> frame_support::weights::Weight { + let mut weight = frame_support::weights::Weight::from_parts(0, 0); + + // pallet_proxy + weight += Self::replace_proxy_proxies_storage(); + weight += Self::replace_proxy_announcements_storage(); + + log::info!( + target: "ReplacePalletProxyStorage", + "Finished performing Proxy storage migration" + ); + + weight + } + + #[cfg(feature = "try-runtime")] + fn post_upgrade(state: Vec) -> Result<(), &'static str> { + let pre_vec: (Vec, Vec) = + Decode::decode(&mut &state[..]).map_err(|_| "Failed to decode Tuple")?; + + // pallet_proxy + Self::post_upgrade_proxy_proxies_storage(pre_vec.0)?; + Self::post_upgrade_proxy_announcements_storage(pre_vec.1)?; + + log::info!( + target: "ReplacePalletProxyStorage", + "Finished performing Proxy post upgrade checks" + ); + + Ok(()) + } +} diff --git a/runtime/paseo/src/migration/P9191/migrate_treasury.rs b/runtime/paseo/src/migration/P9191/migrate_treasury.rs new file mode 100644 index 0000000000..20160a27b7 --- /dev/null +++ b/runtime/paseo/src/migration/P9191/migrate_treasury.rs @@ -0,0 +1,208 @@ +// Copyright 2020-2024 Trust Computing GmbH. +// This file is part of Litentry. +// +// Litentry is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Litentry 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 +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Litentry. If not, see . +use frame_support::traits::{Get, OnRuntimeUpgrade}; +use sp_std::{marker::PhantomData, vec::Vec}; + +use frame_support::{ + migration::{get_storage_value, storage_key_iter}, + pallet_prelude::*, + Twox64Concat, +}; +use pallet_treasury::{BalanceOf, Deactivated, ProposalIndex, Proposals}; +use parity_scale_codec::EncodeLike; +use sp_runtime::Saturating; + +pub const DECIMAL_CONVERTOR: u128 = 1_000_000u128; + +// We are recreating the proposal struct with public fields +#[derive(Encode, Decode, Clone, PartialEq, Eq, MaxEncodedLen, RuntimeDebug, TypeInfo)] +pub struct Proposal { + /// The account proposing it. + pub proposer: AccountId, + /// The (total) amount that should be paid if the proposal is accepted. + pub value: Balance, + /// The account to whom the payment should be made if the proposal is accepted. + pub beneficiary: AccountId, + /// The amount held on deposit (reserved) for making this proposal. + pub bond: Balance, +} + +// This is important when we want to insert into the storage item +impl EncodeLike> + for Proposal +where + AccountId: EncodeLike, + Balance: EncodeLike, +{ +} + +pub struct ReplaceTreasuryStorage(PhantomData<(T, I)>); + +impl ReplaceTreasuryStorage +where + T: pallet_treasury::Config, + BalanceOf: EncodeLike> + From, +{ + fn replace_proposals_storage() -> frame_support::weights::Weight { + log::info!( + target: "ReplaceTreasuryStorage", + "running migration to Treasury Proposals Storage Item" + ); + let pallet_prefix: &[u8] = b"Treasury"; + let storage_item_prefix: &[u8] = b"Proposals"; + let mut weight: Weight = frame_support::weights::Weight::zero(); + + for (proposal_index, mut proposal) in storage_key_iter::< + ProposalIndex, + Proposal>, + Twox64Concat, + >(pallet_prefix, storage_item_prefix) + .drain() + { + proposal.value = proposal.value.saturating_mul(DECIMAL_CONVERTOR.into()); + proposal.bond = proposal.bond.saturating_mul(DECIMAL_CONVERTOR.into()); + + >::insert(proposal_index, proposal); + + weight += T::DbWeight::get().reads_writes(1, 1); + } + weight + } + + fn replace_deactivated_storage() -> frame_support::weights::Weight { + log::info!( + target: "ReplaceTreasuryStorage", + "running migration to Treasury Deactivated Storage Item" + ); + let pallet_prefix: &[u8] = b"Treasury"; + let storage_item_prefix: &[u8] = b"Deactivated"; + let stored_data = + get_storage_value::>(pallet_prefix, storage_item_prefix, b"") + .expect("Storage query fails: Treasury Deactivated"); + + >::put(stored_data.saturating_mul(DECIMAL_CONVERTOR.into())); + + let weight = T::DbWeight::get(); + frame_support::weights::Weight::from_parts(0, weight.write + weight.read) + } +} + +#[cfg(feature = "try-runtime")] +impl ReplaceTreasuryStorage +where + T: pallet_treasury::Config, + BalanceOf: EncodeLike> + From, +{ + fn pre_upgrade_proposals_storage() -> Result, &'static str> { + let pallet_prefix: &[u8] = b"Treasury"; + let storage_item_prefix: &[u8] = b"Proposals"; + let stored_data: Vec<_> = storage_key_iter::< + ProposalIndex, + Proposal>, + Twox64Concat, + >(pallet_prefix, storage_item_prefix) + .collect(); + + let result: Vec<_> = stored_data + .into_iter() + .map(|(proposal_index, proposal)| { + let mut new_proposal = proposal; + new_proposal.value = new_proposal.value.saturating_mul(DECIMAL_CONVERTOR.into()); + new_proposal.bond = new_proposal.bond.saturating_mul(DECIMAL_CONVERTOR.into()); + + (proposal_index, new_proposal) + }) + .collect(); + + Ok(result.encode()) + } + + fn post_upgrade_proposals_storage(state: Vec) -> Result<(), &'static str> { + let expected_result = + Vec::<(ProposalIndex, Proposal>)>::decode( + &mut &state[..], + ) + .map_err(|_| "Failed to decode Bounties")?; + + let pallet_prefix: &[u8] = b"Treasury"; + let storage_item_prefix: &[u8] = b"Proposals"; + let actual_result: Vec<_> = storage_key_iter::< + ProposalIndex, + Proposal>, + Twox64Concat, + >(pallet_prefix, storage_item_prefix) + .collect(); + + for x in 0..actual_result.len() { + assert_eq!(actual_result[x], expected_result[x]) + } + + Ok(()) + } + + fn pre_upgrade_deactivated_storage() -> Result, &'static str> { + Ok(>::get().saturating_mul(DECIMAL_CONVERTOR.into()).encode()) + } + + fn post_upgrade_deactivated_storage(state: Vec) -> Result<(), &'static str> { + let expected_state = BalanceOf::::decode(&mut &state[..]) + .map_err(|_| "Failed to decode Total Balance")?; + let actual_state = >::get(); + assert_eq!(expected_state, actual_state); + Ok(()) + } +} + +impl OnRuntimeUpgrade for ReplaceTreasuryStorage +where + T: pallet_treasury::Config, + BalanceOf: EncodeLike> + From, +{ + #[cfg(feature = "try-runtime")] + fn pre_upgrade() -> Result, &'static str> { + let proposals_state_vec = Self::pre_upgrade_proposals_storage()?; + let deactivated_state_vec = Self::pre_upgrade_deactivated_storage()?; + + log::info!( + target: "ReplaceTreasuryStorage", + "Finished performing post upgrade checks" + ); + Ok((proposals_state_vec, deactivated_state_vec).encode()) + } + + fn on_runtime_upgrade() -> frame_support::weights::Weight { + let mut weight = frame_support::weights::Weight::from_parts(0, 0); + weight += Self::replace_proposals_storage(); + weight += Self::replace_deactivated_storage(); + + log::info!( + target: "ReplaceTreasuryStorage", + "Finished performing storage migration" + ); + + weight + } + + #[cfg(feature = "try-runtime")] + fn post_upgrade(state: Vec) -> Result<(), &'static str> { + let pre_vec: (Vec, Vec) = + Decode::decode(&mut &state[..]).map_err(|_| "Failed to decode Tuple")?; + Self::post_upgrade_proposals_storage(pre_vec.0)?; + Self::post_upgrade_deactivated_storage(pre_vec.1)?; + log::info!(target: "ReplaceTreasuryStorage", "Finished performing post upgrade checks"); + Ok(()) + } +} diff --git a/runtime/paseo/src/migration/P9191/migrate_vesting.rs b/runtime/paseo/src/migration/P9191/migrate_vesting.rs new file mode 100644 index 0000000000..99e0a6ea61 --- /dev/null +++ b/runtime/paseo/src/migration/P9191/migrate_vesting.rs @@ -0,0 +1,172 @@ +// Copyright 2020-2024 Trust Computing GmbH. +// This file is part of Litentry. +// +// Litentry is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Litentry 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 +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Litentry. If not, see . +#![allow(clippy::type_complexity)] + +use frame_support::{ + migration::storage_key_iter, + pallet_prelude::*, + traits::{Currency, Get, OnRuntimeUpgrade}, + Blake2_128Concat, +}; +use sp_runtime::Saturating; +use sp_std::{marker::PhantomData, vec::Vec}; + +pub const DECIMAL_CONVERTOR: u32 = 1_000_000; + +#[cfg(feature = "try-runtime")] +use parity_scale_codec::Encode; +#[cfg(feature = "try-runtime")] +use sp_std::collections::btree_map::BTreeMap; + +use pallet_vesting::{MaxVestingSchedulesGet, Vesting, VestingInfo}; +type BalanceOf = <::Currency as Currency< + ::AccountId, +>>::Balance; + +pub struct ReplacePalletVestingStorage(PhantomData); + +impl ReplacePalletVestingStorage +where + T: pallet_vesting::Config, +{ + // pallet_vesting + pub fn replace_vesting_vesting_storage() -> frame_support::weights::Weight { + log::info!( + target: "ReplacePalletVestingStorage", + "Running migration to Vesting - Vesting" + ); + + let mut weight = frame_support::weights::Weight::zero(); + + let pallet_prefix: &[u8] = b"Vesting"; + let storage_item_prefix: &[u8] = b"Vesting"; + + for (account, mut vest_info) in storage_key_iter::< + T::AccountId, + BoundedVec, T::BlockNumber>, MaxVestingSchedulesGet>, + Blake2_128Concat, + >(pallet_prefix, storage_item_prefix) + .drain() + { + for vest in vest_info.iter_mut() { + *vest = VestingInfo::new( + vest.locked().saturating_mul(DECIMAL_CONVERTOR.into()), + vest.per_block().saturating_mul(DECIMAL_CONVERTOR.into()), + vest.starting_block(), + ); + } + + Vesting::::insert(&account, vest_info); + weight += T::DbWeight::get().reads_writes(1, 1); + } + + weight + } +} + +#[cfg(feature = "try-runtime")] +impl ReplacePalletVestingStorage +where + T: pallet_vesting::Config, +{ + // pallet_vesting + pub fn pre_upgrade_vesting_vesting_storage() -> Result, &'static str> { + let result: BTreeMap< + T::AccountId, + BoundedVec, T::BlockNumber>, MaxVestingSchedulesGet>, + > = >::iter() + .map(|(account, vest_vec)| { + let mut new_vest_vec: BoundedVec< + VestingInfo, T::BlockNumber>, + MaxVestingSchedulesGet, + > = vest_vec; + for vest in new_vest_vec.iter_mut() { + *vest = VestingInfo::new( + vest.locked().saturating_mul(DECIMAL_CONVERTOR.into()), + vest.per_block().saturating_mul(DECIMAL_CONVERTOR.into()), + vest.starting_block(), + ); + } + (account, new_vest_vec) + }) + .collect(); + Ok(result.encode()) + } + + pub fn post_upgrade_vesting_vesting_storage(state: Vec) -> Result<(), &'static str> { + let expected_state = BTreeMap::< + T::AccountId, + BoundedVec, T::BlockNumber>, MaxVestingSchedulesGet>, + >::decode(&mut &state[..]) + .map_err(|_| "Failed to decode BoundedVec")?; + for (account, actual_result) in >::iter() { + let expected_result: BoundedVec< + VestingInfo, T::BlockNumber>, + MaxVestingSchedulesGet, + > = expected_state + .get(&account) + .ok_or("Not Expected BoundedVec")? + .clone(); + assert_eq!(expected_result.encode(), actual_result.encode()); + } + Ok(()) + } +} + +impl OnRuntimeUpgrade for ReplacePalletVestingStorage +where + T: pallet_vesting::Config, +{ + #[cfg(feature = "try-runtime")] + fn pre_upgrade() -> Result, &'static str> { + // pallet_vesting + let vesting_vec = Self::pre_upgrade_vesting_vesting_storage()?; + + log::info!( + target: "ReplacePalletVestingStorage", + "Finished performing Vesting pre upgrade checks" + ); + + Ok((vesting_vec).encode()) + } + + fn on_runtime_upgrade() -> frame_support::weights::Weight { + let mut weight = frame_support::weights::Weight::zero(); + // pallet_vesting + weight += Self::replace_vesting_vesting_storage(); + + log::info!( + target: "ReplacePalletVestingStorage", + "Finished performing Vesting storage migration" + ); + + weight + } + + #[cfg(feature = "try-runtime")] + fn post_upgrade(state: Vec) -> Result<(), &'static str> { + let pre_vec: (Vec,) = + Decode::decode(&mut &state[..]).map_err(|_| "Failed to decode Tuple")?; + Self::post_upgrade_vesting_vesting_storage(pre_vec.0)?; + + log::info!( + target: "ReplacePalletVestingStorage", + "Finished performing Vesting post upgrade checks" + ); + + Ok(()) + } +} diff --git a/runtime/paseo/src/migration/P9191/mod.rs b/runtime/paseo/src/migration/P9191/mod.rs new file mode 100644 index 0000000000..c48ab5f2e6 --- /dev/null +++ b/runtime/paseo/src/migration/P9191/mod.rs @@ -0,0 +1,33 @@ +// Copyright 2020-2024 Trust Computing GmbH. +// This file is part of Litentry. +// +// Litentry is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Litentry 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 +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Litentry. If not, see . +pub mod migrate_identity; +pub use migrate_identity::ReplacePalletIdentityStorage; +pub mod migrate_multisig; +pub use migrate_multisig::ReplacePalletMultisigStorage; +pub mod migrate_proxy; +pub use migrate_proxy::ReplacePalletProxyStorage; +pub mod migrate_vesting; +pub use migrate_vesting::ReplacePalletVestingStorage; +pub mod migrate_bounty; +pub use migrate_bounty::ReplacePalletBountyStorage; +pub mod migrate_democracy; +pub use migrate_democracy::ReplaceDemocracyStorage; +pub mod migrate_preimage; +pub use migrate_preimage::ReplacePreImageStorage; +pub mod migrate_treasury; +pub use migrate_treasury::ReplaceTreasuryStorage; +pub mod fix_balances; +pub use fix_balances::ForceFixAccountFrozenStorage; diff --git a/runtime/paseo/src/migration/P9192.rs b/runtime/paseo/src/migration/P9192.rs new file mode 100644 index 0000000000..0c10ddc50e --- /dev/null +++ b/runtime/paseo/src/migration/P9192.rs @@ -0,0 +1,164 @@ +// Copyright 2020-2024 Trust Computing GmbH. +// This file is part of Litentry. +// +// Litentry is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Litentry 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 +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Litentry. If not, see . +#![allow(clippy::type_complexity)] + +use frame_support::{ + migration::storage_key_iter, + pallet_prelude::*, + traits::{Get, OnRuntimeUpgrade}, + Twox64Concat, +}; +use sp_runtime::Saturating; +use sp_std::{convert::From, marker::PhantomData, vec::Vec}; + +use pallet_parachain_staking::{ + BalanceOf, Bond, CandidateInfo, CandidatePool, Delegations, TopDelegations, Total, +}; +pub const DECIMAL_CONVERTOR: u128 = 1_000_000u128; + +// Fix Parachain Staking Storage for missing migrating TopDelegations total +pub struct FixParachainStakingStorage(PhantomData); + +impl OnRuntimeUpgrade for FixParachainStakingStorage +where + T: frame_system::Config + pallet_parachain_staking::Config, + BalanceOf: From, +{ + #[cfg(feature = "try-runtime")] + fn pre_upgrade() -> Result, &'static str> { + // Does not matter + Ok(Vec::::new()) + } + + // Staked is the snapshot of Total, and remove after used, so no fix + // AtStake, will not be fixed, let's wait extra two round with reward = 0 to make this data + // clean DelayedPayouts, will not fix, let's wait extra two round with reward = 0 to make this + // data clean + + // TopDelegations require fix + // CandidateInfo require fix + // CandidatePool require fix + // Total fix + fn on_runtime_upgrade() -> frame_support::weights::Weight { + log::info!( + target: "ReplaceParachainStakingStorage", + "running migration to ParachainStaking TopDelegations" + ); + let pallet_prefix: &[u8] = b"ParachainStaking"; + let storage_item_prefix: &[u8] = b"TopDelegations"; + let mut weight: Weight = frame_support::weights::Weight::zero(); + + let mut candidates = >::get(); + // remove all bonds + candidates.clear(); + + // intitialized total + let mut total: BalanceOf = 0u128.into(); + + for (account, mut delegations) in storage_key_iter::< + T::AccountId, + Delegations>, + Twox64Concat, + >(pallet_prefix, storage_item_prefix) + .drain() + { + // Patching the missed total value converting + // This storage is already correpted + let mut collator_delegations_sum: BalanceOf = 0u128.into(); + for delegation_bond in delegations.delegations.iter() { + collator_delegations_sum += delegation_bond.amount; + } + delegations.total = collator_delegations_sum; + + // Get CandidateInfo of the same collator key + let mut metadata = >::get(&account).unwrap(); + // Self + delegation total + metadata.total_counted = metadata.bond + delegations.total; + + // Fix TopDelegations + >::insert(&account, delegations); + + // Bond use its owner value to determine if equal without checking its amount + // We need to check amount later + candidates.insert(Bond { owner: account.clone(), amount: metadata.total_counted }); + // Add total + total = total.saturating_add(metadata.total_counted); + + // Fix CandidateInfo + >::insert(&account, metadata); + + weight += T::DbWeight::get().reads_writes(2, 2); + } + + // Fix CandidatePool + candidates.0.sort_by(|a, b| a.amount.cmp(&b.amount)); + >::put(candidates); + // Fix Total + >::put(total); + + weight + } + + // Check Top Delegation total = sum, collator wise + // Check CandidateInfo total count = self bond + sum of delegation, collator wise + // Check CandidatePool = + // Check Total = sum CandidateInfo total count + #[cfg(feature = "try-runtime")] + fn post_upgrade(_state: Vec) -> Result<(), &'static str> { + // Check Top Delegation total = sum + // Check CandidateInfo total count = self bond + sum of delegation + // Check Total = sum CandidateInfo total count + let mut total: BalanceOf = 0u128.into(); + for (account, delegations) in >::iter() { + log::info!("Checking Top Delegations Collator: {:?}", account.encode()); + // Start calculating collator delegation sum + let mut collator_delegations_sum: BalanceOf = 0u128.into(); + + for delegation_bond in delegations.delegations.iter() { + collator_delegations_sum += delegation_bond.amount; + } + + // Check Top Delegation total = sum, collator wise + assert_eq!(collator_delegations_sum, delegations.total); + + let metadata = >::get(account).unwrap(); + // Check CandidateInfo total count = self bond + sum of delegation + assert_eq!(metadata.total_counted, metadata.bond + collator_delegations_sum); + + // Collator self + Collator delegations + total += metadata.bond + collator_delegations_sum; + } + // Check Total = sum CandidateInfo total count + assert_eq!(total, >::get()); + + // It is hard to check CandidatePool without iterating vector + // So we just check its sum = Total + // Get all ordered_set of bond + let ordered_set = >::get(); + let mut candidate_pool_sum: BalanceOf = 0u128.into(); + + // Make sure the number of Order set is correct + for bond in ordered_set.0.iter() { + candidate_pool_sum += bond.amount; + } + + // Check CandidatePool element's amount total = total (self bond + sum of delegation) + log::info!("Checking total: {:?}", total); + assert_eq!(total, candidate_pool_sum); + + Ok(()) + } +} diff --git a/runtime/paseo/src/migration/migration.md b/runtime/paseo/src/migration/migration.md new file mode 100644 index 0000000000..4c618e0bad --- /dev/null +++ b/runtime/paseo/src/migration/migration.md @@ -0,0 +1,40 @@ +# Migrate fix of last decimal upgrade +P9192.rs +it fixes the missing `total` migration in TopDelegations + +# Migrate decimal change 12 -> 18 +P9191/ folder: +These migration is for the follwoing task +https://github.com/litentry/litentry-parachain/releases/tag/v0.9.19-02 +The leftover part of migration including the following pallets: +Bounty, Democracy, Identity, Multisig, Preimage, Proxy, Treasury, Vesting + +Fix the rococo mistake in P9190 +set all account.frozen = 0 + +# Migrate +Under files P9190 +These migration is for the follwoing task +https://github.com/litentry/litentry-parachain/releases/tag/v0.9.19 +(1) token decimal change from 12 to 18 +(2) New token bridge related pallet storage migration. + +Rococo Only: +For rococo, the initial migration contains some error code which make account.frozen = account.reserve * 10^6 +This storage error should be fixed in the following migration of rococo + +And the migration of parachain_staking, pallet_balances and bridge related migration also applied in this migration for rococo. + +# MigrateCollatorSelectionIntoParachainStaking +P9100.rs +https://github.com/litentry/litentry-parachain/releases/tag/v0.9.10 +This migration is for the replacement of CollatorSelection with ParachainStaking + +The main purpose of runtime upgrade is for make up the missing genesis build of ParachainStaking and clean the old CollatorSelection storage. + +# MigrateAtStakeAutoCompound +P9130.rs +https://github.com/litentry/litentry-parachain/releases/tag/v0.9.13 +This migration is for the update of AtStaked with ParachainStaking + +The main purpose of runtime upgrade is for adding the autocompound staking function of ParachainStaking and need to update storage to the latest struct. \ No newline at end of file diff --git a/runtime/paseo/src/migration/mod.rs b/runtime/paseo/src/migration/mod.rs new file mode 100644 index 0000000000..8b13789179 --- /dev/null +++ b/runtime/paseo/src/migration/mod.rs @@ -0,0 +1 @@ + diff --git a/runtime/paseo/src/precompiles.rs b/runtime/paseo/src/precompiles.rs new file mode 100644 index 0000000000..31a425517d --- /dev/null +++ b/runtime/paseo/src/precompiles.rs @@ -0,0 +1,151 @@ +// Copyright 2020-2024 Trust Computing GmbH. +// This file is part of Litentry. +// +// Litentry is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Litentry 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 +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Litentry. If not, see . + +use crate::RuntimeCall; +use core::marker::PhantomData; +use fp_evm::{ExitError, PrecompileFailure}; +use frame_support::{ + dispatch::GetDispatchInfo, + pallet_prelude::{DispatchClass, Pays}, + parameter_types, + traits::Contains, +}; +use pallet_evm_precompile_assets_erc20::Erc20AssetsPrecompileSet; +use pallet_evm_precompile_blake2::Blake2F; +use pallet_evm_precompile_bn128::{Bn128Add, Bn128Mul, Bn128Pairing}; +use pallet_evm_precompile_bridge_transfer::BridgeTransferPrecompile; +use pallet_evm_precompile_dispatch::{Dispatch, DispatchValidateT}; +use pallet_evm_precompile_ed25519::Ed25519Verify; +use pallet_evm_precompile_modexp::Modexp; +use pallet_evm_precompile_parachain_staking::ParachainStakingPrecompile; +use pallet_evm_precompile_score_staking::ScoreStakingPrecompile; +use pallet_evm_precompile_sha3fips::Sha3FIPS256; +use pallet_evm_precompile_simple::{ECRecover, ECRecoverPublicKey, Identity, Ripemd160, Sha256}; +use precompile_utils::precompile_set::*; +use sp_std::fmt::Debug; + +/// The asset precompile address prefix. Addresses that match against this prefix will be routed +/// to Erc20AssetsPrecompileSet +pub const ASSET_PRECOMPILE_ADDRESS_PREFIX: &[u8] = &[255u8; 4]; +parameter_types! { + pub AssetPrefix: &'static [u8] = ASSET_PRECOMPILE_ADDRESS_PREFIX; +} + +pub struct DispatchFilterValidate>( + PhantomData<(RuntimeCall, Filter)>, +); + +impl> + DispatchValidateT for DispatchFilterValidate +{ + fn validate_before_dispatch( + _origin: &AccountId, + call: &RuntimeCall, + ) -> Option { + let info = call.get_dispatch_info(); + let paid_normal_call = info.pays_fee == Pays::Yes && info.class == DispatchClass::Normal; + if !paid_normal_call { + return Some(PrecompileFailure::Error { + exit_status: ExitError::Other("invalid call".into()), + }) + } + if Filter::contains(call) { + None + } else { + Some(PrecompileFailure::Error { + exit_status: ExitError::Other("call filtered out".into()), + }) + } + } +} + +/// Precompile checks for ethereum spec precompiles +/// We allow DELEGATECALL to stay compliant with Ethereum behavior. +type EthereumPrecompilesChecks = (AcceptDelegateCall, CallableByContract, CallableByPrecompile); + +/// Filter that only allows whitelisted runtime call to pass through dispatch precompile +pub struct WhitelistedCalls; + +impl Contains for WhitelistedCalls { + fn contains(t: &RuntimeCall) -> bool { + match t { + RuntimeCall::Assets(pallet_assets::Call::transfer { .. }) => true, + RuntimeCall::Utility(pallet_utility::Call::batch { calls }) | + RuntimeCall::Utility(pallet_utility::Call::batch_all { calls }) => + calls.iter().all(WhitelistedCalls::contains), + _ => false, + } + } +} +/// The PrecompileSet installed in the rococo runtime. +#[precompile_utils::precompile_name_from_address] +pub type PrecompilesSetAt = ( + // Ethereum precompiles: + // We allow DELEGATECALL to stay compliant with Ethereum behavior. + PrecompileAt, ECRecover, EthereumPrecompilesChecks>, + PrecompileAt, Sha256, EthereumPrecompilesChecks>, + PrecompileAt, Ripemd160, EthereumPrecompilesChecks>, + PrecompileAt, Identity, EthereumPrecompilesChecks>, + PrecompileAt, Modexp, EthereumPrecompilesChecks>, + PrecompileAt, Bn128Add, EthereumPrecompilesChecks>, + PrecompileAt, Bn128Mul, EthereumPrecompilesChecks>, + PrecompileAt, Bn128Pairing, EthereumPrecompilesChecks>, + PrecompileAt, Blake2F, EthereumPrecompilesChecks>, + // Non-Litentry specific nor Ethereum precompiles : + PrecompileAt, Sha3FIPS256, (CallableByContract, CallableByPrecompile)>, + PrecompileAt< + AddressU64<1025>, + Dispatch>, + // Not callable from smart contract nor precompiles, only EOA accounts + // TODO: test this without the gensis hack for blacklisted + (), + >, + PrecompileAt, ECRecoverPublicKey, (CallableByContract, CallableByPrecompile)>, + PrecompileAt, Ed25519Verify, (CallableByContract, CallableByPrecompile)>, + // Litentry precompiles (starts from 0x5000): + // ParachainStaking: pallet_parachain_staking = 45 + 20480 + PrecompileAt< + AddressU64<20525>, + ParachainStakingPrecompile, + (CallableByContract, CallableByPrecompile), + >, + // BridgeTransfer: pallet_bridge_transfer = 61 + 20480 + PrecompileAt< + AddressU64<20541>, + BridgeTransferPrecompile, + (CallableByContract, CallableByPrecompile), + >, + // ScoreStaking: pallet_score_staking = 75 + 20480 + PrecompileAt< + AddressU64<20555>, + ScoreStakingPrecompile, + (CallableByContract, CallableByPrecompile), + >, +); + +pub type RococoNetworkPrecompiles = PrecompileSetBuilder< + R, + ( + // Skip precompiles if out of range. + PrecompilesInRangeInclusive< + // We take range as last precompile index, UPDATE this once new prcompile is added + (AddressU64<1>, AddressU64<20556>), + PrecompilesSetAt, + >, + // Prefixed precompile sets (XC20) + PrecompileSetStartingWith, CallableByContract>, + ), +>; diff --git a/runtime/paseo/src/tests/base_call_filter.rs b/runtime/paseo/src/tests/base_call_filter.rs new file mode 100644 index 0000000000..03523bab00 --- /dev/null +++ b/runtime/paseo/src/tests/base_call_filter.rs @@ -0,0 +1,24 @@ +// Copyright 2020-2024 Trust Computing GmbH. +// This file is part of Litentry. +// +// Litentry is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Litentry 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 +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Litentry. If not, see . + +use crate::{Runtime, RuntimeCall, RuntimeOrigin}; + +runtime_common::run_call_filter_tests!(); + +#[test] +fn balance_transfer_works() { + base_call_filter::balance_transfer_works::(); +} diff --git a/runtime/paseo/src/tests/mod.rs b/runtime/paseo/src/tests/mod.rs new file mode 100644 index 0000000000..127fa728ee --- /dev/null +++ b/runtime/paseo/src/tests/mod.rs @@ -0,0 +1,43 @@ +// Copyright 2020-2024 Trust Computing GmbH. +// This file is part of Litentry. +// +// Litentry is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Litentry 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 +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Litentry. If not, see . + +mod base_call_filter; +mod orml_xcm; + +pub mod setup { + use crate::Runtime; + #[cfg(test)] + runtime_common::decl_test_chain!(Runtime); +} + +mod transaction_payment { + use crate::{Runtime, RuntimeCall, RuntimeOrigin, TransactionByteFee}; + + runtime_common::run_transaction_payment_tests!(); +} + +mod xcm_parachain { + use crate::{ + tests::setup::{ + ParaA, ParaB, Relay, RelayChainRuntime, RuntimeCall as RelayCall, + RuntimeOrigin as RelayOrigin, TestNet, + }, + xcm_config::{LocationToAccountId, UnitWeightCost}, + Runtime, RuntimeCall, RuntimeOrigin, + }; + + runtime_common::run_xcm_tests!(); +} diff --git a/runtime/paseo/src/tests/orml_xcm.rs b/runtime/paseo/src/tests/orml_xcm.rs new file mode 100644 index 0000000000..52495baa5f --- /dev/null +++ b/runtime/paseo/src/tests/orml_xcm.rs @@ -0,0 +1,74 @@ +// Copyright 2020-2024 Trust Computing GmbH. +// This file is part of Litentry. +// +// Litentry is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Litentry 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 +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Litentry. If not, see . + +use crate::{ + xcm_config::LocalOriginToLocation, CouncilInstance, Runtime, RuntimeCall, RuntimeOrigin, +}; +use runtime_common::tests::orml_xcm; + +#[test] +fn orml_xcm_root_works() { + orml_xcm::orml_xcm_root_works::(); +} + +#[test] +fn orml_xcm_signed_works() { + orml_xcm::orml_xcm_signed_works::(); +} + +#[test] +fn orml_xcm_two_thirds_council_works() { + orml_xcm::orml_xcm_two_thirds_councli_works::< + Runtime, + RuntimeOrigin, + LocalOriginToLocation, + RuntimeCall, + CouncilInstance, + >(); +} + +#[test] +fn orml_xcm_one_four_council_works() { + orml_xcm::orml_xcm_one_four_councli_works::< + Runtime, + RuntimeOrigin, + LocalOriginToLocation, + RuntimeCall, + CouncilInstance, + >(); +} + +#[test] +fn orml_xcm_half_council_works() { + orml_xcm::orml_xcm_half_councli_works::< + Runtime, + RuntimeOrigin, + LocalOriginToLocation, + RuntimeCall, + CouncilInstance, + >(); +} + +#[test] +fn orml_xcm_member_works() { + orml_xcm::orml_xcm_member_works::< + Runtime, + RuntimeOrigin, + LocalOriginToLocation, + RuntimeCall, + CouncilInstance, + >(); +} diff --git a/runtime/paseo/src/weights/cumulus_pallet_xcmp_queue.rs b/runtime/paseo/src/weights/cumulus_pallet_xcmp_queue.rs new file mode 100644 index 0000000000..11ddda9d2c --- /dev/null +++ b/runtime/paseo/src/weights/cumulus_pallet_xcmp_queue.rs @@ -0,0 +1,76 @@ +// Copyright 2020-2024 Trust Computing GmbH. +// This file is part of Litentry. +// +// Litentry is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Litentry 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 +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Litentry. If not, see . + +//! Autogenerated weights for `cumulus_pallet_xcmp_queue` +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev +//! DATE: 2023-10-17, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! WORST CASE MAP SIZE: `1000000` +//! HOSTNAME: `parachain-benchmark`, CPU: `Intel(R) Xeon(R) Platinum 8259CL CPU @ 2.50GHz` +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("rococo-dev"), DB CACHE: 20 + +// Executed Command: +// ./litentry-collator +// benchmark +// pallet +// --chain=rococo-dev +// --execution=wasm +// --db-cache=20 +// --wasm-execution=compiled +// --pallet=cumulus_pallet_xcmp_queue +// --extrinsic=* +// --heap-pages=4096 +// --steps=20 +// --repeat=50 +// --header=./LICENSE_HEADER +// --output=./runtime/rococo/src/weights/cumulus_pallet_xcmp_queue.rs + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] +#![allow(missing_docs)] + +use frame_support::{traits::Get, weights::Weight}; +use core::marker::PhantomData; + +/// Weight functions for `cumulus_pallet_xcmp_queue`. +pub struct WeightInfo(PhantomData); +impl cumulus_pallet_xcmp_queue::WeightInfo for WeightInfo { + /// Storage: XcmpQueue QueueConfig (r:1 w:1) + /// Proof Skipped: XcmpQueue QueueConfig (max_values: Some(1), max_size: None, mode: Measured) + fn set_config_with_u32() -> Weight { + // Proof Size summary in bytes: + // Measured: `109` + // Estimated: `1594` + // Minimum execution time: 8_168_000 picoseconds. + Weight::from_parts(8_545_000, 0) + .saturating_add(Weight::from_parts(0, 1594)) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: XcmpQueue QueueConfig (r:1 w:1) + /// Proof Skipped: XcmpQueue QueueConfig (max_values: Some(1), max_size: None, mode: Measured) + fn set_config_with_weight() -> Weight { + // Proof Size summary in bytes: + // Measured: `109` + // Estimated: `1594` + // Minimum execution time: 8_244_000 picoseconds. + Weight::from_parts(8_652_000, 0) + .saturating_add(Weight::from_parts(0, 1594)) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(1)) + } +} diff --git a/runtime/paseo/src/weights/frame_system.rs b/runtime/paseo/src/weights/frame_system.rs new file mode 100644 index 0000000000..beb8e20ee4 --- /dev/null +++ b/runtime/paseo/src/weights/frame_system.rs @@ -0,0 +1,132 @@ +// Copyright 2020-2024 Trust Computing GmbH. +// This file is part of Litentry. +// +// Litentry is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Litentry 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 +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Litentry. If not, see . + +//! Autogenerated weights for `frame_system` +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev +//! DATE: 2023-10-17, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! WORST CASE MAP SIZE: `1000000` +//! HOSTNAME: `parachain-benchmark`, CPU: `Intel(R) Xeon(R) Platinum 8259CL CPU @ 2.50GHz` +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("rococo-dev"), DB CACHE: 20 + +// Executed Command: +// ./litentry-collator +// benchmark +// pallet +// --chain=rococo-dev +// --execution=wasm +// --db-cache=20 +// --wasm-execution=compiled +// --pallet=frame_system +// --extrinsic=* +// --heap-pages=4096 +// --steps=20 +// --repeat=50 +// --header=./LICENSE_HEADER +// --output=./runtime/rococo/src/weights/frame_system.rs + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] +#![allow(missing_docs)] + +use frame_support::{traits::Get, weights::Weight}; +use core::marker::PhantomData; + +/// Weight functions for `frame_system`. +pub struct WeightInfo(PhantomData); +impl frame_system::WeightInfo for WeightInfo { + /// The range of component `b` is `[0, 3932160]`. + fn remark(b: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 3_096_000 picoseconds. + Weight::from_parts(3_167_000, 0) + .saturating_add(Weight::from_parts(0, 0)) + // Standard Error: 2 + .saturating_add(Weight::from_parts(617, 0).saturating_mul(b.into())) + } + /// The range of component `b` is `[0, 3932160]`. + fn remark_with_event(b: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 10_656_000 picoseconds. + Weight::from_parts(10_871_000, 0) + .saturating_add(Weight::from_parts(0, 0)) + // Standard Error: 5 + .saturating_add(Weight::from_parts(2_314, 0).saturating_mul(b.into())) + } + /// Storage: System Digest (r:1 w:1) + /// Proof Skipped: System Digest (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: unknown `0x3a686561707061676573` (r:0 w:1) + /// Proof Skipped: unknown `0x3a686561707061676573` (r:0 w:1) + fn set_heap_pages() -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `1485` + // Minimum execution time: 5_535_000 picoseconds. + Weight::from_parts(5_722_000, 0) + .saturating_add(Weight::from_parts(0, 1485)) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(2)) + } + /// Storage: Skipped Metadata (r:0 w:0) + /// Proof Skipped: Skipped Metadata (max_values: None, max_size: None, mode: Measured) + /// The range of component `i` is `[0, 1000]`. + fn set_storage(i: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 2_967_000 picoseconds. + Weight::from_parts(3_030_000, 0) + .saturating_add(Weight::from_parts(0, 0)) + // Standard Error: 5_553 + .saturating_add(Weight::from_parts(1_090_130, 0).saturating_mul(i.into())) + .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(i.into()))) + } + /// Storage: Skipped Metadata (r:0 w:0) + /// Proof Skipped: Skipped Metadata (max_values: None, max_size: None, mode: Measured) + /// The range of component `i` is `[0, 1000]`. + fn kill_storage(i: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 2_889_000 picoseconds. + Weight::from_parts(3_045_000, 0) + .saturating_add(Weight::from_parts(0, 0)) + // Standard Error: 2_430 + .saturating_add(Weight::from_parts(811_384, 0).saturating_mul(i.into())) + .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(i.into()))) + } + /// Storage: Skipped Metadata (r:0 w:0) + /// Proof Skipped: Skipped Metadata (max_values: None, max_size: None, mode: Measured) + /// The range of component `p` is `[0, 1000]`. + fn kill_prefix(p: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `110 + p * (69 ±0)` + // Estimated: `113 + p * (70 ±0)` + // Minimum execution time: 5_480_000 picoseconds. + Weight::from_parts(5_611_000, 0) + .saturating_add(Weight::from_parts(0, 113)) + // Standard Error: 9_382 + .saturating_add(Weight::from_parts(1_967_546, 0).saturating_mul(p.into())) + .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(p.into()))) + .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(p.into()))) + .saturating_add(Weight::from_parts(0, 70).saturating_mul(p.into())) + } +} diff --git a/runtime/paseo/src/weights/mod.rs b/runtime/paseo/src/weights/mod.rs new file mode 100644 index 0000000000..1bb2dda6dc --- /dev/null +++ b/runtime/paseo/src/weights/mod.rs @@ -0,0 +1,42 @@ +// Copyright 2020-2024 Trust Computing GmbH. +// This file is part of Litentry. +// +// Litentry is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Litentry 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 +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Litentry. If not, see . + +#![allow(clippy::unnecessary_cast)] + +pub mod cumulus_pallet_xcmp_queue; +pub mod frame_system; +pub mod pallet_asset_manager; +pub mod pallet_balances; +pub mod pallet_bridge; +pub mod pallet_bridge_transfer; +pub mod pallet_collective; +pub mod pallet_democracy; +pub mod pallet_evm; +pub mod pallet_extrinsic_filter; +pub mod pallet_identity; +pub mod pallet_identity_management; +pub mod pallet_membership; +pub mod pallet_multisig; +pub mod pallet_parachain_staking; +pub mod pallet_preimage; +pub mod pallet_proxy; +pub mod pallet_scheduler; +pub mod pallet_session; +pub mod pallet_teebag; +pub mod pallet_timestamp; +pub mod pallet_treasury; +pub mod pallet_utility; +pub mod pallet_vc_management; diff --git a/runtime/paseo/src/weights/pallet_asset_manager.rs b/runtime/paseo/src/weights/pallet_asset_manager.rs new file mode 100644 index 0000000000..252f531858 --- /dev/null +++ b/runtime/paseo/src/weights/pallet_asset_manager.rs @@ -0,0 +1,126 @@ +// Copyright 2020-2024 Trust Computing GmbH. +// This file is part of Litentry. +// +// Litentry is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Litentry 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 +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Litentry. If not, see . + +//! Autogenerated weights for `pallet_asset_manager` +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev +//! DATE: 2023-10-17, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! WORST CASE MAP SIZE: `1000000` +//! HOSTNAME: `parachain-benchmark`, CPU: `Intel(R) Xeon(R) Platinum 8259CL CPU @ 2.50GHz` +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("rococo-dev"), DB CACHE: 20 + +// Executed Command: +// ./litentry-collator +// benchmark +// pallet +// --chain=rococo-dev +// --execution=wasm +// --db-cache=20 +// --wasm-execution=compiled +// --pallet=pallet_asset_manager +// --extrinsic=* +// --heap-pages=4096 +// --steps=20 +// --repeat=50 +// --header=./LICENSE_HEADER +// --output=./runtime/rococo/src/weights/pallet_asset_manager.rs + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] +#![allow(missing_docs)] + +use frame_support::{traits::Get, weights::Weight}; +use core::marker::PhantomData; + +/// Weight functions for `pallet_asset_manager`. +pub struct WeightInfo(PhantomData); +impl pallet_asset_manager::WeightInfo for WeightInfo { + /// Storage: AssetManager AssetTypeId (r:1 w:1) + /// Proof Skipped: AssetManager AssetTypeId (max_values: None, max_size: None, mode: Measured) + /// Storage: AssetManager ForeignAssetTracker (r:1 w:1) + /// Proof Skipped: AssetManager ForeignAssetTracker (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: AssetManager AssetIdType (r:0 w:1) + /// Proof Skipped: AssetManager AssetIdType (max_values: None, max_size: None, mode: Measured) + /// Storage: AssetManager AssetIdMetadata (r:0 w:1) + /// Proof Skipped: AssetManager AssetIdMetadata (max_values: None, max_size: None, mode: Measured) + fn register_foreign_asset_type() -> Weight { + // Proof Size summary in bytes: + // Measured: `142` + // Estimated: `3607` + // Minimum execution time: 33_201_000 picoseconds. + Weight::from_parts(33_992_000, 0) + .saturating_add(Weight::from_parts(0, 3607)) + .saturating_add(T::DbWeight::get().reads(2)) + .saturating_add(T::DbWeight::get().writes(4)) + } + /// Storage: AssetManager AssetIdType (r:1 w:0) + /// Proof Skipped: AssetManager AssetIdType (max_values: None, max_size: None, mode: Measured) + /// Storage: AssetManager AssetIdMetadata (r:0 w:1) + /// Proof Skipped: AssetManager AssetIdMetadata (max_values: None, max_size: None, mode: Measured) + fn update_foreign_asset_metadata() -> Weight { + // Proof Size summary in bytes: + // Measured: `302` + // Estimated: `3767` + // Minimum execution time: 20_127_000 picoseconds. + Weight::from_parts(20_701_000, 0) + .saturating_add(Weight::from_parts(0, 3767)) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: AssetManager AssetIdType (r:1 w:0) + /// Proof Skipped: AssetManager AssetIdType (max_values: None, max_size: None, mode: Measured) + /// Storage: AssetManager AssetIdUnitsPerSecond (r:0 w:1) + /// Proof Skipped: AssetManager AssetIdUnitsPerSecond (max_values: None, max_size: None, mode: Measured) + fn set_asset_units_per_second() -> Weight { + // Proof Size summary in bytes: + // Measured: `302` + // Estimated: `3767` + // Minimum execution time: 19_489_000 picoseconds. + Weight::from_parts(19_879_000, 0) + .saturating_add(Weight::from_parts(0, 3767)) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: AssetManager AssetIdType (r:1 w:1) + /// Proof Skipped: AssetManager AssetIdType (max_values: None, max_size: None, mode: Measured) + /// Storage: AssetManager AssetTypeId (r:1 w:1) + /// Proof Skipped: AssetManager AssetTypeId (max_values: None, max_size: None, mode: Measured) + fn add_asset_type() -> Weight { + // Proof Size summary in bytes: + // Measured: `325` + // Estimated: `3790` + // Minimum execution time: 25_212_000 picoseconds. + Weight::from_parts(25_708_000, 0) + .saturating_add(Weight::from_parts(0, 3790)) + .saturating_add(T::DbWeight::get().reads(2)) + .saturating_add(T::DbWeight::get().writes(2)) + } + /// Storage: AssetManager AssetTypeId (r:2 w:1) + /// Proof Skipped: AssetManager AssetTypeId (max_values: None, max_size: None, mode: Measured) + /// Storage: AssetManager AssetIdType (r:0 w:1) + /// Proof Skipped: AssetManager AssetIdType (max_values: None, max_size: None, mode: Measured) + fn remove_asset_type() -> Weight { + // Proof Size summary in bytes: + // Measured: `482` + // Estimated: `6422` + // Minimum execution time: 31_996_000 picoseconds. + Weight::from_parts(32_579_000, 0) + .saturating_add(Weight::from_parts(0, 6422)) + .saturating_add(T::DbWeight::get().reads(2)) + .saturating_add(T::DbWeight::get().writes(2)) + } +} diff --git a/runtime/paseo/src/weights/pallet_balances.rs b/runtime/paseo/src/weights/pallet_balances.rs new file mode 100644 index 0000000000..4e4de5a3b0 --- /dev/null +++ b/runtime/paseo/src/weights/pallet_balances.rs @@ -0,0 +1,152 @@ +// Copyright 2020-2024 Trust Computing GmbH. +// This file is part of Litentry. +// +// Litentry is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Litentry 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 +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Litentry. If not, see . + +//! Autogenerated weights for `pallet_balances` +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev +//! DATE: 2023-10-17, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! WORST CASE MAP SIZE: `1000000` +//! HOSTNAME: `parachain-benchmark`, CPU: `Intel(R) Xeon(R) Platinum 8259CL CPU @ 2.50GHz` +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("rococo-dev"), DB CACHE: 20 + +// Executed Command: +// ./litentry-collator +// benchmark +// pallet +// --chain=rococo-dev +// --execution=wasm +// --db-cache=20 +// --wasm-execution=compiled +// --pallet=pallet_balances +// --extrinsic=* +// --heap-pages=4096 +// --steps=20 +// --repeat=50 +// --header=./LICENSE_HEADER +// --output=./runtime/rococo/src/weights/pallet_balances.rs + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] +#![allow(missing_docs)] + +use frame_support::{traits::Get, weights::Weight}; +use core::marker::PhantomData; + +/// Weight functions for `pallet_balances`. +pub struct WeightInfo(PhantomData); +impl pallet_balances::WeightInfo for WeightInfo { + /// Storage: System Account (r:1 w:1) + /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + fn transfer_allow_death() -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `3593` + // Minimum execution time: 73_884_000 picoseconds. + Weight::from_parts(75_841_000, 0) + .saturating_add(Weight::from_parts(0, 3593)) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: System Account (r:1 w:1) + /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + fn transfer_keep_alive() -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `3593` + // Minimum execution time: 55_141_000 picoseconds. + Weight::from_parts(57_048_000, 0) + .saturating_add(Weight::from_parts(0, 3593)) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: System Account (r:1 w:1) + /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + fn force_set_balance_creating() -> Weight { + // Proof Size summary in bytes: + // Measured: `140` + // Estimated: `3593` + // Minimum execution time: 22_969_000 picoseconds. + Weight::from_parts(23_686_000, 0) + .saturating_add(Weight::from_parts(0, 3593)) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: System Account (r:1 w:1) + /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + fn force_set_balance_killing() -> Weight { + // Proof Size summary in bytes: + // Measured: `140` + // Estimated: `3593` + // Minimum execution time: 33_996_000 picoseconds. + Weight::from_parts(34_787_000, 0) + .saturating_add(Weight::from_parts(0, 3593)) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: System Account (r:2 w:2) + /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + fn force_transfer() -> Weight { + // Proof Size summary in bytes: + // Measured: `103` + // Estimated: `6196` + // Minimum execution time: 77_129_000 picoseconds. + Weight::from_parts(78_643_000, 0) + .saturating_add(Weight::from_parts(0, 6196)) + .saturating_add(T::DbWeight::get().reads(2)) + .saturating_add(T::DbWeight::get().writes(2)) + } + /// Storage: System Account (r:1 w:1) + /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + fn transfer_all() -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `3593` + // Minimum execution time: 67_673_000 picoseconds. + Weight::from_parts(68_926_000, 0) + .saturating_add(Weight::from_parts(0, 3593)) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: System Account (r:1 w:1) + /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + fn force_unreserve() -> Weight { + // Proof Size summary in bytes: + // Measured: `140` + // Estimated: `3593` + // Minimum execution time: 26_492_000 picoseconds. + Weight::from_parts(27_038_000, 0) + .saturating_add(Weight::from_parts(0, 3593)) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: System Account (r:1000 w:1000) + /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + /// The range of component `u` is `[1, 1000]`. + fn upgrade_accounts(u: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0 + u * (136 ±0)` + // Estimated: `990 + u * (2603 ±0)` + // Minimum execution time: 25_087_000 picoseconds. + Weight::from_parts(25_453_000, 0) + .saturating_add(Weight::from_parts(0, 990)) + // Standard Error: 91_401 + .saturating_add(Weight::from_parts(22_138_510, 0).saturating_mul(u.into())) + .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(u.into()))) + .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(u.into()))) + .saturating_add(Weight::from_parts(0, 2603).saturating_mul(u.into())) + } +} diff --git a/runtime/paseo/src/weights/pallet_bridge.rs b/runtime/paseo/src/weights/pallet_bridge.rs new file mode 100644 index 0000000000..6e48ad7452 --- /dev/null +++ b/runtime/paseo/src/weights/pallet_bridge.rs @@ -0,0 +1,163 @@ +// Copyright 2020-2024 Trust Computing GmbH. +// This file is part of Litentry. +// +// Litentry is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Litentry 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 +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Litentry. If not, see . + +//! Autogenerated weights for `pallet_bridge` +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev +//! DATE: 2023-10-17, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! WORST CASE MAP SIZE: `1000000` +//! HOSTNAME: `parachain-benchmark`, CPU: `Intel(R) Xeon(R) Platinum 8259CL CPU @ 2.50GHz` +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("rococo-dev"), DB CACHE: 20 + +// Executed Command: +// ./litentry-collator +// benchmark +// pallet +// --chain=rococo-dev +// --execution=wasm +// --db-cache=20 +// --wasm-execution=compiled +// --pallet=pallet_bridge +// --extrinsic=* +// --heap-pages=4096 +// --steps=20 +// --repeat=50 +// --header=./LICENSE_HEADER +// --output=./runtime/rococo/src/weights/pallet_bridge.rs + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] +#![allow(missing_docs)] + +use frame_support::{traits::Get, weights::Weight}; +use core::marker::PhantomData; + +/// Weight functions for `pallet_bridge`. +pub struct WeightInfo(PhantomData); +impl pallet_bridge::WeightInfo for WeightInfo { + /// Storage: ChainBridge RelayerThreshold (r:0 w:1) + /// Proof Skipped: ChainBridge RelayerThreshold (max_values: Some(1), max_size: None, mode: Measured) + fn set_threshold() -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 10_246_000 picoseconds. + Weight::from_parts(10_609_000, 0) + .saturating_add(Weight::from_parts(0, 0)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: ChainBridge ChainNonces (r:1 w:1) + /// Proof Skipped: ChainBridge ChainNonces (max_values: None, max_size: None, mode: Measured) + fn whitelist_chain() -> Weight { + // Proof Size summary in bytes: + // Measured: `142` + // Estimated: `3607` + // Minimum execution time: 15_986_000 picoseconds. + Weight::from_parts(16_451_000, 0) + .saturating_add(Weight::from_parts(0, 3607)) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: ChainBridge Relayers (r:1 w:1) + /// Proof Skipped: ChainBridge Relayers (max_values: None, max_size: None, mode: Measured) + /// Storage: ChainBridge RelayerCount (r:1 w:1) + /// Proof Skipped: ChainBridge RelayerCount (max_values: Some(1), max_size: None, mode: Measured) + fn add_relayer() -> Weight { + // Proof Size summary in bytes: + // Measured: `142` + // Estimated: `3607` + // Minimum execution time: 18_770_000 picoseconds. + Weight::from_parts(19_235_000, 0) + .saturating_add(Weight::from_parts(0, 3607)) + .saturating_add(T::DbWeight::get().reads(2)) + .saturating_add(T::DbWeight::get().writes(2)) + } + /// Storage: ChainBridge Relayers (r:1 w:1) + /// Proof Skipped: ChainBridge Relayers (max_values: None, max_size: None, mode: Measured) + /// Storage: ChainBridge RelayerCount (r:1 w:1) + /// Proof Skipped: ChainBridge RelayerCount (max_values: Some(1), max_size: None, mode: Measured) + fn remove_relayer() -> Weight { + // Proof Size summary in bytes: + // Measured: `223` + // Estimated: `3688` + // Minimum execution time: 20_653_000 picoseconds. + Weight::from_parts(21_109_000, 0) + .saturating_add(Weight::from_parts(0, 3688)) + .saturating_add(T::DbWeight::get().reads(2)) + .saturating_add(T::DbWeight::get().writes(2)) + } + /// Storage: ChainBridge Relayers (r:1 w:0) + /// Proof Skipped: ChainBridge Relayers (max_values: None, max_size: None, mode: Measured) + /// Storage: ChainBridge ChainNonces (r:1 w:0) + /// Proof Skipped: ChainBridge ChainNonces (max_values: None, max_size: None, mode: Measured) + /// Storage: ChainBridge Resources (r:1 w:0) + /// Proof Skipped: ChainBridge Resources (max_values: None, max_size: None, mode: Measured) + /// Storage: ChainBridge Votes (r:1 w:1) + /// Proof Skipped: ChainBridge Votes (max_values: None, max_size: None, mode: Measured) + /// Storage: ChainBridge RelayerThreshold (r:1 w:0) + /// Proof Skipped: ChainBridge RelayerThreshold (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: ChainBridge RelayerCount (r:1 w:0) + /// Proof Skipped: ChainBridge RelayerCount (max_values: Some(1), max_size: None, mode: Measured) + fn acknowledge_proposal() -> Weight { + // Proof Size summary in bytes: + // Measured: `340` + // Estimated: `3805` + // Minimum execution time: 52_203_000 picoseconds. + Weight::from_parts(52_854_000, 0) + .saturating_add(Weight::from_parts(0, 3805)) + .saturating_add(T::DbWeight::get().reads(6)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: ChainBridge Relayers (r:1 w:0) + /// Proof Skipped: ChainBridge Relayers (max_values: None, max_size: None, mode: Measured) + /// Storage: ChainBridge ChainNonces (r:1 w:0) + /// Proof Skipped: ChainBridge ChainNonces (max_values: None, max_size: None, mode: Measured) + /// Storage: ChainBridge Resources (r:1 w:0) + /// Proof Skipped: ChainBridge Resources (max_values: None, max_size: None, mode: Measured) + /// Storage: ChainBridge Votes (r:1 w:1) + /// Proof Skipped: ChainBridge Votes (max_values: None, max_size: None, mode: Measured) + /// Storage: ChainBridge RelayerThreshold (r:1 w:0) + /// Proof Skipped: ChainBridge RelayerThreshold (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: ChainBridge RelayerCount (r:1 w:0) + /// Proof Skipped: ChainBridge RelayerCount (max_values: Some(1), max_size: None, mode: Measured) + fn reject_proposal() -> Weight { + // Proof Size summary in bytes: + // Measured: `340` + // Estimated: `3805` + // Minimum execution time: 44_020_000 picoseconds. + Weight::from_parts(44_771_000, 0) + .saturating_add(Weight::from_parts(0, 3805)) + .saturating_add(T::DbWeight::get().reads(6)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: ChainBridge Votes (r:1 w:1) + /// Proof Skipped: ChainBridge Votes (max_values: None, max_size: None, mode: Measured) + /// Storage: ChainBridge RelayerThreshold (r:1 w:0) + /// Proof Skipped: ChainBridge RelayerThreshold (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: ChainBridge RelayerCount (r:1 w:0) + /// Proof Skipped: ChainBridge RelayerCount (max_values: Some(1), max_size: None, mode: Measured) + fn eval_vote_state() -> Weight { + // Proof Size summary in bytes: + // Measured: `484` + // Estimated: `3949` + // Minimum execution time: 19_330_000 picoseconds. + Weight::from_parts(19_813_000, 0) + .saturating_add(Weight::from_parts(0, 3949)) + .saturating_add(T::DbWeight::get().reads(3)) + .saturating_add(T::DbWeight::get().writes(1)) + } +} diff --git a/runtime/paseo/src/weights/pallet_bridge_transfer.rs b/runtime/paseo/src/weights/pallet_bridge_transfer.rs new file mode 100644 index 0000000000..122e72cce0 --- /dev/null +++ b/runtime/paseo/src/weights/pallet_bridge_transfer.rs @@ -0,0 +1,69 @@ +// Copyright 2020-2024 Trust Computing GmbH. +// This file is part of Litentry. +// +// Litentry is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Litentry 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 +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Litentry. If not, see . + +//! Autogenerated weights for pallet_bridge_transfer +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev +//! DATE: 2022-09-29, STEPS: `20`, REPEAT: 50, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("litentry-dev"), DB CACHE: 20 + +// Executed Command: +// ./target/release/litentry-collator +// benchmark +// pallet +// --chain=litentry-dev +// --execution=wasm +// --db-cache=20 +// --wasm-execution=compiled +// --pallet=pallet_bridge_transfer +// --extrinsic=* +// --heap-pages=4096 +// --steps=20 +// --repeat=50 +// --header=./LICENSE_HEADER +// --template=./templates/benchmark/pallet-weight-template.hbs +// --output=./pallets/bridge-transfer/src/weights.rs + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] +#![allow(clippy::unnecessary_cast)] + +use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}}; +use sp_std::marker::PhantomData; + +/// Weights for pallet_bridge_transfer using the Litentry node and recommended hardware. +pub struct WeightInfo(PhantomData); +impl pallet_bridge_transfer::WeightInfo for WeightInfo { + // Storage: BridgeTransfer ExternalBalances (r:1 w:1) + // Storage: ChainBridge ChainNonces (r:1 w:1) + // Storage: ChainBridge BridgeFee (r:1 w:0) + // Storage: System Account (r:2 w:2) + // Storage: ChainBridge BridgeEvents (r:1 w:1) + fn transfer_assets() -> Weight { + Weight::from_parts(59_963_000 as u64, 0) + .saturating_add(T::DbWeight::get().reads(6 as u64)) + .saturating_add(T::DbWeight::get().writes(5 as u64)) + } + // Storage: BridgeTransfer MaximumIssuance (r:1 w:0) + // Storage: BridgeTransfer ExternalBalances (r:1 w:1) + // Storage: System Account (r:1 w:1) + fn transfer() -> Weight { + Weight::from_parts(29_134_000 as u64, 0) + .saturating_add(T::DbWeight::get().reads(3 as u64)) + .saturating_add(T::DbWeight::get().writes(2 as u64)) + } +} diff --git a/runtime/paseo/src/weights/pallet_collective.rs b/runtime/paseo/src/weights/pallet_collective.rs new file mode 100644 index 0000000000..34960feeaf --- /dev/null +++ b/runtime/paseo/src/weights/pallet_collective.rs @@ -0,0 +1,304 @@ +// Copyright 2020-2024 Trust Computing GmbH. +// This file is part of Litentry. +// +// Litentry is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Litentry 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 +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Litentry. If not, see . + +//! Autogenerated weights for `pallet_collective` +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev +//! DATE: 2023-10-17, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! WORST CASE MAP SIZE: `1000000` +//! HOSTNAME: `parachain-benchmark`, CPU: `Intel(R) Xeon(R) Platinum 8259CL CPU @ 2.50GHz` +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("rococo-dev"), DB CACHE: 20 + +// Executed Command: +// ./litentry-collator +// benchmark +// pallet +// --chain=rococo-dev +// --execution=wasm +// --db-cache=20 +// --wasm-execution=compiled +// --pallet=pallet_collective +// --extrinsic=* +// --heap-pages=4096 +// --steps=20 +// --repeat=50 +// --header=./LICENSE_HEADER +// --output=./runtime/rococo/src/weights/pallet_collective.rs + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] +#![allow(missing_docs)] + +use frame_support::{traits::Get, weights::Weight}; +use core::marker::PhantomData; + +/// Weight functions for `pallet_collective`. +pub struct WeightInfo(PhantomData); +impl pallet_collective::WeightInfo for WeightInfo { + /// Storage: Council Members (r:1 w:1) + /// Proof Skipped: Council Members (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: Council Proposals (r:1 w:0) + /// Proof Skipped: Council Proposals (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: Council Voting (r:100 w:100) + /// Proof Skipped: Council Voting (max_values: None, max_size: None, mode: Measured) + /// Storage: Council Prime (r:0 w:1) + /// Proof Skipped: Council Prime (max_values: Some(1), max_size: None, mode: Measured) + /// The range of component `m` is `[0, 100]`. + /// The range of component `n` is `[0, 100]`. + /// The range of component `p` is `[0, 100]`. + fn set_members(m: u32, _n: u32, p: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0 + m * (3232 ±0) + p * (3190 ±0)` + // Estimated: `32761 + m * (1968 ±26) + p * (4247 ±26)` + // Minimum execution time: 24_624_000 picoseconds. + Weight::from_parts(24_962_000, 0) + .saturating_add(Weight::from_parts(0, 32761)) + // Standard Error: 118_897 + .saturating_add(Weight::from_parts(8_899_231, 0).saturating_mul(m.into())) + // Standard Error: 118_897 + .saturating_add(Weight::from_parts(13_070_322, 0).saturating_mul(p.into())) + .saturating_add(T::DbWeight::get().reads(2)) + .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(p.into()))) + .saturating_add(T::DbWeight::get().writes(2)) + .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(p.into()))) + .saturating_add(Weight::from_parts(0, 1968).saturating_mul(m.into())) + .saturating_add(Weight::from_parts(0, 4247).saturating_mul(p.into())) + } + /// Storage: Council Members (r:1 w:0) + /// Proof Skipped: Council Members (max_values: Some(1), max_size: None, mode: Measured) + /// The range of component `b` is `[2, 1024]`. + /// The range of component `m` is `[1, 100]`. + fn execute(b: u32, m: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `103 + m * (32 ±0)` + // Estimated: `1588 + m * (32 ±0)` + // Minimum execution time: 23_445_000 picoseconds. + Weight::from_parts(24_013_914, 0) + .saturating_add(Weight::from_parts(0, 1588)) + // Standard Error: 154 + .saturating_add(Weight::from_parts(568, 0).saturating_mul(b.into())) + // Standard Error: 1_590 + .saturating_add(Weight::from_parts(15_456, 0).saturating_mul(m.into())) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(Weight::from_parts(0, 32).saturating_mul(m.into())) + } + /// Storage: Council Members (r:1 w:0) + /// Proof Skipped: Council Members (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: Council ProposalOf (r:1 w:0) + /// Proof Skipped: Council ProposalOf (max_values: None, max_size: None, mode: Measured) + /// The range of component `b` is `[2, 1024]`. + /// The range of component `m` is `[1, 100]`. + fn propose_execute(b: u32, m: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `103 + m * (32 ±0)` + // Estimated: `3568 + m * (32 ±0)` + // Minimum execution time: 26_776_000 picoseconds. + Weight::from_parts(25_496_975, 0) + .saturating_add(Weight::from_parts(0, 3568)) + // Standard Error: 56 + .saturating_add(Weight::from_parts(2_189, 0).saturating_mul(b.into())) + // Standard Error: 578 + .saturating_add(Weight::from_parts(32_732, 0).saturating_mul(m.into())) + .saturating_add(T::DbWeight::get().reads(2)) + .saturating_add(Weight::from_parts(0, 32).saturating_mul(m.into())) + } + /// Storage: Council Members (r:1 w:0) + /// Proof Skipped: Council Members (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: Council ProposalOf (r:1 w:1) + /// Proof Skipped: Council ProposalOf (max_values: None, max_size: None, mode: Measured) + /// Storage: Council Proposals (r:1 w:1) + /// Proof Skipped: Council Proposals (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: Council ProposalCount (r:1 w:1) + /// Proof Skipped: Council ProposalCount (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: Council Voting (r:0 w:1) + /// Proof Skipped: Council Voting (max_values: None, max_size: None, mode: Measured) + /// The range of component `b` is `[2, 1024]`. + /// The range of component `m` is `[2, 100]`. + /// The range of component `p` is `[1, 100]`. + fn propose_proposed(b: u32, m: u32, p: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `463 + m * (32 ±0) + p * (36 ±0)` + // Estimated: `3821 + m * (33 ±0) + p * (36 ±0)` + // Minimum execution time: 35_086_000 picoseconds. + Weight::from_parts(31_380_952, 0) + .saturating_add(Weight::from_parts(0, 3821)) + // Standard Error: 304 + .saturating_add(Weight::from_parts(5_004, 0).saturating_mul(b.into())) + // Standard Error: 3_161 + .saturating_add(Weight::from_parts(36_178, 0).saturating_mul(m.into())) + // Standard Error: 3_129 + .saturating_add(Weight::from_parts(346_703, 0).saturating_mul(p.into())) + .saturating_add(T::DbWeight::get().reads(4)) + .saturating_add(T::DbWeight::get().writes(4)) + .saturating_add(Weight::from_parts(0, 33).saturating_mul(m.into())) + .saturating_add(Weight::from_parts(0, 36).saturating_mul(p.into())) + } + /// Storage: Council Members (r:1 w:0) + /// Proof Skipped: Council Members (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: Council Voting (r:1 w:1) + /// Proof Skipped: Council Voting (max_values: None, max_size: None, mode: Measured) + /// The range of component `m` is `[5, 100]`. + fn vote(m: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `841 + m * (64 ±0)` + // Estimated: `4306 + m * (64 ±0)` + // Minimum execution time: 41_221_000 picoseconds. + Weight::from_parts(45_774_322, 0) + .saturating_add(Weight::from_parts(0, 4306)) + // Standard Error: 3_309 + .saturating_add(Weight::from_parts(45_733, 0).saturating_mul(m.into())) + .saturating_add(T::DbWeight::get().reads(2)) + .saturating_add(T::DbWeight::get().writes(1)) + .saturating_add(Weight::from_parts(0, 64).saturating_mul(m.into())) + } + /// Storage: Council Voting (r:1 w:1) + /// Proof Skipped: Council Voting (max_values: None, max_size: None, mode: Measured) + /// Storage: Council Members (r:1 w:0) + /// Proof Skipped: Council Members (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: Council Proposals (r:1 w:1) + /// Proof Skipped: Council Proposals (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: Council ProposalOf (r:0 w:1) + /// Proof Skipped: Council ProposalOf (max_values: None, max_size: None, mode: Measured) + /// The range of component `m` is `[4, 100]`. + /// The range of component `p` is `[1, 100]`. + fn close_early_disapproved(m: u32, p: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `468 + m * (64 ±0) + p * (35 ±0)` + // Estimated: `3856 + m * (65 ±0) + p * (36 ±0)` + // Minimum execution time: 39_720_000 picoseconds. + Weight::from_parts(35_099_918, 0) + .saturating_add(Weight::from_parts(0, 3856)) + // Standard Error: 4_106 + .saturating_add(Weight::from_parts(84_303, 0).saturating_mul(m.into())) + // Standard Error: 3_972 + .saturating_add(Weight::from_parts(327_797, 0).saturating_mul(p.into())) + .saturating_add(T::DbWeight::get().reads(3)) + .saturating_add(T::DbWeight::get().writes(3)) + .saturating_add(Weight::from_parts(0, 65).saturating_mul(m.into())) + .saturating_add(Weight::from_parts(0, 36).saturating_mul(p.into())) + } + /// Storage: Council Voting (r:1 w:1) + /// Proof Skipped: Council Voting (max_values: None, max_size: None, mode: Measured) + /// Storage: Council Members (r:1 w:0) + /// Proof Skipped: Council Members (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: Council ProposalOf (r:1 w:1) + /// Proof Skipped: Council ProposalOf (max_values: None, max_size: None, mode: Measured) + /// Storage: Council Proposals (r:1 w:1) + /// Proof Skipped: Council Proposals (max_values: Some(1), max_size: None, mode: Measured) + /// The range of component `b` is `[2, 1024]`. + /// The range of component `m` is `[4, 100]`. + /// The range of component `p` is `[1, 100]`. + fn close_early_approved(b: u32, m: u32, p: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `778 + m * (64 ±0) + p * (39 ±0)` + // Estimated: `4117 + b * (1 ±0) + m * (65 ±0) + p * (40 ±0)` + // Minimum execution time: 55_941_000 picoseconds. + Weight::from_parts(50_208_394, 0) + .saturating_add(Weight::from_parts(0, 4117)) + // Standard Error: 499 + .saturating_add(Weight::from_parts(6_301, 0).saturating_mul(b.into())) + // Standard Error: 5_306 + .saturating_add(Weight::from_parts(38_886, 0).saturating_mul(m.into())) + // Standard Error: 5_134 + .saturating_add(Weight::from_parts(455_614, 0).saturating_mul(p.into())) + .saturating_add(T::DbWeight::get().reads(4)) + .saturating_add(T::DbWeight::get().writes(3)) + .saturating_add(Weight::from_parts(0, 1).saturating_mul(b.into())) + .saturating_add(Weight::from_parts(0, 65).saturating_mul(m.into())) + .saturating_add(Weight::from_parts(0, 40).saturating_mul(p.into())) + } + /// Storage: Council Voting (r:1 w:1) + /// Proof Skipped: Council Voting (max_values: None, max_size: None, mode: Measured) + /// Storage: Council Members (r:1 w:0) + /// Proof Skipped: Council Members (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: Council Prime (r:1 w:0) + /// Proof Skipped: Council Prime (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: Council Proposals (r:1 w:1) + /// Proof Skipped: Council Proposals (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: Council ProposalOf (r:0 w:1) + /// Proof Skipped: Council ProposalOf (max_values: None, max_size: None, mode: Measured) + /// The range of component `m` is `[4, 100]`. + /// The range of component `p` is `[1, 100]`. + fn close_disapproved(m: u32, p: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `488 + m * (64 ±0) + p * (35 ±0)` + // Estimated: `3876 + m * (65 ±0) + p * (36 ±0)` + // Minimum execution time: 44_262_000 picoseconds. + Weight::from_parts(37_338_317, 0) + .saturating_add(Weight::from_parts(0, 3876)) + // Standard Error: 3_148 + .saturating_add(Weight::from_parts(106_410, 0).saturating_mul(m.into())) + // Standard Error: 3_045 + .saturating_add(Weight::from_parts(323_416, 0).saturating_mul(p.into())) + .saturating_add(T::DbWeight::get().reads(4)) + .saturating_add(T::DbWeight::get().writes(3)) + .saturating_add(Weight::from_parts(0, 65).saturating_mul(m.into())) + .saturating_add(Weight::from_parts(0, 36).saturating_mul(p.into())) + } + /// Storage: Council Voting (r:1 w:1) + /// Proof Skipped: Council Voting (max_values: None, max_size: None, mode: Measured) + /// Storage: Council Members (r:1 w:0) + /// Proof Skipped: Council Members (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: Council Prime (r:1 w:0) + /// Proof Skipped: Council Prime (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: Council ProposalOf (r:1 w:1) + /// Proof Skipped: Council ProposalOf (max_values: None, max_size: None, mode: Measured) + /// Storage: Council Proposals (r:1 w:1) + /// Proof Skipped: Council Proposals (max_values: Some(1), max_size: None, mode: Measured) + /// The range of component `b` is `[2, 1024]`. + /// The range of component `m` is `[4, 100]`. + /// The range of component `p` is `[1, 100]`. + fn close_approved(b: u32, m: u32, p: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `798 + m * (64 ±0) + p * (39 ±0)` + // Estimated: `4137 + b * (1 ±0) + m * (65 ±0) + p * (40 ±0)` + // Minimum execution time: 60_302_000 picoseconds. + Weight::from_parts(50_033_615, 0) + .saturating_add(Weight::from_parts(0, 4137)) + // Standard Error: 515 + .saturating_add(Weight::from_parts(10_303, 0).saturating_mul(b.into())) + // Standard Error: 5_471 + .saturating_add(Weight::from_parts(108_478, 0).saturating_mul(m.into())) + // Standard Error: 5_294 + .saturating_add(Weight::from_parts(428_182, 0).saturating_mul(p.into())) + .saturating_add(T::DbWeight::get().reads(5)) + .saturating_add(T::DbWeight::get().writes(3)) + .saturating_add(Weight::from_parts(0, 1).saturating_mul(b.into())) + .saturating_add(Weight::from_parts(0, 65).saturating_mul(m.into())) + .saturating_add(Weight::from_parts(0, 40).saturating_mul(p.into())) + } + /// Storage: Council Proposals (r:1 w:1) + /// Proof Skipped: Council Proposals (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: Council Voting (r:0 w:1) + /// Proof Skipped: Council Voting (max_values: None, max_size: None, mode: Measured) + /// Storage: Council ProposalOf (r:0 w:1) + /// Proof Skipped: Council ProposalOf (max_values: None, max_size: None, mode: Measured) + /// The range of component `p` is `[1, 100]`. + fn disapprove_proposal(p: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `259 + p * (32 ±0)` + // Estimated: `1745 + p * (32 ±0)` + // Minimum execution time: 22_405_000 picoseconds. + Weight::from_parts(24_485_414, 0) + .saturating_add(Weight::from_parts(0, 1745)) + // Standard Error: 2_398 + .saturating_add(Weight::from_parts(272_317, 0).saturating_mul(p.into())) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(3)) + .saturating_add(Weight::from_parts(0, 32).saturating_mul(p.into())) + } +} diff --git a/runtime/paseo/src/weights/pallet_democracy.rs b/runtime/paseo/src/weights/pallet_democracy.rs new file mode 100644 index 0000000000..7e5417f379 --- /dev/null +++ b/runtime/paseo/src/weights/pallet_democracy.rs @@ -0,0 +1,527 @@ +// Copyright 2020-2024 Trust Computing GmbH. +// This file is part of Litentry. +// +// Litentry is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Litentry 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 +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Litentry. If not, see . + +//! Autogenerated weights for `pallet_democracy` +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev +//! DATE: 2023-10-17, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! WORST CASE MAP SIZE: `1000000` +//! HOSTNAME: `parachain-benchmark`, CPU: `Intel(R) Xeon(R) Platinum 8259CL CPU @ 2.50GHz` +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("rococo-dev"), DB CACHE: 20 + +// Executed Command: +// ./litentry-collator +// benchmark +// pallet +// --chain=rococo-dev +// --execution=wasm +// --db-cache=20 +// --wasm-execution=compiled +// --pallet=pallet_democracy +// --extrinsic=* +// --heap-pages=4096 +// --steps=20 +// --repeat=50 +// --header=./LICENSE_HEADER +// --output=./runtime/rococo/src/weights/pallet_democracy.rs + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] +#![allow(missing_docs)] + +use frame_support::{traits::Get, weights::Weight}; +use core::marker::PhantomData; + +/// Weight functions for `pallet_democracy`. +pub struct WeightInfo(PhantomData); +impl pallet_democracy::WeightInfo for WeightInfo { + /// Storage: Democracy PublicPropCount (r:1 w:1) + /// Proof: Democracy PublicPropCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen) + /// Storage: Democracy PublicProps (r:1 w:1) + /// Proof: Democracy PublicProps (max_values: Some(1), max_size: Some(16702), added: 17197, mode: MaxEncodedLen) + /// Storage: Democracy Blacklist (r:1 w:0) + /// Proof: Democracy Blacklist (max_values: None, max_size: Some(3238), added: 5713, mode: MaxEncodedLen) + /// Storage: Democracy DepositOf (r:0 w:1) + /// Proof: Democracy DepositOf (max_values: None, max_size: Some(3230), added: 5705, mode: MaxEncodedLen) + fn propose() -> Weight { + // Proof Size summary in bytes: + // Measured: `4734` + // Estimated: `18187` + // Minimum execution time: 68_501_000 picoseconds. + Weight::from_parts(73_004_000, 0) + .saturating_add(Weight::from_parts(0, 18187)) + .saturating_add(T::DbWeight::get().reads(3)) + .saturating_add(T::DbWeight::get().writes(3)) + } + /// Storage: Democracy DepositOf (r:1 w:1) + /// Proof: Democracy DepositOf (max_values: None, max_size: Some(3230), added: 5705, mode: MaxEncodedLen) + fn second() -> Weight { + // Proof Size summary in bytes: + // Measured: `3489` + // Estimated: `6695` + // Minimum execution time: 60_988_000 picoseconds. + Weight::from_parts(67_951_000, 0) + .saturating_add(Weight::from_parts(0, 6695)) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: Democracy ReferendumInfoOf (r:1 w:1) + /// Proof: Democracy ReferendumInfoOf (max_values: None, max_size: Some(201), added: 2676, mode: MaxEncodedLen) + /// Storage: Democracy VotingOf (r:1 w:1) + /// Proof: Democracy VotingOf (max_values: None, max_size: Some(3795), added: 6270, mode: MaxEncodedLen) + /// Storage: Balances Locks (r:1 w:1) + /// Proof: Balances Locks (max_values: None, max_size: Some(1299), added: 3774, mode: MaxEncodedLen) + /// Storage: Balances Freezes (r:1 w:0) + /// Proof: Balances Freezes (max_values: None, max_size: Some(49), added: 2524, mode: MaxEncodedLen) + fn vote_new() -> Weight { + // Proof Size summary in bytes: + // Measured: `3365` + // Estimated: `7260` + // Minimum execution time: 81_593_000 picoseconds. + Weight::from_parts(98_345_000, 0) + .saturating_add(Weight::from_parts(0, 7260)) + .saturating_add(T::DbWeight::get().reads(4)) + .saturating_add(T::DbWeight::get().writes(3)) + } + /// Storage: Democracy ReferendumInfoOf (r:1 w:1) + /// Proof: Democracy ReferendumInfoOf (max_values: None, max_size: Some(201), added: 2676, mode: MaxEncodedLen) + /// Storage: Democracy VotingOf (r:1 w:1) + /// Proof: Democracy VotingOf (max_values: None, max_size: Some(3795), added: 6270, mode: MaxEncodedLen) + /// Storage: Balances Locks (r:1 w:1) + /// Proof: Balances Locks (max_values: None, max_size: Some(1299), added: 3774, mode: MaxEncodedLen) + /// Storage: Balances Freezes (r:1 w:0) + /// Proof: Balances Freezes (max_values: None, max_size: Some(49), added: 2524, mode: MaxEncodedLen) + fn vote_existing() -> Weight { + // Proof Size summary in bytes: + // Measured: `3387` + // Estimated: `7260` + // Minimum execution time: 90_734_000 picoseconds. + Weight::from_parts(100_906_000, 0) + .saturating_add(Weight::from_parts(0, 7260)) + .saturating_add(T::DbWeight::get().reads(4)) + .saturating_add(T::DbWeight::get().writes(3)) + } + /// Storage: Democracy ReferendumInfoOf (r:1 w:1) + /// Proof: Democracy ReferendumInfoOf (max_values: None, max_size: Some(201), added: 2676, mode: MaxEncodedLen) + /// Storage: Democracy Cancellations (r:1 w:1) + /// Proof: Democracy Cancellations (max_values: None, max_size: Some(33), added: 2508, mode: MaxEncodedLen) + /// Storage: Democracy MetadataOf (r:1 w:1) + /// Proof: Democracy MetadataOf (max_values: None, max_size: Some(53), added: 2528, mode: MaxEncodedLen) + fn emergency_cancel() -> Weight { + // Proof Size summary in bytes: + // Measured: `299` + // Estimated: `3666` + // Minimum execution time: 38_133_000 picoseconds. + Weight::from_parts(39_819_000, 0) + .saturating_add(Weight::from_parts(0, 3666)) + .saturating_add(T::DbWeight::get().reads(3)) + .saturating_add(T::DbWeight::get().writes(3)) + } + /// Storage: Democracy PublicProps (r:1 w:1) + /// Proof: Democracy PublicProps (max_values: Some(1), max_size: Some(16702), added: 17197, mode: MaxEncodedLen) + /// Storage: Democracy DepositOf (r:1 w:1) + /// Proof: Democracy DepositOf (max_values: None, max_size: Some(3230), added: 5705, mode: MaxEncodedLen) + /// Storage: System Account (r:2 w:2) + /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + /// Storage: Democracy MetadataOf (r:3 w:1) + /// Proof: Democracy MetadataOf (max_values: None, max_size: Some(53), added: 2528, mode: MaxEncodedLen) + /// Storage: Democracy NextExternal (r:1 w:1) + /// Proof: Democracy NextExternal (max_values: Some(1), max_size: Some(132), added: 627, mode: MaxEncodedLen) + /// Storage: Democracy ReferendumInfoOf (r:1 w:1) + /// Proof: Democracy ReferendumInfoOf (max_values: None, max_size: Some(201), added: 2676, mode: MaxEncodedLen) + /// Storage: Democracy Blacklist (r:0 w:1) + /// Proof: Democracy Blacklist (max_values: None, max_size: Some(3238), added: 5713, mode: MaxEncodedLen) + fn blacklist() -> Weight { + // Proof Size summary in bytes: + // Measured: `6182` + // Estimated: `18187` + // Minimum execution time: 154_774_000 picoseconds. + Weight::from_parts(162_834_000, 0) + .saturating_add(Weight::from_parts(0, 18187)) + .saturating_add(T::DbWeight::get().reads(9)) + .saturating_add(T::DbWeight::get().writes(8)) + } + /// Storage: Democracy NextExternal (r:1 w:1) + /// Proof: Democracy NextExternal (max_values: Some(1), max_size: Some(132), added: 627, mode: MaxEncodedLen) + /// Storage: Democracy Blacklist (r:1 w:0) + /// Proof: Democracy Blacklist (max_values: None, max_size: Some(3238), added: 5713, mode: MaxEncodedLen) + fn external_propose() -> Weight { + // Proof Size summary in bytes: + // Measured: `3349` + // Estimated: `6703` + // Minimum execution time: 18_234_000 picoseconds. + Weight::from_parts(18_660_000, 0) + .saturating_add(Weight::from_parts(0, 6703)) + .saturating_add(T::DbWeight::get().reads(2)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: Democracy NextExternal (r:0 w:1) + /// Proof: Democracy NextExternal (max_values: Some(1), max_size: Some(132), added: 627, mode: MaxEncodedLen) + fn external_propose_majority() -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 4_748_000 picoseconds. + Weight::from_parts(4_950_000, 0) + .saturating_add(Weight::from_parts(0, 0)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: Democracy NextExternal (r:0 w:1) + /// Proof: Democracy NextExternal (max_values: Some(1), max_size: Some(132), added: 627, mode: MaxEncodedLen) + fn external_propose_default() -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 4_868_000 picoseconds. + Weight::from_parts(5_087_000, 0) + .saturating_add(Weight::from_parts(0, 0)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: Democracy NextExternal (r:1 w:1) + /// Proof: Democracy NextExternal (max_values: Some(1), max_size: Some(132), added: 627, mode: MaxEncodedLen) + /// Storage: Democracy ReferendumCount (r:1 w:1) + /// Proof: Democracy ReferendumCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen) + /// Storage: Democracy MetadataOf (r:1 w:2) + /// Proof: Democracy MetadataOf (max_values: None, max_size: Some(53), added: 2528, mode: MaxEncodedLen) + /// Storage: Democracy ReferendumInfoOf (r:0 w:1) + /// Proof: Democracy ReferendumInfoOf (max_values: None, max_size: Some(201), added: 2676, mode: MaxEncodedLen) + fn fast_track() -> Weight { + // Proof Size summary in bytes: + // Measured: `219` + // Estimated: `3518` + // Minimum execution time: 38_631_000 picoseconds. + Weight::from_parts(39_319_000, 0) + .saturating_add(Weight::from_parts(0, 3518)) + .saturating_add(T::DbWeight::get().reads(3)) + .saturating_add(T::DbWeight::get().writes(5)) + } + /// Storage: Democracy NextExternal (r:1 w:1) + /// Proof: Democracy NextExternal (max_values: Some(1), max_size: Some(132), added: 627, mode: MaxEncodedLen) + /// Storage: Democracy Blacklist (r:1 w:1) + /// Proof: Democracy Blacklist (max_values: None, max_size: Some(3238), added: 5713, mode: MaxEncodedLen) + /// Storage: Democracy MetadataOf (r:1 w:1) + /// Proof: Democracy MetadataOf (max_values: None, max_size: Some(53), added: 2528, mode: MaxEncodedLen) + fn veto_external() -> Weight { + // Proof Size summary in bytes: + // Measured: `3452` + // Estimated: `6703` + // Minimum execution time: 42_139_000 picoseconds. + Weight::from_parts(43_134_000, 0) + .saturating_add(Weight::from_parts(0, 6703)) + .saturating_add(T::DbWeight::get().reads(3)) + .saturating_add(T::DbWeight::get().writes(3)) + } + /// Storage: Democracy PublicProps (r:1 w:1) + /// Proof: Democracy PublicProps (max_values: Some(1), max_size: Some(16702), added: 17197, mode: MaxEncodedLen) + /// Storage: Democracy DepositOf (r:1 w:1) + /// Proof: Democracy DepositOf (max_values: None, max_size: Some(3230), added: 5705, mode: MaxEncodedLen) + /// Storage: System Account (r:2 w:2) + /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + /// Storage: Democracy MetadataOf (r:1 w:1) + /// Proof: Democracy MetadataOf (max_values: None, max_size: Some(53), added: 2528, mode: MaxEncodedLen) + fn cancel_proposal() -> Weight { + // Proof Size summary in bytes: + // Measured: `6093` + // Estimated: `18187` + // Minimum execution time: 130_460_000 picoseconds. + Weight::from_parts(140_884_000, 0) + .saturating_add(Weight::from_parts(0, 18187)) + .saturating_add(T::DbWeight::get().reads(5)) + .saturating_add(T::DbWeight::get().writes(5)) + } + /// Storage: Democracy MetadataOf (r:1 w:1) + /// Proof: Democracy MetadataOf (max_values: None, max_size: Some(53), added: 2528, mode: MaxEncodedLen) + /// Storage: Democracy ReferendumInfoOf (r:0 w:1) + /// Proof: Democracy ReferendumInfoOf (max_values: None, max_size: Some(201), added: 2676, mode: MaxEncodedLen) + fn cancel_referendum() -> Weight { + // Proof Size summary in bytes: + // Measured: `204` + // Estimated: `3518` + // Minimum execution time: 28_544_000 picoseconds. + Weight::from_parts(29_389_000, 0) + .saturating_add(Weight::from_parts(0, 3518)) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(2)) + } + /// Storage: Democracy LowestUnbaked (r:1 w:1) + /// Proof: Democracy LowestUnbaked (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen) + /// Storage: Democracy ReferendumCount (r:1 w:0) + /// Proof: Democracy ReferendumCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen) + /// Storage: Democracy ReferendumInfoOf (r:99 w:0) + /// Proof: Democracy ReferendumInfoOf (max_values: None, max_size: Some(201), added: 2676, mode: MaxEncodedLen) + /// The range of component `r` is `[0, 99]`. + fn on_initialize_base(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `176 + r * (86 ±0)` + // Estimated: `1489 + r * (2676 ±0)` + // Minimum execution time: 9_538_000 picoseconds. + Weight::from_parts(6_188_260, 0) + .saturating_add(Weight::from_parts(0, 1489)) + // Standard Error: 28_622 + .saturating_add(Weight::from_parts(4_480_990, 0).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().reads(2)) + .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into()))) + .saturating_add(T::DbWeight::get().writes(1)) + .saturating_add(Weight::from_parts(0, 2676).saturating_mul(r.into())) + } + /// Storage: Democracy LowestUnbaked (r:1 w:1) + /// Proof: Democracy LowestUnbaked (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen) + /// Storage: Democracy ReferendumCount (r:1 w:0) + /// Proof: Democracy ReferendumCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen) + /// Storage: Democracy LastTabledWasExternal (r:1 w:0) + /// Proof: Democracy LastTabledWasExternal (max_values: Some(1), max_size: Some(1), added: 496, mode: MaxEncodedLen) + /// Storage: Democracy NextExternal (r:1 w:0) + /// Proof: Democracy NextExternal (max_values: Some(1), max_size: Some(132), added: 627, mode: MaxEncodedLen) + /// Storage: Democracy PublicProps (r:1 w:0) + /// Proof: Democracy PublicProps (max_values: Some(1), max_size: Some(16702), added: 17197, mode: MaxEncodedLen) + /// Storage: Democracy ReferendumInfoOf (r:99 w:0) + /// Proof: Democracy ReferendumInfoOf (max_values: None, max_size: Some(201), added: 2676, mode: MaxEncodedLen) + /// The range of component `r` is `[0, 99]`. + fn on_initialize_base_with_launch_period(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `176 + r * (86 ±0)` + // Estimated: `18187 + r * (2676 ±0)` + // Minimum execution time: 13_664_000 picoseconds. + Weight::from_parts(13_054_634, 0) + .saturating_add(Weight::from_parts(0, 18187)) + // Standard Error: 37_836 + .saturating_add(Weight::from_parts(4_480_067, 0).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().reads(5)) + .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into()))) + .saturating_add(T::DbWeight::get().writes(1)) + .saturating_add(Weight::from_parts(0, 2676).saturating_mul(r.into())) + } + /// Storage: Democracy VotingOf (r:3 w:3) + /// Proof: Democracy VotingOf (max_values: None, max_size: Some(3795), added: 6270, mode: MaxEncodedLen) + /// Storage: Democracy ReferendumInfoOf (r:99 w:99) + /// Proof: Democracy ReferendumInfoOf (max_values: None, max_size: Some(201), added: 2676, mode: MaxEncodedLen) + /// Storage: Balances Locks (r:1 w:1) + /// Proof: Balances Locks (max_values: None, max_size: Some(1299), added: 3774, mode: MaxEncodedLen) + /// Storage: Balances Freezes (r:1 w:0) + /// Proof: Balances Freezes (max_values: None, max_size: Some(49), added: 2524, mode: MaxEncodedLen) + /// The range of component `r` is `[0, 99]`. + fn delegate(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `726 + r * (108 ±0)` + // Estimated: `19800 + r * (2676 ±0)` + // Minimum execution time: 55_326_000 picoseconds. + Weight::from_parts(44_210_870, 0) + .saturating_add(Weight::from_parts(0, 19800)) + // Standard Error: 40_411 + .saturating_add(Weight::from_parts(6_248_306, 0).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().reads(5)) + .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into()))) + .saturating_add(T::DbWeight::get().writes(4)) + .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(r.into()))) + .saturating_add(Weight::from_parts(0, 2676).saturating_mul(r.into())) + } + /// Storage: Democracy VotingOf (r:2 w:2) + /// Proof: Democracy VotingOf (max_values: None, max_size: Some(3795), added: 6270, mode: MaxEncodedLen) + /// Storage: Democracy ReferendumInfoOf (r:99 w:99) + /// Proof: Democracy ReferendumInfoOf (max_values: None, max_size: Some(201), added: 2676, mode: MaxEncodedLen) + /// The range of component `r` is `[0, 99]`. + fn undelegate(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `424 + r * (108 ±0)` + // Estimated: `13530 + r * (2676 ±0)` + // Minimum execution time: 29_037_000 picoseconds. + Weight::from_parts(21_737_510, 0) + .saturating_add(Weight::from_parts(0, 13530)) + // Standard Error: 36_345 + .saturating_add(Weight::from_parts(6_033_418, 0).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().reads(2)) + .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into()))) + .saturating_add(T::DbWeight::get().writes(2)) + .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(r.into()))) + .saturating_add(Weight::from_parts(0, 2676).saturating_mul(r.into())) + } + /// Storage: Democracy PublicProps (r:0 w:1) + /// Proof: Democracy PublicProps (max_values: Some(1), max_size: Some(16702), added: 17197, mode: MaxEncodedLen) + fn clear_public_proposals() -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 5_117_000 picoseconds. + Weight::from_parts(5_265_000, 0) + .saturating_add(Weight::from_parts(0, 0)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: Democracy VotingOf (r:1 w:1) + /// Proof: Democracy VotingOf (max_values: None, max_size: Some(3795), added: 6270, mode: MaxEncodedLen) + /// Storage: Balances Locks (r:1 w:1) + /// Proof: Balances Locks (max_values: None, max_size: Some(1299), added: 3774, mode: MaxEncodedLen) + /// Storage: Balances Freezes (r:1 w:0) + /// Proof: Balances Freezes (max_values: None, max_size: Some(49), added: 2524, mode: MaxEncodedLen) + /// Storage: System Account (r:1 w:1) + /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + /// The range of component `r` is `[0, 99]`. + fn unlock_remove(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `421` + // Estimated: `7260` + // Minimum execution time: 30_989_000 picoseconds. + Weight::from_parts(52_927_107, 0) + .saturating_add(Weight::from_parts(0, 7260)) + // Standard Error: 12_137 + .saturating_add(Weight::from_parts(338_550, 0).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().reads(4)) + .saturating_add(T::DbWeight::get().writes(3)) + } + /// Storage: Democracy VotingOf (r:1 w:1) + /// Proof: Democracy VotingOf (max_values: None, max_size: Some(3795), added: 6270, mode: MaxEncodedLen) + /// Storage: Balances Locks (r:1 w:1) + /// Proof: Balances Locks (max_values: None, max_size: Some(1299), added: 3774, mode: MaxEncodedLen) + /// Storage: Balances Freezes (r:1 w:0) + /// Proof: Balances Freezes (max_values: None, max_size: Some(49), added: 2524, mode: MaxEncodedLen) + /// Storage: System Account (r:1 w:1) + /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + /// The range of component `r` is `[0, 99]`. + fn unlock_set(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `421 + r * (22 ±0)` + // Estimated: `7260` + // Minimum execution time: 47_714_000 picoseconds. + Weight::from_parts(51_340_260, 0) + .saturating_add(Weight::from_parts(0, 7260)) + // Standard Error: 4_665 + .saturating_add(Weight::from_parts(301_397, 0).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().reads(4)) + .saturating_add(T::DbWeight::get().writes(3)) + } + /// Storage: Democracy ReferendumInfoOf (r:1 w:1) + /// Proof: Democracy ReferendumInfoOf (max_values: None, max_size: Some(201), added: 2676, mode: MaxEncodedLen) + /// Storage: Democracy VotingOf (r:1 w:1) + /// Proof: Democracy VotingOf (max_values: None, max_size: Some(3795), added: 6270, mode: MaxEncodedLen) + /// The range of component `r` is `[1, 100]`. + fn remove_vote(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `638 + r * (27 ±0)` + // Estimated: `7260` + // Minimum execution time: 21_546_000 picoseconds. + Weight::from_parts(23_830_447, 0) + .saturating_add(Weight::from_parts(0, 7260)) + // Standard Error: 3_456 + .saturating_add(Weight::from_parts(293_834, 0).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().reads(2)) + .saturating_add(T::DbWeight::get().writes(2)) + } + /// Storage: Democracy ReferendumInfoOf (r:1 w:1) + /// Proof: Democracy ReferendumInfoOf (max_values: None, max_size: Some(201), added: 2676, mode: MaxEncodedLen) + /// Storage: Democracy VotingOf (r:1 w:1) + /// Proof: Democracy VotingOf (max_values: None, max_size: Some(3795), added: 6270, mode: MaxEncodedLen) + /// The range of component `r` is `[1, 100]`. + fn remove_other_vote(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `638 + r * (27 ±0)` + // Estimated: `7260` + // Minimum execution time: 21_713_000 picoseconds. + Weight::from_parts(25_538_950, 0) + .saturating_add(Weight::from_parts(0, 7260)) + // Standard Error: 5_129 + .saturating_add(Weight::from_parts(287_753, 0).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().reads(2)) + .saturating_add(T::DbWeight::get().writes(2)) + } + /// Storage: Democracy NextExternal (r:1 w:0) + /// Proof: Democracy NextExternal (max_values: Some(1), max_size: Some(132), added: 627, mode: MaxEncodedLen) + /// Storage: Preimage StatusFor (r:1 w:0) + /// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen) + /// Storage: Democracy MetadataOf (r:0 w:1) + /// Proof: Democracy MetadataOf (max_values: None, max_size: Some(53), added: 2528, mode: MaxEncodedLen) + fn set_external_metadata() -> Weight { + // Proof Size summary in bytes: + // Measured: `323` + // Estimated: `3556` + // Minimum execution time: 26_082_000 picoseconds. + Weight::from_parts(26_667_000, 0) + .saturating_add(Weight::from_parts(0, 3556)) + .saturating_add(T::DbWeight::get().reads(2)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: Democracy NextExternal (r:1 w:0) + /// Proof: Democracy NextExternal (max_values: Some(1), max_size: Some(132), added: 627, mode: MaxEncodedLen) + /// Storage: Democracy MetadataOf (r:1 w:1) + /// Proof: Democracy MetadataOf (max_values: None, max_size: Some(53), added: 2528, mode: MaxEncodedLen) + fn clear_external_metadata() -> Weight { + // Proof Size summary in bytes: + // Measured: `219` + // Estimated: `3518` + // Minimum execution time: 24_174_000 picoseconds. + Weight::from_parts(24_697_000, 0) + .saturating_add(Weight::from_parts(0, 3518)) + .saturating_add(T::DbWeight::get().reads(2)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: Democracy PublicProps (r:1 w:0) + /// Proof: Democracy PublicProps (max_values: Some(1), max_size: Some(16702), added: 17197, mode: MaxEncodedLen) + /// Storage: Preimage StatusFor (r:1 w:0) + /// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen) + /// Storage: Democracy MetadataOf (r:0 w:1) + /// Proof: Democracy MetadataOf (max_values: None, max_size: Some(53), added: 2528, mode: MaxEncodedLen) + fn set_proposal_metadata() -> Weight { + // Proof Size summary in bytes: + // Measured: `4855` + // Estimated: `18187` + // Minimum execution time: 60_980_000 picoseconds. + Weight::from_parts(66_004_000, 0) + .saturating_add(Weight::from_parts(0, 18187)) + .saturating_add(T::DbWeight::get().reads(2)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: Democracy PublicProps (r:1 w:0) + /// Proof: Democracy PublicProps (max_values: Some(1), max_size: Some(16702), added: 17197, mode: MaxEncodedLen) + /// Storage: Democracy MetadataOf (r:1 w:1) + /// Proof: Democracy MetadataOf (max_values: None, max_size: Some(53), added: 2528, mode: MaxEncodedLen) + fn clear_proposal_metadata() -> Weight { + // Proof Size summary in bytes: + // Measured: `4755` + // Estimated: `18187` + // Minimum execution time: 55_795_000 picoseconds. + Weight::from_parts(60_205_000, 0) + .saturating_add(Weight::from_parts(0, 18187)) + .saturating_add(T::DbWeight::get().reads(2)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: Preimage StatusFor (r:1 w:0) + /// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen) + /// Storage: Democracy MetadataOf (r:0 w:1) + /// Proof: Democracy MetadataOf (max_values: None, max_size: Some(53), added: 2528, mode: MaxEncodedLen) + fn set_referendum_metadata() -> Weight { + // Proof Size summary in bytes: + // Measured: `178` + // Estimated: `3556` + // Minimum execution time: 21_666_000 picoseconds. + Weight::from_parts(23_214_000, 0) + .saturating_add(Weight::from_parts(0, 3556)) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: Democracy ReferendumInfoOf (r:1 w:0) + /// Proof: Democracy ReferendumInfoOf (max_values: None, max_size: Some(201), added: 2676, mode: MaxEncodedLen) + /// Storage: Democracy MetadataOf (r:1 w:1) + /// Proof: Democracy MetadataOf (max_values: None, max_size: Some(53), added: 2528, mode: MaxEncodedLen) + fn clear_referendum_metadata() -> Weight { + // Proof Size summary in bytes: + // Measured: `235` + // Estimated: `3666` + // Minimum execution time: 26_874_000 picoseconds. + Weight::from_parts(27_807_000, 0) + .saturating_add(Weight::from_parts(0, 3666)) + .saturating_add(T::DbWeight::get().reads(2)) + .saturating_add(T::DbWeight::get().writes(1)) + } +} diff --git a/runtime/paseo/src/weights/pallet_evm.rs b/runtime/paseo/src/weights/pallet_evm.rs new file mode 100644 index 0000000000..1ea11571cd --- /dev/null +++ b/runtime/paseo/src/weights/pallet_evm.rs @@ -0,0 +1,58 @@ +// This file is part of Frontier. + +// Copyright (C) Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: Apache-2.0 + +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +//! Autogenerated weights for pallet_evm +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev +//! DATE: 2023-05-06, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! WORST CASE MAP SIZE: `1000000` +//! HOSTNAME: `archlinux`, CPU: `AMD Ryzen 9 5900X 12-Core Processor` +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024 + +// Executed Command: +// ./target/release/frontier-template-node +// benchmark +// pallet +// --chain=dev +// --steps=50 +// --repeat=20 +// --pallet=pallet_evm +// --extrinsic=withdraw +// --execution=wasm +// --wasm-execution=compiled +// --output=weights.rs +// --header=HEADER-APACHE2 +// --template=./.maintain/frame-weight-template.hbs + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] + +use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}}; +use sp_std::marker::PhantomData; + +/// Weights for pallet_evm using the Substrate node and recommended hardware. +pub struct WeightInfo(PhantomData); +impl pallet_evm::WeightInfo for WeightInfo { + fn withdraw() -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 2_000_000 picoseconds. + Weight::from_parts(2_000_000, 0) + } +} diff --git a/runtime/paseo/src/weights/pallet_extrinsic_filter.rs b/runtime/paseo/src/weights/pallet_extrinsic_filter.rs new file mode 100644 index 0000000000..d0020f8a51 --- /dev/null +++ b/runtime/paseo/src/weights/pallet_extrinsic_filter.rs @@ -0,0 +1,90 @@ +// Copyright 2020-2024 Trust Computing GmbH. +// This file is part of Litentry. +// +// Litentry is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Litentry 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 +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Litentry. If not, see . + +//! Autogenerated weights for `pallet_extrinsic_filter` +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev +//! DATE: 2023-10-17, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! WORST CASE MAP SIZE: `1000000` +//! HOSTNAME: `parachain-benchmark`, CPU: `Intel(R) Xeon(R) Platinum 8259CL CPU @ 2.50GHz` +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("rococo-dev"), DB CACHE: 20 + +// Executed Command: +// ./litentry-collator +// benchmark +// pallet +// --chain=rococo-dev +// --execution=wasm +// --db-cache=20 +// --wasm-execution=compiled +// --pallet=pallet_extrinsic_filter +// --extrinsic=* +// --heap-pages=4096 +// --steps=20 +// --repeat=50 +// --header=./LICENSE_HEADER +// --output=./runtime/rococo/src/weights/pallet_extrinsic_filter.rs + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] +#![allow(missing_docs)] + +use frame_support::{traits::Get, weights::Weight}; +use core::marker::PhantomData; + +/// Weight functions for `pallet_extrinsic_filter`. +pub struct WeightInfo(PhantomData); +impl pallet_extrinsic_filter::WeightInfo for WeightInfo { + /// Storage: ExtrinsicFilter BlockedExtrinsics (r:1 w:1) + /// Proof Skipped: ExtrinsicFilter BlockedExtrinsics (max_values: None, max_size: None, mode: Measured) + /// The range of component `p` is `[1, 1024]`. + /// The range of component `f` is `[1, 1024]`. + fn block_extrinsics(p: u32, f: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `142` + // Estimated: `3607` + // Minimum execution time: 22_532_000 picoseconds. + Weight::from_parts(21_407_222, 0) + .saturating_add(Weight::from_parts(0, 3607)) + // Standard Error: 134 + .saturating_add(Weight::from_parts(2_594, 0).saturating_mul(p.into())) + // Standard Error: 134 + .saturating_add(Weight::from_parts(2_945, 0).saturating_mul(f.into())) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: ExtrinsicFilter BlockedExtrinsics (r:1 w:1) + /// Proof Skipped: ExtrinsicFilter BlockedExtrinsics (max_values: None, max_size: None, mode: Measured) + /// The range of component `p` is `[1, 1024]`. + /// The range of component `f` is `[1, 1024]`. + fn unblock_extrinsics(p: u32, f: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `178 + f * (1 ±0) + p * (1 ±0)` + // Estimated: `3644 + f * (1 ±0) + p * (1 ±0)` + // Minimum execution time: 34_403_000 picoseconds. + Weight::from_parts(23_998_401, 0) + .saturating_add(Weight::from_parts(0, 3644)) + // Standard Error: 181 + .saturating_add(Weight::from_parts(13_204, 0).saturating_mul(p.into())) + // Standard Error: 181 + .saturating_add(Weight::from_parts(12_287, 0).saturating_mul(f.into())) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(1)) + .saturating_add(Weight::from_parts(0, 1).saturating_mul(f.into())) + .saturating_add(Weight::from_parts(0, 1).saturating_mul(p.into())) + } +} diff --git a/runtime/paseo/src/weights/pallet_identity.rs b/runtime/paseo/src/weights/pallet_identity.rs new file mode 100644 index 0000000000..561456e983 --- /dev/null +++ b/runtime/paseo/src/weights/pallet_identity.rs @@ -0,0 +1,199 @@ + +//! Autogenerated weights for `pallet_identity` +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev +//! DATE: 2021-10-27, STEPS: `20`, REPEAT: 50, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("./source/local.json"), DB CACHE: 20 + +// Executed Command: +// ./target/release/litentry-collator +// benchmark +// --chain=./source/local.json +// --execution=wasm +// --db-cache=20 +// --wasm-execution=compiled +// --pallet=pallet-identity +// --extrinsic=* +// --heap-pages=4096 +// --steps=20 +// --repeat=50 +// --output=./runtime/src/weights/pallet-identity.rs + + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] + +use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}}; +use sp_std::marker::PhantomData; + +/// Weight functions for `pallet_identity`. +pub struct WeightInfo(PhantomData); +impl pallet_identity::WeightInfo for WeightInfo { + // Storage: Identity Registrars (r:1 w:1) + fn add_registrar(r: u32, ) -> Weight { + Weight::from_parts(30_842_000 as u64, 0) + // Standard Error: 6_000 + .saturating_add(Weight::from_parts(463_000 as u64, 0).saturating_mul(r as u64)) + .saturating_add(T::DbWeight::get().reads(1 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } + // Storage: Identity IdentityOf (r:1 w:1) + fn set_identity(r: u32, x: u32, ) -> Weight { + Weight::from_parts(69_189_000 as u64, 0) + // Standard Error: 37_000 + .saturating_add(Weight::from_parts(550_000 as u64, 0).saturating_mul(r as u64)) + // Standard Error: 6_000 + .saturating_add(Weight::from_parts(1_467_000 as u64, 0).saturating_mul(x as u64)) + .saturating_add(T::DbWeight::get().reads(1 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } + // Storage: Identity IdentityOf (r:1 w:0) + // Storage: Identity SubsOf (r:1 w:1) + // Storage: Identity SuperOf (r:1 w:1) + fn set_subs_new(s: u32, ) -> Weight { + Weight::from_parts(60_117_000 as u64, 0) + // Standard Error: 5_000 + .saturating_add(Weight::from_parts(9_215_000 as u64, 0).saturating_mul(s as u64)) + .saturating_add(T::DbWeight::get().reads(2 as u64)) + .saturating_add(T::DbWeight::get().reads((1 as u64).saturating_mul(s as u64))) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + .saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(s as u64))) + } + // Storage: Identity IdentityOf (r:1 w:0) + // Storage: Identity SubsOf (r:1 w:1) + // Storage: Identity SuperOf (r:0 w:1) + fn set_subs_old(p: u32, ) -> Weight { + Weight::from_parts(59_651_000 as u64, 0) + // Standard Error: 4_000 + .saturating_add(Weight::from_parts(3_043_000 as u64, 0).saturating_mul(p as u64)) + .saturating_add(T::DbWeight::get().reads(2 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + .saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(p as u64))) + } + // Storage: Identity SubsOf (r:1 w:1) + // Storage: Identity IdentityOf (r:1 w:1) + // Storage: Identity SuperOf (r:0 w:100) + fn clear_identity(r: u32, s: u32, x: u32, ) -> Weight { + Weight::from_parts(64_330_000 as u64, 0) + // Standard Error: 18_000 + .saturating_add(Weight::from_parts(659_000 as u64, 0).saturating_mul(r as u64)) + // Standard Error: 3_000 + .saturating_add(Weight::from_parts(3_089_000 as u64, 0).saturating_mul(s as u64)) + // Standard Error: 3_000 + .saturating_add(Weight::from_parts(812_000 as u64, 0).saturating_mul(x as u64)) + .saturating_add(T::DbWeight::get().reads(2 as u64)) + .saturating_add(T::DbWeight::get().writes(2 as u64)) + .saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(s as u64))) + } + // Storage: Identity Registrars (r:1 w:0) + // Storage: Identity IdentityOf (r:1 w:1) + fn request_judgement(r: u32, x: u32, ) -> Weight { + Weight::from_parts(79_592_000 as u64, 0) + // Standard Error: 6_000 + .saturating_add(Weight::from_parts(435_000 as u64, 0).saturating_mul(r as u64)) + // Standard Error: 1_000 + .saturating_add(Weight::from_parts(1_483_000 as u64, 0).saturating_mul(x as u64)) + .saturating_add(T::DbWeight::get().reads(2 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } + // Storage: Identity IdentityOf (r:1 w:1) + fn cancel_request(r: u32, x: u32, ) -> Weight { + Weight::from_parts(74_756_000 as u64, 0) + // Standard Error: 26_000 + .saturating_add(Weight::from_parts(291_000 as u64, 0).saturating_mul(r as u64)) + // Standard Error: 4_000 + .saturating_add(Weight::from_parts(1_461_000 as u64, 0).saturating_mul(x as u64)) + .saturating_add(T::DbWeight::get().reads(1 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } + // Storage: Identity Registrars (r:1 w:1) + fn set_fee(r: u32, ) -> Weight { + Weight::from_parts(12_562_000 as u64, 0) + // Standard Error: 3_000 + .saturating_add(Weight::from_parts(407_000 as u64, 0).saturating_mul(r as u64)) + .saturating_add(T::DbWeight::get().reads(1 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } + // Storage: Identity Registrars (r:1 w:1) + fn set_account_id(r: u32, ) -> Weight { + Weight::from_parts(12_588_000 as u64, 0) + // Standard Error: 3_000 + .saturating_add(Weight::from_parts(406_000 as u64, 0).saturating_mul(r as u64)) + .saturating_add(T::DbWeight::get().reads(1 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } + // Storage: Identity Registrars (r:1 w:1) + fn set_fields(r: u32, ) -> Weight { + Weight::from_parts(12_601_000 as u64, 0) + // Standard Error: 3_000 + .saturating_add(Weight::from_parts(404_000 as u64, 0).saturating_mul(r as u64)) + .saturating_add(T::DbWeight::get().reads(1 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } + // Storage: Identity Registrars (r:1 w:0) + // Storage: Identity IdentityOf (r:1 w:1) + fn provide_judgement(r: u32, x: u32, ) -> Weight { + Weight::from_parts(55_809_000 as u64, 0) + // Standard Error: 22_000 + .saturating_add(Weight::from_parts(142_000 as u64, 0).saturating_mul(r as u64)) + // Standard Error: 3_000 + .saturating_add(Weight::from_parts(1_483_000 as u64, 0).saturating_mul(x as u64)) + .saturating_add(T::DbWeight::get().reads(2 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } + // Storage: Identity SubsOf (r:1 w:1) + // Storage: Identity IdentityOf (r:1 w:1) + // Storage: System Account (r:2 w:2) + // Storage: Identity SuperOf (r:0 w:100) + fn kill_identity(r: u32, s: u32, x: u32, ) -> Weight { + Weight::from_parts(82_981_000 as u64, 0) + // Standard Error: 16_000 + .saturating_add(Weight::from_parts(586_000 as u64, 0).saturating_mul(r as u64)) + // Standard Error: 3_000 + .saturating_add(Weight::from_parts(3_095_000 as u64, 0).saturating_mul(s as u64)) + // Standard Error: 3_000 + .saturating_add(Weight::from_parts(2_000 as u64, 0).saturating_mul(x as u64)) + .saturating_add(T::DbWeight::get().reads(4 as u64)) + .saturating_add(T::DbWeight::get().writes(4 as u64)) + .saturating_add(T::DbWeight::get().writes((1 as u64).saturating_mul(s as u64))) + } + // Storage: Identity IdentityOf (r:1 w:0) + // Storage: Identity SuperOf (r:1 w:1) + // Storage: Identity SubsOf (r:1 w:1) + fn add_sub(s: u32, ) -> Weight { + Weight::from_parts(82_321_000 as u64, 0) + // Standard Error: 3_000 + .saturating_add(Weight::from_parts(268_000 as u64, 0).saturating_mul(s as u64)) + .saturating_add(T::DbWeight::get().reads(3 as u64)) + .saturating_add(T::DbWeight::get().writes(2 as u64)) + } + // Storage: Identity IdentityOf (r:1 w:0) + // Storage: Identity SuperOf (r:1 w:1) + fn rename_sub(s: u32, ) -> Weight { + Weight::from_parts(23_968_000 as u64, 0) + // Standard Error: 0 + .saturating_add(Weight::from_parts(85_000 as u64, 0).saturating_mul(s as u64)) + .saturating_add(T::DbWeight::get().reads(2 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } + // Storage: Identity IdentityOf (r:1 w:0) + // Storage: Identity SuperOf (r:1 w:1) + // Storage: Identity SubsOf (r:1 w:1) + fn remove_sub(s: u32, ) -> Weight { + Weight::from_parts(82_550_000 as u64, 0) + // Standard Error: 2_000 + .saturating_add(Weight::from_parts(264_000 as u64, 0).saturating_mul(s as u64)) + .saturating_add(T::DbWeight::get().reads(3 as u64)) + .saturating_add(T::DbWeight::get().writes(2 as u64)) + } + // Storage: Identity SuperOf (r:1 w:1) + // Storage: Identity SubsOf (r:1 w:1) + fn quit_sub(s: u32, ) -> Weight { + Weight::from_parts(50_979_000 as u64, 0) + // Standard Error: 2_000 + .saturating_add(Weight::from_parts(251_000 as u64, 0).saturating_mul(s as u64)) + .saturating_add(T::DbWeight::get().reads(2 as u64)) + .saturating_add(T::DbWeight::get().writes(2 as u64)) + } +} diff --git a/runtime/paseo/src/weights/pallet_identity_management.rs b/runtime/paseo/src/weights/pallet_identity_management.rs new file mode 100644 index 0000000000..f34c50665d --- /dev/null +++ b/runtime/paseo/src/weights/pallet_identity_management.rs @@ -0,0 +1,163 @@ +// Copyright 2020-2024 Trust Computing GmbH. +// This file is part of Litentry. +// +// Litentry is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Litentry 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 +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Litentry. If not, see . + +//! Autogenerated weights for `pallet_identity_management` +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev +//! DATE: 2023-11-30, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! WORST CASE MAP SIZE: `1000000` +//! HOSTNAME: `parachain-benchmark`, CPU: `Intel(R) Xeon(R) Platinum 8259CL CPU @ 2.50GHz` +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("rococo-dev"), DB CACHE: 20 + +// Executed Command: +// ./litentry-collator +// benchmark +// pallet +// --chain=rococo-dev +// --execution=wasm +// --db-cache=20 +// --wasm-execution=compiled +// --pallet=pallet_identity_management +// --extrinsic=* +// --heap-pages=4096 +// --steps=20 +// --repeat=50 +// --header=./LICENSE_HEADER +// --output=./runtime/rococo/src/weights/pallet_identity_management.rs + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] +#![allow(missing_docs)] + +use frame_support::{traits::Get, weights::Weight}; +use core::marker::PhantomData; + +/// Weight functions for `pallet_identity_management`. +pub struct WeightInfo(PhantomData); +impl pallet_identity_management::WeightInfo for WeightInfo { + /// Storage: IdentityManagement Delegatee (r:0 w:1) + /// Proof: IdentityManagement Delegatee (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen) + fn add_delegatee() -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 13_843_000 picoseconds. + Weight::from_parts(14_244_000, 0) + .saturating_add(Weight::from_parts(0, 0)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: IdentityManagement Delegatee (r:1 w:1) + /// Proof: IdentityManagement Delegatee (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen) + fn remove_delegatee() -> Weight { + // Proof Size summary in bytes: + // Measured: `79` + // Estimated: `3513` + // Minimum execution time: 19_880_000 picoseconds. + Weight::from_parts(20_277_000, 0) + .saturating_add(Weight::from_parts(0, 3513)) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: IMPExtrinsicWhitelist GroupControlOn (r:1 w:0) + /// Proof Skipped: IMPExtrinsicWhitelist GroupControlOn (max_values: Some(1), max_size: None, mode: Measured) + fn link_identity() -> Weight { + // Proof Size summary in bytes: + // Measured: `76` + // Estimated: `1561` + // Minimum execution time: 20_439_000 picoseconds. + Weight::from_parts(20_798_000, 0) + .saturating_add(Weight::from_parts(0, 1561)) + .saturating_add(T::DbWeight::get().reads(1)) + } + /// Storage: IMPExtrinsicWhitelist GroupControlOn (r:1 w:0) + /// Proof Skipped: IMPExtrinsicWhitelist GroupControlOn (max_values: Some(1), max_size: None, mode: Measured) + fn deactivate_identity() -> Weight { + // Proof Size summary in bytes: + // Measured: `76` + // Estimated: `1561` + // Minimum execution time: 17_116_000 picoseconds. + Weight::from_parts(17_493_000, 0) + .saturating_add(Weight::from_parts(0, 1561)) + .saturating_add(T::DbWeight::get().reads(1)) + } + /// Storage: IMPExtrinsicWhitelist GroupControlOn (r:1 w:0) + /// Proof Skipped: IMPExtrinsicWhitelist GroupControlOn (max_values: Some(1), max_size: None, mode: Measured) + fn activate_identity() -> Weight { + // Proof Size summary in bytes: + // Measured: `76` + // Estimated: `1561` + // Minimum execution time: 17_117_000 picoseconds. + Weight::from_parts(17_592_000, 0) + .saturating_add(Weight::from_parts(0, 1561)) + .saturating_add(T::DbWeight::get().reads(1)) + } + /// Storage: Teerex EnclaveIndex (r:1 w:0) + /// Proof Skipped: Teerex EnclaveIndex (max_values: None, max_size: None, mode: Measured) + fn identity_linked() -> Weight { + // Proof Size summary in bytes: + // Measured: `255` + // Estimated: `3720` + // Minimum execution time: 20_155_000 picoseconds. + Weight::from_parts(20_822_000, 0) + .saturating_add(Weight::from_parts(0, 3720)) + .saturating_add(T::DbWeight::get().reads(1)) + } + /// Storage: Teerex EnclaveIndex (r:1 w:0) + /// Proof Skipped: Teerex EnclaveIndex (max_values: None, max_size: None, mode: Measured) + fn identity_deactivated() -> Weight { + // Proof Size summary in bytes: + // Measured: `255` + // Estimated: `3720` + // Minimum execution time: 20_158_000 picoseconds. + Weight::from_parts(20_898_000, 0) + .saturating_add(Weight::from_parts(0, 3720)) + .saturating_add(T::DbWeight::get().reads(1)) + } + /// Storage: Teerex EnclaveIndex (r:1 w:0) + /// Proof Skipped: Teerex EnclaveIndex (max_values: None, max_size: None, mode: Measured) + fn identity_activated() -> Weight { + // Proof Size summary in bytes: + // Measured: `255` + // Estimated: `3720` + // Minimum execution time: 20_057_000 picoseconds. + Weight::from_parts(20_846_000, 0) + .saturating_add(Weight::from_parts(0, 3720)) + .saturating_add(T::DbWeight::get().reads(1)) + } + /// Storage: Teerex EnclaveIndex (r:1 w:0) + /// Proof Skipped: Teerex EnclaveIndex (max_values: None, max_size: None, mode: Measured) + fn identity_networks_set() -> Weight { + // Proof Size summary in bytes: + // Measured: `255` + // Estimated: `3720` + // Minimum execution time: 20_057_000 picoseconds. + Weight::from_parts(20_846_000, 0) + .saturating_add(Weight::from_parts(0, 3720)) + .saturating_add(T::DbWeight::get().reads(1)) + } + /// Storage: Teerex EnclaveIndex (r:1 w:0) + /// Proof Skipped: Teerex EnclaveIndex (max_values: None, max_size: None, mode: Measured) + fn some_error() -> Weight { + // Proof Size summary in bytes: + // Measured: `255` + // Estimated: `3720` + // Minimum execution time: 20_419_000 picoseconds. + Weight::from_parts(21_055_000, 0) + .saturating_add(Weight::from_parts(0, 3720)) + .saturating_add(T::DbWeight::get().reads(1)) + } +} diff --git a/runtime/paseo/src/weights/pallet_membership.rs b/runtime/paseo/src/weights/pallet_membership.rs new file mode 100644 index 0000000000..90be12f750 --- /dev/null +++ b/runtime/paseo/src/weights/pallet_membership.rs @@ -0,0 +1,206 @@ +// Copyright 2020-2024 Trust Computing GmbH. +// This file is part of Litentry. +// +// Litentry is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Litentry 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 +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Litentry. If not, see . + +//! Autogenerated weights for `pallet_membership` +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev +//! DATE: 2023-10-17, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! WORST CASE MAP SIZE: `1000000` +//! HOSTNAME: `parachain-benchmark`, CPU: `Intel(R) Xeon(R) Platinum 8259CL CPU @ 2.50GHz` +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("rococo-dev"), DB CACHE: 20 + +// Executed Command: +// ./litentry-collator +// benchmark +// pallet +// --chain=rococo-dev +// --execution=wasm +// --db-cache=20 +// --wasm-execution=compiled +// --pallet=pallet_membership +// --extrinsic=* +// --heap-pages=4096 +// --steps=20 +// --repeat=50 +// --header=./LICENSE_HEADER +// --output=./runtime/rococo/src/weights/pallet_membership.rs + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] +#![allow(missing_docs)] + +use frame_support::{traits::Get, weights::Weight}; +use core::marker::PhantomData; + +/// Weight functions for `pallet_membership`. +pub struct WeightInfo(PhantomData); +impl pallet_membership::WeightInfo for WeightInfo { + /// Storage: CouncilMembership Members (r:1 w:1) + /// Proof: CouncilMembership Members (max_values: Some(1), max_size: Some(3202), added: 3697, mode: MaxEncodedLen) + /// Storage: Council Proposals (r:1 w:0) + /// Proof Skipped: Council Proposals (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: Council Members (r:0 w:1) + /// Proof Skipped: Council Members (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: Council Prime (r:0 w:1) + /// Proof Skipped: Council Prime (max_values: Some(1), max_size: None, mode: Measured) + /// The range of component `m` is `[1, 99]`. + fn add_member(m: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `211 + m * (64 ±0)` + // Estimated: `4687 + m * (64 ±0)` + // Minimum execution time: 23_819_000 picoseconds. + Weight::from_parts(24_057_385, 0) + .saturating_add(Weight::from_parts(0, 4687)) + // Standard Error: 1_588 + .saturating_add(Weight::from_parts(45_968, 0).saturating_mul(m.into())) + .saturating_add(T::DbWeight::get().reads(2)) + .saturating_add(T::DbWeight::get().writes(3)) + .saturating_add(Weight::from_parts(0, 64).saturating_mul(m.into())) + } + /// Storage: CouncilMembership Members (r:1 w:1) + /// Proof: CouncilMembership Members (max_values: Some(1), max_size: Some(3202), added: 3697, mode: MaxEncodedLen) + /// Storage: Council Proposals (r:1 w:0) + /// Proof Skipped: Council Proposals (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: CouncilMembership Prime (r:1 w:0) + /// Proof: CouncilMembership Prime (max_values: Some(1), max_size: Some(32), added: 527, mode: MaxEncodedLen) + /// Storage: Council Members (r:0 w:1) + /// Proof Skipped: Council Members (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: Council Prime (r:0 w:1) + /// Proof Skipped: Council Prime (max_values: Some(1), max_size: None, mode: Measured) + /// The range of component `m` is `[2, 100]`. + fn remove_member(m: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `316 + m * (64 ±0)` + // Estimated: `4687 + m * (64 ±0)` + // Minimum execution time: 27_230_000 picoseconds. + Weight::from_parts(29_007_635, 0) + .saturating_add(Weight::from_parts(0, 4687)) + // Standard Error: 1_583 + .saturating_add(Weight::from_parts(21_863, 0).saturating_mul(m.into())) + .saturating_add(T::DbWeight::get().reads(3)) + .saturating_add(T::DbWeight::get().writes(3)) + .saturating_add(Weight::from_parts(0, 64).saturating_mul(m.into())) + } + /// Storage: CouncilMembership Members (r:1 w:1) + /// Proof: CouncilMembership Members (max_values: Some(1), max_size: Some(3202), added: 3697, mode: MaxEncodedLen) + /// Storage: Council Proposals (r:1 w:0) + /// Proof Skipped: Council Proposals (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: CouncilMembership Prime (r:1 w:0) + /// Proof: CouncilMembership Prime (max_values: Some(1), max_size: Some(32), added: 527, mode: MaxEncodedLen) + /// Storage: Council Members (r:0 w:1) + /// Proof Skipped: Council Members (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: Council Prime (r:0 w:1) + /// Proof Skipped: Council Prime (max_values: Some(1), max_size: None, mode: Measured) + /// The range of component `m` is `[2, 100]`. + fn swap_member(m: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `316 + m * (64 ±0)` + // Estimated: `4687 + m * (64 ±0)` + // Minimum execution time: 27_233_000 picoseconds. + Weight::from_parts(27_049_469, 0) + .saturating_add(Weight::from_parts(0, 4687)) + // Standard Error: 2_713 + .saturating_add(Weight::from_parts(90_175, 0).saturating_mul(m.into())) + .saturating_add(T::DbWeight::get().reads(3)) + .saturating_add(T::DbWeight::get().writes(3)) + .saturating_add(Weight::from_parts(0, 64).saturating_mul(m.into())) + } + /// Storage: CouncilMembership Members (r:1 w:1) + /// Proof: CouncilMembership Members (max_values: Some(1), max_size: Some(3202), added: 3697, mode: MaxEncodedLen) + /// Storage: Council Proposals (r:1 w:0) + /// Proof Skipped: Council Proposals (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: CouncilMembership Prime (r:1 w:0) + /// Proof: CouncilMembership Prime (max_values: Some(1), max_size: Some(32), added: 527, mode: MaxEncodedLen) + /// Storage: Council Members (r:0 w:1) + /// Proof Skipped: Council Members (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: Council Prime (r:0 w:1) + /// Proof Skipped: Council Prime (max_values: Some(1), max_size: None, mode: Measured) + /// The range of component `m` is `[1, 100]`. + fn reset_member(m: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `315 + m * (64 ±0)` + // Estimated: `4687 + m * (64 ±0)` + // Minimum execution time: 26_858_000 picoseconds. + Weight::from_parts(28_191_552, 0) + .saturating_add(Weight::from_parts(0, 4687)) + // Standard Error: 5_225 + .saturating_add(Weight::from_parts(245_055, 0).saturating_mul(m.into())) + .saturating_add(T::DbWeight::get().reads(3)) + .saturating_add(T::DbWeight::get().writes(3)) + .saturating_add(Weight::from_parts(0, 64).saturating_mul(m.into())) + } + /// Storage: CouncilMembership Members (r:1 w:1) + /// Proof: CouncilMembership Members (max_values: Some(1), max_size: Some(3202), added: 3697, mode: MaxEncodedLen) + /// Storage: Council Proposals (r:1 w:0) + /// Proof Skipped: Council Proposals (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: CouncilMembership Prime (r:1 w:1) + /// Proof: CouncilMembership Prime (max_values: Some(1), max_size: Some(32), added: 527, mode: MaxEncodedLen) + /// Storage: Council Members (r:0 w:1) + /// Proof Skipped: Council Members (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: Council Prime (r:0 w:1) + /// Proof Skipped: Council Prime (max_values: Some(1), max_size: None, mode: Measured) + /// The range of component `m` is `[1, 100]`. + fn change_key(m: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `315 + m * (64 ±0)` + // Estimated: `4687 + m * (64 ±0)` + // Minimum execution time: 27_678_000 picoseconds. + Weight::from_parts(28_977_909, 0) + .saturating_add(Weight::from_parts(0, 4687)) + // Standard Error: 691 + .saturating_add(Weight::from_parts(42_476, 0).saturating_mul(m.into())) + .saturating_add(T::DbWeight::get().reads(3)) + .saturating_add(T::DbWeight::get().writes(4)) + .saturating_add(Weight::from_parts(0, 64).saturating_mul(m.into())) + } + /// Storage: CouncilMembership Members (r:1 w:0) + /// Proof: CouncilMembership Members (max_values: Some(1), max_size: Some(3202), added: 3697, mode: MaxEncodedLen) + /// Storage: CouncilMembership Prime (r:0 w:1) + /// Proof: CouncilMembership Prime (max_values: Some(1), max_size: Some(32), added: 527, mode: MaxEncodedLen) + /// Storage: Council Prime (r:0 w:1) + /// Proof Skipped: Council Prime (max_values: Some(1), max_size: None, mode: Measured) + /// The range of component `m` is `[1, 100]`. + fn set_prime(m: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `107 + m * (32 ±0)` + // Estimated: `4687 + m * (32 ±0)` + // Minimum execution time: 11_764_000 picoseconds. + Weight::from_parts(12_306_500, 0) + .saturating_add(Weight::from_parts(0, 4687)) + // Standard Error: 222 + .saturating_add(Weight::from_parts(13_917, 0).saturating_mul(m.into())) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(2)) + .saturating_add(Weight::from_parts(0, 32).saturating_mul(m.into())) + } + /// Storage: CouncilMembership Prime (r:0 w:1) + /// Proof: CouncilMembership Prime (max_values: Some(1), max_size: Some(32), added: 527, mode: MaxEncodedLen) + /// Storage: Council Prime (r:0 w:1) + /// Proof Skipped: Council Prime (max_values: Some(1), max_size: None, mode: Measured) + /// The range of component `m` is `[1, 100]`. + fn clear_prime(m: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 4_526_000 picoseconds. + Weight::from_parts(4_799_478, 0) + .saturating_add(Weight::from_parts(0, 0)) + // Standard Error: 92 + .saturating_add(Weight::from_parts(899, 0).saturating_mul(m.into())) + .saturating_add(T::DbWeight::get().writes(2)) + } +} diff --git a/runtime/paseo/src/weights/pallet_multisig.rs b/runtime/paseo/src/weights/pallet_multisig.rs new file mode 100644 index 0000000000..a953d564ae --- /dev/null +++ b/runtime/paseo/src/weights/pallet_multisig.rs @@ -0,0 +1,164 @@ +// Copyright 2020-2024 Trust Computing GmbH. +// This file is part of Litentry. +// +// Litentry is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Litentry 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 +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Litentry. If not, see . + +//! Autogenerated weights for `pallet_multisig` +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev +//! DATE: 2023-10-17, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! WORST CASE MAP SIZE: `1000000` +//! HOSTNAME: `parachain-benchmark`, CPU: `Intel(R) Xeon(R) Platinum 8259CL CPU @ 2.50GHz` +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("rococo-dev"), DB CACHE: 20 + +// Executed Command: +// ./litentry-collator +// benchmark +// pallet +// --chain=rococo-dev +// --execution=wasm +// --db-cache=20 +// --wasm-execution=compiled +// --pallet=pallet_multisig +// --extrinsic=* +// --heap-pages=4096 +// --steps=20 +// --repeat=50 +// --header=./LICENSE_HEADER +// --output=./runtime/rococo/src/weights/pallet_multisig.rs + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] +#![allow(missing_docs)] + +use frame_support::{traits::Get, weights::Weight}; +use core::marker::PhantomData; + +/// Weight functions for `pallet_multisig`. +pub struct WeightInfo(PhantomData); +impl pallet_multisig::WeightInfo for WeightInfo { + /// The range of component `z` is `[0, 10000]`. + fn as_multi_threshold_1(z: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 18_853_000 picoseconds. + Weight::from_parts(22_999_407, 0) + .saturating_add(Weight::from_parts(0, 0)) + // Standard Error: 43 + .saturating_add(Weight::from_parts(1_135, 0).saturating_mul(z.into())) + } + /// Storage: Multisig Multisigs (r:1 w:1) + /// Proof: Multisig Multisigs (max_values: None, max_size: Some(3346), added: 5821, mode: MaxEncodedLen) + /// The range of component `s` is `[2, 100]`. + /// The range of component `z` is `[0, 10000]`. + fn as_multi_create(s: u32, z: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `289 + s * (2 ±0)` + // Estimated: `6811` + // Minimum execution time: 60_323_000 picoseconds. + Weight::from_parts(44_617_716, 0) + .saturating_add(Weight::from_parts(0, 6811)) + // Standard Error: 6_665 + .saturating_add(Weight::from_parts(247_225, 0).saturating_mul(s.into())) + // Standard Error: 65 + .saturating_add(Weight::from_parts(1_915, 0).saturating_mul(z.into())) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: Multisig Multisigs (r:1 w:1) + /// Proof: Multisig Multisigs (max_values: None, max_size: Some(3346), added: 5821, mode: MaxEncodedLen) + /// The range of component `s` is `[3, 100]`. + /// The range of component `z` is `[0, 10000]`. + fn as_multi_approve(s: u32, z: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `315` + // Estimated: `6811` + // Minimum execution time: 40_600_000 picoseconds. + Weight::from_parts(30_192_721, 0) + .saturating_add(Weight::from_parts(0, 6811)) + // Standard Error: 4_152 + .saturating_add(Weight::from_parts(173_614, 0).saturating_mul(s.into())) + // Standard Error: 40 + .saturating_add(Weight::from_parts(1_575, 0).saturating_mul(z.into())) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: Multisig Multisigs (r:1 w:1) + /// Proof: Multisig Multisigs (max_values: None, max_size: Some(3346), added: 5821, mode: MaxEncodedLen) + /// Storage: System Account (r:1 w:1) + /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + /// The range of component `s` is `[2, 100]`. + /// The range of component `z` is `[0, 10000]`. + fn as_multi_complete(s: u32, z: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `421 + s * (33 ±0)` + // Estimated: `6811` + // Minimum execution time: 67_111_000 picoseconds. + Weight::from_parts(46_781_350, 0) + .saturating_add(Weight::from_parts(0, 6811)) + // Standard Error: 4_632 + .saturating_add(Weight::from_parts(324_137, 0).saturating_mul(s.into())) + // Standard Error: 45 + .saturating_add(Weight::from_parts(2_200, 0).saturating_mul(z.into())) + .saturating_add(T::DbWeight::get().reads(2)) + .saturating_add(T::DbWeight::get().writes(2)) + } + /// Storage: Multisig Multisigs (r:1 w:1) + /// Proof: Multisig Multisigs (max_values: None, max_size: Some(3346), added: 5821, mode: MaxEncodedLen) + /// The range of component `s` is `[2, 100]`. + fn approve_as_multi_create(s: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `292 + s * (2 ±0)` + // Estimated: `6811` + // Minimum execution time: 43_194_000 picoseconds. + Weight::from_parts(46_632_221, 0) + .saturating_add(Weight::from_parts(0, 6811)) + // Standard Error: 5_115 + .saturating_add(Weight::from_parts(208_635, 0).saturating_mul(s.into())) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: Multisig Multisigs (r:1 w:1) + /// Proof: Multisig Multisigs (max_values: None, max_size: Some(3346), added: 5821, mode: MaxEncodedLen) + /// The range of component `s` is `[2, 100]`. + fn approve_as_multi_approve(s: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `315` + // Estimated: `6811` + // Minimum execution time: 24_929_000 picoseconds. + Weight::from_parts(26_889_285, 0) + .saturating_add(Weight::from_parts(0, 6811)) + // Standard Error: 3_688 + .saturating_add(Weight::from_parts(144_932, 0).saturating_mul(s.into())) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: Multisig Multisigs (r:1 w:1) + /// Proof: Multisig Multisigs (max_values: None, max_size: Some(3346), added: 5821, mode: MaxEncodedLen) + /// The range of component `s` is `[2, 100]`. + fn cancel_as_multi(s: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `486 + s * (1 ±0)` + // Estimated: `6811` + // Minimum execution time: 44_914_000 picoseconds. + Weight::from_parts(45_393_276, 0) + .saturating_add(Weight::from_parts(0, 6811)) + // Standard Error: 4_458 + .saturating_add(Weight::from_parts(201_411, 0).saturating_mul(s.into())) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(1)) + } +} diff --git a/runtime/paseo/src/weights/pallet_parachain_staking.rs b/runtime/paseo/src/weights/pallet_parachain_staking.rs new file mode 100644 index 0000000000..b09131e24e --- /dev/null +++ b/runtime/paseo/src/weights/pallet_parachain_staking.rs @@ -0,0 +1,718 @@ +// Copyright 2020-2024 Trust Computing GmbH. +// This file is part of Litentry. +// +// Litentry is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Litentry 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 +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Litentry. If not, see . + +//! Autogenerated weights for `pallet_parachain_staking` +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev +//! DATE: 2023-10-17, STEPS: `25`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! WORST CASE MAP SIZE: `1000000` +//! HOSTNAME: `parachain-benchmark`, CPU: `Intel(R) Xeon(R) Platinum 8259CL CPU @ 2.50GHz` +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("rococo-dev"), DB CACHE: 20 + +// Executed Command: +// ./litentry-collator +// benchmark +// pallet +// --chain=rococo-dev +// --execution=wasm +// --db-cache=20 +// --wasm-execution=compiled +// --pallet=pallet_parachain_staking +// --extrinsic=* +// --heap-pages=4096 +// --steps=25 +// --repeat=20 +// --header=./LICENSE_HEADER +// --output=./runtime/rococo/src/weights/pallet_parachain_staking.rs + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] +#![allow(missing_docs)] + +use frame_support::{traits::Get, weights::Weight}; +use core::marker::PhantomData; + +/// Weight functions for `pallet_parachain_staking`. +pub struct WeightInfo(PhantomData); +impl pallet_parachain_staking::WeightInfo for WeightInfo { + /// Storage: ParachainStaking Candidates (r:1 w:1) + /// Proof Skipped: ParachainStaking Candidates (max_values: Some(1), max_size: None, mode: Measured) + /// The range of component `x` is `[1, 100]`. + fn add_candidates_whitelist(x: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `337 + x * (32 ±0)` + // Estimated: `1826 + x * (32 ±0)` + // Minimum execution time: 18_935_000 picoseconds. + Weight::from_parts(22_854_413, 0) + .saturating_add(Weight::from_parts(0, 1826)) + // Standard Error: 4_674 + .saturating_add(Weight::from_parts(186_518, 0).saturating_mul(x.into())) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(1)) + .saturating_add(Weight::from_parts(0, 32).saturating_mul(x.into())) + } + /// Storage: ParachainStaking Candidates (r:1 w:1) + /// Proof Skipped: ParachainStaking Candidates (max_values: Some(1), max_size: None, mode: Measured) + /// The range of component `x` is `[1, 100]`. + fn remove_candidates_whitelist(x: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `369 + x * (32 ±0)` + // Estimated: `1859 + x * (32 ±0)` + // Minimum execution time: 18_040_000 picoseconds. + Weight::from_parts(21_361_636, 0) + .saturating_add(Weight::from_parts(0, 1859)) + // Standard Error: 3_039 + .saturating_add(Weight::from_parts(191_134, 0).saturating_mul(x.into())) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(1)) + .saturating_add(Weight::from_parts(0, 32).saturating_mul(x.into())) + } + /// Storage: ParachainStaking InflationConfig (r:1 w:1) + /// Proof Skipped: ParachainStaking InflationConfig (max_values: Some(1), max_size: None, mode: Measured) + fn set_staking_expectations() -> Weight { + // Proof Size summary in bytes: + // Measured: `466` + // Estimated: `1951` + // Minimum execution time: 19_519_000 picoseconds. + Weight::from_parts(20_309_000, 0) + .saturating_add(Weight::from_parts(0, 1951)) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: ParachainStaking InflationConfig (r:1 w:1) + /// Proof Skipped: ParachainStaking InflationConfig (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: ParachainStaking Round (r:1 w:0) + /// Proof Skipped: ParachainStaking Round (max_values: Some(1), max_size: None, mode: Measured) + fn set_inflation() -> Weight { + // Proof Size summary in bytes: + // Measured: `502` + // Estimated: `1987` + // Minimum execution time: 73_978_000 picoseconds. + Weight::from_parts(74_907_000, 0) + .saturating_add(Weight::from_parts(0, 1987)) + .saturating_add(T::DbWeight::get().reads(2)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: ParachainStaking ParachainBondInfo (r:1 w:1) + /// Proof Skipped: ParachainStaking ParachainBondInfo (max_values: Some(1), max_size: None, mode: Measured) + fn set_parachain_bond_account() -> Weight { + // Proof Size summary in bytes: + // Measured: `434` + // Estimated: `1919` + // Minimum execution time: 19_450_000 picoseconds. + Weight::from_parts(20_104_000, 0) + .saturating_add(Weight::from_parts(0, 1919)) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: ParachainStaking ParachainBondInfo (r:1 w:1) + /// Proof Skipped: ParachainStaking ParachainBondInfo (max_values: Some(1), max_size: None, mode: Measured) + fn set_parachain_bond_reserve_percent() -> Weight { + // Proof Size summary in bytes: + // Measured: `434` + // Estimated: `1919` + // Minimum execution time: 18_900_000 picoseconds. + Weight::from_parts(19_444_000, 0) + .saturating_add(Weight::from_parts(0, 1919)) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: ParachainStaking TotalSelected (r:1 w:1) + /// Proof Skipped: ParachainStaking TotalSelected (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: ParachainStaking Round (r:1 w:0) + /// Proof Skipped: ParachainStaking Round (max_values: Some(1), max_size: None, mode: Measured) + fn set_total_selected() -> Weight { + // Proof Size summary in bytes: + // Measured: `442` + // Estimated: `1927` + // Minimum execution time: 20_390_000 picoseconds. + Weight::from_parts(20_843_000, 0) + .saturating_add(Weight::from_parts(0, 1927)) + .saturating_add(T::DbWeight::get().reads(2)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: ParachainStaking CollatorCommission (r:1 w:1) + /// Proof Skipped: ParachainStaking CollatorCommission (max_values: Some(1), max_size: None, mode: Measured) + fn set_collator_commission() -> Weight { + // Proof Size summary in bytes: + // Measured: `405` + // Estimated: `1890` + // Minimum execution time: 17_496_000 picoseconds. + Weight::from_parts(18_022_000, 0) + .saturating_add(Weight::from_parts(0, 1890)) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: ParachainStaking Round (r:1 w:1) + /// Proof Skipped: ParachainStaking Round (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: ParachainStaking TotalSelected (r:1 w:0) + /// Proof Skipped: ParachainStaking TotalSelected (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: ParachainStaking InflationConfig (r:1 w:1) + /// Proof Skipped: ParachainStaking InflationConfig (max_values: Some(1), max_size: None, mode: Measured) + fn set_blocks_per_round() -> Weight { + // Proof Size summary in bytes: + // Measured: `530` + // Estimated: `2015` + // Minimum execution time: 28_375_000 picoseconds. + Weight::from_parts(29_217_000, 0) + .saturating_add(Weight::from_parts(0, 2015)) + .saturating_add(T::DbWeight::get().reads(3)) + .saturating_add(T::DbWeight::get().writes(2)) + } + /// Storage: ParachainStaking Candidates (r:1 w:0) + /// Proof Skipped: ParachainStaking Candidates (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: ParachainStaking CandidateInfo (r:1 w:1) + /// Proof Skipped: ParachainStaking CandidateInfo (max_values: None, max_size: None, mode: Measured) + /// Storage: ParachainStaking DelegatorState (r:1 w:0) + /// Proof Skipped: ParachainStaking DelegatorState (max_values: None, max_size: None, mode: Measured) + /// Storage: ParachainStaking CandidatePool (r:1 w:1) + /// Proof Skipped: ParachainStaking CandidatePool (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: System Account (r:1 w:1) + /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + /// Storage: ParachainStaking Total (r:1 w:1) + /// Proof Skipped: ParachainStaking Total (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: ParachainStaking TopDelegations (r:0 w:1) + /// Proof Skipped: ParachainStaking TopDelegations (max_values: None, max_size: None, mode: Measured) + /// Storage: ParachainStaking BottomDelegations (r:0 w:1) + /// Proof Skipped: ParachainStaking BottomDelegations (max_values: None, max_size: None, mode: Measured) + /// The range of component `x` is `[3, 1000]`. + fn join_candidates(x: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `1512 + x * (80 ±0)` + // Estimated: `4815 + x * (81 ±0)` + // Minimum execution time: 69_450_000 picoseconds. + Weight::from_parts(79_683_069, 0) + .saturating_add(Weight::from_parts(0, 4815)) + // Standard Error: 3_397 + .saturating_add(Weight::from_parts(244_217, 0).saturating_mul(x.into())) + .saturating_add(T::DbWeight::get().reads(6)) + .saturating_add(T::DbWeight::get().writes(6)) + .saturating_add(Weight::from_parts(0, 81).saturating_mul(x.into())) + } + /// Storage: ParachainStaking CandidateInfo (r:1 w:1) + /// Proof Skipped: ParachainStaking CandidateInfo (max_values: None, max_size: None, mode: Measured) + /// Storage: ParachainStaking Round (r:1 w:0) + /// Proof Skipped: ParachainStaking Round (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: ParachainStaking CandidatePool (r:1 w:1) + /// Proof Skipped: ParachainStaking CandidatePool (max_values: Some(1), max_size: None, mode: Measured) + /// The range of component `x` is `[3, 1000]`. + fn schedule_leave_candidates(x: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `1327 + x * (48 ±0)` + // Estimated: `4691 + x * (49 ±0)` + // Minimum execution time: 34_474_000 picoseconds. + Weight::from_parts(41_039_462, 0) + .saturating_add(Weight::from_parts(0, 4691)) + // Standard Error: 3_343 + .saturating_add(Weight::from_parts(168_119, 0).saturating_mul(x.into())) + .saturating_add(T::DbWeight::get().reads(3)) + .saturating_add(T::DbWeight::get().writes(2)) + .saturating_add(Weight::from_parts(0, 49).saturating_mul(x.into())) + } + /// Storage: ParachainStaking CandidateInfo (r:1 w:1) + /// Proof Skipped: ParachainStaking CandidateInfo (max_values: None, max_size: None, mode: Measured) + /// Storage: ParachainStaking Round (r:1 w:0) + /// Proof Skipped: ParachainStaking Round (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: ParachainStaking TopDelegations (r:1 w:1) + /// Proof Skipped: ParachainStaking TopDelegations (max_values: None, max_size: None, mode: Measured) + /// Storage: System Account (r:1200 w:1200) + /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + /// Storage: ParachainStaking DelegatorState (r:1199 w:1199) + /// Proof Skipped: ParachainStaking DelegatorState (max_values: None, max_size: None, mode: Measured) + /// Storage: ParachainStaking DelegationScheduledRequests (r:1 w:1) + /// Proof Skipped: ParachainStaking DelegationScheduledRequests (max_values: None, max_size: None, mode: Measured) + /// Storage: ParachainStaking AutoCompoundingDelegations (r:1 w:1) + /// Proof Skipped: ParachainStaking AutoCompoundingDelegations (max_values: None, max_size: None, mode: Measured) + /// Storage: ParachainStaking BottomDelegations (r:1 w:1) + /// Proof Skipped: ParachainStaking BottomDelegations (max_values: None, max_size: None, mode: Measured) + /// Storage: ParachainStaking Total (r:1 w:1) + /// Proof Skipped: ParachainStaking Total (max_values: Some(1), max_size: None, mode: Measured) + /// The range of component `x` is `[2, 1200]`. + fn execute_leave_candidates(x: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `469 + x * (447 ±0)` + // Estimated: `5094 + x * (2915 ±0)` + // Minimum execution time: 128_571_000 picoseconds. + Weight::from_parts(131_137_000, 0) + .saturating_add(Weight::from_parts(0, 5094)) + // Standard Error: 941_692 + .saturating_add(Weight::from_parts(74_880_071, 0).saturating_mul(x.into())) + .saturating_add(T::DbWeight::get().reads(6)) + .saturating_add(T::DbWeight::get().reads((2_u64).saturating_mul(x.into()))) + .saturating_add(T::DbWeight::get().writes(5)) + .saturating_add(T::DbWeight::get().writes((2_u64).saturating_mul(x.into()))) + .saturating_add(Weight::from_parts(0, 2915).saturating_mul(x.into())) + } + /// Storage: ParachainStaking CandidateInfo (r:1 w:1) + /// Proof Skipped: ParachainStaking CandidateInfo (max_values: None, max_size: None, mode: Measured) + /// Storage: ParachainStaking CandidatePool (r:1 w:1) + /// Proof Skipped: ParachainStaking CandidatePool (max_values: Some(1), max_size: None, mode: Measured) + /// The range of component `x` is `[3, 1000]`. + fn cancel_leave_candidates(x: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `1247 + x * (48 ±0)` + // Estimated: `4611 + x * (49 ±0)` + // Minimum execution time: 30_835_000 picoseconds. + Weight::from_parts(37_764_708, 0) + .saturating_add(Weight::from_parts(0, 4611)) + // Standard Error: 2_813 + .saturating_add(Weight::from_parts(176_901, 0).saturating_mul(x.into())) + .saturating_add(T::DbWeight::get().reads(2)) + .saturating_add(T::DbWeight::get().writes(2)) + .saturating_add(Weight::from_parts(0, 49).saturating_mul(x.into())) + } + /// Storage: ParachainStaking CandidateInfo (r:1 w:1) + /// Proof Skipped: ParachainStaking CandidateInfo (max_values: None, max_size: None, mode: Measured) + /// Storage: ParachainStaking CandidatePool (r:1 w:1) + /// Proof Skipped: ParachainStaking CandidatePool (max_values: Some(1), max_size: None, mode: Measured) + fn go_offline() -> Weight { + // Proof Size summary in bytes: + // Measured: `686` + // Estimated: `4151` + // Minimum execution time: 29_940_000 picoseconds. + Weight::from_parts(30_604_000, 0) + .saturating_add(Weight::from_parts(0, 4151)) + .saturating_add(T::DbWeight::get().reads(2)) + .saturating_add(T::DbWeight::get().writes(2)) + } + /// Storage: ParachainStaking CandidateInfo (r:1 w:1) + /// Proof Skipped: ParachainStaking CandidateInfo (max_values: None, max_size: None, mode: Measured) + /// Storage: ParachainStaking CandidatePool (r:1 w:1) + /// Proof Skipped: ParachainStaking CandidatePool (max_values: Some(1), max_size: None, mode: Measured) + fn go_online() -> Weight { + // Proof Size summary in bytes: + // Measured: `637` + // Estimated: `4102` + // Minimum execution time: 29_182_000 picoseconds. + Weight::from_parts(29_953_000, 0) + .saturating_add(Weight::from_parts(0, 4102)) + .saturating_add(T::DbWeight::get().reads(2)) + .saturating_add(T::DbWeight::get().writes(2)) + } + /// Storage: ParachainStaking CandidateInfo (r:1 w:1) + /// Proof Skipped: ParachainStaking CandidateInfo (max_values: None, max_size: None, mode: Measured) + /// Storage: System Account (r:1 w:1) + /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + /// Storage: ParachainStaking Total (r:1 w:1) + /// Proof Skipped: ParachainStaking Total (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: ParachainStaking CandidatePool (r:1 w:1) + /// Proof Skipped: ParachainStaking CandidatePool (max_values: Some(1), max_size: None, mode: Measured) + fn candidate_bond_more() -> Weight { + // Proof Size summary in bytes: + // Measured: `829` + // Estimated: `4294` + // Minimum execution time: 53_816_000 picoseconds. + Weight::from_parts(54_568_000, 0) + .saturating_add(Weight::from_parts(0, 4294)) + .saturating_add(T::DbWeight::get().reads(4)) + .saturating_add(T::DbWeight::get().writes(4)) + } + /// Storage: ParachainStaking CandidateInfo (r:1 w:1) + /// Proof Skipped: ParachainStaking CandidateInfo (max_values: None, max_size: None, mode: Measured) + /// Storage: ParachainStaking Round (r:1 w:0) + /// Proof Skipped: ParachainStaking Round (max_values: Some(1), max_size: None, mode: Measured) + fn schedule_candidate_bond_less() -> Weight { + // Proof Size summary in bytes: + // Measured: `598` + // Estimated: `4063` + // Minimum execution time: 27_495_000 picoseconds. + Weight::from_parts(28_152_000, 0) + .saturating_add(Weight::from_parts(0, 4063)) + .saturating_add(T::DbWeight::get().reads(2)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: ParachainStaking CandidateInfo (r:1 w:1) + /// Proof Skipped: ParachainStaking CandidateInfo (max_values: None, max_size: None, mode: Measured) + /// Storage: ParachainStaking Round (r:1 w:0) + /// Proof Skipped: ParachainStaking Round (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: System Account (r:1 w:1) + /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + /// Storage: ParachainStaking Total (r:1 w:1) + /// Proof Skipped: ParachainStaking Total (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: ParachainStaking CandidatePool (r:1 w:1) + /// Proof Skipped: ParachainStaking CandidatePool (max_values: Some(1), max_size: None, mode: Measured) + fn execute_candidate_bond_less() -> Weight { + // Proof Size summary in bytes: + // Measured: `918` + // Estimated: `4383` + // Minimum execution time: 68_836_000 picoseconds. + Weight::from_parts(78_824_000, 0) + .saturating_add(Weight::from_parts(0, 4383)) + .saturating_add(T::DbWeight::get().reads(5)) + .saturating_add(T::DbWeight::get().writes(4)) + } + /// Storage: ParachainStaking CandidateInfo (r:1 w:1) + /// Proof Skipped: ParachainStaking CandidateInfo (max_values: None, max_size: None, mode: Measured) + fn cancel_candidate_bond_less() -> Weight { + // Proof Size summary in bytes: + // Measured: `582` + // Estimated: `4047` + // Minimum execution time: 23_222_000 picoseconds. + Weight::from_parts(23_888_000, 0) + .saturating_add(Weight::from_parts(0, 4047)) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: ParachainStaking DelegatorState (r:1 w:1) + /// Proof Skipped: ParachainStaking DelegatorState (max_values: None, max_size: None, mode: Measured) + /// Storage: ParachainStaking Round (r:1 w:0) + /// Proof Skipped: ParachainStaking Round (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: ParachainStaking DelegationScheduledRequests (r:1 w:1) + /// Proof Skipped: ParachainStaking DelegationScheduledRequests (max_values: None, max_size: None, mode: Measured) + fn schedule_leave_delegators() -> Weight { + // Proof Size summary in bytes: + // Measured: `595` + // Estimated: `4060` + // Minimum execution time: 32_704_000 picoseconds. + Weight::from_parts(33_765_000, 0) + .saturating_add(Weight::from_parts(0, 4060)) + .saturating_add(T::DbWeight::get().reads(3)) + .saturating_add(T::DbWeight::get().writes(2)) + } + /// Storage: ParachainStaking DelegatorState (r:1 w:1) + /// Proof Skipped: ParachainStaking DelegatorState (max_values: None, max_size: None, mode: Measured) + /// Storage: ParachainStaking Round (r:1 w:0) + /// Proof Skipped: ParachainStaking Round (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: ParachainStaking DelegationScheduledRequests (r:99 w:99) + /// Proof Skipped: ParachainStaking DelegationScheduledRequests (max_values: None, max_size: None, mode: Measured) + /// Storage: ParachainStaking CandidateInfo (r:99 w:99) + /// Proof Skipped: ParachainStaking CandidateInfo (max_values: None, max_size: None, mode: Measured) + /// Storage: ParachainStaking TopDelegations (r:99 w:99) + /// Proof Skipped: ParachainStaking TopDelegations (max_values: None, max_size: None, mode: Measured) + /// Storage: ParachainStaking CandidatePool (r:1 w:1) + /// Proof Skipped: ParachainStaking CandidatePool (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: System Account (r:1 w:1) + /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + /// Storage: ParachainStaking Total (r:1 w:1) + /// Proof Skipped: ParachainStaking Total (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: ParachainStaking AutoCompoundingDelegations (r:99 w:0) + /// Proof Skipped: ParachainStaking AutoCompoundingDelegations (max_values: None, max_size: None, mode: Measured) + /// The range of component `x` is `[2, 100]`. + fn execute_leave_delegators(x: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `842 + x * (458 ±0)` + // Estimated: `4895 + x * (2852 ±0)` + // Minimum execution time: 107_084_000 picoseconds. + Weight::from_parts(110_608_000, 0) + .saturating_add(Weight::from_parts(0, 4895)) + // Standard Error: 249_345 + .saturating_add(Weight::from_parts(49_492_618, 0).saturating_mul(x.into())) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().reads((4_u64).saturating_mul(x.into()))) + .saturating_add(T::DbWeight::get().writes(1)) + .saturating_add(T::DbWeight::get().writes((3_u64).saturating_mul(x.into()))) + .saturating_add(Weight::from_parts(0, 2852).saturating_mul(x.into())) + } + /// Storage: ParachainStaking DelegatorState (r:1 w:1) + /// Proof Skipped: ParachainStaking DelegatorState (max_values: None, max_size: None, mode: Measured) + /// Storage: ParachainStaking DelegationScheduledRequests (r:1 w:1) + /// Proof Skipped: ParachainStaking DelegationScheduledRequests (max_values: None, max_size: None, mode: Measured) + fn cancel_leave_delegators() -> Weight { + // Proof Size summary in bytes: + // Measured: `720` + // Estimated: `4185` + // Minimum execution time: 34_602_000 picoseconds. + Weight::from_parts(35_390_000, 0) + .saturating_add(Weight::from_parts(0, 4185)) + .saturating_add(T::DbWeight::get().reads(2)) + .saturating_add(T::DbWeight::get().writes(2)) + } + /// Storage: ParachainStaking DelegatorState (r:1 w:1) + /// Proof Skipped: ParachainStaking DelegatorState (max_values: None, max_size: None, mode: Measured) + /// Storage: ParachainStaking DelegationScheduledRequests (r:1 w:1) + /// Proof Skipped: ParachainStaking DelegationScheduledRequests (max_values: None, max_size: None, mode: Measured) + /// Storage: ParachainStaking Round (r:1 w:0) + /// Proof Skipped: ParachainStaking Round (max_values: Some(1), max_size: None, mode: Measured) + fn schedule_revoke_delegation() -> Weight { + // Proof Size summary in bytes: + // Measured: `595` + // Estimated: `4060` + // Minimum execution time: 33_224_000 picoseconds. + Weight::from_parts(36_404_000, 0) + .saturating_add(Weight::from_parts(0, 4060)) + .saturating_add(T::DbWeight::get().reads(3)) + .saturating_add(T::DbWeight::get().writes(2)) + } + /// Storage: ParachainStaking DelegationScheduledRequests (r:1 w:0) + /// Proof Skipped: ParachainStaking DelegationScheduledRequests (max_values: None, max_size: None, mode: Measured) + /// Storage: ParachainStaking DelegatorState (r:1 w:1) + /// Proof Skipped: ParachainStaking DelegatorState (max_values: None, max_size: None, mode: Measured) + /// Storage: ParachainStaking CandidateInfo (r:1 w:1) + /// Proof Skipped: ParachainStaking CandidateInfo (max_values: None, max_size: None, mode: Measured) + /// Storage: System Account (r:1 w:1) + /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + /// Storage: ParachainStaking TopDelegations (r:1 w:1) + /// Proof Skipped: ParachainStaking TopDelegations (max_values: None, max_size: None, mode: Measured) + /// Storage: ParachainStaking CandidatePool (r:1 w:1) + /// Proof Skipped: ParachainStaking CandidatePool (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: ParachainStaking Total (r:1 w:1) + /// Proof Skipped: ParachainStaking Total (max_values: Some(1), max_size: None, mode: Measured) + fn delegator_bond_more() -> Weight { + // Proof Size summary in bytes: + // Measured: `1217` + // Estimated: `4682` + // Minimum execution time: 79_647_000 picoseconds. + Weight::from_parts(81_615_000, 0) + .saturating_add(Weight::from_parts(0, 4682)) + .saturating_add(T::DbWeight::get().reads(7)) + .saturating_add(T::DbWeight::get().writes(6)) + } + /// Storage: ParachainStaking DelegatorState (r:1 w:1) + /// Proof Skipped: ParachainStaking DelegatorState (max_values: None, max_size: None, mode: Measured) + /// Storage: ParachainStaking DelegationScheduledRequests (r:1 w:1) + /// Proof Skipped: ParachainStaking DelegationScheduledRequests (max_values: None, max_size: None, mode: Measured) + /// Storage: ParachainStaking Round (r:1 w:0) + /// Proof Skipped: ParachainStaking Round (max_values: Some(1), max_size: None, mode: Measured) + fn schedule_delegator_bond_less() -> Weight { + // Proof Size summary in bytes: + // Measured: `595` + // Estimated: `4060` + // Minimum execution time: 32_901_000 picoseconds. + Weight::from_parts(34_138_000, 0) + .saturating_add(Weight::from_parts(0, 4060)) + .saturating_add(T::DbWeight::get().reads(3)) + .saturating_add(T::DbWeight::get().writes(2)) + } + /// Storage: ParachainStaking DelegatorState (r:1 w:1) + /// Proof Skipped: ParachainStaking DelegatorState (max_values: None, max_size: None, mode: Measured) + /// Storage: ParachainStaking DelegationScheduledRequests (r:1 w:1) + /// Proof Skipped: ParachainStaking DelegationScheduledRequests (max_values: None, max_size: None, mode: Measured) + /// Storage: ParachainStaking Round (r:1 w:0) + /// Proof Skipped: ParachainStaking Round (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: ParachainStaking AutoCompoundingDelegations (r:1 w:0) + /// Proof Skipped: ParachainStaking AutoCompoundingDelegations (max_values: None, max_size: None, mode: Measured) + /// Storage: ParachainStaking CandidateInfo (r:1 w:1) + /// Proof Skipped: ParachainStaking CandidateInfo (max_values: None, max_size: None, mode: Measured) + /// Storage: ParachainStaking TopDelegations (r:1 w:1) + /// Proof Skipped: ParachainStaking TopDelegations (max_values: None, max_size: None, mode: Measured) + /// Storage: ParachainStaking CandidatePool (r:1 w:1) + /// Proof Skipped: ParachainStaking CandidatePool (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: System Account (r:1 w:1) + /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + /// Storage: ParachainStaking Total (r:1 w:1) + /// Proof Skipped: ParachainStaking Total (max_values: Some(1), max_size: None, mode: Measured) + fn execute_revoke_delegation() -> Weight { + // Proof Size summary in bytes: + // Measured: `1430` + // Estimated: `4895` + // Minimum execution time: 110_571_000 picoseconds. + Weight::from_parts(119_690_000, 0) + .saturating_add(Weight::from_parts(0, 4895)) + .saturating_add(T::DbWeight::get().reads(9)) + .saturating_add(T::DbWeight::get().writes(7)) + } + /// Storage: ParachainStaking DelegatorState (r:1 w:1) + /// Proof Skipped: ParachainStaking DelegatorState (max_values: None, max_size: None, mode: Measured) + /// Storage: ParachainStaking DelegationScheduledRequests (r:1 w:1) + /// Proof Skipped: ParachainStaking DelegationScheduledRequests (max_values: None, max_size: None, mode: Measured) + /// Storage: ParachainStaking Round (r:1 w:0) + /// Proof Skipped: ParachainStaking Round (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: ParachainStaking CandidateInfo (r:1 w:1) + /// Proof Skipped: ParachainStaking CandidateInfo (max_values: None, max_size: None, mode: Measured) + /// Storage: System Account (r:1 w:1) + /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + /// Storage: ParachainStaking TopDelegations (r:1 w:1) + /// Proof Skipped: ParachainStaking TopDelegations (max_values: None, max_size: None, mode: Measured) + /// Storage: ParachainStaking CandidatePool (r:1 w:1) + /// Proof Skipped: ParachainStaking CandidatePool (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: ParachainStaking Total (r:1 w:1) + /// Proof Skipped: ParachainStaking Total (max_values: Some(1), max_size: None, mode: Measured) + fn execute_delegator_bond_less() -> Weight { + // Proof Size summary in bytes: + // Measured: `1375` + // Estimated: `4840` + // Minimum execution time: 95_049_000 picoseconds. + Weight::from_parts(102_650_000, 0) + .saturating_add(Weight::from_parts(0, 4840)) + .saturating_add(T::DbWeight::get().reads(8)) + .saturating_add(T::DbWeight::get().writes(7)) + } + /// Storage: ParachainStaking DelegatorState (r:1 w:1) + /// Proof Skipped: ParachainStaking DelegatorState (max_values: None, max_size: None, mode: Measured) + /// Storage: ParachainStaking DelegationScheduledRequests (r:1 w:1) + /// Proof Skipped: ParachainStaking DelegationScheduledRequests (max_values: None, max_size: None, mode: Measured) + fn cancel_revoke_delegation() -> Weight { + // Proof Size summary in bytes: + // Measured: `720` + // Estimated: `4185` + // Minimum execution time: 31_569_000 picoseconds. + Weight::from_parts(32_404_000, 0) + .saturating_add(Weight::from_parts(0, 4185)) + .saturating_add(T::DbWeight::get().reads(2)) + .saturating_add(T::DbWeight::get().writes(2)) + } + /// Storage: ParachainStaking DelegatorState (r:1 w:1) + /// Proof Skipped: ParachainStaking DelegatorState (max_values: None, max_size: None, mode: Measured) + /// Storage: ParachainStaking DelegationScheduledRequests (r:1 w:1) + /// Proof Skipped: ParachainStaking DelegationScheduledRequests (max_values: None, max_size: None, mode: Measured) + fn cancel_delegator_bond_less() -> Weight { + // Proof Size summary in bytes: + // Measured: `753` + // Estimated: `4218` + // Minimum execution time: 37_328_000 picoseconds. + Weight::from_parts(39_282_000, 0) + .saturating_add(Weight::from_parts(0, 4218)) + .saturating_add(T::DbWeight::get().reads(2)) + .saturating_add(T::DbWeight::get().writes(2)) + } + /// Storage: ParachainStaking Round (r:1 w:1) + /// Proof Skipped: ParachainStaking Round (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: ParachainStaking Points (r:1 w:0) + /// Proof Skipped: ParachainStaking Points (max_values: None, max_size: None, mode: Measured) + /// Storage: ParachainStaking Staked (r:1 w:2) + /// Proof Skipped: ParachainStaking Staked (max_values: None, max_size: None, mode: Measured) + /// Storage: ParachainStaking InflationConfig (r:1 w:0) + /// Proof Skipped: ParachainStaking InflationConfig (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: BridgeTransfer ExternalBalances (r:1 w:0) + /// Proof Skipped: BridgeTransfer ExternalBalances (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: ParachainStaking ParachainBondInfo (r:1 w:0) + /// Proof Skipped: ParachainStaking ParachainBondInfo (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: ParachainStaking CollatorCommission (r:1 w:0) + /// Proof Skipped: ParachainStaking CollatorCommission (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: ParachainStaking CandidatePool (r:1 w:0) + /// Proof Skipped: ParachainStaking CandidatePool (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: ParachainStaking TotalSelected (r:1 w:0) + /// Proof Skipped: ParachainStaking TotalSelected (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: ParachainStaking CandidateInfo (r:99 w:0) + /// Proof Skipped: ParachainStaking CandidateInfo (max_values: None, max_size: None, mode: Measured) + /// Storage: ParachainStaking DelegationScheduledRequests (r:99 w:0) + /// Proof Skipped: ParachainStaking DelegationScheduledRequests (max_values: None, max_size: None, mode: Measured) + /// Storage: ParachainStaking TopDelegations (r:99 w:0) + /// Proof Skipped: ParachainStaking TopDelegations (max_values: None, max_size: None, mode: Measured) + /// Storage: ParachainStaking AutoCompoundingDelegations (r:99 w:0) + /// Proof Skipped: ParachainStaking AutoCompoundingDelegations (max_values: None, max_size: None, mode: Measured) + /// Storage: ParachainStaking Total (r:1 w:0) + /// Proof Skipped: ParachainStaking Total (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: ParachainStaking AwardedPts (r:2 w:1) + /// Proof Skipped: ParachainStaking AwardedPts (max_values: None, max_size: None, mode: Measured) + /// Storage: ParachainStaking AtStake (r:1 w:100) + /// Proof Skipped: ParachainStaking AtStake (max_values: None, max_size: None, mode: Measured) + /// Storage: System Account (r:1 w:1) + /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + /// Storage: ParachainStaking SelectedCandidates (r:0 w:1) + /// Proof Skipped: ParachainStaking SelectedCandidates (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: ParachainStaking DelayedPayouts (r:0 w:1) + /// Proof Skipped: ParachainStaking DelayedPayouts (max_values: None, max_size: None, mode: Measured) + /// The range of component `x` is `[8, 100]`. + /// The range of component `y` is `[0, 5000]`. + fn round_transition_on_initialize(x: u32, y: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `4314 + x * (297 ±0) + y * (47 ±0)` + // Estimated: `519520 + x * (2390 ±43) + y * (46 ±0)` + // Minimum execution time: 1_115_440_000 picoseconds. + Weight::from_parts(5_542_981_467, 0) + .saturating_add(Weight::from_parts(0, 519520)) + .saturating_add(T::DbWeight::get().reads(214)) + .saturating_add(T::DbWeight::get().reads((2_u64).saturating_mul(x.into()))) + .saturating_add(T::DbWeight::get().writes(207)) + .saturating_add(Weight::from_parts(0, 2390).saturating_mul(x.into())) + .saturating_add(Weight::from_parts(0, 46).saturating_mul(y.into())) + } + /// Storage: ParachainStaking DelayedPayouts (r:1 w:0) + /// Proof Skipped: ParachainStaking DelayedPayouts (max_values: None, max_size: None, mode: Measured) + /// Storage: ParachainStaking Points (r:1 w:0) + /// Proof Skipped: ParachainStaking Points (max_values: None, max_size: None, mode: Measured) + /// Storage: ParachainStaking AwardedPts (r:2 w:1) + /// Proof Skipped: ParachainStaking AwardedPts (max_values: None, max_size: None, mode: Measured) + /// Storage: ParachainStaking AtStake (r:1 w:1) + /// Proof Skipped: ParachainStaking AtStake (max_values: None, max_size: None, mode: Measured) + /// Storage: System Account (r:1001 w:1001) + /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + /// The range of component `y` is `[0, 1000]`. + fn pay_one_collator_reward(y: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `399 + y * (185 ±0)` + // Estimated: `6424 + y * (2603 ±0)` + // Minimum execution time: 57_443_000 picoseconds. + Weight::from_parts(58_174_000, 0) + .saturating_add(Weight::from_parts(0, 6424)) + // Standard Error: 88_095 + .saturating_add(Weight::from_parts(24_777_782, 0).saturating_mul(y.into())) + .saturating_add(T::DbWeight::get().reads(6)) + .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(y.into()))) + .saturating_add(T::DbWeight::get().writes(3)) + .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(y.into()))) + .saturating_add(Weight::from_parts(0, 2603).saturating_mul(y.into())) + } + /// Storage: ParachainStaking Round (r:1 w:0) + /// Proof Skipped: ParachainStaking Round (max_values: Some(1), max_size: None, mode: Measured) + fn base_on_initialize() -> Weight { + // Proof Size summary in bytes: + // Measured: `447` + // Estimated: `1932` + // Minimum execution time: 7_210_000 picoseconds. + Weight::from_parts(7_485_000, 0) + .saturating_add(Weight::from_parts(0, 1932)) + .saturating_add(T::DbWeight::get().reads(1)) + } + /// Storage: ParachainStaking DelegatorState (r:1 w:0) + /// Proof Skipped: ParachainStaking DelegatorState (max_values: None, max_size: None, mode: Measured) + /// Storage: ParachainStaking AutoCompoundingDelegations (r:1 w:1) + /// Proof Skipped: ParachainStaking AutoCompoundingDelegations (max_values: None, max_size: None, mode: Measured) + /// The range of component `x` is `[0, 1000]`. + /// The range of component `y` is `[0, 100]`. + fn set_auto_compound(x: u32, y: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `1273 + x * (33 ±0) + y * (48 ±0)` + // Estimated: `4574 + x * (34 ±0) + y * (49 ±0)` + // Minimum execution time: 55_958_000 picoseconds. + Weight::from_parts(77_348_747, 0) + .saturating_add(Weight::from_parts(0, 4574)) + // Standard Error: 2_370 + .saturating_add(Weight::from_parts(122_993, 0).saturating_mul(x.into())) + .saturating_add(T::DbWeight::get().reads(2)) + .saturating_add(T::DbWeight::get().writes(1)) + .saturating_add(Weight::from_parts(0, 34).saturating_mul(x.into())) + .saturating_add(Weight::from_parts(0, 49).saturating_mul(y.into())) + } + /// Storage: System Account (r:1 w:1) + /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + /// Storage: ParachainStaking DelegatorState (r:1 w:1) + /// Proof Skipped: ParachainStaking DelegatorState (max_values: None, max_size: None, mode: Measured) + /// Storage: ParachainStaking CandidateInfo (r:1 w:1) + /// Proof Skipped: ParachainStaking CandidateInfo (max_values: None, max_size: None, mode: Measured) + /// Storage: ParachainStaking AutoCompoundingDelegations (r:1 w:1) + /// Proof Skipped: ParachainStaking AutoCompoundingDelegations (max_values: None, max_size: None, mode: Measured) + /// Storage: ParachainStaking BottomDelegations (r:1 w:1) + /// Proof Skipped: ParachainStaking BottomDelegations (max_values: None, max_size: None, mode: Measured) + /// Storage: ParachainStaking Total (r:1 w:1) + /// Proof Skipped: ParachainStaking Total (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: ParachainStaking TopDelegations (r:1 w:1) + /// Proof Skipped: ParachainStaking TopDelegations (max_values: None, max_size: None, mode: Measured) + /// Storage: ParachainStaking CandidatePool (r:1 w:1) + /// Proof Skipped: ParachainStaking CandidatePool (max_values: Some(1), max_size: None, mode: Measured) + /// The range of component `x` is `[0, 1200]`. + /// The range of component `y` is `[0, 1200]`. + /// The range of component `z` is `[0, 100]`. + fn delegate_with_auto_compound(x: u32, y: u32, z: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0 + x * (81 ±0) + y * (33 ±0) + z * (55 ±0)` + // Estimated: `21773 + x * (82 ±0) + y * (31 ±0) + z * (29 ±0)` + // Minimum execution time: 131_239_000 picoseconds. + Weight::from_parts(135_171_000, 0) + .saturating_add(Weight::from_parts(0, 21773)) + // Standard Error: 2_862 + .saturating_add(Weight::from_parts(71_798, 0).saturating_mul(x.into())) + // Standard Error: 2_862 + .saturating_add(Weight::from_parts(94_592, 0).saturating_mul(y.into())) + .saturating_add(T::DbWeight::get().reads(7)) + .saturating_add(T::DbWeight::get().writes(7)) + .saturating_add(Weight::from_parts(0, 82).saturating_mul(x.into())) + .saturating_add(Weight::from_parts(0, 31).saturating_mul(y.into())) + .saturating_add(Weight::from_parts(0, 29).saturating_mul(z.into())) + } +} diff --git a/runtime/paseo/src/weights/pallet_preimage.rs b/runtime/paseo/src/weights/pallet_preimage.rs new file mode 100644 index 0000000000..967472a8e9 --- /dev/null +++ b/runtime/paseo/src/weights/pallet_preimage.rs @@ -0,0 +1,217 @@ +// Copyright 2020-2024 Trust Computing GmbH. +// This file is part of Litentry. +// +// Litentry is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Litentry 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 +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Litentry. If not, see . + +//! Autogenerated weights for `pallet_preimage` +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev +//! DATE: 2023-10-17, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! WORST CASE MAP SIZE: `1000000` +//! HOSTNAME: `parachain-benchmark`, CPU: `Intel(R) Xeon(R) Platinum 8259CL CPU @ 2.50GHz` +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("rococo-dev"), DB CACHE: 20 + +// Executed Command: +// ./litentry-collator +// benchmark +// pallet +// --chain=rococo-dev +// --execution=wasm +// --db-cache=20 +// --wasm-execution=compiled +// --pallet=pallet_preimage +// --extrinsic=* +// --heap-pages=4096 +// --steps=20 +// --repeat=50 +// --header=./LICENSE_HEADER +// --output=./runtime/rococo/src/weights/pallet_preimage.rs + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] +#![allow(missing_docs)] + +use frame_support::{traits::Get, weights::Weight}; +use core::marker::PhantomData; + +/// Weight functions for `pallet_preimage`. +pub struct WeightInfo(PhantomData); +impl pallet_preimage::WeightInfo for WeightInfo { + /// Storage: Preimage StatusFor (r:1 w:1) + /// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen) + /// Storage: Preimage PreimageFor (r:0 w:1) + /// Proof: Preimage PreimageFor (max_values: None, max_size: Some(4194344), added: 4196819, mode: MaxEncodedLen) + /// The range of component `s` is `[0, 4194304]`. + fn note_preimage(s: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `177` + // Estimated: `3556` + // Minimum execution time: 41_433_000 picoseconds. + Weight::from_parts(42_090_000, 0) + .saturating_add(Weight::from_parts(0, 3556)) + // Standard Error: 4 + .saturating_add(Weight::from_parts(3_458, 0).saturating_mul(s.into())) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(2)) + } + /// Storage: Preimage StatusFor (r:1 w:1) + /// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen) + /// Storage: Preimage PreimageFor (r:0 w:1) + /// Proof: Preimage PreimageFor (max_values: None, max_size: Some(4194344), added: 4196819, mode: MaxEncodedLen) + /// The range of component `s` is `[0, 4194304]`. + fn note_requested_preimage(s: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `140` + // Estimated: `3556` + // Minimum execution time: 23_563_000 picoseconds. + Weight::from_parts(23_826_000, 0) + .saturating_add(Weight::from_parts(0, 3556)) + // Standard Error: 9 + .saturating_add(Weight::from_parts(3_534, 0).saturating_mul(s.into())) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(2)) + } + /// Storage: Preimage StatusFor (r:1 w:1) + /// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen) + /// Storage: Preimage PreimageFor (r:0 w:1) + /// Proof: Preimage PreimageFor (max_values: None, max_size: Some(4194344), added: 4196819, mode: MaxEncodedLen) + /// The range of component `s` is `[0, 4194304]`. + fn note_no_deposit_preimage(s: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `140` + // Estimated: `3556` + // Minimum execution time: 22_126_000 picoseconds. + Weight::from_parts(22_630_000, 0) + .saturating_add(Weight::from_parts(0, 3556)) + // Standard Error: 7 + .saturating_add(Weight::from_parts(3_475, 0).saturating_mul(s.into())) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(2)) + } + /// Storage: Preimage StatusFor (r:1 w:1) + /// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen) + /// Storage: Preimage PreimageFor (r:0 w:1) + /// Proof: Preimage PreimageFor (max_values: None, max_size: Some(4194344), added: 4196819, mode: MaxEncodedLen) + fn unnote_preimage() -> Weight { + // Proof Size summary in bytes: + // Measured: `323` + // Estimated: `3556` + // Minimum execution time: 77_583_000 picoseconds. + Weight::from_parts(82_134_000, 0) + .saturating_add(Weight::from_parts(0, 3556)) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(2)) + } + /// Storage: Preimage StatusFor (r:1 w:1) + /// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen) + /// Storage: Preimage PreimageFor (r:0 w:1) + /// Proof: Preimage PreimageFor (max_values: None, max_size: Some(4194344), added: 4196819, mode: MaxEncodedLen) + fn unnote_no_deposit_preimage() -> Weight { + // Proof Size summary in bytes: + // Measured: `178` + // Estimated: `3556` + // Minimum execution time: 54_470_000 picoseconds. + Weight::from_parts(58_016_000, 0) + .saturating_add(Weight::from_parts(0, 3556)) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(2)) + } + /// Storage: Preimage StatusFor (r:1 w:1) + /// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen) + fn request_preimage() -> Weight { + // Proof Size summary in bytes: + // Measured: `222` + // Estimated: `3556` + // Minimum execution time: 48_971_000 picoseconds. + Weight::from_parts(53_088_000, 0) + .saturating_add(Weight::from_parts(0, 3556)) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: Preimage StatusFor (r:1 w:1) + /// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen) + fn request_no_deposit_preimage() -> Weight { + // Proof Size summary in bytes: + // Measured: `178` + // Estimated: `3556` + // Minimum execution time: 34_485_000 picoseconds. + Weight::from_parts(37_286_000, 0) + .saturating_add(Weight::from_parts(0, 3556)) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: Preimage StatusFor (r:1 w:1) + /// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen) + fn request_unnoted_preimage() -> Weight { + // Proof Size summary in bytes: + // Measured: `76` + // Estimated: `3556` + // Minimum execution time: 40_145_000 picoseconds. + Weight::from_parts(43_200_000, 0) + .saturating_add(Weight::from_parts(0, 3556)) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: Preimage StatusFor (r:1 w:1) + /// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen) + fn request_requested_preimage() -> Weight { + // Proof Size summary in bytes: + // Measured: `140` + // Estimated: `3556` + // Minimum execution time: 19_404_000 picoseconds. + Weight::from_parts(21_866_000, 0) + .saturating_add(Weight::from_parts(0, 3556)) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: Preimage StatusFor (r:1 w:1) + /// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen) + /// Storage: Preimage PreimageFor (r:0 w:1) + /// Proof: Preimage PreimageFor (max_values: None, max_size: Some(4194344), added: 4196819, mode: MaxEncodedLen) + fn unrequest_preimage() -> Weight { + // Proof Size summary in bytes: + // Measured: `178` + // Estimated: `3556` + // Minimum execution time: 51_315_000 picoseconds. + Weight::from_parts(55_663_000, 0) + .saturating_add(Weight::from_parts(0, 3556)) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(2)) + } + /// Storage: Preimage StatusFor (r:1 w:1) + /// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen) + fn unrequest_unnoted_preimage() -> Weight { + // Proof Size summary in bytes: + // Measured: `140` + // Estimated: `3556` + // Minimum execution time: 18_755_000 picoseconds. + Weight::from_parts(21_083_000, 0) + .saturating_add(Weight::from_parts(0, 3556)) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: Preimage StatusFor (r:1 w:1) + /// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen) + fn unrequest_multi_referenced_preimage() -> Weight { + // Proof Size summary in bytes: + // Measured: `140` + // Estimated: `3556` + // Minimum execution time: 18_516_000 picoseconds. + Weight::from_parts(19_962_000, 0) + .saturating_add(Weight::from_parts(0, 3556)) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(1)) + } +} diff --git a/runtime/paseo/src/weights/pallet_proxy.rs b/runtime/paseo/src/weights/pallet_proxy.rs new file mode 100644 index 0000000000..56a78bd262 --- /dev/null +++ b/runtime/paseo/src/weights/pallet_proxy.rs @@ -0,0 +1,225 @@ +// Copyright 2020-2024 Trust Computing GmbH. +// This file is part of Litentry. +// +// Litentry is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Litentry 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 +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Litentry. If not, see . + +//! Autogenerated weights for `pallet_proxy` +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev +//! DATE: 2023-10-17, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! WORST CASE MAP SIZE: `1000000` +//! HOSTNAME: `parachain-benchmark`, CPU: `Intel(R) Xeon(R) Platinum 8259CL CPU @ 2.50GHz` +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("rococo-dev"), DB CACHE: 20 + +// Executed Command: +// ./litentry-collator +// benchmark +// pallet +// --chain=rococo-dev +// --execution=wasm +// --db-cache=20 +// --wasm-execution=compiled +// --pallet=pallet_proxy +// --extrinsic=* +// --heap-pages=4096 +// --steps=20 +// --repeat=50 +// --header=./LICENSE_HEADER +// --output=./runtime/rococo/src/weights/pallet_proxy.rs + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] +#![allow(missing_docs)] + +use frame_support::{traits::Get, weights::Weight}; +use core::marker::PhantomData; + +/// Weight functions for `pallet_proxy`. +pub struct WeightInfo(PhantomData); +impl pallet_proxy::WeightInfo for WeightInfo { + /// Storage: Proxy Proxies (r:1 w:0) + /// Proof: Proxy Proxies (max_values: None, max_size: Some(1241), added: 3716, mode: MaxEncodedLen) + /// The range of component `p` is `[1, 31]`. + fn proxy(p: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `161 + p * (37 ±0)` + // Estimated: `4706` + // Minimum execution time: 21_822_000 picoseconds. + Weight::from_parts(24_219_925, 0) + .saturating_add(Weight::from_parts(0, 4706)) + // Standard Error: 7_971 + .saturating_add(Weight::from_parts(929, 0).saturating_mul(p.into())) + .saturating_add(T::DbWeight::get().reads(1)) + } + /// Storage: Proxy Proxies (r:1 w:0) + /// Proof: Proxy Proxies (max_values: None, max_size: Some(1241), added: 3716, mode: MaxEncodedLen) + /// Storage: Proxy Announcements (r:1 w:1) + /// Proof: Proxy Announcements (max_values: None, max_size: Some(2233), added: 4708, mode: MaxEncodedLen) + /// Storage: System Account (r:1 w:1) + /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + /// The range of component `a` is `[0, 31]`. + /// The range of component `p` is `[1, 31]`. + fn proxy_announced(a: u32, p: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `451 + a * (68 ±0) + p * (37 ±0)` + // Estimated: `5698` + // Minimum execution time: 50_263_000 picoseconds. + Weight::from_parts(48_891_760, 0) + .saturating_add(Weight::from_parts(0, 5698)) + // Standard Error: 10_810 + .saturating_add(Weight::from_parts(274_273, 0).saturating_mul(a.into())) + // Standard Error: 11_177 + .saturating_add(Weight::from_parts(107_749, 0).saturating_mul(p.into())) + .saturating_add(T::DbWeight::get().reads(3)) + .saturating_add(T::DbWeight::get().writes(2)) + } + /// Storage: Proxy Announcements (r:1 w:1) + /// Proof: Proxy Announcements (max_values: None, max_size: Some(2233), added: 4708, mode: MaxEncodedLen) + /// Storage: System Account (r:1 w:1) + /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + /// The range of component `a` is `[0, 31]`. + /// The range of component `p` is `[1, 31]`. + fn remove_announcement(a: u32, p: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `366 + a * (68 ±0)` + // Estimated: `5698` + // Minimum execution time: 32_330_000 picoseconds. + Weight::from_parts(35_755_184, 0) + .saturating_add(Weight::from_parts(0, 5698)) + // Standard Error: 8_423 + .saturating_add(Weight::from_parts(107_724, 0).saturating_mul(a.into())) + // Standard Error: 8_709 + .saturating_add(Weight::from_parts(11_662, 0).saturating_mul(p.into())) + .saturating_add(T::DbWeight::get().reads(2)) + .saturating_add(T::DbWeight::get().writes(2)) + } + /// Storage: Proxy Announcements (r:1 w:1) + /// Proof: Proxy Announcements (max_values: None, max_size: Some(2233), added: 4708, mode: MaxEncodedLen) + /// Storage: System Account (r:1 w:1) + /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + /// The range of component `a` is `[0, 31]`. + /// The range of component `p` is `[1, 31]`. + fn reject_announcement(a: u32, p: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `366 + a * (68 ±0)` + // Estimated: `5698` + // Minimum execution time: 32_899_000 picoseconds. + Weight::from_parts(33_709_865, 0) + .saturating_add(Weight::from_parts(0, 5698)) + // Standard Error: 6_137 + .saturating_add(Weight::from_parts(178_682, 0).saturating_mul(a.into())) + // Standard Error: 6_346 + .saturating_add(Weight::from_parts(26_520, 0).saturating_mul(p.into())) + .saturating_add(T::DbWeight::get().reads(2)) + .saturating_add(T::DbWeight::get().writes(2)) + } + /// Storage: Proxy Proxies (r:1 w:0) + /// Proof: Proxy Proxies (max_values: None, max_size: Some(1241), added: 3716, mode: MaxEncodedLen) + /// Storage: Proxy Announcements (r:1 w:1) + /// Proof: Proxy Announcements (max_values: None, max_size: Some(2233), added: 4708, mode: MaxEncodedLen) + /// Storage: System Account (r:1 w:1) + /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + /// The range of component `a` is `[0, 31]`. + /// The range of component `p` is `[1, 31]`. + fn announce(a: u32, p: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `383 + a * (68 ±0) + p * (37 ±0)` + // Estimated: `5698` + // Minimum execution time: 45_300_000 picoseconds. + Weight::from_parts(44_589_976, 0) + .saturating_add(Weight::from_parts(0, 5698)) + // Standard Error: 8_943 + .saturating_add(Weight::from_parts(224_292, 0).saturating_mul(a.into())) + // Standard Error: 9_246 + .saturating_add(Weight::from_parts(79_467, 0).saturating_mul(p.into())) + .saturating_add(T::DbWeight::get().reads(3)) + .saturating_add(T::DbWeight::get().writes(2)) + } + /// Storage: Proxy Proxies (r:1 w:1) + /// Proof: Proxy Proxies (max_values: None, max_size: Some(1241), added: 3716, mode: MaxEncodedLen) + /// The range of component `p` is `[1, 31]`. + fn add_proxy(p: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `161 + p * (37 ±0)` + // Estimated: `4706` + // Minimum execution time: 33_880_000 picoseconds. + Weight::from_parts(35_554_943, 0) + .saturating_add(Weight::from_parts(0, 4706)) + // Standard Error: 6_212 + .saturating_add(Weight::from_parts(29_857, 0).saturating_mul(p.into())) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: Proxy Proxies (r:1 w:1) + /// Proof: Proxy Proxies (max_values: None, max_size: Some(1241), added: 3716, mode: MaxEncodedLen) + /// The range of component `p` is `[1, 31]`. + fn remove_proxy(p: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `161 + p * (37 ±0)` + // Estimated: `4706` + // Minimum execution time: 33_732_000 picoseconds. + Weight::from_parts(35_168_099, 0) + .saturating_add(Weight::from_parts(0, 4706)) + // Standard Error: 1_950 + .saturating_add(Weight::from_parts(46_083, 0).saturating_mul(p.into())) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: Proxy Proxies (r:1 w:1) + /// Proof: Proxy Proxies (max_values: None, max_size: Some(1241), added: 3716, mode: MaxEncodedLen) + /// The range of component `p` is `[1, 31]`. + fn remove_proxies(p: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `161 + p * (37 ±0)` + // Estimated: `4706` + // Minimum execution time: 29_415_000 picoseconds. + Weight::from_parts(31_124_083, 0) + .saturating_add(Weight::from_parts(0, 4706)) + // Standard Error: 3_457 + .saturating_add(Weight::from_parts(21_133, 0).saturating_mul(p.into())) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: Proxy Proxies (r:1 w:1) + /// Proof: Proxy Proxies (max_values: None, max_size: Some(1241), added: 3716, mode: MaxEncodedLen) + /// The range of component `p` is `[1, 31]`. + fn create_pure(p: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `173` + // Estimated: `4706` + // Minimum execution time: 36_274_000 picoseconds. + Weight::from_parts(37_226_498, 0) + .saturating_add(Weight::from_parts(0, 4706)) + // Standard Error: 5_148 + .saturating_add(Weight::from_parts(32_411, 0).saturating_mul(p.into())) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: Proxy Proxies (r:1 w:1) + /// Proof: Proxy Proxies (max_values: None, max_size: Some(1241), added: 3716, mode: MaxEncodedLen) + /// The range of component `p` is `[0, 30]`. + fn kill_pure(p: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `198 + p * (37 ±0)` + // Estimated: `4706` + // Minimum execution time: 31_134_000 picoseconds. + Weight::from_parts(31_461_750, 0) + .saturating_add(Weight::from_parts(0, 4706)) + // Standard Error: 13_764 + .saturating_add(Weight::from_parts(197_174, 0).saturating_mul(p.into())) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(1)) + } +} diff --git a/runtime/paseo/src/weights/pallet_scheduler.rs b/runtime/paseo/src/weights/pallet_scheduler.rs new file mode 100644 index 0000000000..cedb804851 --- /dev/null +++ b/runtime/paseo/src/weights/pallet_scheduler.rs @@ -0,0 +1,206 @@ +// Copyright 2020-2024 Trust Computing GmbH. +// This file is part of Litentry. +// +// Litentry is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Litentry 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 +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Litentry. If not, see . + +//! Autogenerated weights for `pallet_scheduler` +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev +//! DATE: 2023-10-17, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! WORST CASE MAP SIZE: `1000000` +//! HOSTNAME: `parachain-benchmark`, CPU: `Intel(R) Xeon(R) Platinum 8259CL CPU @ 2.50GHz` +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("rococo-dev"), DB CACHE: 20 + +// Executed Command: +// ./litentry-collator +// benchmark +// pallet +// --chain=rococo-dev +// --execution=wasm +// --db-cache=20 +// --wasm-execution=compiled +// --pallet=pallet_scheduler +// --extrinsic=* +// --heap-pages=4096 +// --steps=20 +// --repeat=50 +// --header=./LICENSE_HEADER +// --output=./runtime/rococo/src/weights/pallet_scheduler.rs + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] +#![allow(missing_docs)] + +use frame_support::{traits::Get, weights::Weight}; +use core::marker::PhantomData; + +/// Weight functions for `pallet_scheduler`. +pub struct WeightInfo(PhantomData); +impl pallet_scheduler::WeightInfo for WeightInfo { + /// Storage: Scheduler IncompleteSince (r:1 w:1) + /// Proof: Scheduler IncompleteSince (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen) + fn service_agendas_base() -> Weight { + // Proof Size summary in bytes: + // Measured: `31` + // Estimated: `1489` + // Minimum execution time: 5_456_000 picoseconds. + Weight::from_parts(5_680_000, 0) + .saturating_add(Weight::from_parts(0, 1489)) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: Scheduler Agenda (r:1 w:1) + /// Proof: Scheduler Agenda (max_values: None, max_size: Some(38963), added: 41438, mode: MaxEncodedLen) + /// The range of component `s` is `[0, 50]`. + fn service_agenda_base(s: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `78 + s * (177 ±0)` + // Estimated: `42428` + // Minimum execution time: 4_748_000 picoseconds. + Weight::from_parts(7_596_766, 0) + .saturating_add(Weight::from_parts(0, 42428)) + // Standard Error: 2_307 + .saturating_add(Weight::from_parts(1_067_723, 0).saturating_mul(s.into())) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(1)) + } + fn service_task_base() -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 7_980_000 picoseconds. + Weight::from_parts(8_186_000, 0) + .saturating_add(Weight::from_parts(0, 0)) + } + /// Storage: Preimage PreimageFor (r:1 w:1) + /// Proof: Preimage PreimageFor (max_values: None, max_size: Some(4194344), added: 4196819, mode: Measured) + /// Storage: Preimage StatusFor (r:1 w:1) + /// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen) + /// The range of component `s` is `[128, 4194304]`. + fn service_task_fetched(s: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `213 + s * (1 ±0)` + // Estimated: `3677 + s * (1 ±0)` + // Minimum execution time: 28_200_000 picoseconds. + Weight::from_parts(28_629_000, 0) + .saturating_add(Weight::from_parts(0, 3677)) + // Standard Error: 8 + .saturating_add(Weight::from_parts(2_076, 0).saturating_mul(s.into())) + .saturating_add(T::DbWeight::get().reads(2)) + .saturating_add(T::DbWeight::get().writes(2)) + .saturating_add(Weight::from_parts(0, 1).saturating_mul(s.into())) + } + /// Storage: Scheduler Lookup (r:0 w:1) + /// Proof: Scheduler Lookup (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen) + fn service_task_named() -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 9_782_000 picoseconds. + Weight::from_parts(10_002_000, 0) + .saturating_add(Weight::from_parts(0, 0)) + .saturating_add(T::DbWeight::get().writes(1)) + } + fn service_task_periodic() -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 7_907_000 picoseconds. + Weight::from_parts(8_091_000, 0) + .saturating_add(Weight::from_parts(0, 0)) + } + fn execute_dispatch_signed() -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 3_681_000 picoseconds. + Weight::from_parts(3_839_000, 0) + .saturating_add(Weight::from_parts(0, 0)) + } + fn execute_dispatch_unsigned() -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 3_721_000 picoseconds. + Weight::from_parts(3_872_000, 0) + .saturating_add(Weight::from_parts(0, 0)) + } + /// Storage: Scheduler Agenda (r:1 w:1) + /// Proof: Scheduler Agenda (max_values: None, max_size: Some(38963), added: 41438, mode: MaxEncodedLen) + /// The range of component `s` is `[0, 49]`. + fn schedule(s: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `78 + s * (177 ±0)` + // Estimated: `42428` + // Minimum execution time: 18_535_000 picoseconds. + Weight::from_parts(21_300_382, 0) + .saturating_add(Weight::from_parts(0, 42428)) + // Standard Error: 3_644 + .saturating_add(Weight::from_parts(1_151_489, 0).saturating_mul(s.into())) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: Scheduler Agenda (r:1 w:1) + /// Proof: Scheduler Agenda (max_values: None, max_size: Some(38963), added: 41438, mode: MaxEncodedLen) + /// Storage: Scheduler Lookup (r:0 w:1) + /// Proof: Scheduler Lookup (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen) + /// The range of component `s` is `[1, 50]`. + fn cancel(s: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `78 + s * (177 ±0)` + // Estimated: `42428` + // Minimum execution time: 24_780_000 picoseconds. + Weight::from_parts(25_316_813, 0) + .saturating_add(Weight::from_parts(0, 42428)) + // Standard Error: 9_036 + .saturating_add(Weight::from_parts(1_968_882, 0).saturating_mul(s.into())) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(2)) + } + /// Storage: Scheduler Lookup (r:1 w:1) + /// Proof: Scheduler Lookup (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen) + /// Storage: Scheduler Agenda (r:1 w:1) + /// Proof: Scheduler Agenda (max_values: None, max_size: Some(38963), added: 41438, mode: MaxEncodedLen) + /// The range of component `s` is `[0, 49]`. + fn schedule_named(s: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `230 + s * (186 ±0)` + // Estimated: `42428` + // Minimum execution time: 22_646_000 picoseconds. + Weight::from_parts(26_448_036, 0) + .saturating_add(Weight::from_parts(0, 42428)) + // Standard Error: 4_324 + .saturating_add(Weight::from_parts(1_228_658, 0).saturating_mul(s.into())) + .saturating_add(T::DbWeight::get().reads(2)) + .saturating_add(T::DbWeight::get().writes(2)) + } + /// Storage: Scheduler Lookup (r:1 w:1) + /// Proof: Scheduler Lookup (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen) + /// Storage: Scheduler Agenda (r:1 w:1) + /// Proof: Scheduler Agenda (max_values: None, max_size: Some(38963), added: 41438, mode: MaxEncodedLen) + /// The range of component `s` is `[1, 50]`. + fn cancel_named(s: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `282 + s * (185 ±0)` + // Estimated: `42428` + // Minimum execution time: 26_463_000 picoseconds. + Weight::from_parts(27_007_292, 0) + .saturating_add(Weight::from_parts(0, 42428)) + // Standard Error: 8_452 + .saturating_add(Weight::from_parts(2_015_442, 0).saturating_mul(s.into())) + .saturating_add(T::DbWeight::get().reads(2)) + .saturating_add(T::DbWeight::get().writes(2)) + } +} diff --git a/runtime/paseo/src/weights/pallet_session.rs b/runtime/paseo/src/weights/pallet_session.rs new file mode 100644 index 0000000000..bbd70fb8a9 --- /dev/null +++ b/runtime/paseo/src/weights/pallet_session.rs @@ -0,0 +1,80 @@ +// Copyright 2020-2024 Trust Computing GmbH. +// This file is part of Litentry. +// +// Litentry is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Litentry 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 +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Litentry. If not, see . + +//! Autogenerated weights for `pallet_session` +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev +//! DATE: 2023-10-17, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! WORST CASE MAP SIZE: `1000000` +//! HOSTNAME: `parachain-benchmark`, CPU: `Intel(R) Xeon(R) Platinum 8259CL CPU @ 2.50GHz` +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("rococo-dev"), DB CACHE: 20 + +// Executed Command: +// ./litentry-collator +// benchmark +// pallet +// --chain=rococo-dev +// --execution=wasm +// --db-cache=20 +// --wasm-execution=compiled +// --pallet=pallet_session +// --extrinsic=* +// --heap-pages=4096 +// --steps=20 +// --repeat=50 +// --header=./LICENSE_HEADER +// --output=./runtime/rococo/src/weights/pallet_session.rs + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] +#![allow(missing_docs)] + +use frame_support::{traits::Get, weights::Weight}; +use core::marker::PhantomData; + +/// Weight functions for `pallet_session`. +pub struct WeightInfo(PhantomData); +impl pallet_session::WeightInfo for WeightInfo { + /// Storage: Session NextKeys (r:1 w:1) + /// Proof Skipped: Session NextKeys (max_values: None, max_size: None, mode: Measured) + /// Storage: Session KeyOwner (r:1 w:1) + /// Proof Skipped: Session KeyOwner (max_values: None, max_size: None, mode: Measured) + fn set_keys() -> Weight { + // Proof Size summary in bytes: + // Measured: `270` + // Estimated: `3735` + // Minimum execution time: 21_515_000 picoseconds. + Weight::from_parts(22_122_000, 0) + .saturating_add(Weight::from_parts(0, 3735)) + .saturating_add(T::DbWeight::get().reads(2)) + .saturating_add(T::DbWeight::get().writes(2)) + } + /// Storage: Session NextKeys (r:1 w:1) + /// Proof Skipped: Session NextKeys (max_values: None, max_size: None, mode: Measured) + /// Storage: Session KeyOwner (r:0 w:1) + /// Proof Skipped: Session KeyOwner (max_values: None, max_size: None, mode: Measured) + fn purge_keys() -> Weight { + // Proof Size summary in bytes: + // Measured: `242` + // Estimated: `3707` + // Minimum execution time: 15_976_000 picoseconds. + Weight::from_parts(16_449_000, 0) + .saturating_add(Weight::from_parts(0, 3707)) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(2)) + } +} diff --git a/runtime/paseo/src/weights/pallet_teebag.rs b/runtime/paseo/src/weights/pallet_teebag.rs new file mode 100644 index 0000000000..d03dd76b8f --- /dev/null +++ b/runtime/paseo/src/weights/pallet_teebag.rs @@ -0,0 +1,261 @@ +// Copyright 2020-2024 Trust Computing GmbH. +// This file is part of Litentry. +// +// Litentry is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Litentry 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 +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Litentry. If not, see . + +//! Autogenerated weights for `pallet_teebag` +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev +//! DATE: 2024-07-31, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! WORST CASE MAP SIZE: `1000000` +//! HOSTNAME: `litentry-benchmark-server`, CPU: `Intel(R) Xeon(R) CPU E5-2686 v4 @ 2.30GHz` +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("rococo-dev"), DB CACHE: 20 + +// Executed Command: +// ./litentry-collator +// benchmark +// pallet +// --chain=rococo-dev +// --execution=wasm +// --db-cache=20 +// --wasm-execution=compiled +// --pallet=pallet_teebag +// --extrinsic=* +// --heap-pages=4096 +// --steps=20 +// --repeat=50 +// --header=./LICENSE_HEADER +// --output=./runtime/rococo/src/weights/pallet_teebag.rs + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] +#![allow(missing_docs)] + +use frame_support::{traits::Get, weights::Weight}; +use core::marker::PhantomData; + +/// Weight functions for `pallet_teebag`. +pub struct WeightInfo(PhantomData); +impl pallet_teebag::WeightInfo for WeightInfo { + /// Storage: Teebag EnclaveRegistry (r:1 w:1) + /// Proof Skipped: Teebag EnclaveRegistry (max_values: None, max_size: None, mode: Measured) + /// Storage: Teebag EnclaveIdentifier (r:1 w:1) + /// Proof Skipped: Teebag EnclaveIdentifier (max_values: None, max_size: None, mode: Measured) + fn force_add_enclave() -> Weight { + // Proof Size summary in bytes: + // Measured: `213` + // Estimated: `3678` + // Minimum execution time: 30_593_000 picoseconds. + Weight::from_parts(31_441_000, 0) + .saturating_add(Weight::from_parts(0, 3678)) + .saturating_add(T::DbWeight::get().reads(2)) + .saturating_add(T::DbWeight::get().writes(2)) + } + /// Storage: Teebag EnclaveRegistry (r:1 w:1) + /// Proof Skipped: Teebag EnclaveRegistry (max_values: None, max_size: None, mode: Measured) + /// Storage: Teebag EnclaveIdentifier (r:1 w:1) + /// Proof Skipped: Teebag EnclaveIdentifier (max_values: None, max_size: None, mode: Measured) + fn force_remove_enclave() -> Weight { + // Proof Size summary in bytes: + // Measured: `541` + // Estimated: `4006` + // Minimum execution time: 37_504_000 picoseconds. + Weight::from_parts(38_236_000, 0) + .saturating_add(Weight::from_parts(0, 4006)) + .saturating_add(T::DbWeight::get().reads(2)) + .saturating_add(T::DbWeight::get().writes(2)) + } + /// Storage: Teebag EnclaveRegistry (r:4 w:3) + /// Proof Skipped: Teebag EnclaveRegistry (max_values: None, max_size: None, mode: Measured) + /// Storage: Teebag EnclaveIdentifier (r:1 w:1) + /// Proof Skipped: Teebag EnclaveIdentifier (max_values: None, max_size: None, mode: Measured) + fn force_remove_enclave_by_mrenclave() -> Weight { + // Proof Size summary in bytes: + // Measured: `720` + // Estimated: `11610` + // Minimum execution time: 85_940_000 picoseconds. + Weight::from_parts(87_419_000, 0) + .saturating_add(Weight::from_parts(0, 11610)) + .saturating_add(T::DbWeight::get().reads(5)) + .saturating_add(T::DbWeight::get().writes(4)) + } + /// Storage: Teebag EnclaveRegistry (r:4 w:3) + /// Proof Skipped: Teebag EnclaveRegistry (max_values: None, max_size: None, mode: Measured) + /// Storage: Teebag EnclaveIdentifier (r:1 w:1) + /// Proof Skipped: Teebag EnclaveIdentifier (max_values: None, max_size: None, mode: Measured) + fn force_remove_enclave_by_worker_type() -> Weight { + // Proof Size summary in bytes: + // Measured: `720` + // Estimated: `11610` + // Minimum execution time: 86_021_000 picoseconds. + Weight::from_parts(87_344_000, 0) + .saturating_add(Weight::from_parts(0, 11610)) + .saturating_add(T::DbWeight::get().reads(5)) + .saturating_add(T::DbWeight::get().writes(4)) + } + /// Storage: Teebag AuthorizedEnclave (r:1 w:1) + /// Proof Skipped: Teebag AuthorizedEnclave (max_values: None, max_size: None, mode: Measured) + fn force_add_authorized_enclave() -> Weight { + // Proof Size summary in bytes: + // Measured: `383` + // Estimated: `3848` + // Minimum execution time: 27_204_000 picoseconds. + Weight::from_parts(27_934_000, 0) + .saturating_add(Weight::from_parts(0, 3848)) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: Teebag AuthorizedEnclave (r:1 w:1) + /// Proof Skipped: Teebag AuthorizedEnclave (max_values: None, max_size: None, mode: Measured) + /// Storage: Teebag EnclaveRegistry (r:1 w:0) + /// Proof Skipped: Teebag EnclaveRegistry (max_values: None, max_size: None, mode: Measured) + fn force_remove_authorized_enclave() -> Weight { + // Proof Size summary in bytes: + // Measured: `415` + // Estimated: `3880` + // Minimum execution time: 38_033_000 picoseconds. + Weight::from_parts(38_965_000, 0) + .saturating_add(Weight::from_parts(0, 3880)) + .saturating_add(T::DbWeight::get().reads(2)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: Timestamp Now (r:1 w:0) + /// Proof: Timestamp Now (max_values: Some(1), max_size: Some(8), added: 503, mode: MaxEncodedLen) + /// Storage: Teebag Mode (r:1 w:0) + /// Proof Skipped: Teebag Mode (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: Teebag AuthorizedEnclave (r:1 w:1) + /// Proof Skipped: Teebag AuthorizedEnclave (max_values: None, max_size: None, mode: Measured) + /// Storage: Teebag EnclaveRegistry (r:1 w:1) + /// Proof Skipped: Teebag EnclaveRegistry (max_values: None, max_size: None, mode: Measured) + /// Storage: Teebag EnclaveIdentifier (r:1 w:1) + /// Proof Skipped: Teebag EnclaveIdentifier (max_values: None, max_size: None, mode: Measured) + fn register_enclave_with_ias_attestation() -> Weight { + // Proof Size summary in bytes: + // Measured: `427` + // Estimated: `3892` + // Minimum execution time: 2_226_497_000 picoseconds. + Weight::from_parts(2_253_466_000, 0) + .saturating_add(Weight::from_parts(0, 3892)) + .saturating_add(T::DbWeight::get().reads(5)) + .saturating_add(T::DbWeight::get().writes(3)) + } + /// Storage: Timestamp Now (r:1 w:0) + /// Proof: Timestamp Now (max_values: Some(1), max_size: Some(8), added: 503, mode: MaxEncodedLen) + /// Storage: Teebag QuotingEnclaveRegistry (r:1 w:0) + /// Proof Skipped: Teebag QuotingEnclaveRegistry (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: Teebag TcbInfo (r:1 w:0) + /// Proof Skipped: Teebag TcbInfo (max_values: None, max_size: None, mode: Measured) + /// Storage: Teebag Mode (r:1 w:0) + /// Proof Skipped: Teebag Mode (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: Teebag AuthorizedEnclave (r:1 w:1) + /// Proof Skipped: Teebag AuthorizedEnclave (max_values: None, max_size: None, mode: Measured) + /// Storage: Teebag EnclaveRegistry (r:1 w:1) + /// Proof Skipped: Teebag EnclaveRegistry (max_values: None, max_size: None, mode: Measured) + /// Storage: Teebag EnclaveIdentifier (r:1 w:1) + /// Proof Skipped: Teebag EnclaveIdentifier (max_values: None, max_size: None, mode: Measured) + fn register_enclave_with_dcap_attestation() -> Weight { + // Proof Size summary in bytes: + // Measured: `644` + // Estimated: `4109` + // Minimum execution time: 4_929_967_000 picoseconds. + Weight::from_parts(4_950_124_000, 0) + .saturating_add(Weight::from_parts(0, 4109)) + .saturating_add(T::DbWeight::get().reads(7)) + .saturating_add(T::DbWeight::get().writes(3)) + } + /// Storage: Teebag EnclaveRegistry (r:1 w:1) + /// Proof Skipped: Teebag EnclaveRegistry (max_values: None, max_size: None, mode: Measured) + /// Storage: Teebag EnclaveIdentifier (r:1 w:1) + /// Proof Skipped: Teebag EnclaveIdentifier (max_values: None, max_size: None, mode: Measured) + fn unregister_enclave() -> Weight { + // Proof Size summary in bytes: + // Measured: `458` + // Estimated: `3923` + // Minimum execution time: 37_905_000 picoseconds. + Weight::from_parts(39_228_000, 0) + .saturating_add(Weight::from_parts(0, 3923)) + .saturating_add(T::DbWeight::get().reads(2)) + .saturating_add(T::DbWeight::get().writes(2)) + } + /// Storage: Timestamp Now (r:1 w:0) + /// Proof: Timestamp Now (max_values: Some(1), max_size: Some(8), added: 503, mode: MaxEncodedLen) + /// Storage: Teebag QuotingEnclaveRegistry (r:0 w:1) + /// Proof Skipped: Teebag QuotingEnclaveRegistry (max_values: Some(1), max_size: None, mode: Measured) + fn register_quoting_enclave() -> Weight { + // Proof Size summary in bytes: + // Measured: `94` + // Estimated: `1493` + // Minimum execution time: 2_458_437_000 picoseconds. + Weight::from_parts(2_484_116_000, 0) + .saturating_add(Weight::from_parts(0, 1493)) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: Timestamp Now (r:1 w:0) + /// Proof: Timestamp Now (max_values: Some(1), max_size: Some(8), added: 503, mode: MaxEncodedLen) + /// Storage: Teebag TcbInfo (r:0 w:1) + /// Proof Skipped: Teebag TcbInfo (max_values: None, max_size: None, mode: Measured) + fn register_tcb_info() -> Weight { + // Proof Size summary in bytes: + // Measured: `94` + // Estimated: `1493` + // Minimum execution time: 2_683_839_000 picoseconds. + Weight::from_parts(2_712_843_000, 0) + .saturating_add(Weight::from_parts(0, 1493)) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(1)) + } + fn post_opaque_task() -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 15_138_000 picoseconds. + Weight::from_parts(15_618_000, 0) + .saturating_add(Weight::from_parts(0, 0)) + } + /// Storage: Teebag EnclaveRegistry (r:1 w:0) + /// Proof Skipped: Teebag EnclaveRegistry (max_values: None, max_size: None, mode: Measured) + /// Storage: Timestamp Now (r:1 w:0) + /// Proof: Timestamp Now (max_values: Some(1), max_size: Some(8), added: 503, mode: MaxEncodedLen) + fn parentchain_block_processed() -> Weight { + // Proof Size summary in bytes: + // Measured: `407` + // Estimated: `3872` + // Minimum execution time: 32_150_000 picoseconds. + Weight::from_parts(33_017_000, 0) + .saturating_add(Weight::from_parts(0, 3872)) + .saturating_add(T::DbWeight::get().reads(2)) + } + /// Storage: Teebag EnclaveRegistry (r:1 w:0) + /// Proof Skipped: Teebag EnclaveRegistry (max_values: None, max_size: None, mode: Measured) + /// Storage: Timestamp Now (r:1 w:0) + /// Proof: Timestamp Now (max_values: Some(1), max_size: Some(8), added: 503, mode: MaxEncodedLen) + /// Storage: Teebag EnclaveIdentifier (r:1 w:0) + /// Proof Skipped: Teebag EnclaveIdentifier (max_values: None, max_size: None, mode: Measured) + /// Storage: Teebag SidechainBlockFinalizationCandidate (r:1 w:1) + /// Proof Skipped: Teebag SidechainBlockFinalizationCandidate (max_values: None, max_size: None, mode: Measured) + /// Storage: Teebag LatestSidechainBlockConfirmation (r:0 w:1) + /// Proof Skipped: Teebag LatestSidechainBlockConfirmation (max_values: None, max_size: None, mode: Measured) + fn sidechain_block_imported() -> Weight { + // Proof Size summary in bytes: + // Measured: `528` + // Estimated: `3993` + // Minimum execution time: 47_699_000 picoseconds. + Weight::from_parts(48_615_000, 0) + .saturating_add(Weight::from_parts(0, 3993)) + .saturating_add(T::DbWeight::get().reads(4)) + .saturating_add(T::DbWeight::get().writes(2)) + } +} diff --git a/runtime/paseo/src/weights/pallet_timestamp.rs b/runtime/paseo/src/weights/pallet_timestamp.rs new file mode 100644 index 0000000000..6aaf72bd60 --- /dev/null +++ b/runtime/paseo/src/weights/pallet_timestamp.rs @@ -0,0 +1,76 @@ +// Copyright 2020-2024 Trust Computing GmbH. +// This file is part of Litentry. +// +// Litentry is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Litentry 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 +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Litentry. If not, see . + +//! Autogenerated weights for `pallet_timestamp` +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev +//! DATE: 2023-10-17, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! WORST CASE MAP SIZE: `1000000` +//! HOSTNAME: `parachain-benchmark`, CPU: `Intel(R) Xeon(R) Platinum 8259CL CPU @ 2.50GHz` +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("rococo-dev"), DB CACHE: 20 + +// Executed Command: +// ./litentry-collator +// benchmark +// pallet +// --chain=rococo-dev +// --execution=wasm +// --db-cache=20 +// --wasm-execution=compiled +// --pallet=pallet_timestamp +// --extrinsic=* +// --heap-pages=4096 +// --steps=20 +// --repeat=50 +// --header=./LICENSE_HEADER +// --output=./runtime/rococo/src/weights/pallet_timestamp.rs + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] +#![allow(missing_docs)] + +use frame_support::{traits::Get, weights::Weight}; +use core::marker::PhantomData; + +/// Weight functions for `pallet_timestamp`. +pub struct WeightInfo(PhantomData); +impl pallet_timestamp::WeightInfo for WeightInfo { + /// Storage: Timestamp Now (r:1 w:1) + /// Proof: Timestamp Now (max_values: Some(1), max_size: Some(8), added: 503, mode: MaxEncodedLen) + /// Storage: Teerex HeartbeatTimeout (r:1 w:0) + /// Proof Skipped: Teerex HeartbeatTimeout (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: Teerex EnclaveRegistry (r:1 w:0) + /// Proof Skipped: Teerex EnclaveRegistry (max_values: None, max_size: None, mode: Measured) + fn set() -> Weight { + // Proof Size summary in bytes: + // Measured: `197` + // Estimated: `3662` + // Minimum execution time: 18_036_000 picoseconds. + Weight::from_parts(18_600_000, 0) + .saturating_add(Weight::from_parts(0, 3662)) + .saturating_add(T::DbWeight::get().reads(3)) + .saturating_add(T::DbWeight::get().writes(1)) + } + fn on_finalize() -> Weight { + // Proof Size summary in bytes: + // Measured: `94` + // Estimated: `0` + // Minimum execution time: 6_082_000 picoseconds. + Weight::from_parts(6_334_000, 0) + .saturating_add(Weight::from_parts(0, 0)) + } +} diff --git a/runtime/paseo/src/weights/pallet_treasury.rs b/runtime/paseo/src/weights/pallet_treasury.rs new file mode 100644 index 0000000000..e9b15b993d --- /dev/null +++ b/runtime/paseo/src/weights/pallet_treasury.rs @@ -0,0 +1,153 @@ +// Copyright 2020-2024 Trust Computing GmbH. +// This file is part of Litentry. +// +// Litentry is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Litentry 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 +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Litentry. If not, see . + +//! Autogenerated weights for `pallet_treasury` +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev +//! DATE: 2023-10-17, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! WORST CASE MAP SIZE: `1000000` +//! HOSTNAME: `parachain-benchmark`, CPU: `Intel(R) Xeon(R) Platinum 8259CL CPU @ 2.50GHz` +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("rococo-dev"), DB CACHE: 20 + +// Executed Command: +// ./litentry-collator +// benchmark +// pallet +// --chain=rococo-dev +// --execution=wasm +// --db-cache=20 +// --wasm-execution=compiled +// --pallet=pallet_treasury +// --extrinsic=* +// --heap-pages=4096 +// --steps=20 +// --repeat=50 +// --header=./LICENSE_HEADER +// --output=./runtime/rococo/src/weights/pallet_treasury.rs + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] +#![allow(missing_docs)] + +use frame_support::{traits::Get, weights::Weight}; +use core::marker::PhantomData; + +/// Weight functions for `pallet_treasury`. +pub struct WeightInfo(PhantomData); +impl pallet_treasury::WeightInfo for WeightInfo { + /// Storage: Treasury ProposalCount (r:1 w:1) + /// Proof: Treasury ProposalCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen) + /// Storage: Treasury Approvals (r:1 w:1) + /// Proof: Treasury Approvals (max_values: Some(1), max_size: Some(402), added: 897, mode: MaxEncodedLen) + /// Storage: Treasury Proposals (r:0 w:1) + /// Proof: Treasury Proposals (max_values: None, max_size: Some(108), added: 2583, mode: MaxEncodedLen) + fn spend() -> Weight { + // Proof Size summary in bytes: + // Measured: `80` + // Estimated: `1887` + // Minimum execution time: 22_391_000 picoseconds. + Weight::from_parts(22_904_000, 0) + .saturating_add(Weight::from_parts(0, 1887)) + .saturating_add(T::DbWeight::get().reads(2)) + .saturating_add(T::DbWeight::get().writes(3)) + } + /// Storage: Treasury ProposalCount (r:1 w:1) + /// Proof: Treasury ProposalCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen) + /// Storage: Treasury Proposals (r:0 w:1) + /// Proof: Treasury Proposals (max_values: None, max_size: Some(108), added: 2583, mode: MaxEncodedLen) + fn propose_spend() -> Weight { + // Proof Size summary in bytes: + // Measured: `181` + // Estimated: `1489` + // Minimum execution time: 39_338_000 picoseconds. + Weight::from_parts(40_451_000, 0) + .saturating_add(Weight::from_parts(0, 1489)) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(2)) + } + /// Storage: Treasury Proposals (r:1 w:1) + /// Proof: Treasury Proposals (max_values: None, max_size: Some(108), added: 2583, mode: MaxEncodedLen) + /// Storage: System Account (r:2 w:2) + /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + fn reject_proposal() -> Weight { + // Proof Size summary in bytes: + // Measured: `442` + // Estimated: `6196` + // Minimum execution time: 60_263_000 picoseconds. + Weight::from_parts(61_113_000, 0) + .saturating_add(Weight::from_parts(0, 6196)) + .saturating_add(T::DbWeight::get().reads(3)) + .saturating_add(T::DbWeight::get().writes(3)) + } + /// Storage: Treasury Proposals (r:1 w:0) + /// Proof: Treasury Proposals (max_values: None, max_size: Some(108), added: 2583, mode: MaxEncodedLen) + /// Storage: Treasury Approvals (r:1 w:1) + /// Proof: Treasury Approvals (max_values: Some(1), max_size: Some(402), added: 897, mode: MaxEncodedLen) + /// The range of component `p` is `[0, 99]`. + fn approve_proposal(p: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `486 + p * (9 ±0)` + // Estimated: `3573` + // Minimum execution time: 14_906_000 picoseconds. + Weight::from_parts(17_983_887, 0) + .saturating_add(Weight::from_parts(0, 3573)) + // Standard Error: 3_770 + .saturating_add(Weight::from_parts(172_549, 0).saturating_mul(p.into())) + .saturating_add(T::DbWeight::get().reads(2)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: Treasury Approvals (r:1 w:1) + /// Proof: Treasury Approvals (max_values: Some(1), max_size: Some(402), added: 897, mode: MaxEncodedLen) + fn remove_approval() -> Weight { + // Proof Size summary in bytes: + // Measured: `165` + // Estimated: `1887` + // Minimum execution time: 11_656_000 picoseconds. + Weight::from_parts(12_011_000, 0) + .saturating_add(Weight::from_parts(0, 1887)) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: System Account (r:201 w:201) + /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + /// Storage: Treasury Deactivated (r:1 w:1) + /// Proof: Treasury Deactivated (max_values: Some(1), max_size: Some(16), added: 511, mode: MaxEncodedLen) + /// Storage: Balances InactiveIssuance (r:1 w:1) + /// Proof: Balances InactiveIssuance (max_values: Some(1), max_size: Some(16), added: 511, mode: MaxEncodedLen) + /// Storage: Treasury Approvals (r:1 w:1) + /// Proof: Treasury Approvals (max_values: Some(1), max_size: Some(402), added: 897, mode: MaxEncodedLen) + /// Storage: Treasury Proposals (r:100 w:100) + /// Proof: Treasury Proposals (max_values: None, max_size: Some(108), added: 2583, mode: MaxEncodedLen) + /// Storage: Bounties BountyApprovals (r:1 w:1) + /// Proof: Bounties BountyApprovals (max_values: Some(1), max_size: Some(402), added: 897, mode: MaxEncodedLen) + /// The range of component `p` is `[0, 100]`. + fn on_initialize_proposals(p: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `149 + p * (252 ±0)` + // Estimated: `3593 + p * (5206 ±0)` + // Minimum execution time: 45_523_000 picoseconds. + Weight::from_parts(93_057_917, 0) + .saturating_add(Weight::from_parts(0, 3593)) + // Standard Error: 182_147 + .saturating_add(Weight::from_parts(54_962_246, 0).saturating_mul(p.into())) + .saturating_add(T::DbWeight::get().reads(5)) + .saturating_add(T::DbWeight::get().reads((3_u64).saturating_mul(p.into()))) + .saturating_add(T::DbWeight::get().writes(5)) + .saturating_add(T::DbWeight::get().writes((3_u64).saturating_mul(p.into()))) + .saturating_add(Weight::from_parts(0, 5206).saturating_mul(p.into())) + } +} diff --git a/runtime/paseo/src/weights/pallet_utility.rs b/runtime/paseo/src/weights/pallet_utility.rs new file mode 100644 index 0000000000..477b911611 --- /dev/null +++ b/runtime/paseo/src/weights/pallet_utility.rs @@ -0,0 +1,101 @@ +// Copyright 2020-2024 Trust Computing GmbH. +// This file is part of Litentry. +// +// Litentry is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Litentry 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 +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Litentry. If not, see . + +//! Autogenerated weights for `pallet_utility` +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev +//! DATE: 2023-10-17, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! WORST CASE MAP SIZE: `1000000` +//! HOSTNAME: `parachain-benchmark`, CPU: `Intel(R) Xeon(R) Platinum 8259CL CPU @ 2.50GHz` +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("rococo-dev"), DB CACHE: 20 + +// Executed Command: +// ./litentry-collator +// benchmark +// pallet +// --chain=rococo-dev +// --execution=wasm +// --db-cache=20 +// --wasm-execution=compiled +// --pallet=pallet_utility +// --extrinsic=* +// --heap-pages=4096 +// --steps=20 +// --repeat=50 +// --header=./LICENSE_HEADER +// --output=./runtime/rococo/src/weights/pallet_utility.rs + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] +#![allow(missing_docs)] + +use frame_support::{traits::Get, weights::Weight}; +use core::marker::PhantomData; + +/// Weight functions for `pallet_utility`. +pub struct WeightInfo(PhantomData); +impl pallet_utility::WeightInfo for WeightInfo { + /// The range of component `c` is `[0, 1000]`. + fn batch(c: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 10_307_000 picoseconds. + Weight::from_parts(36_977_209, 0) + .saturating_add(Weight::from_parts(0, 0)) + // Standard Error: 40_489 + .saturating_add(Weight::from_parts(7_773_419, 0).saturating_mul(c.into())) + } + fn as_derivative() -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 6_956_000 picoseconds. + Weight::from_parts(7_237_000, 0) + .saturating_add(Weight::from_parts(0, 0)) + } + /// The range of component `c` is `[0, 1000]`. + fn batch_all(c: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 10_202_000 picoseconds. + Weight::from_parts(10_311_000, 0) + .saturating_add(Weight::from_parts(0, 0)) + // Standard Error: 36_725 + .saturating_add(Weight::from_parts(8_385_209, 0).saturating_mul(c.into())) + } + fn dispatch_as() -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 12_851_000 picoseconds. + Weight::from_parts(13_230_000, 0) + .saturating_add(Weight::from_parts(0, 0)) + } + /// The range of component `c` is `[0, 1000]`. + fn force_batch(c: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 10_042_000 picoseconds. + Weight::from_parts(26_429_449, 0) + .saturating_add(Weight::from_parts(0, 0)) + // Standard Error: 69_016 + .saturating_add(Weight::from_parts(7_675_740, 0).saturating_mul(c.into())) + } +} diff --git a/runtime/paseo/src/weights/pallet_vc_management.rs b/runtime/paseo/src/weights/pallet_vc_management.rs new file mode 100644 index 0000000000..6ede65a8ae --- /dev/null +++ b/runtime/paseo/src/weights/pallet_vc_management.rs @@ -0,0 +1,178 @@ +// Copyright 2020-2024 Trust Computing GmbH. +// This file is part of Litentry. +// +// Litentry is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Litentry 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 +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Litentry. If not, see . + +//! Autogenerated weights for `pallet_vc_management` +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev +//! DATE: 2024-01-19, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! WORST CASE MAP SIZE: `1000000` +//! HOSTNAME: `parachain-benchmark`, CPU: `Intel(R) Xeon(R) Platinum 8259CL CPU @ 2.50GHz` +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("rococo-dev"), DB CACHE: 20 + +// Executed Command: +// ./litentry-collator +// benchmark +// pallet +// --chain=rococo-dev +// --execution=wasm +// --db-cache=20 +// --wasm-execution=compiled +// --pallet=pallet_vc_management +// --extrinsic=* +// --heap-pages=4096 +// --steps=20 +// --repeat=50 +// --header=./LICENSE_HEADER +// --output=./runtime/rococo/src/weights/pallet_vc_management.rs + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] +#![allow(missing_docs)] + +use frame_support::{traits::Get, weights::Weight}; +use core::marker::PhantomData; + +/// Weight functions for `pallet_vc_management`. +pub struct WeightInfo(PhantomData); +impl pallet_vc_management::WeightInfo for WeightInfo { + /// Storage: VCManagement Delegatee (r:0 w:1) + /// Proof: VCManagement Delegatee (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen) + fn add_delegatee() -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 12_994_000 picoseconds. + Weight::from_parts(13_371_000, 0) + .saturating_add(Weight::from_parts(0, 0)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: VCManagement Delegatee (r:1 w:1) + /// Proof: VCManagement Delegatee (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen) + fn remove_delegatee() -> Weight { + // Proof Size summary in bytes: + // Measured: `113` + // Estimated: `3513` + // Minimum execution time: 18_939_000 picoseconds. + Weight::from_parts(19_373_000, 0) + .saturating_add(Weight::from_parts(0, 3513)) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: VCMPExtrinsicWhitelist GroupControlOn (r:1 w:0) + /// Proof Skipped: VCMPExtrinsicWhitelist GroupControlOn (max_values: Some(1), max_size: None, mode: Measured) + fn request_vc() -> Weight { + // Proof Size summary in bytes: + // Measured: `42` + // Estimated: `1527` + // Minimum execution time: 15_031_000 picoseconds. + Weight::from_parts(16_267_000, 0) + .saturating_add(Weight::from_parts(0, 1527)) + .saturating_add(T::DbWeight::get().reads(1)) + } + /// Storage: Teerex EnclaveIndex (r:1 w:0) + /// Proof Skipped: Teerex EnclaveIndex (max_values: None, max_size: None, mode: Measured) + fn vc_issued() -> Weight { + // Proof Size summary in bytes: + // Measured: `255` + // Estimated: `3720` + // Minimum execution time: 19_878_000 picoseconds. + Weight::from_parts(20_219_000, 0) + .saturating_add(Weight::from_parts(0, 3720)) + .saturating_add(T::DbWeight::get().reads(1)) + } + /// Storage: Teerex EnclaveIndex (r:1 w:0) + /// Proof Skipped: Teerex EnclaveIndex (max_values: None, max_size: None, mode: Measured) + fn some_error() -> Weight { + // Proof Size summary in bytes: + // Measured: `255` + // Estimated: `3720` + // Minimum execution time: 20_075_000 picoseconds. + Weight::from_parts(20_681_000, 0) + .saturating_add(Weight::from_parts(0, 3720)) + .saturating_add(T::DbWeight::get().reads(1)) + } + /// Storage: VCManagement Admin (r:1 w:1) + /// Proof: VCManagement Admin (max_values: Some(1), max_size: Some(32), added: 527, mode: MaxEncodedLen) + fn set_admin() -> Weight { + // Proof Size summary in bytes: + // Measured: `61` + // Estimated: `1517` + // Minimum execution time: 16_327_000 picoseconds. + Weight::from_parts(16_714_000, 0) + .saturating_add(Weight::from_parts(0, 1517)) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: VCManagement Admin (r:1 w:0) + /// Proof: VCManagement Admin (max_values: Some(1), max_size: Some(32), added: 527, mode: MaxEncodedLen) + /// Storage: VCManagement SchemaRegistryIndex (r:1 w:1) + /// Proof: VCManagement SchemaRegistryIndex (max_values: Some(1), max_size: Some(8), added: 503, mode: MaxEncodedLen) + /// Storage: VCManagement SchemaRegistry (r:0 w:1) + /// Proof: VCManagement SchemaRegistry (max_values: None, max_size: Some(2621), added: 5096, mode: MaxEncodedLen) + fn add_schema() -> Weight { + // Proof Size summary in bytes: + // Measured: `61` + // Estimated: `1517` + // Minimum execution time: 20_968_000 picoseconds. + Weight::from_parts(21_334_000, 0) + .saturating_add(Weight::from_parts(0, 1517)) + .saturating_add(T::DbWeight::get().reads(2)) + .saturating_add(T::DbWeight::get().writes(2)) + } + /// Storage: VCManagement Admin (r:1 w:0) + /// Proof: VCManagement Admin (max_values: Some(1), max_size: Some(32), added: 527, mode: MaxEncodedLen) + /// Storage: VCManagement SchemaRegistry (r:1 w:1) + /// Proof: VCManagement SchemaRegistry (max_values: None, max_size: Some(2621), added: 5096, mode: MaxEncodedLen) + fn disable_schema() -> Weight { + // Proof Size summary in bytes: + // Measured: `179` + // Estimated: `6086` + // Minimum execution time: 21_697_000 picoseconds. + Weight::from_parts(22_113_000, 0) + .saturating_add(Weight::from_parts(0, 6086)) + .saturating_add(T::DbWeight::get().reads(2)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: VCManagement Admin (r:1 w:0) + /// Proof: VCManagement Admin (max_values: Some(1), max_size: Some(32), added: 527, mode: MaxEncodedLen) + /// Storage: VCManagement SchemaRegistry (r:1 w:1) + /// Proof: VCManagement SchemaRegistry (max_values: None, max_size: Some(2621), added: 5096, mode: MaxEncodedLen) + fn activate_schema() -> Weight { + // Proof Size summary in bytes: + // Measured: `179` + // Estimated: `6086` + // Minimum execution time: 21_328_000 picoseconds. + Weight::from_parts(21_743_000, 0) + .saturating_add(Weight::from_parts(0, 6086)) + .saturating_add(T::DbWeight::get().reads(2)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: VCManagement Admin (r:1 w:0) + /// Proof: VCManagement Admin (max_values: Some(1), max_size: Some(32), added: 527, mode: MaxEncodedLen) + /// Storage: VCManagement SchemaRegistry (r:1 w:1) + /// Proof: VCManagement SchemaRegistry (max_values: None, max_size: Some(2621), added: 5096, mode: MaxEncodedLen) + fn revoke_schema() -> Weight { + // Proof Size summary in bytes: + // Measured: `179` + // Estimated: `6086` + // Minimum execution time: 22_141_000 picoseconds. + Weight::from_parts(22_502_000, 0) + .saturating_add(Weight::from_parts(0, 6086)) + .saturating_add(T::DbWeight::get().reads(2)) + .saturating_add(T::DbWeight::get().writes(1)) + } +} diff --git a/runtime/paseo/src/xcm_config.rs b/runtime/paseo/src/xcm_config.rs new file mode 100644 index 0000000000..d8231a64a8 --- /dev/null +++ b/runtime/paseo/src/xcm_config.rs @@ -0,0 +1,356 @@ +// Copyright 2020-2024 Trust Computing GmbH. +// This file is part of Litentry. +// +// Litentry is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Litentry 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 +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Litentry. If not, see . +#![allow(clippy::clone_on_copy)] +#![allow(clippy::useless_conversion)] + +// use frame_system::RawOrigin as SystemRawOrigin; +// use pallet_collective::RawOrigin as CollectiveRawOrigin; +use frame_support::{ + match_types, + pallet_prelude::ConstU32, + parameter_types, + traits::{Everything, Nothing}, + weights::ConstantMultiplier, + PalletId, +}; +use frame_system::EnsureRoot; +use orml_traits::{location::AbsoluteReserveProvider, parameter_type_with_key}; +use pallet_xcm::XcmPassthrough; +use polkadot_parachain::primitives::Sibling; +use xcm_builder::{ConvertedConcreteId, NoChecking}; +// Litentry: The CheckAccount implementation is forced by the bug of FungiblesAdapter. +// We should replace () regarding fake_pallet_id account after our PR passed. +use core_primitives::{AccountId, Weight}; +use runtime_common::xcm_impl::{ + AccountIdToMultiLocation, AssetIdMuliLocationConvert, CurrencyId, + CurrencyIdMultiLocationConvert, FirstAssetTrader, MultiNativeAsset, NewAnchoringSelfReserve, + OldAnchoringSelfReserve, XcmFeesToAccount, +}; + +use runtime_common::{EnsureRootOrTwoThirdsCouncil, FilterEnsureOrigin, WEIGHT_TO_FEE_FACTOR}; +use sp_runtime::traits::AccountIdConversion; +use xcm::latest::prelude::*; +use xcm_builder::{ + AccountId32Aliases, AllowTopLevelPaidExecutionFrom, AllowUnpaidExecutionFrom, CurrencyAdapter, + EnsureXcmOrigin, FixedWeightBounds, FungiblesAdapter, IsConcrete, ParentIsPreset, + RelayChainAsNative, SiblingParachainAsNative, SiblingParachainConvertsVia, + SignedAccountId32AsNative, SignedToAccountId32, SovereignSignedViaLocation, TakeWeightCredit, + UsingComponents, +}; +use xcm_executor::{traits::JustTry, XcmExecutor}; + +#[cfg(test)] +use crate::tests::setup::ParachainXcmRouter; + +use super::{ + AllPalletsWithSystem, AssetId, AssetManager, Assets, Balance, Balances, DealWithFees, + ParachainInfo, PolkadotXcm, Runtime, RuntimeCall, RuntimeEvent, RuntimeOrigin, Treasury, +}; +#[cfg(not(test))] +use super::{ParachainSystem, XcmpQueue}; + +parameter_types! { + pub const RelayLocation: MultiLocation = MultiLocation::parent(); + pub const RelayNetwork: Option = None; + pub RelayChainOrigin: RuntimeOrigin = cumulus_pallet_xcm::Origin::Relay.into(); + pub UniversalLocation: InteriorMultiLocation = Parachain(ParachainInfo::parachain_id().into()).into(); +} + +/// Type for specifying how a `MultiLocation` can be converted into an `AccountId`. This is used +/// when determining ownership of accounts for asset transacting and when attempting to use XCM +/// `Transact` in order to determine the dispatch Origin. +pub type LocationToAccountId = ( + // The parent (Relay-chain) origin converts to the parent `AccountId`. + ParentIsPreset, + // Sibling parachain origins convert to AccountId via the `ParaId::into`. + SiblingParachainConvertsVia, + // Straight up local `AccountId32` origins just alias directly to `AccountId`. + AccountId32Aliases, +); + +/// Means for transacting self reserve assets on this chain. +pub type LocalAssetTransactor = CurrencyAdapter< + // Use this currency: + Balances, + // Use this currency when it is a fungible asset matching the given location or name: + (IsConcrete>, IsConcrete>), + // Do a simple punn to convert an AccountId32 MultiLocation into a native chain account ID: + LocationToAccountId, + // Our chain's account ID type (we can't get away without mentioning it explicitly): + AccountId, + // We don't track any teleports. + (), +>; + +parameter_types! { + pub const TempPalletId: PalletId = PalletId(*b"py/tempA"); + pub TempAccount: AccountId = TempPalletId::get().into_account_truncating(); +} +// The non-reserve fungible transactor type +// It will use pallet_assets, and the Id will be CurrencyId::ParachainReserve(MultiLocation) +pub type ForeignFungiblesTransactor = FungiblesAdapter< + // Use this fungibles implementation + Assets, + // Use this currency when it is a fungible asset matching the given location or name: + ConvertedConcreteId, JustTry>, + // Do a simple punn to convert an AccountId32 MultiLocation into a native chain account ID: + LocationToAccountId, + // Our chain's account ID type (we can't get away without mentioning it explicitly): + AccountId, + // We dont allow teleports. + NoChecking, + // We dont track any teleports + TempAccount, +>; + +// The XCM transaction handlers for different type of assets. +pub type AssetTransactors = ( + // SelfReserve asset, both pre and post 0.9.16 + LocalAssetTransactor, + // // Foreign assets (non native minted token crossed from remote chain) + ForeignFungiblesTransactor, +); + +/// Litentry: As our current XcmRouter (which used for receiving remote XCM message and call +/// XcmExecutor to handle) will force the origin to remoteChain sovereign account, this +/// XcmOriginToTransactDispatchOrigin implementation is not that useful. This is the type we use to +/// convert an (incoming) XCM origin into a local `Origin` instance, ready for dispatching a +/// transaction with Xcm's `Transact`. There is an `OriginKind` which can biases the kind of local +/// `Origin` it will become. +pub type XcmOriginToTransactDispatchOrigin = ( + // Sovereign account converter; this attempts to derive an `AccountId` from the origin location + // using `LocationToAccountId` and then turn that into the usual `Signed` origin. Useful for + // foreign chains who want to have a local sovereign account on this chain which they control. + SovereignSignedViaLocation, + // Native converter for Relay-chain (Parent) location; will converts to a `Relay` origin when + // recognized. + RelayChainAsNative, + // Native converter for sibling Parachains; will convert to a `SiblingPara` origin when + // recognized. + SiblingParachainAsNative, + // Native signed account converter; this just converts an `AccountId32` origin into a normal + // `Origin::Signed` origin of the same 32-byte value. + SignedAccountId32AsNative, + // Xcm origins can be represented natively under the Xcm pallet's Xcm origin. + XcmPassthrough, +); + +parameter_types! { + // One XCM operation is 1_000_000_000 weight - almost certainly a conservative estimate. + // How much we charge for XCM from remote chain per XCM command. + pub UnitWeightCost: Weight = Weight::from_parts(200_000_000u64, 0); + pub const MaxInstructions: u32 = 100; +} + +match_types! { + pub type ParentOrParentsExecutivePlurality: impl Contains = { + MultiLocation { parents: 1, interior: Here } | + MultiLocation { parents: 1, interior: X1(Plurality { id: BodyId::Executive, .. }) } + }; +} + +pub type Barriers = ( + TakeWeightCredit, + AllowTopLevelPaidExecutionFrom, + AllowUnpaidExecutionFrom, + // ^^^ Parent and its exec plurality get free execution +); + +parameter_types! { + /// Xcm fees will go to the treasury account + pub XcmFeesAccount: AccountId = Treasury::account_id(); + pub const MaxAssetsIntoHolding: u32 = 64; + pub const WeightToFeeFactor: Balance = WEIGHT_TO_FEE_FACTOR; // 10^6 +} + +pub type Traders = ( + UsingComponents< + ConstantMultiplier, + NewAnchoringSelfReserve, + AccountId, + Balances, + DealWithFees, + >, + UsingComponents< + ConstantMultiplier, + OldAnchoringSelfReserve, + AccountId, + Balances, + DealWithFees, + >, + // TODO::Implement foreign asset fee to weight rule from AssetManager Setting; Need more test + FirstAssetTrader< + CurrencyId, + AssetManager, + XcmFeesToAccount< + Assets, + ConvertedConcreteId, JustTry>, + AccountId, + XcmFeesAccount, + >, + >, +); + +/// Xcm Weigher shared between multiple Xcm-related configs. +pub type XcmWeigher = FixedWeightBounds; + +pub struct XcmConfig; +impl xcm_executor::Config for XcmConfig { + type RuntimeCall = RuntimeCall; + type XcmSender = XcmRouter; + // How to withdraw and deposit an asset. + type AssetTransactor = AssetTransactors; + type OriginConverter = XcmOriginToTransactDispatchOrigin; + // Only Allow chains to handle their own reserve assets crossed on local chain whatever way they + // want. + type IsReserve = MultiNativeAsset; + type IsTeleporter = (); // Teleporting is disabled. + type UniversalLocation = UniversalLocation; + type Barrier = Barriers; + type Weigher = XcmWeigher; + // Litentry: This is the tool used for calculating that inside XcmExecutor vm, how to transfer + // asset into weight fee. Usually this is in order to fulfull Barrier + // AllowTopLevelPaidExecutionFrom requirement. Currently we have not implement the asset to fee + // rule for Foreign Asset, so pure cross chain transfer from XCM parachain will be rejected no + // matter. + type Trader = Traders; + type ResponseHandler = PolkadotXcm; + type AssetTrap = PolkadotXcm; + type AssetClaims = PolkadotXcm; + type SubscriptionService = PolkadotXcm; + type PalletInstancesInfo = AllPalletsWithSystem; + type MaxAssetsIntoHolding = MaxAssetsIntoHolding; + type AssetLocker = (); + type AssetExchanger = (); + type FeeManager = (); + type MessageExporter = (); + type UniversalAliases = Nothing; + type CallDispatcher = RuntimeCall; + type SafeCallFilter = Everything; +} + +/// No local origins on this chain are allowed to dispatch XCM sends/executions. +pub type LocalOriginToLocation = SignedToAccountId32; + +#[cfg(test)] +/// The mimic XcmRouter which only change storage locally for Xcm to digest. +/// XCM router for parachain. +pub type XcmRouter = ParachainXcmRouter; +#[cfg(not(test))] +/// The means for routing XCM messages which are not for local execution into the right message +/// queues. +pub type XcmRouter = ( + // Two routers - use UMP to communicate with the relay chain: + // We use PolkadotXcm to confirm the XCM Version; Use () instead if pass anyway + cumulus_primitives_utility::ParentAsUmp, + // ..and XCMP to communicate with the sibling chains. + XcmpQueue, +); + +match_types! { + pub type ParentOrParachains: impl Contains = { + // Local account: Litmus + MultiLocation { parents: 0, interior: X1(Junction::AccountId32 { .. }) } | + // Relay-chain account: Kusama + MultiLocation { parents: 1, interior: X1(Junction::AccountId32 { .. }) } | + // AccountKey20 based parachain: Moonriver + MultiLocation { parents: 1, interior: X2(Parachain( .. ), Junction::AccountKey20 { .. }) } | + // AccountId 32 based parachain: Statemint + MultiLocation { parents: 1, interior: X2(Parachain( .. ), Junction::AccountId32 { .. }) } + }; +} + +parameter_type_with_key! { + pub ParachainMinFee: |_location: MultiLocation| -> Option { + // Always return `None` to disallow using fee asset and target asset with different reserve chains + None + }; +} + +parameter_types! { + pub SelfLocation: MultiLocation = MultiLocation { + parents:1, + interior: Junctions::X1( + Parachain(ParachainInfo::parachain_id().into()) + ) + }; + pub const BaseXcmWeight: Weight = Weight::from_parts(100_000_000u64, 0); + pub const MaxAssetsForTransfer: usize = 3; +} + +#[cfg(feature = "runtime-benchmarks")] +parameter_types! { + pub ReachableDest: Option = Some(Parent.into()); +} + +impl pallet_xcm::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + // We allow anyone to send any XCM to anywhere + // This is highly relied on if target chain properly filtered + // Check their Barriers implementation + // And for TakeWeightCredit + // Check if their executor's ShouldExecute trait weight_credit + type SendXcmOrigin = + FilterEnsureOrigin; + type XcmRouter = XcmRouter; + type ExecuteXcmOrigin = EnsureXcmOrigin; + type XcmExecuteFilter = Nothing; + // ^ Disable dispatchable execute on the XCM pallet. + // Needs to be `Everything` for local testing. + type XcmExecutor = XcmExecutor; + type XcmTeleportFilter = Nothing; + // This filter here defines what is allowed for XcmExecutor to handle with TransferReserveAsset + // Rule. + type XcmReserveTransferFilter = Everything; + type Weigher = XcmWeigher; + type UniversalLocation = UniversalLocation; + type RuntimeOrigin = RuntimeOrigin; + type RuntimeCall = RuntimeCall; + const VERSION_DISCOVERY_QUEUE_SIZE: u32 = 100; + // ^ Override for AdvertisedXcmVersion default + type AdvertisedXcmVersion = pallet_xcm::CurrentXcmVersion; + type Currency = Balances; + type CurrencyMatcher = (); + type TrustedLockers = (); + type SovereignAccountOf = LocationToAccountId; + type MaxLockers = ConstU32<8>; + type WeightInfo = pallet_xcm::TestWeightInfo; + #[cfg(feature = "runtime-benchmarks")] + type ReachableDest = ReachableDest; + type AdminOrigin = EnsureRoot; +} + +impl cumulus_pallet_xcm::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type XcmExecutor = XcmExecutor; +} + +impl orml_xtokens::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type Balance = Balance; + type CurrencyId = CurrencyId; + type AccountIdToMultiLocation = AccountIdToMultiLocation; + type CurrencyIdConvert = CurrencyIdMultiLocationConvert; + type XcmExecutor = XcmExecutor; + type SelfLocation = SelfLocation; + type MultiLocationsFilter = ParentOrParachains; + type MinXcmFee = ParachainMinFee; + type Weigher = XcmWeigher; + type BaseXcmWeight = BaseXcmWeight; + type UniversalLocation = UniversalLocation; + type MaxAssetsForTransfer = MaxAssetsForTransfer; + type ReserveProvider = AbsoluteReserveProvider; +} diff --git a/scripts/launch-local-binary.sh b/scripts/launch-local-binary.sh index f2e1354fe5..7584fb3969 100755 --- a/scripts/launch-local-binary.sh +++ b/scripts/launch-local-binary.sh @@ -13,7 +13,7 @@ set -eo pipefail function usage() { echo - echo "Usage: $0 litentry|litmus|rococo [path-to-polkadot-bin] [path-to-litentry-collator]" + echo "Usage: $0 litentry|litmus|rococo|paseo [path-to-polkadot-bin] [path-to-litentry-collator]" echo "Default: polkadot bin from the latest official release" echo " litentry-collator bin from litentry/litentry-parachain:latest image" echo " both are of Linux verion" From 66318e22ab0a19f051f20371014b28a93df179fd Mon Sep 17 00:00:00 2001 From: felixfaisal Date: Mon, 12 Aug 2024 07:51:43 +0000 Subject: [PATCH 02/21] fix: update CI to run tests on paseo --- Makefile | 16 ++++++++ docker/paseo-parachain-launch-config.yml | 47 ++++++++++++++++++++++++ scripts/launch-local-docker.sh | 2 +- scripts/run-ts-test.sh | 2 +- 4 files changed, 65 insertions(+), 2 deletions(-) create mode 100644 docker/paseo-parachain-launch-config.yml diff --git a/Makefile b/Makefile index 875b5f5954..b11515298f 100644 --- a/Makefile +++ b/Makefile @@ -100,6 +100,10 @@ launch-docker-litmus: generate-docker-compose-litmus launch-docker-rococo: generate-docker-compose-rococo @./scripts/launch-local-docker.sh rococo +.PHONY: launch-docker-paseo ## Launch a local rococo-parachain network with docker +launch-docker-paseo: generate-docker-compose-paseo + @./scripts/launch-local-docker.sh paseo + .PHONY: launch-binary-litentry ## Launch a local litentry-parachain network with binaries launch-binary-litentry: @./scripts/launch-local-binary.sh litentry @@ -142,6 +146,10 @@ test-ts-docker-litmus: launch-docker-litmus launch-docker-bridge test-ts-docker-rococo: launch-docker-rococo launch-docker-bridge @./scripts/run-ts-test.sh rococo bridge evm +.PHONY: test-ts-docker-paseo ## Run rococo ts tests with docker without clean-up +test-ts-docker-rococo: launch-docker-paseo launch-docker-bridge + @./scripts/run-ts-test.sh paseo bridge evm + .PHONY: test-ts-binary-litentry ## Run litentry ts tests with binary without clean-up test-ts-binary-litentry: launch-binary-litentry @./scripts/run-ts-test.sh litentry no_bridge no_evm @@ -154,6 +162,10 @@ test-ts-binary-litmus: launch-binary-litmus test-ts-binary-rococo: launch-binary-rococo @./scripts/run-ts-test.sh rococo no_bridge evm +.PHONY: test-ts-binary-paseo ## Run rococo ts tests with binary without clean-up +test-ts-binary-rococo: launch-binary-paseo + @./scripts/run-ts-test.sh paseo no_bridge evm + # clean up .PHONY: clean-docker-litentry ## Clean up litentry docker images, containers, volumes, etc @@ -186,6 +198,10 @@ generate-docker-compose-litmus: generate-docker-compose-rococo: @./scripts/generate-docker-files.sh rococo +.PHONY: generate-docker-compose-paseo ## Generate docker-compose files for rococo local network +generate-docker-compose-paseo: + @./scripts/generate-docker-files.sh paseo + # update dependencies .PHONY: update-ts-dep ## update ts-tests dependencies diff --git a/docker/paseo-parachain-launch-config.yml b/docker/paseo-parachain-launch-config.yml new file mode 100644 index 0000000000..a81068ff76 --- /dev/null +++ b/docker/paseo-parachain-launch-config.yml @@ -0,0 +1,47 @@ +# A parachain-launch (https://github.com/open-web3-stack/parachain-launch) config +# used in dev env +# contains 2 relaychain nodes + 1 parachain node +# +# Relaychain Configuration +relaychain: + image: parity/polkadot:v0.9.42 + chain: rococo-local + env: + RUST_LOG: parachain::candidate-backing=trace,parachain::candidate-selection=trace,parachain::pvf=trace,parachain::collator-protocol=trace,parachain::provisioner=trace + flags: + - --rpc-methods=unsafe + - --execution=wasm + nodes: + - name: alice + wsPort: ${AliceWSPort:-9946} + rpcPort: ${AliceRPCPort:-9936} + port: ${AlicePort:-30336} + - name: bob + wsPort: ${BobWSPort:-9947} + rpcPort: ${BobRPCPort:-9937} + port: ${BobPort:-30337} + +# Parachain Configuration +parachains: +- image: litentry/litentry-parachain:latest + chain: paseo-dev + id: 2106 + parachain: true + flags: + - --rpc-methods=unsafe + - --force-authoring + - --execution=wasm + - --state-pruning=archive + - --blocks-pruning=archive + - --enable-evm-rpc + relaychainFlags: + - --execution=wasm + env: + RUST_LOG: sc_basic_authorship=trace,cumulus-consensus=trace,cumulus-collator=trace,collator_protocol=trace,collation_generation=trace,aura=debug + volumePath: /data + nodes: + - flags: + - --alice + wsPort: ${CollatorWSPort:-9944} + rpcPort: ${CollatorRPCPort:-9933} + port: ${CollatorPort:-30333} diff --git a/scripts/launch-local-docker.sh b/scripts/launch-local-docker.sh index 6d912e6400..248e078ab6 100755 --- a/scripts/launch-local-docker.sh +++ b/scripts/launch-local-docker.sh @@ -3,7 +3,7 @@ set -eo pipefail function usage() { - echo "Usage: $0 litentry|litmus|rococo" + echo "Usage: $0 litentry|litmus|rococo|paseo" } [ $# -ne 1 ] && (usage; exit 1) diff --git a/scripts/run-ts-test.sh b/scripts/run-ts-test.sh index 9eb645a079..9ab7a55636 100755 --- a/scripts/run-ts-test.sh +++ b/scripts/run-ts-test.sh @@ -6,7 +6,7 @@ bridge=false evm=false case "$1" in - litentry|litmus|rococo) export PARACHAIN_TYPE=$1 ;; + litentry|litmus|rococo|paseo) export PARACHAIN_TYPE=$1 ;; *) echo "usage: ./$0 litmus|litentry [bridge]"; exit 1 ;; esac From f8e6cb0bfd00db5749799dcca3b8935a79cbdbae Mon Sep 17 00:00:00 2001 From: felixfaisal Date: Mon, 12 Aug 2024 07:58:35 +0000 Subject: [PATCH 03/21] fix: update lock files --- Cargo.lock | 112 +++++++++++++++++ docker/pnpm-lock.yaml | 271 +++++++++++++++++++++--------------------- 2 files changed, 249 insertions(+), 134 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 3fcf1a636b..e3a84979af 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -5471,6 +5471,7 @@ dependencies = [ "moonbeam-rpc-trace", "moonbeam-rpc-txpool", "pallet-transaction-payment-rpc", + "paseo-parachain-runtime", "polkadot-cli", "polkadot-primitives", "polkadot-service", @@ -8448,6 +8449,117 @@ dependencies = [ "windows-targets 0.48.1", ] +[[package]] +name = "paseo-parachain-runtime" +version = "0.1.0" +dependencies = [ + "core-primitives", + "cumulus-pallet-aura-ext", + "cumulus-pallet-dmp-queue", + "cumulus-pallet-parachain-system", + "cumulus-pallet-session-benchmarking", + "cumulus-pallet-xcm", + "cumulus-pallet-xcmp-queue", + "cumulus-primitives-core", + "cumulus-primitives-parachain-inherent", + "cumulus-primitives-timestamp", + "cumulus-primitives-utility", + "fp-evm", + "fp-rpc", + "fp-self-contained", + "frame-benchmarking", + "frame-executive", + "frame-support", + "frame-system", + "frame-system-benchmarking", + "frame-system-rpc-runtime-api", + "frame-try-runtime", + "hex-literal 0.4.1", + "log", + "moonbeam-evm-tracer", + "moonbeam-rpc-primitives-debug", + "moonbeam-rpc-primitives-txpool", + "num_enum 0.7.3", + "orml-traits", + "orml-xtokens", + "pallet-account-fix", + "pallet-asset-manager", + "pallet-assets", + "pallet-assets-handler", + "pallet-aura", + "pallet-authorship", + "pallet-balances", + "pallet-bitacross", + "pallet-bounties", + "pallet-bridge", + "pallet-bridge-transfer", + "pallet-collective", + "pallet-democracy", + "pallet-ethereum", + "pallet-evm", + "pallet-evm-assertions", + "pallet-evm-precompile-assets-erc20", + "pallet-evm-precompile-blake2", + "pallet-evm-precompile-bn128", + "pallet-evm-precompile-bridge-transfer", + "pallet-evm-precompile-dispatch", + "pallet-evm-precompile-ed25519", + "pallet-evm-precompile-modexp", + "pallet-evm-precompile-parachain-staking", + "pallet-evm-precompile-score-staking", + "pallet-evm-precompile-sha3fips", + "pallet-evm-precompile-simple", + "pallet-extrinsic-filter", + "pallet-group", + "pallet-identity", + "pallet-identity-management", + "pallet-membership", + "pallet-multisig", + "pallet-parachain-staking", + "pallet-preimage", + "pallet-proxy", + "pallet-scheduler", + "pallet-score-staking", + "pallet-session", + "pallet-sudo", + "pallet-teebag", + "pallet-timestamp", + "pallet-tips", + "pallet-transaction-payment", + "pallet-transaction-payment-rpc-runtime-api", + "pallet-treasury", + "pallet-utility", + "pallet-vc-management", + "pallet-vesting", + "pallet-xcm", + "parachain-info", + "parity-scale-codec", + "polkadot-parachain", + "polkadot-primitives", + "polkadot-runtime-parachains", + "precompile-utils", + "runtime-common", + "scale-info", + "sp-api", + "sp-block-builder", + "sp-consensus-aura", + "sp-core", + "sp-inherents", + "sp-io", + "sp-offchain", + "sp-runtime", + "sp-session", + "sp-state-machine", + "sp-std", + "sp-transaction-pool", + "sp-version", + "substrate-wasm-builder", + "xcm", + "xcm-builder", + "xcm-executor", + "xcm-simulator", +] + [[package]] name = "paste" version = "1.0.15" diff --git a/docker/pnpm-lock.yaml b/docker/pnpm-lock.yaml index b44139ab89..3c0152d20d 100644 --- a/docker/pnpm-lock.yaml +++ b/docker/pnpm-lock.yaml @@ -11,8 +11,8 @@ dependencies: packages: - /@noble/curves@1.4.0: - resolution: {integrity: sha512-p+4cb332SFCrReJkCYe8Xzm0OWi4Jji5jVdIZRL/PmacmDkFNw6MrrV+gGpiPxLHbV+zKFRywUWbaseT+tZRXg==} + /@noble/curves@1.5.0: + resolution: {integrity: sha512-J5EKamIHnKPyClwVrzmaf5wSdQXgdHcPZIZLu3bwnbeCx8/7NPK5q2ZBWF+5FvYGByjiQQsJYX6jfgB2wDPn3A==} dependencies: '@noble/hashes': 1.4.0 dev: false @@ -63,7 +63,7 @@ packages: dependencies: '@noble/hashes': 1.4.0 '@polkadot-api/utils': 0.0.1-492c132563ea6b40ae1fc5470dec4cd18768d182.1.0 - '@scure/base': 1.1.6 + '@scure/base': 1.1.7 scale-ts: 1.6.0 dev: false optional: true @@ -80,79 +80,79 @@ packages: dev: false optional: true - /@polkadot/api-augment@10.12.6: - resolution: {integrity: sha512-CZHaFAd6zexk3JCm1mY5doE1E634xNpKaTGpbs61Ch285d5EqBY25GdzGNiMprNl4VyRFT4N7dXKfwEdsM6Z9w==} + /@polkadot/api-augment@10.13.1: + resolution: {integrity: sha512-IAKaCp19QxgOG4HKk9RAgUgC/VNVqymZ2GXfMNOZWImZhxRIbrK+raH5vN2MbWwtVHpjxyXvGsd1RRhnohI33A==} engines: {node: '>=18'} dependencies: - '@polkadot/api-base': 10.12.6 - '@polkadot/rpc-augment': 10.12.6 - '@polkadot/types': 10.12.6 - '@polkadot/types-augment': 10.12.6 - '@polkadot/types-codec': 10.12.6 + '@polkadot/api-base': 10.13.1 + '@polkadot/rpc-augment': 10.13.1 + '@polkadot/types': 10.13.1 + '@polkadot/types-augment': 10.13.1 + '@polkadot/types-codec': 10.13.1 '@polkadot/util': 12.6.2 - tslib: 2.6.2 + tslib: 2.6.3 transitivePeerDependencies: - bufferutil - supports-color - utf-8-validate dev: false - /@polkadot/api-base@10.12.6: - resolution: {integrity: sha512-6EzMettffiadB5j0X2nValtrEZJ2dKZMArfWHbSCV1QRSPOaMO3Phf/idqtF8HgBHD3FCHJ+JsZEns6xpkpteg==} + /@polkadot/api-base@10.13.1: + resolution: {integrity: sha512-Okrw5hjtEjqSMOG08J6qqEwlUQujTVClvY1/eZkzKwNzPelWrtV6vqfyJklB7zVhenlxfxqhZKKcY7zWSW/q5Q==} engines: {node: '>=18'} dependencies: - '@polkadot/rpc-core': 10.12.6 - '@polkadot/types': 10.12.6 + '@polkadot/rpc-core': 10.13.1 + '@polkadot/types': 10.13.1 '@polkadot/util': 12.6.2 rxjs: 7.8.1 - tslib: 2.6.2 + tslib: 2.6.3 transitivePeerDependencies: - bufferutil - supports-color - utf-8-validate dev: false - /@polkadot/api-derive@10.12.6: - resolution: {integrity: sha512-stjciYU9caSvPrcPo40zwPu15O7Q9OK9ldMFyyQkDdUT4cCE0LHuCmTNwcm4XhQq3XXJn+e7WNdhBfquwvkuhw==} + /@polkadot/api-derive@10.13.1: + resolution: {integrity: sha512-ef0H0GeCZ4q5Om+c61eLLLL29UxFC2/u/k8V1K2JOIU+2wD5LF7sjAoV09CBMKKHfkLenRckVk2ukm4rBqFRpg==} engines: {node: '>=18'} dependencies: - '@polkadot/api': 10.12.6 - '@polkadot/api-augment': 10.12.6 - '@polkadot/api-base': 10.12.6 - '@polkadot/rpc-core': 10.12.6 - '@polkadot/types': 10.12.6 - '@polkadot/types-codec': 10.12.6 + '@polkadot/api': 10.13.1 + '@polkadot/api-augment': 10.13.1 + '@polkadot/api-base': 10.13.1 + '@polkadot/rpc-core': 10.13.1 + '@polkadot/types': 10.13.1 + '@polkadot/types-codec': 10.13.1 '@polkadot/util': 12.6.2 '@polkadot/util-crypto': 12.6.2(@polkadot/util@12.6.2) rxjs: 7.8.1 - tslib: 2.6.2 + tslib: 2.6.3 transitivePeerDependencies: - bufferutil - supports-color - utf-8-validate dev: false - /@polkadot/api@10.12.6: - resolution: {integrity: sha512-qWF7qFLZtpSILuPeZcvz0oCBXe89XndDjzgCnflvEVIUkQvxtFM8mDXpzI4bz8klrLYHlyFbP7HJl/xLi+XTew==} + /@polkadot/api@10.13.1: + resolution: {integrity: sha512-YrKWR4TQR5CDyGkF0mloEUo7OsUA+bdtENpJGOtNavzOQUDEbxFE0PVzokzZfVfHhHX2CojPVmtzmmLxztyJkg==} engines: {node: '>=18'} dependencies: - '@polkadot/api-augment': 10.12.6 - '@polkadot/api-base': 10.12.6 - '@polkadot/api-derive': 10.12.6 + '@polkadot/api-augment': 10.13.1 + '@polkadot/api-base': 10.13.1 + '@polkadot/api-derive': 10.13.1 '@polkadot/keyring': 12.6.2(@polkadot/util-crypto@12.6.2)(@polkadot/util@12.6.2) - '@polkadot/rpc-augment': 10.12.6 - '@polkadot/rpc-core': 10.12.6 - '@polkadot/rpc-provider': 10.12.6 - '@polkadot/types': 10.12.6 - '@polkadot/types-augment': 10.12.6 - '@polkadot/types-codec': 10.12.6 - '@polkadot/types-create': 10.12.6 - '@polkadot/types-known': 10.12.6 + '@polkadot/rpc-augment': 10.13.1 + '@polkadot/rpc-core': 10.13.1 + '@polkadot/rpc-provider': 10.13.1 + '@polkadot/types': 10.13.1 + '@polkadot/types-augment': 10.13.1 + '@polkadot/types-codec': 10.13.1 + '@polkadot/types-create': 10.13.1 + '@polkadot/types-known': 10.13.1 '@polkadot/util': 12.6.2 '@polkadot/util-crypto': 12.6.2(@polkadot/util@12.6.2) eventemitter3: 5.0.1 rxjs: 7.8.1 - tslib: 2.6.2 + tslib: 2.6.3 transitivePeerDependencies: - bufferutil - supports-color @@ -168,7 +168,7 @@ packages: dependencies: '@polkadot/util': 12.6.2 '@polkadot/util-crypto': 12.6.2(@polkadot/util@12.6.2) - tslib: 2.6.2 + tslib: 2.6.3 dev: false /@polkadot/networks@12.6.2: @@ -176,48 +176,48 @@ packages: engines: {node: '>=18'} dependencies: '@polkadot/util': 12.6.2 - '@substrate/ss58-registry': 1.47.0 - tslib: 2.6.2 + '@substrate/ss58-registry': 1.49.0 + tslib: 2.6.3 dev: false - /@polkadot/rpc-augment@10.12.6: - resolution: {integrity: sha512-MMZgdZtVygHqgsmCdKhfaN9ywf6im72xJzc9H8fkqyoJ+cGVy36uI3e8YwEM9vV6g/nallFmz4mU46u8/TjGlw==} + /@polkadot/rpc-augment@10.13.1: + resolution: {integrity: sha512-iLsWUW4Jcx3DOdVrSHtN0biwxlHuTs4QN2hjJV0gd0jo7W08SXhWabZIf9mDmvUJIbR7Vk+9amzvegjRyIf5+A==} engines: {node: '>=18'} dependencies: - '@polkadot/rpc-core': 10.12.6 - '@polkadot/types': 10.12.6 - '@polkadot/types-codec': 10.12.6 + '@polkadot/rpc-core': 10.13.1 + '@polkadot/types': 10.13.1 + '@polkadot/types-codec': 10.13.1 '@polkadot/util': 12.6.2 - tslib: 2.6.2 + tslib: 2.6.3 transitivePeerDependencies: - bufferutil - supports-color - utf-8-validate dev: false - /@polkadot/rpc-core@10.12.6: - resolution: {integrity: sha512-aBXhkryv2NMNg+cWajn/G0DF13inXIW+6iZV9cGc6lfsYT9Di/sasO0EIx7UUZW3ILYQ6Gh9jRgNLkwSNlAV9Q==} + /@polkadot/rpc-core@10.13.1: + resolution: {integrity: sha512-eoejSHa+/tzHm0vwic62/aptTGbph8vaBpbvLIK7gd00+rT813ROz5ckB1CqQBFB23nHRLuzzX/toY8ID3xrKw==} engines: {node: '>=18'} dependencies: - '@polkadot/rpc-augment': 10.12.6 - '@polkadot/rpc-provider': 10.12.6 - '@polkadot/types': 10.12.6 + '@polkadot/rpc-augment': 10.13.1 + '@polkadot/rpc-provider': 10.13.1 + '@polkadot/types': 10.13.1 '@polkadot/util': 12.6.2 rxjs: 7.8.1 - tslib: 2.6.2 + tslib: 2.6.3 transitivePeerDependencies: - bufferutil - supports-color - utf-8-validate dev: false - /@polkadot/rpc-provider@10.12.6: - resolution: {integrity: sha512-xLmzb2rMQXEWQlrIDY3E3IXo1jcV9+Vy3A8zMw/s/UIrwXZ3I0TefP8+mXcqEjLkkz7zwldDQvHfdmtnxdE14g==} + /@polkadot/rpc-provider@10.13.1: + resolution: {integrity: sha512-oJ7tatVXYJ0L7NpNiGd69D558HG5y5ZDmH2Bp9Dd4kFTQIiV8A39SlWwWUPCjSsen9lqSvvprNLnG/VHTpenbw==} engines: {node: '>=18'} dependencies: '@polkadot/keyring': 12.6.2(@polkadot/util-crypto@12.6.2)(@polkadot/util@12.6.2) - '@polkadot/types': 10.12.6 - '@polkadot/types-support': 10.12.6 + '@polkadot/types': 10.13.1 + '@polkadot/types-support': 10.13.1 '@polkadot/util': 12.6.2 '@polkadot/util-crypto': 12.6.2(@polkadot/util@12.6.2) '@polkadot/x-fetch': 12.6.2 @@ -226,7 +226,7 @@ packages: eventemitter3: 5.0.1 mock-socket: 9.3.1 nock: 13.5.4 - tslib: 2.6.2 + tslib: 2.6.3 optionalDependencies: '@substrate/connect': 0.8.8 transitivePeerDependencies: @@ -235,66 +235,66 @@ packages: - utf-8-validate dev: false - /@polkadot/types-augment@10.12.6: - resolution: {integrity: sha512-eUNanLs0w7SQLlsjFs7kTPfOTclfjllJxghwRqWZFHWjUbVcGcPwr8ITv/mfx1WTCqUqLMe6K8CPJ7BSggAWBA==} + /@polkadot/types-augment@10.13.1: + resolution: {integrity: sha512-TcrLhf95FNFin61qmVgOgayzQB/RqVsSg9thAso1Fh6pX4HSbvI35aGPBAn3SkA6R+9/TmtECirpSNLtIGFn0g==} engines: {node: '>=18'} dependencies: - '@polkadot/types': 10.12.6 - '@polkadot/types-codec': 10.12.6 + '@polkadot/types': 10.13.1 + '@polkadot/types-codec': 10.13.1 '@polkadot/util': 12.6.2 - tslib: 2.6.2 + tslib: 2.6.3 dev: false - /@polkadot/types-codec@10.12.6: - resolution: {integrity: sha512-yCzKdj/mLhjSG3mR1XhQdzzpAy0Exv9UuEhGQHPpdjkF0CCfVgsFoOAF3ScsSzwacJxGgxPWvlk849DfTrBYGA==} + /@polkadot/types-codec@10.13.1: + resolution: {integrity: sha512-AiQ2Vv2lbZVxEdRCN8XSERiWlOWa2cTDLnpAId78EnCtx4HLKYQSd+Jk9Y4BgO35R79mchK4iG+w6gZ+ukG2bg==} engines: {node: '>=18'} dependencies: '@polkadot/util': 12.6.2 '@polkadot/x-bigint': 12.6.2 - tslib: 2.6.2 + tslib: 2.6.3 dev: false - /@polkadot/types-create@10.12.6: - resolution: {integrity: sha512-byuPy7IUFjzoxG3qrP4kEScfR92KFOAkaJksNT4kDZILPCeZSPPN7cLqdejypwDBqJthTJM0LqKK4g+eHGKdvw==} + /@polkadot/types-create@10.13.1: + resolution: {integrity: sha512-Usn1jqrz35SXgCDAqSXy7mnD6j4RvB4wyzTAZipFA6DGmhwyxxIgOzlWQWDb+1PtPKo9vtMzen5IJ+7w5chIeA==} engines: {node: '>=18'} dependencies: - '@polkadot/types-codec': 10.12.6 + '@polkadot/types-codec': 10.13.1 '@polkadot/util': 12.6.2 - tslib: 2.6.2 + tslib: 2.6.3 dev: false - /@polkadot/types-known@10.12.6: - resolution: {integrity: sha512-E/LWfOAPUW7YKAiioY7Ax/s+G4cuNQop3U/TPPM7sxXOv9hSia2hgFjtiU4NyTRVwf1O07YASXtYSecdSgcCuQ==} + /@polkadot/types-known@10.13.1: + resolution: {integrity: sha512-uHjDW05EavOT5JeU8RbiFWTgPilZ+odsCcuEYIJGmK+es3lk/Qsdns9Zb7U7NJl7eJ6OWmRtyrWsLs+bU+jjIQ==} engines: {node: '>=18'} dependencies: '@polkadot/networks': 12.6.2 - '@polkadot/types': 10.12.6 - '@polkadot/types-codec': 10.12.6 - '@polkadot/types-create': 10.12.6 + '@polkadot/types': 10.13.1 + '@polkadot/types-codec': 10.13.1 + '@polkadot/types-create': 10.13.1 '@polkadot/util': 12.6.2 - tslib: 2.6.2 + tslib: 2.6.3 dev: false - /@polkadot/types-support@10.12.6: - resolution: {integrity: sha512-SMq/hUZJLCZXq26pNDaxgXNJqAJD8YhVXWXulCg0YvbIoVwEkFE66TEkUbtoRLKcsZXbPdxJ3JfSoa9r6Ewhnw==} + /@polkadot/types-support@10.13.1: + resolution: {integrity: sha512-4gEPfz36XRQIY7inKq0HXNVVhR6HvXtm7yrEmuBuhM86LE0lQQBkISUSgR358bdn2OFSLMxMoRNoh3kcDvdGDQ==} engines: {node: '>=18'} dependencies: '@polkadot/util': 12.6.2 - tslib: 2.6.2 + tslib: 2.6.3 dev: false - /@polkadot/types@10.12.6: - resolution: {integrity: sha512-ByjvZkKJclHSWEETk1m9HPYn/IdIyjWONOdy7Ih+/Nd0wVIahvXDYbV4CXe25xO0RhfFJzkGIZP+LFHL5F63Uw==} + /@polkadot/types@10.13.1: + resolution: {integrity: sha512-Hfvg1ZgJlYyzGSAVrDIpp3vullgxrjOlh/CSThd/PI4TTN1qHoPSFm2hs77k3mKkOzg+LrWsLE0P/LP2XddYcw==} engines: {node: '>=18'} dependencies: '@polkadot/keyring': 12.6.2(@polkadot/util-crypto@12.6.2)(@polkadot/util@12.6.2) - '@polkadot/types-augment': 10.12.6 - '@polkadot/types-codec': 10.12.6 - '@polkadot/types-create': 10.12.6 + '@polkadot/types-augment': 10.13.1 + '@polkadot/types-codec': 10.13.1 + '@polkadot/types-create': 10.13.1 '@polkadot/util': 12.6.2 '@polkadot/util-crypto': 12.6.2(@polkadot/util@12.6.2) rxjs: 7.8.1 - tslib: 2.6.2 + tslib: 2.6.3 dev: false /@polkadot/util-crypto@12.6.2(@polkadot/util@12.6.2): @@ -303,7 +303,7 @@ packages: peerDependencies: '@polkadot/util': 12.6.2 dependencies: - '@noble/curves': 1.4.0 + '@noble/curves': 1.5.0 '@noble/hashes': 1.4.0 '@polkadot/networks': 12.6.2 '@polkadot/util': 12.6.2 @@ -311,8 +311,8 @@ packages: '@polkadot/wasm-util': 7.3.2(@polkadot/util@12.6.2) '@polkadot/x-bigint': 12.6.2 '@polkadot/x-randomvalues': 12.6.2(@polkadot/util@12.6.2)(@polkadot/wasm-util@7.3.2) - '@scure/base': 1.1.6 - tslib: 2.6.2 + '@scure/base': 1.1.7 + tslib: 2.6.3 dev: false /@polkadot/util@12.6.2: @@ -325,7 +325,7 @@ packages: '@polkadot/x-textencoder': 12.6.2 '@types/bn.js': 5.1.5 bn.js: 5.2.1 - tslib: 2.6.2 + tslib: 2.6.3 dev: false /@polkadot/wasm-bridge@7.3.2(@polkadot/util@12.6.2)(@polkadot/x-randomvalues@12.6.2): @@ -338,7 +338,7 @@ packages: '@polkadot/util': 12.6.2 '@polkadot/wasm-util': 7.3.2(@polkadot/util@12.6.2) '@polkadot/x-randomvalues': 12.6.2(@polkadot/util@12.6.2)(@polkadot/wasm-util@7.3.2) - tslib: 2.6.2 + tslib: 2.6.3 dev: false /@polkadot/wasm-crypto-asmjs@7.3.2(@polkadot/util@12.6.2): @@ -348,7 +348,7 @@ packages: '@polkadot/util': '*' dependencies: '@polkadot/util': 12.6.2 - tslib: 2.6.2 + tslib: 2.6.3 dev: false /@polkadot/wasm-crypto-init@7.3.2(@polkadot/util@12.6.2)(@polkadot/x-randomvalues@12.6.2): @@ -364,7 +364,7 @@ packages: '@polkadot/wasm-crypto-wasm': 7.3.2(@polkadot/util@12.6.2) '@polkadot/wasm-util': 7.3.2(@polkadot/util@12.6.2) '@polkadot/x-randomvalues': 12.6.2(@polkadot/util@12.6.2)(@polkadot/wasm-util@7.3.2) - tslib: 2.6.2 + tslib: 2.6.3 dev: false /@polkadot/wasm-crypto-wasm@7.3.2(@polkadot/util@12.6.2): @@ -375,7 +375,7 @@ packages: dependencies: '@polkadot/util': 12.6.2 '@polkadot/wasm-util': 7.3.2(@polkadot/util@12.6.2) - tslib: 2.6.2 + tslib: 2.6.3 dev: false /@polkadot/wasm-crypto@7.3.2(@polkadot/util@12.6.2)(@polkadot/x-randomvalues@12.6.2): @@ -392,7 +392,7 @@ packages: '@polkadot/wasm-crypto-wasm': 7.3.2(@polkadot/util@12.6.2) '@polkadot/wasm-util': 7.3.2(@polkadot/util@12.6.2) '@polkadot/x-randomvalues': 12.6.2(@polkadot/util@12.6.2)(@polkadot/wasm-util@7.3.2) - tslib: 2.6.2 + tslib: 2.6.3 dev: false /@polkadot/wasm-util@7.3.2(@polkadot/util@12.6.2): @@ -402,7 +402,7 @@ packages: '@polkadot/util': '*' dependencies: '@polkadot/util': 12.6.2 - tslib: 2.6.2 + tslib: 2.6.3 dev: false /@polkadot/x-bigint@12.6.2: @@ -410,7 +410,7 @@ packages: engines: {node: '>=18'} dependencies: '@polkadot/x-global': 12.6.2 - tslib: 2.6.2 + tslib: 2.6.3 dev: false /@polkadot/x-fetch@12.6.2: @@ -419,14 +419,14 @@ packages: dependencies: '@polkadot/x-global': 12.6.2 node-fetch: 3.3.2 - tslib: 2.6.2 + tslib: 2.6.3 dev: false /@polkadot/x-global@12.6.2: resolution: {integrity: sha512-a8d6m+PW98jmsYDtAWp88qS4dl8DyqUBsd0S+WgyfSMtpEXu6v9nXDgPZgwF5xdDvXhm+P0ZfVkVTnIGrScb5g==} engines: {node: '>=18'} dependencies: - tslib: 2.6.2 + tslib: 2.6.3 dev: false /@polkadot/x-randomvalues@12.6.2(@polkadot/util@12.6.2)(@polkadot/wasm-util@7.3.2): @@ -439,7 +439,7 @@ packages: '@polkadot/util': 12.6.2 '@polkadot/wasm-util': 7.3.2(@polkadot/util@12.6.2) '@polkadot/x-global': 12.6.2 - tslib: 2.6.2 + tslib: 2.6.3 dev: false /@polkadot/x-textdecoder@12.6.2: @@ -447,7 +447,7 @@ packages: engines: {node: '>=18'} dependencies: '@polkadot/x-global': 12.6.2 - tslib: 2.6.2 + tslib: 2.6.3 dev: false /@polkadot/x-textencoder@12.6.2: @@ -455,7 +455,7 @@ packages: engines: {node: '>=18'} dependencies: '@polkadot/x-global': 12.6.2 - tslib: 2.6.2 + tslib: 2.6.3 dev: false /@polkadot/x-ws@12.6.2: @@ -463,15 +463,15 @@ packages: engines: {node: '>=18'} dependencies: '@polkadot/x-global': 12.6.2 - tslib: 2.6.2 - ws: 8.16.0 + tslib: 2.6.3 + ws: 8.18.0 transitivePeerDependencies: - bufferutil - utf-8-validate dev: false - /@scure/base@1.1.6: - resolution: {integrity: sha512-ok9AWwhcgYuGG3Zfhyqg+zwl+Wn5uE+dwC0NV/2qQkx4dABbb/bx96vWu8NSj+BNjjSjno+JRYRjle1jV08k3g==} + /@scure/base@1.1.7: + resolution: {integrity: sha512-PPNYBslrLNNUQ/Yad37MHYsNQtK67EhWb6WtSvNLLPo7SdVZgkUjD6Dg+5On7zNwmskf8OX7I7Nx5oN+MIWE0g==} dev: false /@substrate/connect-extension-protocol@2.0.0: @@ -480,8 +480,8 @@ packages: dev: false optional: true - /@substrate/connect-known-chains@1.1.4: - resolution: {integrity: sha512-iT+BdKqvKl/uBLd8BAJysFM1BaMZXRkaXBP2B7V7ob/EyNs5h0EMhTVbO6MJxV/IEOg5OKsyl6FUqQK7pKnqyw==} + /@substrate/connect-known-chains@1.2.2: + resolution: {integrity: sha512-gOGrXSWA2d/3kf8Yco00VlHZl48smzAGW5Z9MDxMht98hRpT2yEEN4N5QdoEKMI4ihDW8goXGzmp79D0hFPpuA==} requiresBuild: true dev: false optional: true @@ -491,7 +491,7 @@ packages: requiresBuild: true dependencies: '@substrate/connect-extension-protocol': 2.0.0 - '@substrate/connect-known-chains': 1.1.4 + '@substrate/connect-known-chains': 1.2.2 '@substrate/light-client-extension-helpers': 0.0.4(smoldot@2.0.22) smoldot: 2.0.22 transitivePeerDependencies: @@ -511,26 +511,26 @@ packages: '@polkadot-api/json-rpc-provider-proxy': 0.0.1-492c132563ea6b40ae1fc5470dec4cd18768d182.1.0 '@polkadot-api/substrate-client': 0.0.1-492c132563ea6b40ae1fc5470dec4cd18768d182.1.0 '@substrate/connect-extension-protocol': 2.0.0 - '@substrate/connect-known-chains': 1.1.4 + '@substrate/connect-known-chains': 1.2.2 rxjs: 7.8.1 smoldot: 2.0.22 dev: false optional: true - /@substrate/ss58-registry@1.47.0: - resolution: {integrity: sha512-6kuIJedRcisUJS2pgksEH2jZf3hfSIVzqtFzs/AyjTW3ETbMg5q1Bb7VWa0WYaT6dTrEXp/6UoXM5B9pSIUmcw==} + /@substrate/ss58-registry@1.49.0: + resolution: {integrity: sha512-leW6Ix4LD7XgvxT7+aobPWSw+WvPcN2Rxof1rmd0mNC5t2n99k1N7UNEvz7YEFSOUeHWmKIY7F5q8KeIqYoHfA==} dev: false /@types/bn.js@5.1.5: resolution: {integrity: sha512-V46N0zwKRF5Q00AZ6hWtN0T8gGmDUaUzLWQvHFo5yThtVwK/VCenFY3wXVbOvNfajEpsTfQM4IN9k/d6gUVX3A==} dependencies: - '@types/node': 20.12.7 + '@types/node': 22.2.0 dev: false - /@types/node@20.12.7: - resolution: {integrity: sha512-wq0cICSkRLVaf3UGLMGItu/PtdY7oaXaI/RVU+xliKVOtRna3PRY57ZDfztpDL0n11vfymMUnXv8QwYCO7L1wg==} + /@types/node@22.2.0: + resolution: {integrity: sha512-bm6EG6/pCpkxDf/0gDNDdtDILMOHgaQBVOJGdwsqClnxA3xL6jtMv76rLBc006RVMWbmaf0xbmom4Z/5o2nRkQ==} dependencies: - undici-types: 5.26.5 + undici-types: 6.13.0 dev: false /ansi-regex@5.0.1: @@ -589,8 +589,8 @@ packages: engines: {node: '>= 12'} dev: false - /debug@4.3.4: - resolution: {integrity: sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==} + /debug@4.3.6: + resolution: {integrity: sha512-O/09Bd4Z1fBrU4VzkhFqVgpPzaGbw6Sm9FEkBT1A/YBXQFGuuSxa1dN2nxgxS34JmKXqYx8CZAwEVoJFImUXIg==} engines: {node: '>=6.0'} peerDependencies: supports-color: '*' @@ -644,6 +644,7 @@ packages: /glob@7.2.3: resolution: {integrity: sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==} + deprecated: Glob versions prior to v9 are no longer supported dependencies: fs.realpath: 1.0.0 inflight: 1.0.6 @@ -662,6 +663,7 @@ packages: /inflight@1.0.6: resolution: {integrity: sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==} + deprecated: This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful. dependencies: once: 1.4.0 wrappy: 1.0.2 @@ -676,8 +678,9 @@ packages: engines: {node: '>= 0.10'} dev: false - /is-core-module@2.13.1: - resolution: {integrity: sha512-hHrIjvZsftOsvKSn2TRYl63zvxsgE0K+0mYMoH6gD4omR5IWB2KynivBQczo3+wF1cCkjzvptnI9Q0sPU66ilw==} + /is-core-module@2.15.0: + resolution: {integrity: sha512-Dd+Lb2/zvk9SKy1TGCt1wFJFo/MWBPMX5x7KcvLajWTGuomczdQX61PvY5yK6SVACwpoexWo81IfFyoKY2QnTA==} + engines: {node: '>= 0.4'} dependencies: hasown: 2.0.2 dev: false @@ -714,7 +717,7 @@ packages: resolution: {integrity: sha512-yAyTfdeNJGGBFxWdzSKCBYxs5FxLbCg5X5Q4ets974hcQzG1+qCxvIyOo4j2Ry6MUlhWVMX4OoYDefAIIwupjw==} engines: {node: '>= 10.13'} dependencies: - debug: 4.3.4 + debug: 4.3.6 json-stringify-safe: 5.0.1 propagate: 2.0.1 transitivePeerDependencies: @@ -776,7 +779,7 @@ packages: resolution: {integrity: sha512-oKWePCxqpd6FlLvGV1VU0x7bkPmmCNolxzjMf4NczoDnQcIWrAF+cPtZn5i6n+RfD2d9i0tzpKnG6Yk168yIyw==} hasBin: true dependencies: - is-core-module: 2.13.1 + is-core-module: 2.15.0 path-parse: 1.0.7 supports-preserve-symlinks-flag: 1.0.0 dev: false @@ -784,7 +787,7 @@ packages: /rxjs@7.8.1: resolution: {integrity: sha512-AA3TVj+0A2iuIoQkWEK/tqFjBq2j+6PO6Y0zJcvzLAFhEFIO3HL0vls9hWLncZbAAbK0mar7oZ4V079I/qPMxg==} dependencies: - tslib: 2.6.2 + tslib: 2.6.3 dev: false /scale-ts@1.6.0: @@ -807,7 +810,7 @@ packages: resolution: {integrity: sha512-B50vRgTY6v3baYH6uCgL15tfaag5tcS2o/P5q1OiXcKGv1axZDfz2dzzMuIkVpyMR2ug11F6EAtQlmYBQd292g==} requiresBuild: true dependencies: - ws: 8.16.0 + ws: 8.18.0 transitivePeerDependencies: - bufferutil - utf-8-validate @@ -835,12 +838,12 @@ packages: engines: {node: '>= 0.4'} dev: false - /tslib@2.6.2: - resolution: {integrity: sha512-AEYxH93jGFPn/a2iVAwW87VuUIkR1FVUKB77NwMF7nBTDkDrrT/Hpt/IrCJ0QXhW27jTBDcf5ZY7w6RiqTMw2Q==} + /tslib@2.6.3: + resolution: {integrity: sha512-xNvxJEOUiWPGhUuUdQgAJPKOOJfGnIyKySOc09XkKsgdUV/3E2zvwZYdejjmRgPCgcym1juLH3226yA7sEFJKQ==} dev: false - /undici-types@5.26.5: - resolution: {integrity: sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==} + /undici-types@6.13.0: + resolution: {integrity: sha512-xtFJHudx8S2DSoujjMd1WeWvn7KKWFRESZTMeL1RptAYERu29D6jphMjjY+vn96jvN3kVPDNxU/E13VTaXj6jg==} dev: false /web-streams-polyfill@3.3.3: @@ -861,8 +864,8 @@ packages: resolution: {integrity: sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==} dev: false - /ws@8.16.0: - resolution: {integrity: sha512-HS0c//TP7Ina87TfiPUz1rQzMhHrl/SG2guqRcTOIUYD2q8uhUdNHZYJUaQ8aTGPzCh+c6oawMKW35nFl1dxyQ==} + /ws@8.18.0: + resolution: {integrity: sha512-8VbfWfHLbbwu3+N6OKsOMpBdT4kXPDDB9cJk2bJ6mh9ucxdlnNvH1e+roYkKmN9Nxw2yjz7VzeO9oOz2zJ04Pw==} engines: {node: '>=10.0.0'} peerDependencies: bufferutil: ^4.0.1 @@ -879,8 +882,8 @@ packages: engines: {node: '>=10'} dev: false - /yaml@2.4.1: - resolution: {integrity: sha512-pIXzoImaqmfOrL7teGUBt/T7ZDnyeGBWyXQBvOVhLkWLN37GXv8NMLK406UY6dS51JfcQHsmcW5cJ441bHg6Lg==} + /yaml@2.5.0: + resolution: {integrity: sha512-2wWLbGbYDiSqqIKoPjar3MPgB94ErzCtrNE1FdqGuaO0pi2JGjmE8aW8TDZwzU7vuxcGRdL/4gPQwQ7hD5AMSw==} engines: {node: '>= 14'} hasBin: true dev: false @@ -909,14 +912,14 @@ packages: version: 1.4.2 hasBin: true dependencies: - '@polkadot/api': 10.12.6 + '@polkadot/api': 10.13.1 '@polkadot/keyring': 12.6.2(@polkadot/util-crypto@12.6.2)(@polkadot/util@12.6.2) '@polkadot/util': 12.6.2 '@polkadot/util-crypto': 12.6.2(@polkadot/util@12.6.2) lodash: 4.17.21 readline-sync: 1.4.10 shelljs: 0.8.5 - yaml: 2.4.1 + yaml: 2.5.0 yargs: 17.7.2 transitivePeerDependencies: - bufferutil From a301db4ed631720925b5aa8d5f53b3ca47e151fe Mon Sep 17 00:00:00 2001 From: felixfaisal Date: Tue, 13 Aug 2024 10:07:07 +0000 Subject: [PATCH 04/21] fix: add ts-tests for paseo in CI --- .github/workflows/ci.yml | 1 + Makefile | 8 ++++---- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 81922671e3..6703d96c0c 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -610,6 +610,7 @@ jobs: - litmus - litentry - rococo + - paseo name: ${{ matrix.chain }} steps: - uses: actions/checkout@v4 diff --git a/Makefile b/Makefile index b11515298f..571c130543 100644 --- a/Makefile +++ b/Makefile @@ -146,8 +146,8 @@ test-ts-docker-litmus: launch-docker-litmus launch-docker-bridge test-ts-docker-rococo: launch-docker-rococo launch-docker-bridge @./scripts/run-ts-test.sh rococo bridge evm -.PHONY: test-ts-docker-paseo ## Run rococo ts tests with docker without clean-up -test-ts-docker-rococo: launch-docker-paseo launch-docker-bridge +.PHONY: test-ts-docker-paseo ## Run paseo ts tests with docker without clean-up +test-ts-docker-paseo: launch-docker-paseo launch-docker-bridge @./scripts/run-ts-test.sh paseo bridge evm .PHONY: test-ts-binary-litentry ## Run litentry ts tests with binary without clean-up @@ -162,8 +162,8 @@ test-ts-binary-litmus: launch-binary-litmus test-ts-binary-rococo: launch-binary-rococo @./scripts/run-ts-test.sh rococo no_bridge evm -.PHONY: test-ts-binary-paseo ## Run rococo ts tests with binary without clean-up -test-ts-binary-rococo: launch-binary-paseo +.PHONY: test-ts-binary-paseo ## Run paseo ts tests with binary without clean-up +test-ts-binary-paseo: launch-binary-paseo @./scripts/run-ts-test.sh paseo no_bridge evm # clean up From 661d25195a44bd37484e60148db8d58872db1da4 Mon Sep 17 00:00:00 2001 From: felixfaisal Date: Tue, 20 Aug 2024 15:44:49 +0000 Subject: [PATCH 05/21] fix: remove paseo to push docker --- .github/workflows/ci.yml | 1 - 1 file changed, 1 deletion(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 81167c8530..e2edf7875e 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -610,7 +610,6 @@ jobs: - litmus - litentry - rococo - - paseo name: ${{ matrix.chain }} steps: - uses: actions/checkout@v4 From 8833c75027c347b52172ab64159cd057cb0e83e9 Mon Sep 17 00:00:00 2001 From: felixfaisal Date: Wed, 21 Aug 2024 19:29:32 +0000 Subject: [PATCH 06/21] fix: add paseo to ci --- .github/workflows/ci.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index e2edf7875e..81167c8530 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -610,6 +610,7 @@ jobs: - litmus - litentry - rococo + - paseo name: ${{ matrix.chain }} steps: - uses: actions/checkout@v4 From e26114dcd893504e667ebb6f3d131d25b3e89c0c Mon Sep 17 00:00:00 2001 From: felixfaisal Date: Wed, 21 Aug 2024 21:38:40 +0000 Subject: [PATCH 07/21] fix: add paseo to node files --- node/res/genesis_info/paseo.json | 5 ++- node/src/command.rs | 53 ++++++++++++++++++++++++++++++-- node/src/service.rs | 15 +++++++++ runtime/paseo/src/lib.rs | 4 +-- 4 files changed, 71 insertions(+), 6 deletions(-) diff --git a/node/res/genesis_info/paseo.json b/node/res/genesis_info/paseo.json index 8b34c2427c..4cdfa36e43 100644 --- a/node/res/genesis_info/paseo.json +++ b/node/res/genesis_info/paseo.json @@ -41,7 +41,10 @@ "jcRVUU8svEMTtwJjX1HzySNrrVEHVnoAdNAmhnbM8ub5dfbM9", "jcSQcu5RXtWXKPN78zJogNyqsff1j4ffgoJ2njNcDbZ3qNEh5" ], + "bootNodes": [ + "/dns/rpc.rococo-parachain.litentry.io/tcp/40333/ws/p2p/12D3KooWD9t5jsf5m2g4acXfyVf2KxR5j11F9SLC5wKhv6JRquyv" + ], "telemetryEndpoints": [ "wss://telemetry.polkadot.io/submit/" ] -} +} \ No newline at end of file diff --git a/node/src/command.rs b/node/src/command.rs index 4d8a2b9c34..0137629dd0 100644 --- a/node/src/command.rs +++ b/node/src/command.rs @@ -50,7 +50,9 @@ impl IdentifyChain for dyn sc_service::ChainSpec { // we need the combined condition as the id in our rococo spec starts with `litentry-rococo` // simply renaming `litentry-rococo` to `rococo` everywhere would have an impact on the // existing litentry-rococo chain - self.id().starts_with("litentry") && !self.id().starts_with("litentry-rococo") + self.id().starts_with("litentry") && + !self.id().starts_with("litentry-rococo") && + !self.id().starts_with("litentry-paseo") } fn is_litmus(&self) -> bool { self.id().starts_with("litmus") @@ -181,6 +183,8 @@ impl SubstrateCli for Cli { &litmus_parachain_runtime::VERSION } else if chain_spec.is_rococo() { &rococo_parachain_runtime::VERSION + } else if chain_spec.is_paseo() { + &paseo_parachain_runtime::VERSION } else { // By default litentry is used &litentry_parachain_runtime::VERSION @@ -271,6 +275,20 @@ macro_rules! construct_benchmark_partials { >, )?; $code + } else if $config.chain_spec.is_paseo() { + let $partials = new_partial::< + paseo_parachain_runtime::RuntimeApi, + PaseoParachainRuntimeExecutor, + _, + >( + &$config, + false, + crate::service::build_import_queue::< + paseo_parachain_runtime::RuntimeApi, + PaseoParachainRuntimeExecutor, + >, + )?; + $code } else { panic!("{}", UNSUPPORTED_CHAIN_MESSAGE) } @@ -323,7 +341,22 @@ macro_rules! construct_async_run { let task_manager = $components.task_manager; { $( $code )* }.map(|v| (v, task_manager)) }) - } else { + } else if runner.config().chain_spec.is_paseo() { + runner.async_run(|$config| { + let $components = new_partial::< + paseo_parachain_runtime::RuntimeApi, + PaseoParachainRuntimeExecutor, + _ + >( + &$config, + false, + crate::service::build_import_queue::, + )?; + let task_manager = $components.task_manager; + { $( $code )* }.map(|v| (v, task_manager)) + }) + } + else { panic!("{}", UNSUPPORTED_CHAIN_MESSAGE) } }} @@ -332,7 +365,6 @@ macro_rules! construct_async_run { /// Parse command line arguments into service configuration. pub fn run() -> Result<()> { let cli = Cli::from_args(); - match &cli.subcommand { Some(Subcommand::BuildSpec(cmd)) => { let runner = cli.create_runner(cmd)?; @@ -388,6 +420,7 @@ pub fn run() -> Result<()> { runner.sync_run(|_config| { let spec = cli.load_spec(&cmd.shared_params.chain.clone().unwrap_or_default())?; let state_version = Cli::native_runtime_version(&spec).state_version(); + println!("State Version: {:?}", state_version); cmd.run::(&*spec, state_version) }) }, @@ -417,6 +450,8 @@ pub fn run() -> Result<()> { cmd.run::(config) } else if config.chain_spec.is_rococo() { cmd.run::(config) + } else if config.chain_spec.is_paseo() { + cmd.run::(config) } else { Err(UNSUPPORTED_CHAIN_MESSAGE.into()) } @@ -617,6 +652,18 @@ pub fn run() -> Result<()> { .await .map(|r| r.0) .map_err(Into::into) + } else if config.chain_spec.is_paseo() { + crate::service::start_node::( + config, + polkadot_config, + collator_options, + id, + additional_config, + hwbench, + ) + .await + .map(|r| r.0) + .map_err(Into::into) } else { Err(UNSUPPORTED_CHAIN_MESSAGE.into()) } diff --git a/node/src/service.rs b/node/src/service.rs index 18582b26d6..e3edb6217b 100644 --- a/node/src/service.rs +++ b/node/src/service.rs @@ -126,6 +126,21 @@ impl sc_executor::NativeExecutionDispatch for RococoParachainRuntimeExecutor { } } +// Native executor instance. +pub struct PaseoParachainRuntimeExecutor; + +impl sc_executor::NativeExecutionDispatch for PaseoParachainRuntimeExecutor { + type ExtendHostFunctions = HostFunctions; + + fn dispatch(method: &str, data: &[u8]) -> Option> { + paseo_parachain_runtime::api::dispatch(method, data) + } + + fn native_version() -> sc_executor::NativeVersion { + paseo_parachain_runtime::native_version() + } +} + type ParachainClient = TFullClient>; diff --git a/runtime/paseo/src/lib.rs b/runtime/paseo/src/lib.rs index 7b3ae824c8..63e03971df 100644 --- a/runtime/paseo/src/lib.rs +++ b/runtime/paseo/src/lib.rs @@ -246,8 +246,8 @@ impl_opaque_keys! { pub const VERSION: RuntimeVersion = RuntimeVersion { // Note: // It's important to match `rococo-parachain-runtime`, which is runtime pkg name - spec_name: create_runtime_str!("rococo-parachain"), - impl_name: create_runtime_str!("rococo-parachain"), + spec_name: create_runtime_str!("paseo-parachain"), + impl_name: create_runtime_str!("paseo-parachain"), authoring_version: 1, // same versioning-mechanism as polkadot: use last digit for minor updates spec_version: 9193, From 8fd5f40d8d8743535f3c4f6d5408f500c2b558f8 Mon Sep 17 00:00:00 2001 From: felixfaisal Date: Wed, 21 Aug 2024 21:51:28 +0000 Subject: [PATCH 08/21] fix: update load-spec --- node/src/command.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/node/src/command.rs b/node/src/command.rs index 0137629dd0..b8818becd2 100644 --- a/node/src/command.rs +++ b/node/src/command.rs @@ -137,6 +137,8 @@ fn load_spec(id: &str) -> std::result::Result, St Box::new(chain_specs::litmus::ChainSpec::from_json_file(path.into())?) } else if chain_spec.is_rococo() { Box::new(chain_specs::rococo::ChainSpec::from_json_file(path.into())?) + } else if chain_spec.is_paseo() { + Box::new(chain_specs::paseo::ChainSpec::from_json_file(path.into())?) } else { // Fallback: use Litentry chain spec Box::new(chain_spec) From 9c8dbd5ceaddae1f4d17e0bd25438e9aa59f8419 Mon Sep 17 00:00:00 2001 From: felixfaisal Date: Fri, 23 Aug 2024 07:04:33 +0000 Subject: [PATCH 09/21] fix: update node command --- node/src/chain_specs/paseo.rs | 2 +- node/src/command.rs | 1 - 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/node/src/chain_specs/paseo.rs b/node/src/chain_specs/paseo.rs index 8a0d40234f..7ba9892a46 100644 --- a/node/src/chain_specs/paseo.rs +++ b/node/src/chain_specs/paseo.rs @@ -128,7 +128,7 @@ pub fn get_chain_spec_prod() -> ChainSpec { "Litentry-paseo", "litentry-paseo", ChainType::Live, - "paseo".into(), + "rococo-local".into(), DEFAULT_PARA_ID.into(), ) } diff --git a/node/src/command.rs b/node/src/command.rs index b8818becd2..1a759f4355 100644 --- a/node/src/command.rs +++ b/node/src/command.rs @@ -422,7 +422,6 @@ pub fn run() -> Result<()> { runner.sync_run(|_config| { let spec = cli.load_spec(&cmd.shared_params.chain.clone().unwrap_or_default())?; let state_version = Cli::native_runtime_version(&spec).state_version(); - println!("State Version: {:?}", state_version); cmd.run::(&*spec, state_version) }) }, From e9b872a6cf59ed9894de0246e0c22307fd551b7e Mon Sep 17 00:00:00 2001 From: felixfaisal Date: Mon, 26 Aug 2024 06:37:17 +0000 Subject: [PATCH 10/21] fix: update chain_spec file --- node/src/chain_specs/paseo.rs | 35 +++++++++++++++++++---------------- 1 file changed, 19 insertions(+), 16 deletions(-) diff --git a/node/src/chain_specs/paseo.rs b/node/src/chain_specs/paseo.rs index 7ba9892a46..dbd5751633 100644 --- a/node/src/chain_specs/paseo.rs +++ b/node/src/chain_specs/paseo.rs @@ -18,19 +18,18 @@ use super::*; use cumulus_primitives_core::ParaId; use paseo_parachain_runtime::{ AccountId, AuraId, Balance, BalancesConfig, BitacrossConfig, CouncilMembershipConfig, - DeveloperCommitteeMembershipConfig, GenesisConfig, ParachainInfoConfig, ParachainStakingConfig, - PolkadotXcmConfig, SessionConfig, SudoConfig, SystemConfig, TechnicalCommitteeMembershipConfig, - TeebagConfig, TeebagOperationalMode, VCManagementConfig, UNIT, WASM_BINARY, + DeveloperCommitteeMembershipConfig, ParachainInfoConfig, ParachainStakingConfig, + PolkadotXcmConfig, RuntimeGenesisConfig, SessionConfig, SudoConfig, SystemConfig, + TechnicalCommitteeMembershipConfig, TeebagConfig, TeebagOperationalMode, VCManagementConfig, + ROCOCO_PARA_ID, UNIT, WASM_BINARY, }; use sc_service::ChainType; use sc_telemetry::TelemetryEndpoints; use serde::Deserialize; use sp_core::sr25519; -const DEFAULT_PARA_ID: u32 = 2106; - /// Specialized `ChainSpec` for the normal parachain runtime. -pub type ChainSpec = sc_service::GenericChainSpec; +pub type ChainSpec = sc_service::GenericChainSpec; /// The default XCM version to set in genesis config. const SAFE_XCM_VERSION: u32 = xcm::prelude::XCM_VERSION; @@ -94,7 +93,7 @@ pub fn get_chain_spec_dev(is_standalone: bool) -> ChainSpec { ], vec![get_account_id_from_seed::("Alice")], vec![get_account_id_from_seed::("Alice")], - DEFAULT_PARA_ID.into(), + ROCOCO_PARA_ID.into(), ) }, Vec::new(), @@ -102,7 +101,7 @@ pub fn get_chain_spec_dev(is_standalone: bool) -> ChainSpec { Some("litentry-paseo"), None, default_parachain_properties(), - Extensions { relay_chain: "rococo-local".into(), para_id: DEFAULT_PARA_ID }, + Extensions { relay_chain: "rococo-local".into(), para_id: ROCOCO_PARA_ID }, ) } @@ -118,7 +117,7 @@ pub fn get_chain_spec_staging() -> ChainSpec { "litentry-paseo-staging", ChainType::Local, "rococo-local".into(), - DEFAULT_PARA_ID.into(), + ROCOCO_PARA_ID.into(), ) } @@ -128,8 +127,8 @@ pub fn get_chain_spec_prod() -> ChainSpec { "Litentry-paseo", "litentry-paseo", ChainType::Live, - "rococo-local".into(), - DEFAULT_PARA_ID.into(), + "rococo".into(), + ROCOCO_PARA_ID.into(), ) } @@ -183,7 +182,7 @@ fn get_chain_spec_from_genesis_info( ) .expect("Invalid telemetry URL; qed."), ), - Some("litentry-paseo"), + Some("litentry-rococo"), None, default_parachain_properties(), Extensions { relay_chain: relay_chain_name, para_id: para_id.into() }, @@ -198,14 +197,15 @@ fn generate_genesis( technical_committee_members: Vec, developer_committee_members: Vec, id: ParaId, -) -> GenesisConfig { - GenesisConfig { +) -> RuntimeGenesisConfig { + RuntimeGenesisConfig { system: SystemConfig { code: WASM_BINARY.expect("WASM binary was not build, please build it!").to_vec(), + ..Default::default() }, balances: BalancesConfig { balances: endowed_accounts }, sudo: SudoConfig { key: Some(root_key.clone()) }, - parachain_info: ParachainInfoConfig { parachain_id: id }, + parachain_info: ParachainInfoConfig { parachain_id: id, ..Default::default() }, parachain_staking: ParachainStakingConfig { candidates: invulnerables.iter().cloned().map(|(acc, _)| (acc, 50 * UNIT)).collect(), ..Default::default() @@ -244,7 +244,10 @@ fn generate_genesis( aura: Default::default(), aura_ext: Default::default(), parachain_system: Default::default(), - polkadot_xcm: PolkadotXcmConfig { safe_xcm_version: Some(SAFE_XCM_VERSION) }, + polkadot_xcm: PolkadotXcmConfig { + safe_xcm_version: Some(SAFE_XCM_VERSION), + ..Default::default() + }, vc_management: VCManagementConfig { admin: Some(root_key.clone()) }, transaction_payment: Default::default(), assets: Default::default(), From c5e6991b974d408bbe8a546f2b9fe17bbee09d7e Mon Sep 17 00:00:00 2001 From: felixfaisal Date: Mon, 26 Aug 2024 08:10:02 +0000 Subject: [PATCH 11/21] fix: update command.rs --- node/src/command.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/node/src/command.rs b/node/src/command.rs index 1e8bc50a2e..185fbf527f 100644 --- a/node/src/command.rs +++ b/node/src/command.rs @@ -645,7 +645,7 @@ pub fn run() -> Result<()> { crate::service::start_node::< paseo_parachain_runtime::RuntimeApi, PaseoParachainRuntimeExecutor, - >(config, polkadot_config, collator_options, id, additional_config, hwbench) + >(config, polkadot_config, collator_options, para_id, additional_config, hwbench) .await .map(|r| r.0) .map_err(Into::into) From 19171f898a59b9436e90839223e70d192e88fd2b Mon Sep 17 00:00:00 2001 From: felixfaisal Date: Mon, 2 Sep 2024 05:30:54 +0000 Subject: [PATCH 12/21] fix: update based on comments --- Makefile | 2 +- docker/paseo-parachain-launch-config.yml | 3 - node/res/genesis_info/paseo.json | 1 - node/src/chain_specs/paseo.rs | 11 +- runtime/paseo/src/migration/P9100.rs | 301 --------- runtime/paseo/src/migration/P9130.rs | 208 ------ .../P9190/balances_transaction_payment.rs | 311 --------- .../src/migration/P9190/bridge_related.rs | 300 --------- runtime/paseo/src/migration/P9190/mod.rs | 6 - .../src/migration/P9190/parachain_staking.rs | 626 ------------------ .../paseo/src/migration/P9191/fix_balances.rs | 89 --- .../src/migration/P9191/migrate_bounty.rs | 159 ----- .../src/migration/P9191/migrate_democracy.rs | 511 -------------- .../src/migration/P9191/migrate_identity.rs | 209 ------ .../src/migration/P9191/migrate_multisig.rs | 91 --- .../src/migration/P9191/migrate_preimage.rs | 163 ----- .../src/migration/P9191/migrate_proxy.rs | 265 -------- .../src/migration/P9191/migrate_treasury.rs | 208 ------ .../src/migration/P9191/migrate_vesting.rs | 172 ----- runtime/paseo/src/migration/P9191/mod.rs | 33 - runtime/paseo/src/migration/P9192.rs | 164 ----- runtime/paseo/src/migration/migration.md | 40 -- runtime/paseo/src/migration/mod.rs | 1 - 23 files changed, 7 insertions(+), 3867 deletions(-) delete mode 100644 runtime/paseo/src/migration/P9100.rs delete mode 100644 runtime/paseo/src/migration/P9130.rs delete mode 100644 runtime/paseo/src/migration/P9190/balances_transaction_payment.rs delete mode 100644 runtime/paseo/src/migration/P9190/bridge_related.rs delete mode 100644 runtime/paseo/src/migration/P9190/mod.rs delete mode 100644 runtime/paseo/src/migration/P9190/parachain_staking.rs delete mode 100644 runtime/paseo/src/migration/P9191/fix_balances.rs delete mode 100644 runtime/paseo/src/migration/P9191/migrate_bounty.rs delete mode 100644 runtime/paseo/src/migration/P9191/migrate_democracy.rs delete mode 100644 runtime/paseo/src/migration/P9191/migrate_identity.rs delete mode 100644 runtime/paseo/src/migration/P9191/migrate_multisig.rs delete mode 100644 runtime/paseo/src/migration/P9191/migrate_preimage.rs delete mode 100644 runtime/paseo/src/migration/P9191/migrate_proxy.rs delete mode 100644 runtime/paseo/src/migration/P9191/migrate_treasury.rs delete mode 100644 runtime/paseo/src/migration/P9191/migrate_vesting.rs delete mode 100644 runtime/paseo/src/migration/P9191/mod.rs delete mode 100644 runtime/paseo/src/migration/P9192.rs delete mode 100644 runtime/paseo/src/migration/migration.md delete mode 100644 runtime/paseo/src/migration/mod.rs diff --git a/Makefile b/Makefile index 1c49a9e23e..173fa8a20f 100644 --- a/Makefile +++ b/Makefile @@ -100,7 +100,7 @@ launch-docker-litmus: generate-docker-compose-litmus launch-docker-rococo: generate-docker-compose-rococo @./scripts/launch-local-docker.sh rococo -.PHONY: launch-docker-paseo ## Launch a local rococo-parachain network with docker +.PHONY: launch-docker-paseo ## Launch a local paseo-parachain network with docker launch-docker-paseo: generate-docker-compose-paseo @./scripts/launch-local-docker.sh paseo diff --git a/docker/paseo-parachain-launch-config.yml b/docker/paseo-parachain-launch-config.yml index a81068ff76..eb710c325d 100644 --- a/docker/paseo-parachain-launch-config.yml +++ b/docker/paseo-parachain-launch-config.yml @@ -13,11 +13,9 @@ relaychain: - --execution=wasm nodes: - name: alice - wsPort: ${AliceWSPort:-9946} rpcPort: ${AliceRPCPort:-9936} port: ${AlicePort:-30336} - name: bob - wsPort: ${BobWSPort:-9947} rpcPort: ${BobRPCPort:-9937} port: ${BobPort:-30337} @@ -42,6 +40,5 @@ parachains: nodes: - flags: - --alice - wsPort: ${CollatorWSPort:-9944} rpcPort: ${CollatorRPCPort:-9933} port: ${CollatorPort:-30333} diff --git a/node/res/genesis_info/paseo.json b/node/res/genesis_info/paseo.json index 4cdfa36e43..d1e78ab585 100644 --- a/node/res/genesis_info/paseo.json +++ b/node/res/genesis_info/paseo.json @@ -42,7 +42,6 @@ "jcSQcu5RXtWXKPN78zJogNyqsff1j4ffgoJ2njNcDbZ3qNEh5" ], "bootNodes": [ - "/dns/rpc.rococo-parachain.litentry.io/tcp/40333/ws/p2p/12D3KooWD9t5jsf5m2g4acXfyVf2KxR5j11F9SLC5wKhv6JRquyv" ], "telemetryEndpoints": [ "wss://telemetry.polkadot.io/submit/" diff --git a/node/src/chain_specs/paseo.rs b/node/src/chain_specs/paseo.rs index dbd5751633..1ba5b59297 100644 --- a/node/src/chain_specs/paseo.rs +++ b/node/src/chain_specs/paseo.rs @@ -15,13 +15,14 @@ // along with Litentry. If not, see . use super::*; +use core_primitives::LITENTRY_PARA_ID; use cumulus_primitives_core::ParaId; use paseo_parachain_runtime::{ AccountId, AuraId, Balance, BalancesConfig, BitacrossConfig, CouncilMembershipConfig, DeveloperCommitteeMembershipConfig, ParachainInfoConfig, ParachainStakingConfig, PolkadotXcmConfig, RuntimeGenesisConfig, SessionConfig, SudoConfig, SystemConfig, TechnicalCommitteeMembershipConfig, TeebagConfig, TeebagOperationalMode, VCManagementConfig, - ROCOCO_PARA_ID, UNIT, WASM_BINARY, + LITENTRY_PARA_ID, UNIT, WASM_BINARY, }; use sc_service::ChainType; use sc_telemetry::TelemetryEndpoints; @@ -93,7 +94,7 @@ pub fn get_chain_spec_dev(is_standalone: bool) -> ChainSpec { ], vec![get_account_id_from_seed::("Alice")], vec![get_account_id_from_seed::("Alice")], - ROCOCO_PARA_ID.into(), + LITENTRY_PARA_ID.into(), ) }, Vec::new(), @@ -101,7 +102,7 @@ pub fn get_chain_spec_dev(is_standalone: bool) -> ChainSpec { Some("litentry-paseo"), None, default_parachain_properties(), - Extensions { relay_chain: "rococo-local".into(), para_id: ROCOCO_PARA_ID }, + Extensions { relay_chain: "rococo-local".into(), para_id: LITENTRY_PARA_ID }, ) } @@ -117,7 +118,7 @@ pub fn get_chain_spec_staging() -> ChainSpec { "litentry-paseo-staging", ChainType::Local, "rococo-local".into(), - ROCOCO_PARA_ID.into(), + LITENTRY_PARA_ID.into(), ) } @@ -128,7 +129,7 @@ pub fn get_chain_spec_prod() -> ChainSpec { "litentry-paseo", ChainType::Live, "rococo".into(), - ROCOCO_PARA_ID.into(), + LITENTRY_PARA_ID.into(), ) } diff --git a/runtime/paseo/src/migration/P9100.rs b/runtime/paseo/src/migration/P9100.rs deleted file mode 100644 index 3765266c0f..0000000000 --- a/runtime/paseo/src/migration/P9100.rs +++ /dev/null @@ -1,301 +0,0 @@ -// Copyright 2020-2021 Trust Computing GmbH. -// This file is part of Litentry. -// -// Litentry is free software: you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// Litentry 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 -// GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License -// along with Litentry. If not, see . -use frame_support::{ - inherent::Vec, - pallet_prelude::*, - storage::storage_prefix, - traits::{Currency, Get, OnRuntimeUpgrade}, - StorageHasher, Twox128, -}; -use pallet_parachain_staking::BalanceOf; -use sp_runtime::{traits::Zero, Perbill}; -use sp_std::marker::PhantomData; - -pub struct MigrateCollatorSelectionIntoParachainStaking(PhantomData); -impl OnRuntimeUpgrade for MigrateCollatorSelectionIntoParachainStaking -where - T: pallet_parachain_staking::Config + pallet_bridge_transfer::Config, - ::Event: From>, -{ - #[cfg(feature = "try-runtime")] - fn pre_upgrade() -> Result<(), &'static str> { - use frame_support::traits::OnRuntimeUpgradeHelpersExt; - use core_primitives::AccountId; - - log::info!("Pre check pallet CollatorSelection exists"); - // Get Invulnerables address from CollatorSelection - // WARN: We do not care about any Candidates storage, as we forbid any general transaction - // by sudo and so no info there in practice - let invulnerables = frame_support::storage::migration::get_storage_value::>( - b"CollatorSelection", - b"Invulnerables", - b"", - ) - .expect("Storage query fails: CollatorSelection Invulnerables"); - - if invulnerables.is_empty() { - return Err("CollatorSelection empty") - }; - let invulnerables_len: u32 = invulnerables.len().try_into().unwrap_or(0); - assert!( - invulnerables_len >= - ::MinSelectedCandidates::get(), - "Need More Initial Candidates" - ); - - // Set the temporary storage for post upgrade check - Self::set_temp_storage(invulnerables, "invulnerables"); - - // Ensure ParachainStaking is Empty - assert!( - !frame_support::storage::migration::have_storage_value( - b"ParachainStaking", - b"SelectedCandidates", - b"", - ), - "ParachainStaking SelectedCandidates Storage Already Exist" - ); - - assert!( - !frame_support::storage::migration::have_storage_value( - b"ParachainStaking", - b"CandidatePool", - b"", - ), - "ParachainStaking CandidatePool Storage Already Exist" - ); - - assert!( - !frame_support::storage::migration::have_storage_value( - b"ParachainStaking", - b"Total", - b"", - ), - "ParachainStaking Total Storage Already Exist" - ); - Ok(()) - } - - fn on_runtime_upgrade() -> frame_support::weights::Weight { - use sp_io::KillStorageResult; - let mut invulnerables = frame_support::storage::migration::get_storage_value::< - Vec<::AccountId>, - >(b"CollatorSelection", b"Invulnerables", b"") - .expect("Storage query fails: CollatorSelection Invulnerables"); - invulnerables.sort(); - - let invulnerables_len: u32 = invulnerables.len().try_into().unwrap_or(0); - assert!( - invulnerables_len >= - ::MinSelectedCandidates::get(), - "Need More Initial Candidates" - ); - - // Add whitelist Storage - frame_support::storage::migration::put_storage_value::< - Vec<::AccountId>, - >(b"ParachainStaking", b"Candidates", b"", invulnerables.clone()); - - let mut candidate_count = 0u32; - // Get the minimum collator stake amount - let min_collator_stk = ::MinCollatorStk::get(); - // Initialize the candidates - for candidate in invulnerables { - assert!( - ::Currency::free_balance(&candidate) >= - min_collator_stk, - "Account does not have enough balance to bond as a candidate." - ); - - if let Err(error) = >::join_candidates( - ::Origin::from(Some(candidate.clone()).into()), - min_collator_stk, - ) { - log::warn!("Join candidates failed in genesis with error {:?}", error); - } else { - candidate_count = candidate_count.saturating_add(1u32); - } - } - - assert!(candidate_count > 0, "No valid candidates"); - - // Reproduce the genesis build - // Initialize the rest setup of parachain-staking - // After runtimeUpgrade, we should: - // (1) Set the inflation by set_inflation - // (2) Set collator commission by set_collator_commission - // (3) Set parachain bond config by parachset_parachain_bond_account - // (4) Set total selected candidates to minimum config set_total_selected - // (5) Choose top TotalSelected collator candidates - // (6) Refresh round if it is during runtimeUpgrade - // (7) Snapshot total staked (through select_top_candidates) - // (8) NewRound Event Deposit - - // Inflation config as Default, so do nothing - // ... - // Set collator commission to default config - frame_support::storage::migration::put_storage_value::( - b"ParachainStaking", - b"CollatorCommission", - b"", - ::DefaultCollatorCommission::get(), - ); - // Set parachain bond config to default config - frame_support::storage::migration::put_storage_value::< - pallet_parachain_staking::ParachainBondConfig<::AccountId>, - >( - b"ParachainStaking", - b"ParachainBondInfo", - b"", - pallet_parachain_staking::ParachainBondConfig { - // must be set soon; if not => due inflation will be sent to some weird place - account: ::AccountId::decode( - &mut sp_runtime::traits::TrailingZeroInput::zeroes(), - ) - .expect("infinite length input; no invalid inputs for type; qed"), - percent: - ::DefaultParachainBondReservePercent::get( - ), - }, - ); - - // // Set total selected candidates to minimum config - frame_support::storage::migration::put_storage_value::( - b"ParachainStaking", - b"TotalSelected", - b"", - candidate_count, - ); - // Choose top TotalSelected collator candidates - // WARNING/TODO: We change the private into public of select_top_candidates function in - // pallet. We should change it back in next runtime upgrade for safety. - let (v_count, _, total_staked) = - >::select_top_candidates(1u32); - - // Start Round 1 at Block 0 - let round: pallet_parachain_staking::RoundInfo<::BlockNumber> = - pallet_parachain_staking::RoundInfo::new( - 1u32, - 0u32.into(), - ::DefaultBlocksPerRound::get(), - ); - frame_support::storage::migration::put_storage_value::< - pallet_parachain_staking::RoundInfo<::BlockNumber>, - >(b"ParachainStaking", b"Round", b"", round); - - // // Snapshot total stake - // The code below is supposed to behave same as: - // >::insert(1u32, >::get()) - let val = frame_support::storage::migration::get_storage_value::>( - b"ParachainStaking", - b"Total", - b"", - ); - let storage_prefix = storage_prefix(b"ParachainStaking", b"Staked"); - let key_hashed = 1u32.using_encoded(Twox64Concat::hash); - let mut final_key = Vec::with_capacity(storage_prefix.len() + key_hashed.len()); - final_key.extend_from_slice(&storage_prefix); - final_key.extend_from_slice(key_hashed.as_ref()); - frame_support::storage::unhashed::put(final_key.as_ref(), &val); - - // Deposit NewRound event at RuntimeUpgrade - >::deposit_event(pallet_parachain_staking::Event::NewRound { - starting_block: ::BlockNumber::zero(), - round: 1u32, - selected_collators_number: v_count, - total_balance: total_staked, - }); - - // Remove CollatorSelection Storage - // TODO: Very Weak safety - let entries: u64 = 4 + 6142; - let _res: KillStorageResult = frame_support::storage::unhashed::clear_prefix( - &Twox128::hash(b"CollatorSelection"), - Some(entries.try_into().unwrap()), - None, - ) - .into(); - ::DbWeight::get().writes(entries) - } - - #[cfg(feature = "try-runtime")] - fn post_upgrade() -> Result<(), &'static str> { - use frame_support::traits::OnRuntimeUpgradeHelpersExt; - use core_primitives::AccountId; - use sp_io::KillStorageResult; - - log::info!("Post check CollatorSelection"); - let res: KillStorageResult = frame_support::storage::unhashed::clear_prefix( - &Twox128::hash(b"CollatorSelection"), - Some(0), - None, - ) - .into(); - - match res { - KillStorageResult::AllRemoved(0) | KillStorageResult::SomeRemaining(0) => {}, - KillStorageResult::AllRemoved(n) | KillStorageResult::SomeRemaining(n) => { - log::error!("Remaining entries: {:?}", n); - return Err("CollatorSelection not removed") - }, - }; - - assert!( - frame_support::storage::migration::have_storage_value( - b"ParachainStaking", - b"CandidatePool", - b"", - ), - "ParachainStaking CandidatePool Storage not migrate properly" - ); - - assert!( - frame_support::storage::migration::have_storage_value( - b"ParachainStaking", - b"Total", - b"", - ), - "ParachainStaking Total Storage not migrate properly" - ); - - // Check the Selected Candidates info - let mut selected_candidates = frame_support::storage::migration::get_storage_value::< - Vec, - >(b"ParachainStaking", b"SelectedCandidates", b"") - .expect("Storage query fails: ParachainStaking SelectedCandidates"); - selected_candidates.sort(); - let mut invulnerables: Vec = - Self::get_temp_storage("invulnerables").expect("qed"); - invulnerables.sort(); - - assert!(selected_candidates == invulnerables, "candidates not migrate properly"); - - // Check the Round info - let round_info = frame_support::storage::migration::get_storage_value::< - pallet_parachain_staking::RoundInfo, - >(b"ParachainStaking", b"Round", b"") - .expect("Storage query fails: ParachainStaking Round"); - - let expected_round_info = pallet_parachain_staking::RoundInfo::::new( - 1u32, - 0u32.into(), - ::DefaultBlocksPerRound::get(), - ); - assert!(round_info == expected_round_info, "round info not migrate properly"); - - Ok(()) - } -} diff --git a/runtime/paseo/src/migration/P9130.rs b/runtime/paseo/src/migration/P9130.rs deleted file mode 100644 index 473976f6d7..0000000000 --- a/runtime/paseo/src/migration/P9130.rs +++ /dev/null @@ -1,208 +0,0 @@ -// Copyright 2020-2021 Trust Computing GmbH. -// This file is part of Litentry. -// -// Litentry is free software: you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// Litentry 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 -// GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License -// along with Litentry. If not, see . -#![allow(deprecated)] -#![allow(clippy::type_complexity)] -use frame_support::{ - storage, - traits::{Get, OnRuntimeUpgrade}, -}; -use pallet_parachain_staking::{ - AtStake, BalanceOf, BondWithAutoCompound, CollatorSnapshot, Round, RoundIndex, -}; -use sp_runtime::Percent; -use sp_std::{marker::PhantomData, prelude::*, vec::Vec}; - -use parity_scale_codec::{Decode, Encode}; -extern crate alloc; -#[cfg(feature = "try-runtime")] -use alloc::{format, string::ToString}; -#[cfg(feature = "try-runtime")] -use scale_info::prelude::string::String; -#[cfg(feature = "try-runtime")] -use sp_std::{collections::btree_map::BTreeMap, vec}; - -mod deprecated { - use super::*; - use sp_core::RuntimeDebug; - use pallet_parachain_staking::Bond; - use scale_info::TypeInfo; - // CollatorSnapshot - #[deprecated(note = "use CollatorSnapshot with BondWithAutoCompound delegations")] - #[derive(Encode, Decode, RuntimeDebug, TypeInfo)] - /// Snapshot of collator state at the start of the round for which they are selected - pub struct CollatorSnapshot { - /// The total value locked by the collator. - pub bond: Balance, - - /// The rewardable delegations. This list is a subset of total delegators, where certain - /// delegators are adjusted based on their scheduled - /// [DelegationChange::Revoke] or [DelegationChange::Decrease] action. - pub delegations: Vec>, - - /// The total counted value locked for the collator, including the self bond + total staked - /// by top delegators. - pub total: Balance, - } - - impl PartialEq for CollatorSnapshot { - fn eq(&self, other: &Self) -> bool { - let must_be_true = self.bond == other.bond && self.total == other.total; - if !must_be_true { - return false - } - for (Bond { owner: o1, amount: a1 }, Bond { owner: o2, amount: a2 }) in - self.delegations.iter().zip(other.delegations.iter()) - { - if o1 != o2 || a1 != a2 { - return false - } - } - true - } - } - - impl Default for CollatorSnapshot { - fn default() -> CollatorSnapshot { - CollatorSnapshot { bond: B::default(), delegations: Vec::new(), total: B::default() } - } - } -} -use deprecated::CollatorSnapshot as OldCollatorSnapshot; -pub struct MigrateAtStakeAutoCompound(PhantomData); -impl MigrateAtStakeAutoCompound { - /// Get keys for the `AtStake` storage for the rounds up to `RewardPaymentDelay` rounds ago. - /// We migrate only the last unpaid rounds due to the presence of stale entries in `AtStake` - /// which significantly increase the PoV size. - fn unpaid_rounds_keys() -> impl Iterator)> { - let current_round = >::get().current; - let max_unpaid_round = current_round.saturating_sub(T::RewardPaymentDelay::get()); - (max_unpaid_round..=current_round).into_iter().flat_map(|round| { - >::iter_key_prefix(round).map(move |candidate| { - let key = >::hashed_key_for(round, candidate.clone()); - (round, candidate, key) - }) - }) - } -} -impl OnRuntimeUpgrade for MigrateAtStakeAutoCompound -where - T: pallet_parachain_staking::Config, -{ - #[cfg(feature = "try-runtime")] - fn pre_upgrade() -> Result, &'static str> { - let mut num_to_update = 0u32; - let mut rounds_candidates: Vec<(RoundIndex, T::AccountId)> = vec![]; - let mut state_map: BTreeMap = BTreeMap::new(); - - for (round, candidate, key) in Self::unpaid_rounds_keys() { - let state: OldCollatorSnapshot> = - storage::unhashed::get(&key).expect("unable to decode value"); - - num_to_update = num_to_update.saturating_add(1); - rounds_candidates.push((round, candidate.clone())); - let mut delegation_str = vec![]; - for d in state.delegations { - delegation_str - .push(format!("owner={:?}_amount={:?}_autoCompound=0%", d.owner, d.amount)); - } - state_map.insert( - (*format!("round_{:?}_candidate_{:?}", round, candidate)).to_string(), - format!( - "bond={:?}_total={:?}_delegations={:?}", - state.bond, state.total, delegation_str - ), - ); - } - - rounds_candidates.sort(); - Ok((state_map, rounds_candidates, num_to_update).encode()) - } - - fn on_runtime_upgrade() -> frame_support::weights::Weight { - log::info!( - target: "MigrateAtStakeAutoCompound", - "running migration to add auto-compound values" - ); - let mut reads = 0u64; - let mut writes = 0u64; - for (round, candidate, key) in Self::unpaid_rounds_keys() { - let old_state: OldCollatorSnapshot> = - storage::unhashed::get(&key).expect("unable to decode value"); - reads = reads.saturating_add(1); - writes = writes.saturating_add(1); - log::info!( - target: "MigrateAtStakeAutoCompound", - "migration from old format round {:?}, candidate {:?}", round, candidate - ); - let new_state = CollatorSnapshot { - bond: old_state.bond, - delegations: old_state - .delegations - .into_iter() - .map(|d| BondWithAutoCompound { - owner: d.owner, - amount: d.amount, - auto_compound: Percent::zero(), - }) - .collect(), - total: old_state.total, - }; - storage::unhashed::put(&key, &new_state); - } - - T::DbWeight::get().reads_writes(reads, writes) - } - - #[cfg(feature = "try-runtime")] - fn post_upgrade(state: Vec) -> Result<(), &'static str> { - let (state_map, rounds_candidates_received, num_updated_received): ( - BTreeMap, - Vec<(RoundIndex, T::AccountId)>, - u32, - ) = Decode::decode(&mut &state[..]).expect("pre_upgrade provides a valid state; qed"); - - let mut num_updated = 0u32; - let mut rounds_candidates = vec![]; - for (round, candidate, _) in Self::unpaid_rounds_keys() { - let state = >::get(round, &candidate); - num_updated = num_updated.saturating_add(1); - rounds_candidates.push((round, candidate.clone())); - let mut delegation_str = vec![]; - for d in state.delegations { - delegation_str.push(format!( - "owner={:?}_amount={:?}_autoCompound={:?}", - d.owner, d.amount, d.auto_compound - )); - } - assert_eq!( - Some(&format!( - "bond={:?}_total={:?}_delegations={:?}", - state.bond, state.total, delegation_str - )), - state_map - .get(&((*format!("round_{:?}_candidate_{:?}", round, candidate)).to_string())), - "incorrect delegations migration for round_{:?}_candidate_{:?}", - round, - candidate, - ); - } - - rounds_candidates.sort(); - assert_eq!(rounds_candidates, rounds_candidates_received); - assert_eq!(num_updated, num_updated_received); - Ok(()) - } -} diff --git a/runtime/paseo/src/migration/P9190/balances_transaction_payment.rs b/runtime/paseo/src/migration/P9190/balances_transaction_payment.rs deleted file mode 100644 index f1d4caed2b..0000000000 --- a/runtime/paseo/src/migration/P9190/balances_transaction_payment.rs +++ /dev/null @@ -1,311 +0,0 @@ -// Copyright 2020-2024 Trust Computing GmbH. -// This file is part of Litentry. -// -// Litentry is free software: you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// Litentry 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 -// GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License -// along with Litentry. If not, see . -#![allow(clippy::type_complexity)] - -use frame_support::{ - migration::storage_key_iter, - pallet_prelude::*, - traits::{Get, OnRuntimeUpgrade}, - Blake2_128Concat, WeakBoundedVec, -}; -use frame_system::{Account, AccountInfo}; -use pallet_balances::{ - Account as BAccount, AccountData, BalanceLock, Freezes, Holds, InactiveIssuance, Locks, - Reserves, TotalIssuance, -}; -use sp_std::{marker::PhantomData, vec::Vec}; - -pub const DECIMAL_CONVERTOR: u128 = 1_000_000u128; - -#[cfg(feature = "try-runtime")] -use parity_scale_codec::Encode; -#[cfg(feature = "try-runtime")] -use sp_std::collections::btree_map::BTreeMap; -use storage::migration::get_storage_value; - -// Replace Frame System Storage for Decimal Change from 12 to 18 -// Replace Balances Storage for Decimal Change from 12 to 18 -pub struct ReplaceBalancesRelatedStorage(PhantomData); -impl ReplaceBalancesRelatedStorage -where - T: frame_system::Config> - + pallet_balances::Config, -{ - pub fn replace_frame_system_account_storage() -> frame_support::weights::Weight { - // The storage of Account for pallet balances is in frame_system pallet - log::info!( - target: "ReplaceBalancesRelatedStorage", - "running migration to Frame System Account" - ); - let pallet_prefix: &[u8] = b"System"; - let storage_item_prefix: &[u8] = b"Account"; - let mut weight: Weight = frame_support::weights::Weight::zero(); - - for (account, mut account_info) in storage_key_iter::< - T::AccountId, - AccountInfo, - Blake2_128Concat, - >(pallet_prefix, storage_item_prefix) - .drain() - { - account_info.data.free = account_info.data.free.saturating_mul(DECIMAL_CONVERTOR); - account_info.data.reserved = - account_info.data.reserved.saturating_mul(DECIMAL_CONVERTOR); - // Runtime migration is wrong at first. The below code has been mistakenly applied to - // online rococo account_info.data.frozen = - // account_info.data.reserved.saturating_mul(DECIMAL_CONVERTOR); - account_info.data.frozen = account_info.data.frozen.saturating_mul(DECIMAL_CONVERTOR); - - >::insert(&account, account_info); - weight += T::DbWeight::get().reads_writes(1, 1); - } - weight - } - pub fn repalce_balances_total_issuance_storage() -> frame_support::weights::Weight { - log::info!( - target: "ReplaceBalancesRelatedStorage", - "running migration to Balances TotalIssuance" - ); - let pallet_prefix: &[u8] = b"Balances"; - let storage_item_prefix: &[u8] = b"TotalIssuance"; - let stored_data = get_storage_value::(pallet_prefix, storage_item_prefix, b"") - .expect("Storage query fails: Balances TotalIssuance"); - >::put(stored_data.saturating_mul(DECIMAL_CONVERTOR)); - let weight = T::DbWeight::get(); - frame_support::weights::Weight::from_parts(0, weight.write + weight.read) - } - pub fn repalce_balances_inactive_issuance_storage() -> frame_support::weights::Weight { - log::info!( - target: "ReplaceBalancesRelatedStorage", - "running migration to Balances InactiveIssuance" - ); - let pallet_prefix: &[u8] = b"Balances"; - let storage_item_prefix: &[u8] = b"InactiveIssuance"; - let stored_data = get_storage_value::(pallet_prefix, storage_item_prefix, b"") - .expect("Storage query fails: Balances InactiveIssuance"); - >::put(stored_data.saturating_mul(DECIMAL_CONVERTOR)); - let weight = T::DbWeight::get(); - frame_support::weights::Weight::from_parts(0, weight.write + weight.read) - } - pub fn replace_balances_locks_storage() -> frame_support::weights::Weight { - log::info!( - target: "ReplaceBalancesRelatedStorage", - "running checking to Balances Locks" - ); - let pallet_prefix: &[u8] = b"Balances"; - let storage_item_prefix: &[u8] = b"Locks"; - let mut weight: Weight = frame_support::weights::Weight::zero(); - - for (account, mut locks) in storage_key_iter::< - T::AccountId, - WeakBoundedVec, T::MaxLocks>, - Blake2_128Concat, - >(pallet_prefix, storage_item_prefix) - .drain() - { - let new_locks: &mut WeakBoundedVec, T::MaxLocks> = &mut locks; - for balance_lock in new_locks.into_iter() { - balance_lock.amount = balance_lock.amount.saturating_mul(DECIMAL_CONVERTOR); - } - >::insert(&account, new_locks); - weight += T::DbWeight::get().reads_writes(1, 1); - } - - weight - } -} - -#[cfg(feature = "try-runtime")] -impl ReplaceBalancesRelatedStorage -where - T: frame_system::Config> - + pallet_balances::Config, -{ - pub fn pre_upgrade_frame_system_account_storage() -> Result, &'static str> { - let result: BTreeMap>> = - >::iter() - .map(|(account, state)| { - let mut new_account: AccountInfo> = state; - new_account.data.free = new_account.data.free.saturating_mul(DECIMAL_CONVERTOR); - new_account.data.reserved = - new_account.data.reserved.saturating_mul(DECIMAL_CONVERTOR); - new_account.data.frozen = - new_account.data.frozen.saturating_mul(DECIMAL_CONVERTOR); - - (account, new_account) - }) - .collect(); - Ok(result.encode()) - } - pub fn post_upgrade_frame_system_account_storage(state: Vec) -> Result<(), &'static str> { - let expected_state = - BTreeMap::>>::decode( - &mut &state[..], - ) - .map_err(|_| "Failed to decode AccountInfo")?; - for (account, actual_result) in >::iter() { - let expected_result: AccountInfo> = - expected_state.get(&account).ok_or("Not Expected AccountInfo")?.clone(); - assert_eq!(expected_result, actual_result); - } - Ok(()) - } - pub fn pre_upgrade_balances_total_issuance_storage() -> Result, &'static str> { - Ok(>::get().saturating_mul(DECIMAL_CONVERTOR).encode()) - } - pub fn post_upgrade_balances_total_issuance_storage( - state: Vec, - ) -> Result<(), &'static str> { - let expected_state = - u128::decode(&mut &state[..]).map_err(|_| "Failed to decode Total Balance")?; - let actual_state = >::get(); - assert_eq!(expected_state, actual_state); - Ok(()) - } - pub fn pre_upgrade_balances_inactive_issuance_storage() -> Result, &'static str> { - Ok(>::get().saturating_mul(DECIMAL_CONVERTOR).encode()) - } - pub fn post_upgrade_balances_inactive_issuance_storage( - state: Vec, - ) -> Result<(), &'static str> { - let expected_state = - u128::decode(&mut &state[..]).map_err(|_| "Failed to decode Total Balance")?; - let actual_state = >::get(); - assert_eq!(expected_state, actual_state); - Ok(()) - } - pub fn pre_upgrade_balances_account_check() -> Result, &'static str> { - assert!(>::iter().next().is_none()); - Ok(Vec::::new()) - } - pub fn post_upgrade_balances_account_check(_state: Vec) -> Result<(), &'static str> { - assert!(>::iter().next().is_none()); - Ok(()) - } - pub fn pre_upgrade_balances_locks_storage() -> Result, &'static str> { - let result: BTreeMap>> = >::iter() - .map(|(account, state)| { - let mut new_locks: Vec> = state.into_inner(); - for balance_lock in new_locks.iter_mut() { - balance_lock.amount = balance_lock.amount.saturating_mul(DECIMAL_CONVERTOR); - } - (account, new_locks) - }) - .collect(); - Ok(result.encode()) - } - pub fn post_upgrade_balances_locks_storage(state: Vec) -> Result<(), &'static str> { - let expected_state = - BTreeMap::>>::decode(&mut &state[..]) - .map_err(|_| "Failed to decode Locks")?; - for (account, actual_result) in >::iter() { - let expected_result: Vec> = - expected_state.get(&account).ok_or("Not Expected Locks")?.clone(); - assert_eq!(expected_result.encode(), actual_result.into_inner().encode()); - } - Ok(()) - } - pub fn pre_upgrade_balances_reserves_check() -> Result, &'static str> { - assert!(>::iter().next().is_none()); - Ok(Vec::::new()) - } - pub fn post_upgrade_balances_reserves_check(_state: Vec) -> Result<(), &'static str> { - assert!(>::iter().next().is_none()); - Ok(()) - } - pub fn pre_upgrade_balances_holds_check() -> Result, &'static str> { - assert!(>::iter().next().is_none()); - Ok(Vec::::new()) - } - pub fn post_upgrade_balances_holds_check(_state: Vec) -> Result<(), &'static str> { - assert!(>::iter().next().is_none()); - Ok(()) - } - pub fn pre_upgrade_balances_freezes_check() -> Result, &'static str> { - assert!(>::iter().next().is_none()); - Ok(Vec::::new()) - } - pub fn post_upgrade_balances_freezes_check(_state: Vec) -> Result<(), &'static str> { - assert!(>::iter().next().is_none()); - Ok(()) - } -} - -impl OnRuntimeUpgrade for ReplaceBalancesRelatedStorage -where - T: frame_system::Config> - + pallet_balances::Config, -{ - #[cfg(feature = "try-runtime")] - fn pre_upgrade() -> Result, &'static str> { - let frame_system_account_vec = Self::pre_upgrade_frame_system_account_storage()?; - let balances_total_issuance_vec = Self::pre_upgrade_balances_total_issuance_storage()?; - let balances_inactive_issuance_vec = - Self::pre_upgrade_balances_inactive_issuance_storage()?; - - let _ = Self::pre_upgrade_balances_account_check()?; - - let balances_locks_vec = Self::pre_upgrade_balances_locks_storage()?; - - let _ = Self::pre_upgrade_balances_reserves_check()?; - let _ = Self::pre_upgrade_balances_holds_check()?; - let _ = Self::pre_upgrade_balances_freezes_check()?; - - Ok(( - frame_system_account_vec, - balances_total_issuance_vec, - balances_inactive_issuance_vec, - balances_locks_vec, - ) - .encode()) - } - - fn on_runtime_upgrade() -> frame_support::weights::Weight { - let mut weight = frame_support::weights::Weight::from_parts(0, 0); - // The storage of pallet balances is in frame_system pallet - weight += Self::replace_frame_system_account_storage(); - weight += Self::repalce_balances_total_issuance_storage(); - weight += Self::repalce_balances_inactive_issuance_storage(); - - // The storage of Account for pallet balances is in frame_system pallet - // Should be empty - - weight += Self::replace_balances_locks_storage(); - - // The storage of Reserves/Holds/Freezes for pallet balances is in frame_system pallet - // Should be empty - - weight - } - - #[cfg(feature = "try-runtime")] - fn post_upgrade(state: Vec) -> Result<(), &'static str> { - let pre_vec: (Vec, Vec, Vec, Vec) = - Decode::decode(&mut &state[..]).map_err(|_| "Failed to decode Tuple")?; - Self::post_upgrade_frame_system_account_storage(pre_vec.0)?; - Self::post_upgrade_balances_total_issuance_storage(pre_vec.1)?; - Self::post_upgrade_balances_inactive_issuance_storage(pre_vec.2)?; - - Self::post_upgrade_balances_account_check(Vec::::new())?; - - Self::post_upgrade_balances_locks_storage(pre_vec.3)?; - - Self::post_upgrade_balances_reserves_check(Vec::::new())?; - Self::post_upgrade_balances_holds_check(Vec::::new())?; - Self::post_upgrade_balances_freezes_check(Vec::::new())?; - Ok(()) - } -} diff --git a/runtime/paseo/src/migration/P9190/bridge_related.rs b/runtime/paseo/src/migration/P9190/bridge_related.rs deleted file mode 100644 index 69192a8398..0000000000 --- a/runtime/paseo/src/migration/P9190/bridge_related.rs +++ /dev/null @@ -1,300 +0,0 @@ -// Copyright 2020-2024 Trust Computing GmbH. -// This file is part of Litentry. -// -// Litentry is free software: you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// Litentry 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 -// GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License -// along with Litentry. If not, see . -#![allow(clippy::type_complexity)] - -use frame_support::{ - migration::{clear_storage_prefix, storage_key_iter}, - pallet_prelude::*, - traits::{Get, OnRuntimeUpgrade}, - Blake2_256, Twox64Concat, -}; -use pallet_assets_handler::{AssetInfo, ExternalBalances, MaximumIssuance, ResourceToAssetInfo}; -use pallet_balances::AccountData; -use pallet_bridge::{BridgeChainId, ResourceId}; -use sp_std::{marker::PhantomData, vec::Vec}; - -pub const DECIMAL_CONVERTOR: u128 = 1_000_000u128; - -use hex_literal::hex; -#[cfg(feature = "try-runtime")] -use parity_scale_codec::Encode; -use storage::migration::get_storage_value; - -mod old { - use super::*; - #[frame_support::storage_alias] - pub type BridgeBalances = StorageDoubleMap< - pallet_bridge_transfer::Pallet, - Twox64Concat, - ResourceId, - Twox64Concat, - ::AccountId, - u128, - >; - - #[frame_support::storage_alias] - pub type Resources = - StorageMap, Blake2_256, ResourceId, Vec>; - - #[frame_support::storage_alias] - pub type BridgeFee = - StorageMap, Twox64Concat, BridgeChainId, u128>; -} - -pub const NATIVE_TOKEN_RESOURCE_ID: [u8; 32] = - hex!("00000000000000000000000000000063a7e2be78898ba83824b0c0cc8dfb6001"); -// Hard coded key of NATIVE_TOKEN_RESOURCE_ID -pub const BLAKE2_256_KEY: [u8; 32] = - hex!("560cf5c8bfa0719141e0d1b33ae9fec279c53682ce13220d526ad79cccc8aead"); - -// Replace Frame System Storage for Decimal Change from 12 to 18 -// Replace Balances Storage for Decimal Change from 12 to 18 -pub struct ReplaceBridgeRelatedStorage(PhantomData); -impl ReplaceBridgeRelatedStorage -where - T: frame_system::Config> - + pallet_assets::Config - + pallet_assets_handler::Config - + pallet_balances::Config - + pallet_bridge::Config - + pallet_bridge_transfer::Config, -{ - pub fn relocate_resource_fee_storage() -> frame_support::weights::Weight { - log::info!( - target: "ReplaceBridgeRelatedStorage", - "running migration to Bridge Resources/Bridge Fee" - ); - - // We get only one resource registed - // Which is native tokrn - // Resources Storage is using Blake2_256 - // So we can not reverse it out - // Must hardcode back in - let pallet_prefix: &[u8] = b"ChainBridge"; - let storage_item_prefix_resources: &[u8] = b"Resources"; - let _ = clear_storage_prefix(pallet_prefix, storage_item_prefix_resources, &[], None, None); - // Must hardcode back in - let resource_id: ResourceId = NATIVE_TOKEN_RESOURCE_ID; - - // This is fee for native token - // There should be only 1 item - let storage_item_prefix_fee: &[u8] = b"BridgeFee"; - let stored_data_fee: Vec<_> = storage_key_iter::( - pallet_prefix, - storage_item_prefix_fee, - ) - .collect(); - let _ = clear_storage_prefix(pallet_prefix, storage_item_prefix_fee, &[], None, None); - - // Replace into new storage of AssetsHandler - let fee: u128 = stored_data_fee[0].1.saturating_mul(DECIMAL_CONVERTOR); - let asset_info: AssetInfo = AssetInfo { - fee, - asset: None, // None for native token Asset Id - }; - >::insert(resource_id, asset_info); - - let weight = T::DbWeight::get(); - frame_support::weights::Weight::from_parts(0, 2 * (weight.write + weight.read)) - } - pub fn delete_bridge_balances_storage() -> frame_support::weights::Weight { - log::info!( - target: "ReplaceBridgeRelatedStorage", - "running migration to Bridge Transfer Bridge Balances" - ); - - let result = old::BridgeBalances::::clear(u32::MAX, None); - - let weight = T::DbWeight::get(); - frame_support::weights::Weight::from_parts( - 0, - u64::from(result.unique).saturating_mul(weight.write + weight.read), - ) - } - pub fn relocate_external_balance_storage() -> frame_support::weights::Weight { - log::info!( - target: "ReplaceBridgeRelatedStorage", - "running migration to ExternalBalances" - ); - let pallet_prefix: &[u8] = b"BridgeTransfer"; - let storage_item_prefix: &[u8] = b"ExternalBalances"; - let stored_data = get_storage_value::(pallet_prefix, storage_item_prefix, b"") - .expect("Storage query fails: BridgeTransfer ExternalBalances"); - let _ = clear_storage_prefix(pallet_prefix, storage_item_prefix, &[], None, None); - - >::put(stored_data.saturating_mul(DECIMAL_CONVERTOR)); - let weight = T::DbWeight::get(); - frame_support::weights::Weight::from_parts(0, weight.write + weight.read) - } - pub fn relocate_maximum_issuance_storage() -> frame_support::weights::Weight { - log::info!( - target: "ReplaceBridgeRelatedStorage", - "running migration to MaximumIssuance" - ); - let pallet_prefix: &[u8] = b"BridgeTransfer"; - let storage_item_prefix: &[u8] = b"MaximumIssuance"; - let stored_data = get_storage_value::(pallet_prefix, storage_item_prefix, b"") - .expect("Storage query fails: BridgeTransfer MaximumIssuance"); - let _ = clear_storage_prefix(pallet_prefix, storage_item_prefix, &[], None, None); - - >::put(stored_data.saturating_mul(DECIMAL_CONVERTOR)); - let weight = T::DbWeight::get(); - frame_support::weights::Weight::from_parts(0, weight.write + weight.read) - } -} - -#[cfg(feature = "try-runtime")] -impl ReplaceBridgeRelatedStorage -where - T: frame_system::Config> - + pallet_assets::Config - + pallet_assets_handler::Config - + pallet_balances::Config - + pallet_bridge::Config - + pallet_bridge_transfer::Config, -{ - pub fn pre_upgrade_resource_fee_storage() -> Result, &'static str> { - assert_eq!(old::Resources::::get(NATIVE_TOKEN_RESOURCE_ID), Some(b"aaaaaa?".to_vec())); - - let mut fee_iter = old::BridgeFee::::iter(); - // Just For Reference - // Ethereum: chain_id=0 - // substrate_Litmus: chain_id=1 - // substrate_Litentry:chain_id=2 - // Rinkeby: chain_id=4 - // substrate_Rococo:chain_id=3 - // substrate_Stage: chain_id=5 - // Goerli: chain_id=6 - assert_eq!(fee_iter.next(), Some((4u8, 1_000_000_000_000u128))); - - assert_eq!(fee_iter.next(), Some((97u8, 1u128))); - assert_eq!(fee_iter.next(), Some((6u8, 1_000_000_000_000u128))); - assert_eq!(fee_iter.next(), Some((99u8, 1_000_000_000_000u128))); - assert!(fee_iter.next().is_none()); - - Ok(Vec::new()) - } - pub fn post_upgrade_resource_fee_storage(_state: Vec) -> Result<(), &'static str> { - assert_eq!(old::Resources::::get(NATIVE_TOKEN_RESOURCE_ID), None); - - let mut fee_iter = old::BridgeFee::::iter(); - assert_eq!(fee_iter.next(), None); - - // Check AssetsHandler Storage - let mut new_resource_fee_iter = >::iter(); - let expected_asset_info = AssetInfo { - // The first one get migrated - fee: 1_000_000_000_000u128.saturating_mul(DECIMAL_CONVERTOR), - asset: None, - }; - assert_eq!( - new_resource_fee_iter.next(), - Some((NATIVE_TOKEN_RESOURCE_ID, expected_asset_info)) - ); - Ok(()) - } - pub fn pre_upgrade_bridge_balances_storage() -> Result, &'static str> { - Ok(Vec::new()) - } - pub fn post_upgrade_bridge_balances_storage(_state: Vec) -> Result<(), &'static str> { - assert!(old::BridgeBalances::::iter().next().is_none()); - Ok(()) - } - pub fn pre_upgrade_external_balance_storage() -> Result, &'static str> { - let pallet_prefix: &[u8] = b"BridgeTransfer"; - let storage_item_prefix: &[u8] = b"ExternalBalances"; - let stored_data = get_storage_value::(pallet_prefix, storage_item_prefix, b"") - .expect("Storage query fails: BridgeTransfer ExternalBalances"); - Ok(stored_data.saturating_mul(DECIMAL_CONVERTOR).encode()) - } - pub fn post_upgrade_external_balance_storage(state: Vec) -> Result<(), &'static str> { - let expected_state = u128::decode(&mut &state[..]) - .map_err(|_| "Failed to decode BridgeTransfer ExternalBalances")?; - - let pallet_prefix: &[u8] = b"AssetsHandler"; - let storage_item_prefix: &[u8] = b"ExternalBalances"; - let actual_state = get_storage_value::(pallet_prefix, storage_item_prefix, b"") - .expect("Storage query fails: BridgeTransfer ExternalBalances"); - assert_eq!(expected_state, actual_state); - Ok(()) - } - pub fn pre_upgrade_maximum_issuance_storage() -> Result, &'static str> { - let pallet_prefix: &[u8] = b"BridgeTransfer"; - let storage_item_prefix: &[u8] = b"MaximumIssuance"; - let stored_data = get_storage_value::(pallet_prefix, storage_item_prefix, b"") - .expect("Storage query fails: BridgeTransfer MaximumIssuance"); - Ok(stored_data.saturating_mul(DECIMAL_CONVERTOR).encode()) - } - pub fn post_upgrade_maximum_issuance_storage(state: Vec) -> Result<(), &'static str> { - let expected_state = u128::decode(&mut &state[..]) - .map_err(|_| "Failed to decode BridgeTransfer MaximumIssuance")?; - - let pallet_prefix: &[u8] = b"AssetsHandler"; - let storage_item_prefix: &[u8] = b"MaximumIssuance"; - let actual_state = get_storage_value::(pallet_prefix, storage_item_prefix, b"") - .expect("Storage query fails: BridgeTransfer MaximumIssuance"); - assert_eq!(expected_state, actual_state); - Ok(()) - } -} - -impl OnRuntimeUpgrade for ReplaceBridgeRelatedStorage -where - T: frame_system::Config> - + pallet_assets::Config - + pallet_assets_handler::Config - + pallet_balances::Config - + pallet_bridge::Config - + pallet_bridge_transfer::Config, -{ - #[cfg(feature = "try-runtime")] - fn pre_upgrade() -> Result, &'static str> { - let _ = Self::pre_upgrade_resource_fee_storage()?; - let _ = Self::pre_upgrade_bridge_balances_storage()?; - - let external_balances_vec = Self::pre_upgrade_external_balance_storage()?; - let maximum_issuance_vec = Self::pre_upgrade_maximum_issuance_storage()?; - - Ok((external_balances_vec, maximum_issuance_vec).encode()) - } - - fn on_runtime_upgrade() -> frame_support::weights::Weight { - let mut weight = frame_support::weights::Weight::from_parts(0, 0); - - // Replace Old Bridge's Resources, BridgeFee with AssetsHandler's ResourceToAssetInfo - weight += Self::relocate_resource_fee_storage(); - // Delete BridgeTransfer's Bridge Balances Storage - weight += Self::delete_bridge_balances_storage(); - - weight += Self::relocate_external_balance_storage(); - weight += Self::relocate_maximum_issuance_storage(); - weight - } - - #[cfg(feature = "try-runtime")] - fn post_upgrade(state: Vec) -> Result<(), &'static str> { - let pre_vec: (Vec, Vec) = - Decode::decode(&mut &state[..]).map_err(|_| "Failed to decode Tuple")?; - - Self::post_upgrade_resource_fee_storage(Vec::::new())?; - Self::post_upgrade_bridge_balances_storage(Vec::::new())?; - - Self::post_upgrade_external_balance_storage(pre_vec.0)?; - Self::post_upgrade_maximum_issuance_storage(pre_vec.1)?; - - Ok(()) - } -} diff --git a/runtime/paseo/src/migration/P9190/mod.rs b/runtime/paseo/src/migration/P9190/mod.rs deleted file mode 100644 index bd5e6a22bc..0000000000 --- a/runtime/paseo/src/migration/P9190/mod.rs +++ /dev/null @@ -1,6 +0,0 @@ -pub mod bridge_related; -pub use bridge_related::ReplaceBridgeRelatedStorage; -pub mod parachain_staking; -pub use parachain_staking::ReplaceParachainStakingStorage; -pub mod balances_transaction_payment; -pub use balances_transaction_payment::ReplaceBalancesRelatedStorage; diff --git a/runtime/paseo/src/migration/P9190/parachain_staking.rs b/runtime/paseo/src/migration/P9190/parachain_staking.rs deleted file mode 100644 index 2de502e2c0..0000000000 --- a/runtime/paseo/src/migration/P9190/parachain_staking.rs +++ /dev/null @@ -1,626 +0,0 @@ -// Copyright 2020-2024 Trust Computing GmbH. -// This file is part of Litentry. -// -// Litentry is free software: you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// Litentry 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 -// GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License -// along with Litentry. If not, see . -#![allow(clippy::type_complexity)] - -use frame_support::{ - migration::storage_key_iter, - pallet_prelude::*, - traits::{Get, OnRuntimeUpgrade}, - Blake2_128Concat, Twox64Concat, -}; -use sp_runtime::Saturating; -use sp_std::{convert::From, marker::PhantomData, vec::Vec}; - -use pallet_parachain_staking::{ - set::OrderedSet, BalanceOf, Bond, BottomDelegations, CandidateInfo, CandidateMetadata, - CandidatePool, DelayedPayout, DelayedPayouts, DelegationAction, DelegationScheduledRequests, - Delegations, Delegator, DelegatorState, ScheduledRequest, Staked, TopDelegations, Total, -}; -pub const DECIMAL_CONVERTOR: u128 = 1_000_000u128; - -#[cfg(feature = "try-runtime")] -use parity_scale_codec::Encode; -#[cfg(feature = "try-runtime")] -use sp_std::collections::btree_map::BTreeMap; -use storage::migration::get_storage_value; - -// Replace Parachain Staking Storage for Decimal Change from 12 to 18 -pub struct ReplaceParachainStakingStorage(PhantomData); -impl ReplaceParachainStakingStorage -where - BalanceOf: From, -{ - pub fn replace_delegator_state_storage() -> frame_support::weights::Weight { - log::info!( - target: "ReplaceParachainStakingStorage", - "running migration to ParachainStaking DelegatorState" - ); - let pallet_prefix: &[u8] = b"ParachainStaking"; - let storage_item_prefix: &[u8] = b"DelegatorState"; - let mut weight: Weight = frame_support::weights::Weight::zero(); - - for (account, mut delegator) in storage_key_iter::< - T::AccountId, - Delegator>, - Twox64Concat, - >(pallet_prefix, storage_item_prefix) - .drain() - { - delegator.total = delegator.total.saturating_mul(DECIMAL_CONVERTOR.into()); - delegator.less_total = delegator.less_total.saturating_mul(DECIMAL_CONVERTOR.into()); - let mut sorted_inner_vector = delegator.delegations.0; - for elem in sorted_inner_vector.iter_mut() { - elem.amount = elem.amount.saturating_mul(DECIMAL_CONVERTOR.into()); - } - delegator.delegations = OrderedSet::from(sorted_inner_vector); - - >::insert(&account, delegator); - weight += T::DbWeight::get().reads_writes(1, 1); - } - - weight - } - - pub fn replace_candidate_info_storage() -> frame_support::weights::Weight { - log::info!( - target: "ReplaceParachainStakingStorage", - "running migration to ParachainStaking CandidateInfo" - ); - let pallet_prefix: &[u8] = b"ParachainStaking"; - let storage_item_prefix: &[u8] = b"CandidateInfo"; - let mut weight: Weight = frame_support::weights::Weight::zero(); - - for (account, mut metadata) in storage_key_iter::< - T::AccountId, - CandidateMetadata>, - Twox64Concat, - >(pallet_prefix, storage_item_prefix) - .drain() - { - metadata.bond = metadata.bond.saturating_mul(DECIMAL_CONVERTOR.into()); - metadata.total_counted = - metadata.total_counted.saturating_mul(DECIMAL_CONVERTOR.into()); - metadata.lowest_top_delegation_amount = - metadata.lowest_top_delegation_amount.saturating_mul(DECIMAL_CONVERTOR.into()); - metadata.highest_bottom_delegation_amount = metadata - .highest_bottom_delegation_amount - .saturating_mul(DECIMAL_CONVERTOR.into()); - metadata.lowest_bottom_delegation_amount = metadata - .lowest_bottom_delegation_amount - .saturating_mul(DECIMAL_CONVERTOR.into()); - - if let Some(mut i) = metadata.request { - i.amount = i.amount.saturating_mul(DECIMAL_CONVERTOR.into()); - } - >::insert(&account, metadata); - weight += T::DbWeight::get().reads_writes(1, 1); - } - - weight - } - - pub fn replace_delegation_scheduled_requests_storage() -> frame_support::weights::Weight { - log::info!( - target: "ReplaceParachainStakingStorage", - "running migration to ParachainStaking DelegationScheduledRequests" - ); - let pallet_prefix: &[u8] = b"ParachainStaking"; - let storage_item_prefix: &[u8] = b"DelegationScheduledRequests"; - let mut weight: Weight = frame_support::weights::Weight::zero(); - - for (account, mut scheduled_requests) in storage_key_iter::< - T::AccountId, - Vec>>, - Blake2_128Concat, - >(pallet_prefix, storage_item_prefix) - .drain() - { - for scheduled_request in scheduled_requests.iter_mut() { - match scheduled_request.action { - DelegationAction::Revoke(n) => { - scheduled_request.action = - DelegationAction::Revoke(n.saturating_mul(DECIMAL_CONVERTOR.into())); - }, - DelegationAction::Decrease(n) => { - scheduled_request.action = - DelegationAction::Decrease(n.saturating_mul(DECIMAL_CONVERTOR.into())); - }, - } - } - >::insert(&account, scheduled_requests); - weight += T::DbWeight::get().reads_writes(1, 1); - } - weight - } - - pub fn replace_top_delegations_storage() -> frame_support::weights::Weight { - log::info!( - target: "ReplaceParachainStakingStorage", - "running migration to ParachainStaking TopDelegations" - ); - let pallet_prefix: &[u8] = b"ParachainStaking"; - let storage_item_prefix: &[u8] = b"TopDelegations"; - let mut weight: Weight = frame_support::weights::Weight::zero(); - - for (account, mut delegations) in storage_key_iter::< - T::AccountId, - Delegations>, - Twox64Concat, - >(pallet_prefix, storage_item_prefix) - .drain() - { - for delegation_bond in delegations.delegations.iter_mut() { - delegation_bond.amount = - delegation_bond.amount.saturating_mul(DECIMAL_CONVERTOR.into()); - } - - >::insert(&account, delegations); - weight += T::DbWeight::get().reads_writes(1, 1); - } - weight - } - - pub fn replace_bottom_delegations_storage() -> frame_support::weights::Weight { - log::info!( - target: "ReplaceParachainStakingStorage", - "running migration to ParachainStaking BottomDelegations" - ); - let pallet_prefix: &[u8] = b"ParachainStaking"; - let storage_item_prefix: &[u8] = b"BottomDelegations"; - let mut weight: Weight = frame_support::weights::Weight::zero(); - - for (account, mut delegations) in storage_key_iter::< - T::AccountId, - Delegations>, - Twox64Concat, - >(pallet_prefix, storage_item_prefix) - .drain() - { - for delegation_bond in delegations.delegations.iter_mut() { - delegation_bond.amount = - delegation_bond.amount.saturating_mul(DECIMAL_CONVERTOR.into()); - } - - >::insert(&account, delegations); - weight += T::DbWeight::get().reads_writes(1, 1); - } - - weight - } - - pub fn replace_total_storage() -> frame_support::weights::Weight { - log::info!( - target: "ReplaceParachainStakingStorage", - "running migration to ParachainStaking Total" - ); - let pallet_prefix: &[u8] = b"ParachainStaking"; - let storage_item_prefix: &[u8] = b"Total"; - let stored_data = - get_storage_value::>(pallet_prefix, storage_item_prefix, b"") - .expect("Storage query fails: ParachainStaking Total"); - >::put(stored_data.saturating_mul(DECIMAL_CONVERTOR.into())); - let weight = T::DbWeight::get(); - frame_support::weights::Weight::from_parts(0, weight.write + weight.read) - } - - pub fn replace_candidate_pool_storage() -> frame_support::weights::Weight { - log::info!( - target: "ReplaceParachainStakingStorage", - "running migration to ParachainStaking CandidatePool" - ); - let pallet_prefix: &[u8] = b"ParachainStaking"; - let storage_item_prefix: &[u8] = b"CandidatePool"; - let mut stored_data = get_storage_value::>>>( - pallet_prefix, - storage_item_prefix, - b"", - ) - .expect("Storage query fails: ParachainStaking CandidatePool"); - for bond in stored_data.0.iter_mut() { - bond.amount = bond.amount.saturating_mul(DECIMAL_CONVERTOR.into()); - } - >::put(stored_data); - let weight = T::DbWeight::get(); - frame_support::weights::Weight::from_parts(0, weight.write + weight.read) - } - - pub fn replace_delayed_payouts_storage() -> frame_support::weights::Weight { - log::info!( - target: "ReplaceParachainStakingStorage", - "running migration to ParachainStaking DelayedPayouts" - ); - let pallet_prefix: &[u8] = b"ParachainStaking"; - let storage_item_prefix: &[u8] = b"DelayedPayouts"; - let mut weight: Weight = frame_support::weights::Weight::zero(); - - for (round, mut delayed_payout) in storage_key_iter::< - u32, - DelayedPayout>, - Twox64Concat, - >(pallet_prefix, storage_item_prefix) - .drain() - { - delayed_payout.round_issuance = - delayed_payout.round_issuance.saturating_mul(DECIMAL_CONVERTOR.into()); - delayed_payout.total_staking_reward = - delayed_payout.total_staking_reward.saturating_mul(DECIMAL_CONVERTOR.into()); - - >::insert(round, delayed_payout); - weight += T::DbWeight::get().reads_writes(1, 1); - } - weight - } - - pub fn replace_staked_storage() -> frame_support::weights::Weight { - log::info!( - target: "ReplaceParachainStakingStorage", - "running migration to ParachainStaking Staked" - ); - let pallet_prefix: &[u8] = b"ParachainStaking"; - let storage_item_prefix: &[u8] = b"Staked"; - - let mut weight: Weight = frame_support::weights::Weight::zero(); - - for (round, staked) in - storage_key_iter::, Twox64Concat>(pallet_prefix, storage_item_prefix) - .drain() - { - >::insert(round, staked.saturating_mul(DECIMAL_CONVERTOR.into())); - weight += T::DbWeight::get().reads_writes(1, 1); - } - weight - } -} - -#[cfg(feature = "try-runtime")] -impl ReplaceParachainStakingStorage -where - BalanceOf: From, -{ - pub fn pre_upgrade_delegator_state_storage() -> Result, &'static str> { - let result: BTreeMap>> = - >::iter() - .map(|(account, state)| { - let mut new_delegator: Delegator> = state; - new_delegator.total = - new_delegator.total.saturating_mul(DECIMAL_CONVERTOR.into()); - new_delegator.less_total = - new_delegator.less_total.saturating_mul(DECIMAL_CONVERTOR.into()); - let mut sorted_inner_vector = new_delegator.delegations.0; - for elem in sorted_inner_vector.iter_mut() { - elem.amount = elem.amount.saturating_mul(DECIMAL_CONVERTOR.into()); - } - new_delegator.delegations = OrderedSet::from(sorted_inner_vector); - - (account, new_delegator) - }) - .collect(); - Ok(result.encode()) - } - pub fn post_upgrade_delegator_state_storage(state: Vec) -> Result<(), &'static str> { - let expected_state = - BTreeMap::>>::decode( - &mut &state[..], - ) - .map_err(|_| "Failed to decode Delegator")?; - for (account, actual_result) in >::iter() { - let expected_result: Delegator> = - expected_state.get(&account).ok_or("Not Expected Delegator")?.clone(); - assert_eq!(expected_result, actual_result); - } - Ok(()) - } - pub fn pre_upgrade_candidate_info_storage() -> Result, &'static str> { - let result: BTreeMap>> = - >::iter() - .map(|(account, state)| { - let mut new_metadata: CandidateMetadata> = state; - new_metadata.bond = new_metadata.bond.saturating_mul(DECIMAL_CONVERTOR.into()); - new_metadata.total_counted = - new_metadata.total_counted.saturating_mul(DECIMAL_CONVERTOR.into()); - new_metadata.lowest_top_delegation_amount = new_metadata - .lowest_top_delegation_amount - .saturating_mul(DECIMAL_CONVERTOR.into()); - new_metadata.highest_bottom_delegation_amount = new_metadata - .highest_bottom_delegation_amount - .saturating_mul(DECIMAL_CONVERTOR.into()); - new_metadata.lowest_bottom_delegation_amount = new_metadata - .lowest_bottom_delegation_amount - .saturating_mul(DECIMAL_CONVERTOR.into()); - - if let Some(mut i) = new_metadata.request { - i.amount = i.amount.saturating_mul(DECIMAL_CONVERTOR.into()); - } - - (account, new_metadata) - }) - .collect(); - Ok(result.encode()) - } - pub fn post_upgrade_candidate_info_storage(state: Vec) -> Result<(), &'static str> { - let expected_state = - BTreeMap::>>::decode(&mut &state[..]) - .map_err(|_| "Failed to decode CandidateMetadata")?; - for (account, actual_result) in >::iter() { - let expected_result: CandidateMetadata> = - expected_state.get(&account).ok_or("Not Expected CandidateMetadata")?.clone(); - // Can not compare CandidateMetadata so compare its encode - assert_eq!(expected_result.encode(), actual_result.encode()); - } - Ok(()) - } - pub fn pre_upgrade_delegation_scheduled_requests_storage() -> Result, &'static str> { - let result: BTreeMap>>> = - >::iter() - .map(|(account, state)| { - let mut new_scheduled_requests: Vec< - ScheduledRequest>, - > = state; - for scheduled_request in new_scheduled_requests.iter_mut() { - match scheduled_request.action { - DelegationAction::Revoke(n) => { - scheduled_request.action = DelegationAction::Revoke( - n.saturating_mul(DECIMAL_CONVERTOR.into()), - ); - }, - DelegationAction::Decrease(n) => { - scheduled_request.action = DelegationAction::Decrease( - n.saturating_mul(DECIMAL_CONVERTOR.into()), - ); - }, - } - } - - (account, new_scheduled_requests) - }) - .collect(); - Ok(result.encode()) - } - pub fn post_upgrade_delegation_scheduled_requests_storage( - state: Vec, - ) -> Result<(), &'static str> { - let expected_state = BTreeMap::< - T::AccountId, - Vec>>, - >::decode(&mut &state[..]) - .map_err(|_| "Failed to decode Vec")?; - for (account, actual_result) in >::iter() { - let expected_result: Vec>> = expected_state - .get(&account) - .ok_or("Not Expected Vec")? - .clone(); - // Can not compare Vec so compare its encode - assert_eq!(expected_result.encode(), actual_result.encode()); - } - Ok(()) - } - pub fn pre_upgrade_top_delegations_storage() -> Result, &'static str> { - let result: BTreeMap>> = - >::iter() - .map(|(account, state)| { - let mut new_delegations: Delegations> = state; - - for delegation_bond in new_delegations.delegations.iter_mut() { - delegation_bond.amount = - delegation_bond.amount.saturating_mul(DECIMAL_CONVERTOR.into()); - } - - (account, new_delegations) - }) - .collect(); - Ok(result.encode()) - } - pub fn post_upgrade_top_delegations_storage(state: Vec) -> Result<(), &'static str> { - let expected_state = - BTreeMap::>>::decode( - &mut &state[..], - ) - .map_err(|_| "Failed to decode Delegations")?; - for (account, actual_result) in >::iter() { - let expected_result: Delegations> = - expected_state.get(&account).ok_or("Not Expected Delegations")?.clone(); - assert_eq!(expected_result.encode(), actual_result.encode()); - } - Ok(()) - } - pub fn pre_upgrade_bottom_delegations_storage() -> Result, &'static str> { - let result: BTreeMap>> = - >::iter() - .map(|(account, state)| { - let mut new_delegations: Delegations> = state; - - for delegation_bond in new_delegations.delegations.iter_mut() { - delegation_bond.amount = - delegation_bond.amount.saturating_mul(DECIMAL_CONVERTOR.into()); - } - - (account, new_delegations) - }) - .collect(); - Ok(result.encode()) - } - pub fn post_upgrade_bottom_delegations_storage(state: Vec) -> Result<(), &'static str> { - let expected_state = - BTreeMap::>>::decode( - &mut &state[..], - ) - .map_err(|_| "Failed to decode Delegations")?; - for (account, actual_result) in >::iter() { - let expected_result: Delegations> = - expected_state.get(&account).ok_or("Not Expected Delegations")?.clone(); - assert_eq!(expected_result.encode(), actual_result.encode()); - } - Ok(()) - } - pub fn pre_upgrade_total_storage() -> Result, &'static str> { - Ok(>::get().saturating_mul(DECIMAL_CONVERTOR.into()).encode()) - } - pub fn post_upgrade_total_storage(state: Vec) -> Result<(), &'static str> { - let expected_state = BalanceOf::::decode(&mut &state[..]) - .map_err(|_| "Failed to decode Total Balance")?; - let actual_state = >::get(); - assert_eq!(expected_state, actual_state); - Ok(()) - } - pub fn pre_upgrade_candidate_pool_storage() -> Result, &'static str> { - let result: BTreeMap> = >::get() - .0 - .iter() - .map(|bond| { - let mut new_bond: Bond> = bond.clone(); - new_bond.amount = new_bond.amount.saturating_mul(DECIMAL_CONVERTOR.into()); - (new_bond.owner, new_bond.amount) - }) - .collect(); - Ok(result.encode()) - } - pub fn post_upgrade_candidate_pool_storage(state: Vec) -> Result<(), &'static str> { - let expected_state = BTreeMap::>::decode(&mut &state[..]) - .map_err(|_| "Failed to decode Candidate Pool Bond (owner, amount)")?; - let actual_state: BTreeMap> = >::get() - .0 - .iter() - .map(|bond| (bond.owner.clone(), bond.amount)) - .collect(); - assert_eq!(expected_state.encode(), actual_state.encode()); - Ok(()) - } - pub fn pre_upgrade_delayed_payouts_storage() -> Result, &'static str> { - let result: BTreeMap>> = >::iter() - .map(|(round, state)| { - let mut new_delayed_payout: DelayedPayout> = state; - - new_delayed_payout.round_issuance = - new_delayed_payout.round_issuance.saturating_mul(DECIMAL_CONVERTOR.into()); - new_delayed_payout.total_staking_reward = new_delayed_payout - .total_staking_reward - .saturating_mul(DECIMAL_CONVERTOR.into()); - - (round, new_delayed_payout) - }) - .collect(); - Ok(result.encode()) - } - pub fn post_upgrade_delayed_payouts_storage(state: Vec) -> Result<(), &'static str> { - let expected_state = BTreeMap::>>::decode(&mut &state[..]) - .map_err(|_| "Failed to decode Delayed Payouts")?; - for (round, actual_result) in >::iter() { - let expected_result: DelayedPayout> = - expected_state.get(&round).ok_or("Not Expected DelayedPayout")?.clone(); - assert_eq!(expected_result.encode(), actual_result.encode()); - } - Ok(()) - } - pub fn pre_upgrade_staked_storage() -> Result, &'static str> { - let result: BTreeMap> = >::iter() - .map(|(round, state)| { - let new_staked: BalanceOf = state; - (round, new_staked.saturating_mul(DECIMAL_CONVERTOR.into())) - }) - .collect(); - Ok(result.encode()) - } - pub fn post_upgrade_staked_storage(state: Vec) -> Result<(), &'static str> { - let expected_state = BTreeMap::>::decode(&mut &state[..]) - .map_err(|_| "Failed to decode Staked")?; - for (round, actual_result) in >::iter() { - let expected_result: BalanceOf = - *expected_state.get(&round).ok_or("Not Expected DelayedPayout")?; - assert_eq!(expected_result.encode(), actual_result.encode()); - } - Ok(()) - } -} - -impl OnRuntimeUpgrade for ReplaceParachainStakingStorage -where - T: frame_system::Config + pallet_parachain_staking::Config, - BalanceOf: From, -{ - #[cfg(feature = "try-runtime")] - fn pre_upgrade() -> Result, &'static str> { - let delegator_state_vec = Self::pre_upgrade_delegator_state_storage()?; - let candidate_info_vec = Self::pre_upgrade_candidate_info_storage()?; - let delegation_scheduled_requests_vec = - Self::pre_upgrade_delegation_scheduled_requests_storage()?; - let top_delegations_vec = Self::pre_upgrade_top_delegations_storage()?; - let bottom_delegations_vec = Self::pre_upgrade_bottom_delegations_storage()?; - let total_vec = Self::pre_upgrade_total_storage()?; - let candidate_pool_vec = Self::pre_upgrade_candidate_pool_storage()?; - let delayed_payouts_vec = Self::pre_upgrade_delayed_payouts_storage()?; - let staked_vec = Self::pre_upgrade_staked_storage()?; - Ok(( - delegator_state_vec, - candidate_info_vec, - delegation_scheduled_requests_vec, - top_delegations_vec, - bottom_delegations_vec, - total_vec, - candidate_pool_vec, - delayed_payouts_vec, - staked_vec, - ) - .encode()) - } - - fn on_runtime_upgrade() -> frame_support::weights::Weight { - let mut weight = frame_support::weights::Weight::from_parts(0, 0); - weight += Self::replace_delegator_state_storage(); - weight += Self::replace_candidate_info_storage(); - weight += Self::replace_delegation_scheduled_requests_storage(); - weight += Self::replace_top_delegations_storage(); - weight += Self::replace_bottom_delegations_storage(); - weight += Self::replace_total_storage(); - weight += Self::replace_candidate_pool_storage(); - - // No need for AtStake Migration since this is a snapshot, everything is good as long as it - // will not change proportion AtStake - - weight += Self::replace_delayed_payouts_storage(); - // Staked Storage holds limited amount of recent rounds only, should not cause large PoV - weight += Self::replace_staked_storage(); - - // No need since all balance related config is Zero - // InflationConfig - - weight - } - - #[cfg(feature = "try-runtime")] - fn post_upgrade(state: Vec) -> Result<(), &'static str> { - let pre_vec: ( - Vec, - Vec, - Vec, - Vec, - Vec, - Vec, - Vec, - Vec, - Vec, - ) = Decode::decode(&mut &state[..]).map_err(|_| "Failed to decode Tuple")?; - Self::post_upgrade_delegator_state_storage(pre_vec.0)?; - Self::post_upgrade_candidate_info_storage(pre_vec.1)?; - Self::post_upgrade_delegation_scheduled_requests_storage(pre_vec.2)?; - Self::post_upgrade_top_delegations_storage(pre_vec.3)?; - Self::post_upgrade_bottom_delegations_storage(pre_vec.4)?; - Self::post_upgrade_total_storage(pre_vec.5)?; - Self::post_upgrade_candidate_pool_storage(pre_vec.6)?; - Self::post_upgrade_delayed_payouts_storage(pre_vec.7)?; - Self::post_upgrade_staked_storage(pre_vec.8)?; - Ok(()) - } -} diff --git a/runtime/paseo/src/migration/P9191/fix_balances.rs b/runtime/paseo/src/migration/P9191/fix_balances.rs deleted file mode 100644 index f0c352b099..0000000000 --- a/runtime/paseo/src/migration/P9191/fix_balances.rs +++ /dev/null @@ -1,89 +0,0 @@ -// Copyright 2020-2024 Trust Computing GmbH. -// This file is part of Litentry. -// -// Litentry is free software: you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// Litentry 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 -// GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License -// along with Litentry. If not, see . -#![allow(clippy::type_complexity)] - -use frame_support::{ - migration::storage_key_iter, - pallet_prelude::*, - traits::{Get, OnRuntimeUpgrade}, -}; -use frame_system::{Account, AccountInfo}; -use pallet_balances::AccountData; -use sp_std::{marker::PhantomData, vec::Vec}; - -#[cfg(feature = "try-runtime")] -use sp_std::collections::btree_map::BTreeMap; - -// Force System Balances Storage frozen amount to 0 -pub struct ForceFixAccountFrozenStorage(PhantomData); -impl OnRuntimeUpgrade for ForceFixAccountFrozenStorage -where - T: frame_system::Config> - + pallet_balances::Config, -{ - #[cfg(feature = "try-runtime")] - fn pre_upgrade() -> Result, &'static str> { - let result: BTreeMap>> = - >::iter() - .map(|(account, state)| { - let mut new_account: AccountInfo> = state; - new_account.data.frozen = 0u128; - - (account, new_account) - }) - .collect(); - Ok(result.encode()) - } - - fn on_runtime_upgrade() -> frame_support::weights::Weight { - // The storage of Account for pallet balances is in frame_system pallet - log::info!( - target: "ReplaceBalancesRelatedStorage", - "running migration to Frame System Account" - ); - let pallet_prefix: &[u8] = b"System"; - let storage_item_prefix: &[u8] = b"Account"; - let mut weight: Weight = frame_support::weights::Weight::zero(); - - for (account, mut account_info) in storage_key_iter::< - T::AccountId, - AccountInfo, - Blake2_128Concat, - >(pallet_prefix, storage_item_prefix) - .drain() - { - account_info.data.frozen = 0u128; - >::insert(&account, account_info); - weight += T::DbWeight::get().reads_writes(1, 1); - } - weight - } - - #[cfg(feature = "try-runtime")] - fn post_upgrade(state: Vec) -> Result<(), &'static str> { - let expected_state = - BTreeMap::>>::decode( - &mut &state[..], - ) - .map_err(|_| "Failed to decode AccountInfo")?; - for (account, actual_result) in >::iter() { - let expected_result: AccountInfo> = - expected_state.get(&account).ok_or("Not Expected AccountInfo")?.clone(); - assert_eq!(expected_result, actual_result); - } - Ok(()) - } -} diff --git a/runtime/paseo/src/migration/P9191/migrate_bounty.rs b/runtime/paseo/src/migration/P9191/migrate_bounty.rs deleted file mode 100644 index bf6e73c0bd..0000000000 --- a/runtime/paseo/src/migration/P9191/migrate_bounty.rs +++ /dev/null @@ -1,159 +0,0 @@ -// Copyright 2020-2024 Trust Computing GmbH. -// This file is part of Litentry. -// -// Litentry is free software: you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// Litentry 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 -// GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License -// along with Litentry. If not, see . -use frame_support::traits::{Get, OnRuntimeUpgrade}; -use sp_std::{marker::PhantomData, vec::Vec}; - -use frame_support::{migration::storage_key_iter, pallet_prelude::*, Twox64Concat}; -use frame_system::pallet_prelude::BlockNumberFor; -use pallet_bounties::{Bounties, BountyIndex, BountyStatus}; -use pallet_treasury::BalanceOf; -use parity_scale_codec::EncodeLike; -use sp_runtime::Saturating; - -pub const DECIMAL_CONVERTOR: u128 = 1_000_000u128; - -// We are creating the exact same struct from the bounties pallet because the fields are private in -// the upstream code -#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen)] -pub struct Bounty { - /// The account proposing it. - pub proposer: AccountId, - /// The (total) amount that should be paid if the bounty is rewarded. - pub value: Balance, - /// The curator fee. Included in value. - pub fee: Balance, - /// The deposit of curator. - pub curator_deposit: Balance, - /// The amount held on deposit (reserved) for making this proposal. - pub bond: Balance, - /// The status of this bounty. - pub status: BountyStatus, -} - -// This is important when we want to insert into the storage item -impl - EncodeLike> - for Bounty -where - AccountId: EncodeLike, - Balance: EncodeLike, - BlockNumber: EncodeLike, -{ -} - -pub struct ReplacePalletBountyStorage(PhantomData<(T, I)>); -impl OnRuntimeUpgrade for ReplacePalletBountyStorage -where - T: pallet_bounties::Config + pallet_treasury::Config, - BalanceOf: EncodeLike> + From, -{ - #[cfg(feature = "try-runtime")] - fn pre_upgrade() -> Result, &'static str> { - let pallet_prefix: &[u8] = b"Bounties"; - let storage_item_prefix: &[u8] = b"Bounties"; - let stored_data: Vec<_> = storage_key_iter::< - BountyIndex, - Bounty, BlockNumberFor>, - Twox64Concat, - >(pallet_prefix, storage_item_prefix) - .collect(); - - let result: Vec<_> = stored_data - .into_iter() - .map(|(bounty_index, bounty)| { - let mut new_bounty = bounty; - new_bounty.value = new_bounty.value.saturating_mul(DECIMAL_CONVERTOR.into()); - new_bounty.fee = new_bounty.fee.saturating_mul(DECIMAL_CONVERTOR.into()); - new_bounty.curator_deposit = - new_bounty.curator_deposit.saturating_mul(DECIMAL_CONVERTOR.into()); - new_bounty.bond = new_bounty.bond.saturating_mul(DECIMAL_CONVERTOR.into()); - - (bounty_index, new_bounty) - }) - .collect(); - - log::info!( - target: "ReplacePalletBountyStorage", - "Finished performing pre upgrade checks" - ); - - Ok(result.encode()) - } - - fn on_runtime_upgrade() -> frame_support::weights::Weight { - log::info!( - target: "ReplacePalletBountyStorage", - "running migration to Bounties Bounties Storage Item" - ); - let pallet_prefix: &[u8] = b"Bounties"; - let storage_item_prefix: &[u8] = b"Bounties"; - let mut weight: Weight = frame_support::weights::Weight::zero(); - - for (bounty_index, mut bounty) in storage_key_iter::< - BountyIndex, - Bounty, BlockNumberFor>, - Twox64Concat, - >(pallet_prefix, storage_item_prefix) - .drain() - { - bounty.value = bounty.value.saturating_mul(DECIMAL_CONVERTOR.into()); - bounty.fee = bounty.fee.saturating_mul(DECIMAL_CONVERTOR.into()); - bounty.curator_deposit = - bounty.curator_deposit.saturating_mul(DECIMAL_CONVERTOR.into()); - bounty.bond = bounty.bond.saturating_mul(DECIMAL_CONVERTOR.into()); - - >::insert(bounty_index, bounty); - - weight += T::DbWeight::get().reads_writes(1, 1); - } - - log::info!( - target: "ReplacePalletBountyStorage", - "Finished performing storage migrations" - ); - - weight - } - - #[cfg(feature = "try-runtime")] - fn post_upgrade(state: Vec) -> Result<(), &'static str> { - let expected_result = Vec::<( - BountyIndex, - Bounty, BlockNumberFor>, - )>::decode(&mut &state[..]) - .map_err(|_| "Failed to decode Bounties")?; - - let pallet_prefix: &[u8] = b"Bounties"; - let storage_item_prefix: &[u8] = b"Bounties"; - let actual_result: Vec<_> = storage_key_iter::< - BountyIndex, - Bounty, BlockNumberFor>, - Twox64Concat, - >(pallet_prefix, storage_item_prefix) - .collect(); - - for x in 0..actual_result.len() { - assert_eq!(actual_result[x], expected_result[x]) - } - - log::info!( - target: "ReplacePalletBountyStorage", - "Finished performing post upgrade checks" - ); - - Ok(()) - } -} diff --git a/runtime/paseo/src/migration/P9191/migrate_democracy.rs b/runtime/paseo/src/migration/P9191/migrate_democracy.rs deleted file mode 100644 index d087105548..0000000000 --- a/runtime/paseo/src/migration/P9191/migrate_democracy.rs +++ /dev/null @@ -1,511 +0,0 @@ -// Copyright 2020-2024 Trust Computing GmbH. -// This file is part of Litentry. -// -// Litentry is free software: you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// Litentry 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 -// GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License -// along with Litentry. If not, see . -use frame_support::traits::{Get, OnRuntimeUpgrade}; -use pallet_democracy::{ - AccountVote, BoundedCallOf, Conviction, Delegations, DepositOf, PropIndex, ReferendumIndex, - ReferendumInfo, ReferendumInfoOf, ReferendumStatus, Tally, VotingOf, -}; -use sp_std::{marker::PhantomData, vec::Vec}; - -use frame_support::{ - migration::storage_key_iter, pallet_prelude::*, traits::Currency, Twox64Concat, -}; -use frame_system::pallet_prelude::BlockNumberFor; -use parity_scale_codec::EncodeLike; -use sp_runtime::Saturating; - -type BalanceOf = <::Currency as Currency< - ::AccountId, ->>::Balance; - -pub const DECIMAL_CONVERTOR: u128 = 1_000_000u128; - -/// A "prior" lock, i.e. a lock for some now-forgotten reason. -#[derive( - Encode, - MaxEncodedLen, - Decode, - Default, - Copy, - Clone, - Eq, - PartialEq, - Ord, - PartialOrd, - RuntimeDebug, - TypeInfo, -)] -pub struct PriorLock(BlockNumber, Balance); - -#[derive(Clone, Encode, Decode, Eq, MaxEncodedLen, PartialEq, RuntimeDebug, TypeInfo)] -#[codec(mel_bound(skip_type_params(MaxVotes)))] -#[scale_info(skip_type_params(MaxVotes))] -pub enum Voting> { - /// The account is voting directly. `delegations` is the total amount of post-conviction voting - /// weight that it controls from those that have delegated to it. - Direct { - /// The current votes of the account. - votes: BoundedVec<(ReferendumIndex, AccountVote), MaxVotes>, - /// The total amount of delegations that this account has received. - delegations: Delegations, - /// Any pre-existing locks from past voting/delegating activity. - prior: PriorLock, - }, - /// The account is delegating `balance` of its balance to a `target` account with `conviction`. - Delegating { - balance: Balance, - target: AccountId, - conviction: Conviction, - /// The total amount of delegations that this account has received. - delegations: Delegations, - /// Any pre-existing locks from past voting/delegating activity. - prior: PriorLock, - }, -} - -/// Const doesn't implement partialeq trait, so we have to check manually -#[cfg(feature = "try-runtime")] -fn are_voting_instances_equal>( - a: &Voting, - b: &Voting, -) -> bool -where - Balance: PartialEq, - AccountId: PartialEq, - BlockNumber: PartialEq, -{ - match (a, b) { - ( - Voting::Direct { votes: votes_a, delegations: delegations_a, prior: prior_a }, - Voting::Direct { votes: votes_b, delegations: delegations_b, prior: prior_b }, - ) => votes_a == votes_b && delegations_a == delegations_b && prior_a == prior_b, - - ( - Voting::Delegating { - balance: balance_a, - target: target_a, - conviction: conviction_a, - delegations: delegations_a, - prior: prior_a, - }, - Voting::Delegating { - balance: balance_b, - target: target_b, - conviction: conviction_b, - delegations: delegations_b, - prior: prior_b, - }, - ) => - balance_a == balance_b && - target_a == target_b && - conviction_a == conviction_b && - delegations_a == delegations_b && - prior_a == prior_b, - - _ => false, - } -} - -// This is important when we want to insert into the storage item -impl - EncodeLike> - for Voting -where - AccountId: EncodeLike, - Balance: EncodeLike, - BlockNumber: EncodeLike, - MaxVotes: Get, -{ -} - -pub struct ReplaceDemocracyStorage(PhantomData); -impl ReplaceDemocracyStorage -where - BalanceOf: From, -{ - fn replace_deposit_of_storage() -> frame_support::weights::Weight { - log::info!( - target: "ReplaceDemocracyStorage", - "running migration to Democracy DepositOf Storage Item" - ); - let pallet_prefix: &[u8] = b"Democracy"; - let storage_item_prefix: &[u8] = b"DepositOf"; - let mut weight: Weight = frame_support::weights::Weight::zero(); - - for (prop_index, mut value) in storage_key_iter::< - PropIndex, - (BoundedVec, BalanceOf), - Twox64Concat, - >(pallet_prefix, storage_item_prefix) - .drain() - { - value.1 = value.1.saturating_mul(DECIMAL_CONVERTOR.into()); - - >::insert(prop_index, value); - - weight += T::DbWeight::get().reads_writes(1, 1); - } - - weight - } - - fn replace_referendum_info_of_storage() -> frame_support::weights::Weight { - log::info!( - target: "ReplaceDemocracyStorage", - "running migration to Democracy ReferendumInfoOf Storage Item" - ); - let pallet_prefix: &[u8] = b"Democracy"; - let storage_item_prefix: &[u8] = b"ReferenceInfoOf"; - - let mut weight: Weight = frame_support::weights::Weight::zero(); - for (ref_index, ref_info) in storage_key_iter::< - ReferendumIndex, - ReferendumInfo, BalanceOf>, - Twox64Concat, - >(pallet_prefix, storage_item_prefix) - .drain() - { - let new_ref_info = match ref_info { - ReferendumInfo::Finished { approved, end } => - ReferendumInfo::Finished { approved, end }, - ReferendumInfo::Ongoing(ref_status) => ReferendumInfo::Ongoing(ReferendumStatus { - end: ref_status.end, - proposal: ref_status.proposal, - threshold: ref_status.threshold, - delay: ref_status.delay, - tally: Tally { - ayes: ref_status.tally.ayes.saturating_mul(DECIMAL_CONVERTOR.into()), - nays: ref_status.tally.nays.saturating_mul(DECIMAL_CONVERTOR.into()), - turnout: ref_status.tally.turnout.saturating_mul(DECIMAL_CONVERTOR.into()), - }, - }), - }; - - >::insert(ref_index, new_ref_info); - - weight += T::DbWeight::get().reads_writes(1, 1); - } - - weight - } - - fn replace_voting_of_storage() -> frame_support::weights::Weight { - log::info!( - target: "ReplaceDemocracyStorage", - "running migration to Democracy VotingOf Storage Item" - ); - let pallet_prefix: &[u8] = b"Democracy"; - let storage_item_prefix: &[u8] = b"VotingOf"; - let mut weight: Weight = frame_support::weights::Weight::zero(); - - for (who, voting) in storage_key_iter::< - T::AccountId, - Voting, T::AccountId, BlockNumberFor, T::MaxVotes>, - Twox64Concat, - >(pallet_prefix, storage_item_prefix) - .drain() - { - let new_voting = match voting { - Voting::Delegating { balance, target, conviction, delegations, prior } => { - let new_balance = balance.saturating_mul(DECIMAL_CONVERTOR.into()); - let new_delegation = Delegations { - votes: delegations.votes.saturating_mul(DECIMAL_CONVERTOR.into()), - capital: delegations.capital.saturating_mul(DECIMAL_CONVERTOR.into()), - }; - let new_prior_locks = - PriorLock(prior.0, prior.1.saturating_mul(DECIMAL_CONVERTOR.into())); - Voting::Delegating { - balance: new_balance, - target, - conviction, - delegations: new_delegation, - prior: new_prior_locks, - } - }, - Voting::Direct { votes, delegations, prior } => { - let new_votes: Vec<_> = votes - .into_iter() - .map(|(id, vote)| { - let new_vote = match vote { - AccountVote::Split { aye, nay } => AccountVote::Split { - aye: aye.saturating_mul(DECIMAL_CONVERTOR.into()), - nay: nay.saturating_mul(DECIMAL_CONVERTOR.into()), - }, - AccountVote::Standard { vote, balance } => AccountVote::Standard { - vote, - balance: balance.saturating_mul(DECIMAL_CONVERTOR.into()), - }, - }; - (id, new_vote) - }) - .collect(); - - // This unwrap cannot fail since it is the same BoundedVec - let bounded_new_votes: BoundedVec< - (u32, AccountVote>), - T::MaxVotes, - > = new_votes.try_into().unwrap(); - - let new_delegation = Delegations { - votes: delegations.votes.saturating_mul(DECIMAL_CONVERTOR.into()), - capital: delegations.capital.saturating_mul(DECIMAL_CONVERTOR.into()), - }; - let new_prior_locks = - PriorLock(prior.0, prior.1.saturating_mul(DECIMAL_CONVERTOR.into())); - - Voting::Direct { - votes: bounded_new_votes, - delegations: new_delegation, - prior: new_prior_locks, - } - }, - }; - >::insert(who, new_voting); - - weight += T::DbWeight::get().reads_writes(1, 1); - } - - weight - } -} - -#[cfg(feature = "try-runtime")] -impl ReplaceDemocracyStorage -where - BalanceOf: From, -{ - fn pre_upgrade_deposit_of_storage() -> Result, &'static str> { - let result: Vec<_> = >::iter() - .map(|(prop_index, value)| { - let mut new_value = value; - new_value.1 = new_value.1.saturating_mul(DECIMAL_CONVERTOR.into()); - - (prop_index, new_value) - }) - .collect(); - Ok(result.encode()) - } - - fn post_upgrade_deposit_of_storage(state: Vec) -> Result<(), &'static str> { - let expected_result = Vec::<( - PropIndex, - (BoundedVec, BalanceOf), - )>::decode(&mut &state[..]) - .map_err(|_| "Failed to decode Bounties")?; - - let actual_result: Vec<_> = - >::iter().map(|(prop_index, value)| (prop_index, value)).collect(); - - for x in 0..actual_result.len() { - assert_eq!(actual_result[x], expected_result[x]) - } - - Ok(()) - } - - fn pre_upgrade_referendum_info_of_storage() -> Result, &'static str> { - let result: Vec<_> = >::iter() - .map(|(ref_index, ref_info)| { - let new_ref_info = match ref_info { - ReferendumInfo::Finished { approved, end } => - ReferendumInfo::Finished { approved, end }, - ReferendumInfo::Ongoing(ref_status) => - ReferendumInfo::Ongoing(ReferendumStatus { - end: ref_status.end, - proposal: ref_status.proposal, - threshold: ref_status.threshold, - delay: ref_status.delay, - tally: Tally { - ayes: ref_status - .tally - .ayes - .saturating_mul(DECIMAL_CONVERTOR.into()), - nays: ref_status - .tally - .nays - .saturating_mul(DECIMAL_CONVERTOR.into()), - turnout: ref_status - .tally - .turnout - .saturating_mul(DECIMAL_CONVERTOR.into()), - }, - }), - }; - - (ref_index, new_ref_info) - }) - .collect(); - Ok(result.encode()) - } - - fn post_upgrade_referendum_info_of_storage(state: Vec) -> Result<(), &'static str> { - let expected_result = Vec::<( - ReferendumIndex, - ReferendumInfo, BalanceOf>, - )>::decode(&mut &state[..]) - .map_err(|_| "Failed to decode Bounties")?; - - let actual_result: Vec<_> = >::iter() - .map(|(ref_index, ref_info)| (ref_index, ref_info)) - .collect(); - for x in 0..actual_result.len() { - assert_eq!(actual_result[x], expected_result[x]) - } - Ok(()) - } - - fn pre_upgrade_voting_of_storage() -> Result, &'static str> { - let pallet_prefix: &[u8] = b"Democracy"; - let storage_item_prefix: &[u8] = b"VotingOf"; - let stored_data: Vec<_> = storage_key_iter::< - T::AccountId, - Voting, T::AccountId, BlockNumberFor, T::MaxVotes>, - Twox64Concat, - >(pallet_prefix, storage_item_prefix) - .collect(); - - let result: Vec<_> = stored_data - .into_iter() - .map(|(who, voting)| { - let new_voting = match voting { - Voting::Delegating { balance, target, conviction, delegations, prior } => { - let new_balance = balance.saturating_mul(DECIMAL_CONVERTOR.into()); - let new_delegation = Delegations { - votes: delegations.votes.saturating_mul(DECIMAL_CONVERTOR.into()), - capital: delegations.capital.saturating_mul(DECIMAL_CONVERTOR.into()), - }; - let new_prior_locks = - PriorLock(prior.0, prior.1.saturating_mul(DECIMAL_CONVERTOR.into())); - Voting::Delegating { - balance: new_balance, - target, - conviction, - delegations: new_delegation, - prior: new_prior_locks, - } - }, - Voting::Direct { votes, delegations, prior } => { - let new_votes: Vec<_> = votes - .into_iter() - .map(|(id, vote)| { - let new_vote = match vote { - AccountVote::Split { aye, nay } => AccountVote::Split { - aye: aye.saturating_mul(DECIMAL_CONVERTOR.into()), - nay: nay.saturating_mul(DECIMAL_CONVERTOR.into()), - }, - AccountVote::Standard { vote, balance } => - AccountVote::Standard { - vote, - balance: balance - .saturating_mul(DECIMAL_CONVERTOR.into()), - }, - }; - (id, new_vote) - }) - .collect(); - - let bounded_new_votes: BoundedVec< - (u32, AccountVote>), - T::MaxVotes, - > = new_votes.try_into().unwrap(); - - let new_delegation = Delegations { - votes: delegations.votes.saturating_mul(DECIMAL_CONVERTOR.into()), - capital: delegations.capital.saturating_mul(DECIMAL_CONVERTOR.into()), - }; - let new_prior_locks = - PriorLock(prior.0, prior.1.saturating_mul(DECIMAL_CONVERTOR.into())); - - Voting::Direct { - votes: bounded_new_votes, - delegations: new_delegation, - prior: new_prior_locks, - } - }, - }; - (who, new_voting) - }) - .collect(); - - Ok(result.encode()) - } - - fn post_upgrade_voting_of_storage(state: Vec) -> Result<(), &'static str> { - let expected_result = Vec::<( - T::AccountId, - Voting, T::AccountId, BlockNumberFor, T::MaxVotes>, - )>::decode(&mut &state[..]) - .map_err(|_| "Failed to decode Bounties")?; - - let pallet_prefix: &[u8] = b"Democracy"; - let storage_item_prefix: &[u8] = b"VotingOf"; - let actual_result: Vec<_> = storage_key_iter::< - T::AccountId, - Voting, T::AccountId, BlockNumberFor, T::MaxVotes>, - Twox64Concat, - >(pallet_prefix, storage_item_prefix) - .collect(); - - for x in 0..actual_result.len() { - assert_eq!(actual_result[x].0, expected_result[x].0); - let result = are_voting_instances_equal::< - BalanceOf, - T::AccountId, - BlockNumberFor, - T::MaxVotes, - >(&actual_result[x].1, &expected_result[x].1); - assert!(result); - } - - Ok(()) - } -} - -impl OnRuntimeUpgrade for ReplaceDemocracyStorage -where - BalanceOf: From, -{ - #[cfg(feature = "try-runtime")] - fn pre_upgrade() -> Result, &'static str> { - let deposit_of_state_vec = Self::pre_upgrade_deposit_of_storage()?; - let referendum_info_of_state_vec = Self::pre_upgrade_referendum_info_of_storage()?; - let voting_of_state_vec = Self::pre_upgrade_voting_of_storage()?; - - log::info!(target: "ReplaceDemocracyStorage", "Finished performing pre upgrade checks"); - Ok((deposit_of_state_vec, referendum_info_of_state_vec, voting_of_state_vec).encode()) - } - - fn on_runtime_upgrade() -> frame_support::weights::Weight { - let mut weight = frame_support::weights::Weight::from_parts(0, 0); - weight += Self::replace_deposit_of_storage(); - weight += Self::replace_referendum_info_of_storage(); - weight += Self::replace_voting_of_storage(); - - log::info!(target: "ReplaceDemocracyStorage", "Finished performing storage migrations"); - weight - } - - #[cfg(feature = "try-runtime")] - fn post_upgrade(state: Vec) -> Result<(), &'static str> { - let pre_vec: (Vec, Vec, Vec) = - Decode::decode(&mut &state[..]).map_err(|_| "Failed to decode Tuple")?; - Self::post_upgrade_deposit_of_storage(pre_vec.0)?; - Self::post_upgrade_referendum_info_of_storage(pre_vec.1)?; - Self::post_upgrade_voting_of_storage(pre_vec.2)?; - log::info!(target: "ReplaceDemocracyStorage", "Finished performing post upgrade checks"); - Ok(()) - } -} diff --git a/runtime/paseo/src/migration/P9191/migrate_identity.rs b/runtime/paseo/src/migration/P9191/migrate_identity.rs deleted file mode 100644 index c0bf3eee82..0000000000 --- a/runtime/paseo/src/migration/P9191/migrate_identity.rs +++ /dev/null @@ -1,209 +0,0 @@ -// Copyright 2020-2024 Trust Computing GmbH. -// This file is part of Litentry. -// -// Litentry is free software: you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// Litentry 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 -// GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License -// along with Litentry. If not, see . -#![allow(clippy::type_complexity)] - -use frame_support::{ - migration::storage_key_iter, - pallet_prelude::*, - traits::{Currency, Get, OnRuntimeUpgrade}, - Twox64Concat, -}; -use sp_std::{marker::PhantomData, vec::Vec}; - -#[cfg(feature = "try-runtime")] -use parity_scale_codec::{Decode, Encode}; - -use pallet_identity::{RegistrarInfo, Registration}; -use storage::migration::get_storage_value; -type BalanceOf = <::Currency as Currency< - ::AccountId, ->>::Balance; - -// Replace Parachain Staking Storage for Decimal Change from 12 to 18 -pub struct ReplacePalletIdentityStorage(PhantomData); - -impl ReplacePalletIdentityStorage -where - T: pallet_identity::Config, -{ - // pallet_identity - pub fn check_identityof_storage() -> frame_support::weights::Weight { - log::info!( - target: "ReplacePalletIdentityStorage", - "Running check to ParachainIdentity IdentityOf" - ); - let pallet_prefix: &[u8] = b"ParachainIdentity"; - let storage_item_prefix: &[u8] = b"IdentityOf"; - - assert!(storage_key_iter::< - T::AccountId, - Registration, T::MaxRegistrars, T::MaxAdditionalFields>, - Twox64Concat, - >(pallet_prefix, storage_item_prefix) - .next() - .is_none()); - let weight = T::DbWeight::get(); - frame_support::weights::Weight::from_parts(0, weight.read) - } - - pub fn check_subsof_storage() -> frame_support::weights::Weight { - log::info!( - target: "ReplacePalletIdentityStorage", - "Running check to ParachainIdentity SubsOf" - ); - let pallet_prefix: &[u8] = b"ParachainIdentity"; - let storage_item_prefix: &[u8] = b"SubsOf"; - - assert!(storage_key_iter::< - T::AccountId, - Registration, T::MaxRegistrars, T::MaxAdditionalFields>, - Twox64Concat, - >(pallet_prefix, storage_item_prefix) - .next() - .is_none()); - let weight = T::DbWeight::get(); - frame_support::weights::Weight::from_parts(0, weight.read) - } - - pub fn check_registrars_storage() -> frame_support::weights::Weight { - log::info!( - target: "ReplacePalletIdentityStorage", - "Running check to ParachainIdentity Registrars" - ); - let pallet_prefix: &[u8] = b"ParachainIdentity"; - let storage_item_prefix: &[u8] = b"Registrars"; - - assert!(get_storage_value::< - BoundedVec, T::AccountId>>, T::MaxRegistrars>, - >(pallet_prefix, storage_item_prefix, b"") - .is_none()); - - let weight = T::DbWeight::get(); - frame_support::weights::Weight::from_parts(0, weight.read) - } -} - -#[cfg(feature = "try-runtime")] -impl ReplacePalletIdentityStorage -where - T: pallet_identity::Config, -{ - // pallet_identity - pub fn pre_upgrade_identityof_storage() -> Result, &'static str> { - let pallet_prefix: &[u8] = b"ParachainIdentity"; - let storage_item_prefix: &[u8] = b"IdentityOf"; - - assert!(storage_key_iter::< - T::AccountId, - Registration, T::MaxRegistrars, T::MaxAdditionalFields>, - Twox64Concat, - >(pallet_prefix, storage_item_prefix) - .next() - .is_none()); - Ok(Vec::::new()) - } - pub fn post_upgrade_identityof_storage(_state: Vec) -> Result<(), &'static str> { - let pallet_prefix: &[u8] = b"ParachainIdentity"; - let storage_item_prefix: &[u8] = b"IdentityOf"; - - assert!(storage_key_iter::< - T::AccountId, - Registration, T::MaxRegistrars, T::MaxAdditionalFields>, - Twox64Concat, - >(pallet_prefix, storage_item_prefix) - .next() - .is_none()); - Ok(()) - } - pub fn pre_upgrade_subsof_storage() -> Result, &'static str> { - let pallet_prefix: &[u8] = b"ParachainIdentity"; - let storage_item_prefix: &[u8] = b"SubsOf"; - - assert!(storage_key_iter::< - T::AccountId, - Registration, T::MaxRegistrars, T::MaxAdditionalFields>, - Twox64Concat, - >(pallet_prefix, storage_item_prefix) - .next() - .is_none()); - Ok(Vec::::new()) - } - pub fn post_upgrade_subsof_storage(_state: Vec) -> Result<(), &'static str> { - let pallet_prefix: &[u8] = b"ParachainIdentity"; - let storage_item_prefix: &[u8] = b"SubsOf"; - - assert!(storage_key_iter::< - T::AccountId, - Registration, T::MaxRegistrars, T::MaxAdditionalFields>, - Twox64Concat, - >(pallet_prefix, storage_item_prefix) - .next() - .is_none()); - - Ok(()) - } - pub fn pre_upgrade_registrars_storage() -> Result, &'static str> { - let pallet_prefix: &[u8] = b"ParachainIdentity"; - let storage_item_prefix: &[u8] = b"Registrars"; - - assert!(get_storage_value::< - BoundedVec, T::AccountId>>, T::MaxRegistrars>, - >(pallet_prefix, storage_item_prefix, b"") - .is_none()); - Ok(Vec::::new()) - } - pub fn post_upgrade_registrars_storage(_state: Vec) -> Result<(), &'static str> { - let pallet_prefix: &[u8] = b"ParachainIdentity"; - let storage_item_prefix: &[u8] = b"Registrars"; - - assert!(get_storage_value::< - BoundedVec, T::AccountId>>, T::MaxRegistrars>, - >(pallet_prefix, storage_item_prefix, b"") - .is_none()); - Ok(()) - } -} - -impl OnRuntimeUpgrade for ReplacePalletIdentityStorage -where - T: frame_system::Config + pallet_identity::Config, -{ - #[cfg(feature = "try-runtime")] - fn pre_upgrade() -> Result, &'static str> { - // pallet_identity - let identityof_vec = Self::pre_upgrade_identityof_storage()?; - let subsof_vec = Self::pre_upgrade_subsof_storage()?; - let registrars_vec = Self::pre_upgrade_registrars_storage()?; - - Ok((identityof_vec, subsof_vec, registrars_vec).encode()) - } - - fn on_runtime_upgrade() -> frame_support::weights::Weight { - frame_support::weights::Weight::zero() - } - - #[cfg(feature = "try-runtime")] - fn post_upgrade(state: Vec) -> Result<(), &'static str> { - let pre_vec: (Vec, Vec, Vec) = - Decode::decode(&mut &state[..]).map_err(|_| "Failed to decode Tuple")?; - // pallet_identity - Self::post_upgrade_identityof_storage(pre_vec.0)?; - Self::post_upgrade_subsof_storage(pre_vec.1)?; - Self::post_upgrade_registrars_storage(pre_vec.2)?; - - Ok(()) - } -} diff --git a/runtime/paseo/src/migration/P9191/migrate_multisig.rs b/runtime/paseo/src/migration/P9191/migrate_multisig.rs deleted file mode 100644 index 50209a08fa..0000000000 --- a/runtime/paseo/src/migration/P9191/migrate_multisig.rs +++ /dev/null @@ -1,91 +0,0 @@ -// Copyright 2020-2024 Trust Computing GmbH. -// This file is part of Litentry. -// -// Litentry is free software: you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// Litentry 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 -// GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License -// along with Litentry. If not, see . -#![allow(clippy::type_complexity)] - -use frame_support::{ - pallet_prelude::*, - traits::{Get, OnRuntimeUpgrade}, -}; -use sp_std::{marker::PhantomData, vec::Vec}; - -#[cfg(feature = "try-runtime")] -use parity_scale_codec::Encode; - -use pallet_multisig::Multisigs; - -// Replace Parachain Staking Storage for Decimal Change from 12 to 18 -pub struct ReplacePalletMultisigStorage(PhantomData); - -impl ReplacePalletMultisigStorage -where - T: pallet_multisig::Config, -{ - // pallet_multisig - pub fn check_multisig_multisigs_storage() -> frame_support::weights::Weight { - log::info!( - target: "ReplacePalletMultisigStorage", - "Running checking to Multisig - Multisigs" - ); - - assert!(Multisigs::::iter().next().is_none()); - - let weight = T::DbWeight::get(); - frame_support::weights::Weight::from_parts(0, weight.read) - } -} - -#[cfg(feature = "try-runtime")] -impl ReplacePalletMultisigStorage -where - T: pallet_multisig::Config, -{ - pub fn pre_upgrade_multisig_multisigs_storage() -> Result, &'static str> { - assert!(Multisigs::::iter().next().is_none()); - Ok(Vec::::new()) - } - - pub fn post_upgrade_multisig_multisigs_storage(_state: Vec) -> Result<(), &'static str> { - assert!(Multisigs::::iter().next().is_none()); - Ok(()) - } -} - -impl OnRuntimeUpgrade for ReplacePalletMultisigStorage -where - T: frame_system::Config + pallet_multisig::Config, -{ - #[cfg(feature = "try-runtime")] - fn pre_upgrade() -> Result, &'static str> { - // pallet_multisig - let multisigs_vec = Self::pre_upgrade_multisig_multisigs_storage()?; - - Ok((multisigs_vec,).encode()) - } - - fn on_runtime_upgrade() -> frame_support::weights::Weight { - frame_support::weights::Weight::zero() - } - - #[cfg(feature = "try-runtime")] - fn post_upgrade(state: Vec) -> Result<(), &'static str> { - let pre_vec: (Vec,) = - Decode::decode(&mut &state[..]).map_err(|_| "Failed to decode Tuple")?; - - // pallet_multisig - Self::post_upgrade_multisig_multisigs_storage(pre_vec.0)?; - Ok(()) - } -} diff --git a/runtime/paseo/src/migration/P9191/migrate_preimage.rs b/runtime/paseo/src/migration/P9191/migrate_preimage.rs deleted file mode 100644 index 8fb4b9d2b8..0000000000 --- a/runtime/paseo/src/migration/P9191/migrate_preimage.rs +++ /dev/null @@ -1,163 +0,0 @@ -// Copyright 2020-2024 Trust Computing GmbH. -// This file is part of Litentry. -// -// Litentry is free software: you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// Litentry 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 -// GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License -// along with Litentry. If not, see . -use frame_support::{ - pallet_prelude::*, - traits::{Get, OnRuntimeUpgrade}, - Identity, -}; -use pallet_preimage::RequestStatus; -use sp_std::{marker::PhantomData, vec::Vec}; - -use frame_support::migration::{put_storage_value, storage_key_iter}; -use pallet_treasury::BalanceOf; -#[cfg(feature = "try-runtime")] -use parity_scale_codec::{Decode, Encode}; -use sp_runtime::Saturating; - -pub const DECIMAL_CONVERTOR: u128 = 1_000_000u128; - -pub struct ReplacePreImageStorage(PhantomData); -impl OnRuntimeUpgrade for ReplacePreImageStorage -where - T: pallet_preimage::Config + pallet_treasury::Config, - BalanceOf: From, -{ - #[cfg(feature = "try-runtime")] - fn pre_upgrade() -> Result, &'static str> { - let pallet_prefix: &[u8] = b"Preimage"; - let storage_item_prefix: &[u8] = b"StatusFor"; - let stored_data: Vec<_> = storage_key_iter::< - T::Hash, - RequestStatus>, - Identity, - >(pallet_prefix, storage_item_prefix) - .collect(); - - let result: Vec<_> = stored_data - .into_iter() - .map(|(hash, status)| { - let new_status = match status { - RequestStatus::Requested { deposit, count, len } => { - if let Some((account, balance)) = deposit { - RequestStatus::Requested { - deposit: Some(( - account, - balance.saturating_mul(DECIMAL_CONVERTOR.into()), - )), - count, - len, - } - } else { - RequestStatus::Requested { deposit, count, len } - } - }, - RequestStatus::Unrequested { deposit, len } => RequestStatus::Unrequested { - deposit: (deposit.0, deposit.1.saturating_mul(DECIMAL_CONVERTOR.into())), - len, - }, - }; - - (hash, new_status) - }) - .collect(); - - log::info!( - target: "ReplacePreImageStorage", - "Finished performing pre upgrade checks" - ); - - Ok(result.encode()) - } - - fn on_runtime_upgrade() -> frame_support::weights::Weight { - log::info!( - target: "ReplacePreImageStorage", - "running migration to Preimage StatusFor Storage Item" - ); - let pallet_prefix: &[u8] = b"Preimage"; - let storage_item_prefix: &[u8] = b"StatusFor"; - let mut weight: Weight = frame_support::weights::Weight::zero(); - - for (hash, status) in storage_key_iter::< - T::Hash, - RequestStatus>, - Identity, - >(pallet_prefix, storage_item_prefix) - .drain() - { - let new_status = match status { - RequestStatus::Requested { deposit, count, len } => { - if let Some((account, balance)) = deposit { - RequestStatus::Requested { - deposit: Some(( - account, - balance.saturating_mul(DECIMAL_CONVERTOR.into()), - )), - count, - len, - } - } else { - RequestStatus::Requested { deposit, count, len } - } - }, - RequestStatus::Unrequested { deposit, len } => RequestStatus::Unrequested { - deposit: (deposit.0, deposit.1.saturating_mul(DECIMAL_CONVERTOR.into())), - len, - }, - }; - - // The storage item is using Identity so we don't need to do addtitional hashing and can - // directly put into storage - put_storage_value::>>( - pallet_prefix, - storage_item_prefix, - hash.as_ref(), - new_status, - ); - - weight += T::DbWeight::get().reads_writes(1, 1); - } - - weight - } - - #[cfg(feature = "try-runtime")] - fn post_upgrade(state: Vec) -> Result<(), &'static str> { - let expected_result = - Vec::<(T::Hash, RequestStatus>)>::decode(&mut &state[..]) - .map_err(|_| "Failed to decode Bounties")?; - - let pallet_prefix: &[u8] = b"Preimage"; - let storage_item_prefix: &[u8] = b"StatusFor"; - let actual_result: Vec<_> = storage_key_iter::< - T::Hash, - RequestStatus>, - Identity, - >(pallet_prefix, storage_item_prefix) - .collect(); - - for x in 0..actual_result.len() { - assert_eq!(actual_result[x], expected_result[x]) - } - - log::info!( - target: "ReplacePreImageStorage", - "Finished performing post upgrade checks" - ); - - Ok(()) - } -} diff --git a/runtime/paseo/src/migration/P9191/migrate_proxy.rs b/runtime/paseo/src/migration/P9191/migrate_proxy.rs deleted file mode 100644 index c5be78ebdc..0000000000 --- a/runtime/paseo/src/migration/P9191/migrate_proxy.rs +++ /dev/null @@ -1,265 +0,0 @@ -// Copyright 2020-2024 Trust Computing GmbH. -// This file is part of Litentry. -// -// Litentry is free software: you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// Litentry 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 -// GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License -// along with Litentry. If not, see . -#![allow(clippy::type_complexity)] - -use frame_support::{ - migration::storage_key_iter, - pallet_prelude::*, - traits::{Currency, Get, OnRuntimeUpgrade}, - Twox64Concat, -}; -use sp_runtime::{traits::Hash, Saturating}; -use sp_std::{marker::PhantomData, vec::Vec}; - -pub const DECIMAL_CONVERTOR: u32 = 1_000_000; - -#[cfg(feature = "try-runtime")] -use parity_scale_codec::Encode; -#[cfg(feature = "try-runtime")] -use sp_std::collections::btree_map::BTreeMap; - -use pallet_proxy::{Announcement, Announcements, Proxies, ProxyDefinition}; -type BalanceOf = <::Currency as Currency< - ::AccountId, ->>::Balance; - -type CallHashOf = <::CallHasher as Hash>::Output; - -pub struct ReplacePalletProxyStorage(PhantomData); - -impl ReplacePalletProxyStorage -where - T: pallet_proxy::Config, -{ - // pallet_proxy - pub fn replace_proxy_proxies_storage() -> frame_support::weights::Weight { - log::info!( - target: "ReplacePalletProxyStorage", - "Running migration to Proxy - Proxies" - ); - - let mut weight = frame_support::weights::Weight::zero(); - - let pallet_prefix: &[u8] = b"Proxy"; - let storage_item_prefix: &[u8] = b"Proxies"; - - for (account, (proxies, amount)) in storage_key_iter::< - T::AccountId, - ( - BoundedVec< - ProxyDefinition, - T::MaxProxies, - >, - BalanceOf, - ), - Twox64Concat, - >(pallet_prefix, storage_item_prefix) - .drain() - { - let new_amount = amount.saturating_mul(DECIMAL_CONVERTOR.into()); - >::insert(account, (proxies, new_amount)); - - weight += T::DbWeight::get().reads_writes(1, 1); - } - - weight - } - - pub fn replace_proxy_announcements_storage() -> frame_support::weights::Weight { - log::info!( - target: "ReplacePalletProxyStorage", - "Running migration to Proxy - Announcements" - ); - - let mut weight = frame_support::weights::Weight::zero(); - - let pallet_prefix: &[u8] = b"Proxy"; - let storage_item_prefix: &[u8] = b"Announcements"; - - for (account, (announcements, amount)) in storage_key_iter::< - T::AccountId, - ( - BoundedVec< - Announcement, T::BlockNumber>, - T::MaxPending, - >, - BalanceOf, - ), - Twox64Concat, - >(pallet_prefix, storage_item_prefix) - .drain() - { - let new_amount = amount.saturating_mul(DECIMAL_CONVERTOR.into()); - >::insert(account, (announcements, new_amount)); - - weight += T::DbWeight::get().reads_writes(1, 1); - } - - weight - } -} - -#[cfg(feature = "try-runtime")] -impl ReplacePalletProxyStorage -where - T: pallet_proxy::Config, -{ - // pallet_proxy - pub fn pre_upgrade_proxy_proxies_storage() -> Result, &'static str> { - let result: BTreeMap< - T::AccountId, - ( - BoundedVec< - ProxyDefinition, - T::MaxProxies, - >, - BalanceOf, - ), - > = >::iter() - .map(|(account, (proxies, amount))| { - let new_amount = amount.saturating_mul(DECIMAL_CONVERTOR.into()); - (account, (proxies, new_amount)) - }) - .collect(); - Ok(result.encode()) - } - - pub fn post_upgrade_proxy_proxies_storage(state: Vec) -> Result<(), &'static str> { - let expected_state = BTreeMap::< - T::AccountId, - ( - BoundedVec< - ProxyDefinition, - T::MaxProxies, - >, - BalanceOf, - ), - >::decode(&mut &state[..]) - .map_err(|_| "Failed to decode BoundedVec")?; - for (account, actual_result) in >::iter() { - let expected_result: ( - BoundedVec< - ProxyDefinition, - T::MaxProxies, - >, - BalanceOf, - ) = expected_state - .get(&account) - .ok_or("Not Expected BoundedVec")? - .clone(); - assert_eq!(expected_result.encode(), actual_result.encode()); - } - Ok(()) - } - - pub fn pre_upgrade_proxy_announcements_storage() -> Result, &'static str> { - let result: BTreeMap< - T::AccountId, - ( - BoundedVec< - Announcement, T::BlockNumber>, - T::MaxPending, - >, - BalanceOf, - ), - > = >::iter() - .map(|(account, (announcements, amount))| { - let new_amount = amount.saturating_mul(DECIMAL_CONVERTOR.into()); - (account, (announcements, new_amount)) - }) - .collect(); - Ok(result.encode()) - } - - pub fn post_upgrade_proxy_announcements_storage(state: Vec) -> Result<(), &'static str> { - let expected_state = BTreeMap::< - T::AccountId, - ( - BoundedVec< - Announcement, T::BlockNumber>, - T::MaxPending, - >, - BalanceOf, - ), - >::decode(&mut &state[..]) - .map_err(|_| "Failed to decode BoundedVec")?; - for (account, actual_result) in >::iter() { - let expected_result: ( - BoundedVec< - Announcement, T::BlockNumber>, - T::MaxPending, - >, - BalanceOf, - ) = expected_state - .get(&account) - .ok_or("Not Expected BoundedVec")? - .clone(); - assert_eq!(expected_result.encode(), actual_result.encode()); - } - Ok(()) - } -} - -impl OnRuntimeUpgrade for ReplacePalletProxyStorage -where - T: pallet_proxy::Config, -{ - #[cfg(feature = "try-runtime")] - fn pre_upgrade() -> Result, &'static str> { - // pallet_proxy - let proxies_vec = Self::pre_upgrade_proxy_proxies_storage()?; - let announcements_vec = Self::pre_upgrade_proxy_announcements_storage()?; - - log::info!( - target: "ReplacePalletProxyStorage", - "Finished performing Proxy pre upgrade checks" - ); - - Ok((proxies_vec, announcements_vec).encode()) - } - - fn on_runtime_upgrade() -> frame_support::weights::Weight { - let mut weight = frame_support::weights::Weight::from_parts(0, 0); - - // pallet_proxy - weight += Self::replace_proxy_proxies_storage(); - weight += Self::replace_proxy_announcements_storage(); - - log::info!( - target: "ReplacePalletProxyStorage", - "Finished performing Proxy storage migration" - ); - - weight - } - - #[cfg(feature = "try-runtime")] - fn post_upgrade(state: Vec) -> Result<(), &'static str> { - let pre_vec: (Vec, Vec) = - Decode::decode(&mut &state[..]).map_err(|_| "Failed to decode Tuple")?; - - // pallet_proxy - Self::post_upgrade_proxy_proxies_storage(pre_vec.0)?; - Self::post_upgrade_proxy_announcements_storage(pre_vec.1)?; - - log::info!( - target: "ReplacePalletProxyStorage", - "Finished performing Proxy post upgrade checks" - ); - - Ok(()) - } -} diff --git a/runtime/paseo/src/migration/P9191/migrate_treasury.rs b/runtime/paseo/src/migration/P9191/migrate_treasury.rs deleted file mode 100644 index 20160a27b7..0000000000 --- a/runtime/paseo/src/migration/P9191/migrate_treasury.rs +++ /dev/null @@ -1,208 +0,0 @@ -// Copyright 2020-2024 Trust Computing GmbH. -// This file is part of Litentry. -// -// Litentry is free software: you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// Litentry 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 -// GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License -// along with Litentry. If not, see . -use frame_support::traits::{Get, OnRuntimeUpgrade}; -use sp_std::{marker::PhantomData, vec::Vec}; - -use frame_support::{ - migration::{get_storage_value, storage_key_iter}, - pallet_prelude::*, - Twox64Concat, -}; -use pallet_treasury::{BalanceOf, Deactivated, ProposalIndex, Proposals}; -use parity_scale_codec::EncodeLike; -use sp_runtime::Saturating; - -pub const DECIMAL_CONVERTOR: u128 = 1_000_000u128; - -// We are recreating the proposal struct with public fields -#[derive(Encode, Decode, Clone, PartialEq, Eq, MaxEncodedLen, RuntimeDebug, TypeInfo)] -pub struct Proposal { - /// The account proposing it. - pub proposer: AccountId, - /// The (total) amount that should be paid if the proposal is accepted. - pub value: Balance, - /// The account to whom the payment should be made if the proposal is accepted. - pub beneficiary: AccountId, - /// The amount held on deposit (reserved) for making this proposal. - pub bond: Balance, -} - -// This is important when we want to insert into the storage item -impl EncodeLike> - for Proposal -where - AccountId: EncodeLike, - Balance: EncodeLike, -{ -} - -pub struct ReplaceTreasuryStorage(PhantomData<(T, I)>); - -impl ReplaceTreasuryStorage -where - T: pallet_treasury::Config, - BalanceOf: EncodeLike> + From, -{ - fn replace_proposals_storage() -> frame_support::weights::Weight { - log::info!( - target: "ReplaceTreasuryStorage", - "running migration to Treasury Proposals Storage Item" - ); - let pallet_prefix: &[u8] = b"Treasury"; - let storage_item_prefix: &[u8] = b"Proposals"; - let mut weight: Weight = frame_support::weights::Weight::zero(); - - for (proposal_index, mut proposal) in storage_key_iter::< - ProposalIndex, - Proposal>, - Twox64Concat, - >(pallet_prefix, storage_item_prefix) - .drain() - { - proposal.value = proposal.value.saturating_mul(DECIMAL_CONVERTOR.into()); - proposal.bond = proposal.bond.saturating_mul(DECIMAL_CONVERTOR.into()); - - >::insert(proposal_index, proposal); - - weight += T::DbWeight::get().reads_writes(1, 1); - } - weight - } - - fn replace_deactivated_storage() -> frame_support::weights::Weight { - log::info!( - target: "ReplaceTreasuryStorage", - "running migration to Treasury Deactivated Storage Item" - ); - let pallet_prefix: &[u8] = b"Treasury"; - let storage_item_prefix: &[u8] = b"Deactivated"; - let stored_data = - get_storage_value::>(pallet_prefix, storage_item_prefix, b"") - .expect("Storage query fails: Treasury Deactivated"); - - >::put(stored_data.saturating_mul(DECIMAL_CONVERTOR.into())); - - let weight = T::DbWeight::get(); - frame_support::weights::Weight::from_parts(0, weight.write + weight.read) - } -} - -#[cfg(feature = "try-runtime")] -impl ReplaceTreasuryStorage -where - T: pallet_treasury::Config, - BalanceOf: EncodeLike> + From, -{ - fn pre_upgrade_proposals_storage() -> Result, &'static str> { - let pallet_prefix: &[u8] = b"Treasury"; - let storage_item_prefix: &[u8] = b"Proposals"; - let stored_data: Vec<_> = storage_key_iter::< - ProposalIndex, - Proposal>, - Twox64Concat, - >(pallet_prefix, storage_item_prefix) - .collect(); - - let result: Vec<_> = stored_data - .into_iter() - .map(|(proposal_index, proposal)| { - let mut new_proposal = proposal; - new_proposal.value = new_proposal.value.saturating_mul(DECIMAL_CONVERTOR.into()); - new_proposal.bond = new_proposal.bond.saturating_mul(DECIMAL_CONVERTOR.into()); - - (proposal_index, new_proposal) - }) - .collect(); - - Ok(result.encode()) - } - - fn post_upgrade_proposals_storage(state: Vec) -> Result<(), &'static str> { - let expected_result = - Vec::<(ProposalIndex, Proposal>)>::decode( - &mut &state[..], - ) - .map_err(|_| "Failed to decode Bounties")?; - - let pallet_prefix: &[u8] = b"Treasury"; - let storage_item_prefix: &[u8] = b"Proposals"; - let actual_result: Vec<_> = storage_key_iter::< - ProposalIndex, - Proposal>, - Twox64Concat, - >(pallet_prefix, storage_item_prefix) - .collect(); - - for x in 0..actual_result.len() { - assert_eq!(actual_result[x], expected_result[x]) - } - - Ok(()) - } - - fn pre_upgrade_deactivated_storage() -> Result, &'static str> { - Ok(>::get().saturating_mul(DECIMAL_CONVERTOR.into()).encode()) - } - - fn post_upgrade_deactivated_storage(state: Vec) -> Result<(), &'static str> { - let expected_state = BalanceOf::::decode(&mut &state[..]) - .map_err(|_| "Failed to decode Total Balance")?; - let actual_state = >::get(); - assert_eq!(expected_state, actual_state); - Ok(()) - } -} - -impl OnRuntimeUpgrade for ReplaceTreasuryStorage -where - T: pallet_treasury::Config, - BalanceOf: EncodeLike> + From, -{ - #[cfg(feature = "try-runtime")] - fn pre_upgrade() -> Result, &'static str> { - let proposals_state_vec = Self::pre_upgrade_proposals_storage()?; - let deactivated_state_vec = Self::pre_upgrade_deactivated_storage()?; - - log::info!( - target: "ReplaceTreasuryStorage", - "Finished performing post upgrade checks" - ); - Ok((proposals_state_vec, deactivated_state_vec).encode()) - } - - fn on_runtime_upgrade() -> frame_support::weights::Weight { - let mut weight = frame_support::weights::Weight::from_parts(0, 0); - weight += Self::replace_proposals_storage(); - weight += Self::replace_deactivated_storage(); - - log::info!( - target: "ReplaceTreasuryStorage", - "Finished performing storage migration" - ); - - weight - } - - #[cfg(feature = "try-runtime")] - fn post_upgrade(state: Vec) -> Result<(), &'static str> { - let pre_vec: (Vec, Vec) = - Decode::decode(&mut &state[..]).map_err(|_| "Failed to decode Tuple")?; - Self::post_upgrade_proposals_storage(pre_vec.0)?; - Self::post_upgrade_deactivated_storage(pre_vec.1)?; - log::info!(target: "ReplaceTreasuryStorage", "Finished performing post upgrade checks"); - Ok(()) - } -} diff --git a/runtime/paseo/src/migration/P9191/migrate_vesting.rs b/runtime/paseo/src/migration/P9191/migrate_vesting.rs deleted file mode 100644 index 99e0a6ea61..0000000000 --- a/runtime/paseo/src/migration/P9191/migrate_vesting.rs +++ /dev/null @@ -1,172 +0,0 @@ -// Copyright 2020-2024 Trust Computing GmbH. -// This file is part of Litentry. -// -// Litentry is free software: you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// Litentry 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 -// GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License -// along with Litentry. If not, see . -#![allow(clippy::type_complexity)] - -use frame_support::{ - migration::storage_key_iter, - pallet_prelude::*, - traits::{Currency, Get, OnRuntimeUpgrade}, - Blake2_128Concat, -}; -use sp_runtime::Saturating; -use sp_std::{marker::PhantomData, vec::Vec}; - -pub const DECIMAL_CONVERTOR: u32 = 1_000_000; - -#[cfg(feature = "try-runtime")] -use parity_scale_codec::Encode; -#[cfg(feature = "try-runtime")] -use sp_std::collections::btree_map::BTreeMap; - -use pallet_vesting::{MaxVestingSchedulesGet, Vesting, VestingInfo}; -type BalanceOf = <::Currency as Currency< - ::AccountId, ->>::Balance; - -pub struct ReplacePalletVestingStorage(PhantomData); - -impl ReplacePalletVestingStorage -where - T: pallet_vesting::Config, -{ - // pallet_vesting - pub fn replace_vesting_vesting_storage() -> frame_support::weights::Weight { - log::info!( - target: "ReplacePalletVestingStorage", - "Running migration to Vesting - Vesting" - ); - - let mut weight = frame_support::weights::Weight::zero(); - - let pallet_prefix: &[u8] = b"Vesting"; - let storage_item_prefix: &[u8] = b"Vesting"; - - for (account, mut vest_info) in storage_key_iter::< - T::AccountId, - BoundedVec, T::BlockNumber>, MaxVestingSchedulesGet>, - Blake2_128Concat, - >(pallet_prefix, storage_item_prefix) - .drain() - { - for vest in vest_info.iter_mut() { - *vest = VestingInfo::new( - vest.locked().saturating_mul(DECIMAL_CONVERTOR.into()), - vest.per_block().saturating_mul(DECIMAL_CONVERTOR.into()), - vest.starting_block(), - ); - } - - Vesting::::insert(&account, vest_info); - weight += T::DbWeight::get().reads_writes(1, 1); - } - - weight - } -} - -#[cfg(feature = "try-runtime")] -impl ReplacePalletVestingStorage -where - T: pallet_vesting::Config, -{ - // pallet_vesting - pub fn pre_upgrade_vesting_vesting_storage() -> Result, &'static str> { - let result: BTreeMap< - T::AccountId, - BoundedVec, T::BlockNumber>, MaxVestingSchedulesGet>, - > = >::iter() - .map(|(account, vest_vec)| { - let mut new_vest_vec: BoundedVec< - VestingInfo, T::BlockNumber>, - MaxVestingSchedulesGet, - > = vest_vec; - for vest in new_vest_vec.iter_mut() { - *vest = VestingInfo::new( - vest.locked().saturating_mul(DECIMAL_CONVERTOR.into()), - vest.per_block().saturating_mul(DECIMAL_CONVERTOR.into()), - vest.starting_block(), - ); - } - (account, new_vest_vec) - }) - .collect(); - Ok(result.encode()) - } - - pub fn post_upgrade_vesting_vesting_storage(state: Vec) -> Result<(), &'static str> { - let expected_state = BTreeMap::< - T::AccountId, - BoundedVec, T::BlockNumber>, MaxVestingSchedulesGet>, - >::decode(&mut &state[..]) - .map_err(|_| "Failed to decode BoundedVec")?; - for (account, actual_result) in >::iter() { - let expected_result: BoundedVec< - VestingInfo, T::BlockNumber>, - MaxVestingSchedulesGet, - > = expected_state - .get(&account) - .ok_or("Not Expected BoundedVec")? - .clone(); - assert_eq!(expected_result.encode(), actual_result.encode()); - } - Ok(()) - } -} - -impl OnRuntimeUpgrade for ReplacePalletVestingStorage -where - T: pallet_vesting::Config, -{ - #[cfg(feature = "try-runtime")] - fn pre_upgrade() -> Result, &'static str> { - // pallet_vesting - let vesting_vec = Self::pre_upgrade_vesting_vesting_storage()?; - - log::info!( - target: "ReplacePalletVestingStorage", - "Finished performing Vesting pre upgrade checks" - ); - - Ok((vesting_vec).encode()) - } - - fn on_runtime_upgrade() -> frame_support::weights::Weight { - let mut weight = frame_support::weights::Weight::zero(); - // pallet_vesting - weight += Self::replace_vesting_vesting_storage(); - - log::info!( - target: "ReplacePalletVestingStorage", - "Finished performing Vesting storage migration" - ); - - weight - } - - #[cfg(feature = "try-runtime")] - fn post_upgrade(state: Vec) -> Result<(), &'static str> { - let pre_vec: (Vec,) = - Decode::decode(&mut &state[..]).map_err(|_| "Failed to decode Tuple")?; - Self::post_upgrade_vesting_vesting_storage(pre_vec.0)?; - - log::info!( - target: "ReplacePalletVestingStorage", - "Finished performing Vesting post upgrade checks" - ); - - Ok(()) - } -} diff --git a/runtime/paseo/src/migration/P9191/mod.rs b/runtime/paseo/src/migration/P9191/mod.rs deleted file mode 100644 index c48ab5f2e6..0000000000 --- a/runtime/paseo/src/migration/P9191/mod.rs +++ /dev/null @@ -1,33 +0,0 @@ -// Copyright 2020-2024 Trust Computing GmbH. -// This file is part of Litentry. -// -// Litentry is free software: you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// Litentry 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 -// GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License -// along with Litentry. If not, see . -pub mod migrate_identity; -pub use migrate_identity::ReplacePalletIdentityStorage; -pub mod migrate_multisig; -pub use migrate_multisig::ReplacePalletMultisigStorage; -pub mod migrate_proxy; -pub use migrate_proxy::ReplacePalletProxyStorage; -pub mod migrate_vesting; -pub use migrate_vesting::ReplacePalletVestingStorage; -pub mod migrate_bounty; -pub use migrate_bounty::ReplacePalletBountyStorage; -pub mod migrate_democracy; -pub use migrate_democracy::ReplaceDemocracyStorage; -pub mod migrate_preimage; -pub use migrate_preimage::ReplacePreImageStorage; -pub mod migrate_treasury; -pub use migrate_treasury::ReplaceTreasuryStorage; -pub mod fix_balances; -pub use fix_balances::ForceFixAccountFrozenStorage; diff --git a/runtime/paseo/src/migration/P9192.rs b/runtime/paseo/src/migration/P9192.rs deleted file mode 100644 index 0c10ddc50e..0000000000 --- a/runtime/paseo/src/migration/P9192.rs +++ /dev/null @@ -1,164 +0,0 @@ -// Copyright 2020-2024 Trust Computing GmbH. -// This file is part of Litentry. -// -// Litentry is free software: you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// Litentry 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 -// GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License -// along with Litentry. If not, see . -#![allow(clippy::type_complexity)] - -use frame_support::{ - migration::storage_key_iter, - pallet_prelude::*, - traits::{Get, OnRuntimeUpgrade}, - Twox64Concat, -}; -use sp_runtime::Saturating; -use sp_std::{convert::From, marker::PhantomData, vec::Vec}; - -use pallet_parachain_staking::{ - BalanceOf, Bond, CandidateInfo, CandidatePool, Delegations, TopDelegations, Total, -}; -pub const DECIMAL_CONVERTOR: u128 = 1_000_000u128; - -// Fix Parachain Staking Storage for missing migrating TopDelegations total -pub struct FixParachainStakingStorage(PhantomData); - -impl OnRuntimeUpgrade for FixParachainStakingStorage -where - T: frame_system::Config + pallet_parachain_staking::Config, - BalanceOf: From, -{ - #[cfg(feature = "try-runtime")] - fn pre_upgrade() -> Result, &'static str> { - // Does not matter - Ok(Vec::::new()) - } - - // Staked is the snapshot of Total, and remove after used, so no fix - // AtStake, will not be fixed, let's wait extra two round with reward = 0 to make this data - // clean DelayedPayouts, will not fix, let's wait extra two round with reward = 0 to make this - // data clean - - // TopDelegations require fix - // CandidateInfo require fix - // CandidatePool require fix - // Total fix - fn on_runtime_upgrade() -> frame_support::weights::Weight { - log::info!( - target: "ReplaceParachainStakingStorage", - "running migration to ParachainStaking TopDelegations" - ); - let pallet_prefix: &[u8] = b"ParachainStaking"; - let storage_item_prefix: &[u8] = b"TopDelegations"; - let mut weight: Weight = frame_support::weights::Weight::zero(); - - let mut candidates = >::get(); - // remove all bonds - candidates.clear(); - - // intitialized total - let mut total: BalanceOf = 0u128.into(); - - for (account, mut delegations) in storage_key_iter::< - T::AccountId, - Delegations>, - Twox64Concat, - >(pallet_prefix, storage_item_prefix) - .drain() - { - // Patching the missed total value converting - // This storage is already correpted - let mut collator_delegations_sum: BalanceOf = 0u128.into(); - for delegation_bond in delegations.delegations.iter() { - collator_delegations_sum += delegation_bond.amount; - } - delegations.total = collator_delegations_sum; - - // Get CandidateInfo of the same collator key - let mut metadata = >::get(&account).unwrap(); - // Self + delegation total - metadata.total_counted = metadata.bond + delegations.total; - - // Fix TopDelegations - >::insert(&account, delegations); - - // Bond use its owner value to determine if equal without checking its amount - // We need to check amount later - candidates.insert(Bond { owner: account.clone(), amount: metadata.total_counted }); - // Add total - total = total.saturating_add(metadata.total_counted); - - // Fix CandidateInfo - >::insert(&account, metadata); - - weight += T::DbWeight::get().reads_writes(2, 2); - } - - // Fix CandidatePool - candidates.0.sort_by(|a, b| a.amount.cmp(&b.amount)); - >::put(candidates); - // Fix Total - >::put(total); - - weight - } - - // Check Top Delegation total = sum, collator wise - // Check CandidateInfo total count = self bond + sum of delegation, collator wise - // Check CandidatePool = - // Check Total = sum CandidateInfo total count - #[cfg(feature = "try-runtime")] - fn post_upgrade(_state: Vec) -> Result<(), &'static str> { - // Check Top Delegation total = sum - // Check CandidateInfo total count = self bond + sum of delegation - // Check Total = sum CandidateInfo total count - let mut total: BalanceOf = 0u128.into(); - for (account, delegations) in >::iter() { - log::info!("Checking Top Delegations Collator: {:?}", account.encode()); - // Start calculating collator delegation sum - let mut collator_delegations_sum: BalanceOf = 0u128.into(); - - for delegation_bond in delegations.delegations.iter() { - collator_delegations_sum += delegation_bond.amount; - } - - // Check Top Delegation total = sum, collator wise - assert_eq!(collator_delegations_sum, delegations.total); - - let metadata = >::get(account).unwrap(); - // Check CandidateInfo total count = self bond + sum of delegation - assert_eq!(metadata.total_counted, metadata.bond + collator_delegations_sum); - - // Collator self + Collator delegations - total += metadata.bond + collator_delegations_sum; - } - // Check Total = sum CandidateInfo total count - assert_eq!(total, >::get()); - - // It is hard to check CandidatePool without iterating vector - // So we just check its sum = Total - // Get all ordered_set of bond - let ordered_set = >::get(); - let mut candidate_pool_sum: BalanceOf = 0u128.into(); - - // Make sure the number of Order set is correct - for bond in ordered_set.0.iter() { - candidate_pool_sum += bond.amount; - } - - // Check CandidatePool element's amount total = total (self bond + sum of delegation) - log::info!("Checking total: {:?}", total); - assert_eq!(total, candidate_pool_sum); - - Ok(()) - } -} diff --git a/runtime/paseo/src/migration/migration.md b/runtime/paseo/src/migration/migration.md deleted file mode 100644 index 4c618e0bad..0000000000 --- a/runtime/paseo/src/migration/migration.md +++ /dev/null @@ -1,40 +0,0 @@ -# Migrate fix of last decimal upgrade -P9192.rs -it fixes the missing `total` migration in TopDelegations - -# Migrate decimal change 12 -> 18 -P9191/ folder: -These migration is for the follwoing task -https://github.com/litentry/litentry-parachain/releases/tag/v0.9.19-02 -The leftover part of migration including the following pallets: -Bounty, Democracy, Identity, Multisig, Preimage, Proxy, Treasury, Vesting - -Fix the rococo mistake in P9190 -set all account.frozen = 0 - -# Migrate -Under files P9190 -These migration is for the follwoing task -https://github.com/litentry/litentry-parachain/releases/tag/v0.9.19 -(1) token decimal change from 12 to 18 -(2) New token bridge related pallet storage migration. - -Rococo Only: -For rococo, the initial migration contains some error code which make account.frozen = account.reserve * 10^6 -This storage error should be fixed in the following migration of rococo - -And the migration of parachain_staking, pallet_balances and bridge related migration also applied in this migration for rococo. - -# MigrateCollatorSelectionIntoParachainStaking -P9100.rs -https://github.com/litentry/litentry-parachain/releases/tag/v0.9.10 -This migration is for the replacement of CollatorSelection with ParachainStaking - -The main purpose of runtime upgrade is for make up the missing genesis build of ParachainStaking and clean the old CollatorSelection storage. - -# MigrateAtStakeAutoCompound -P9130.rs -https://github.com/litentry/litentry-parachain/releases/tag/v0.9.13 -This migration is for the update of AtStaked with ParachainStaking - -The main purpose of runtime upgrade is for adding the autocompound staking function of ParachainStaking and need to update storage to the latest struct. \ No newline at end of file diff --git a/runtime/paseo/src/migration/mod.rs b/runtime/paseo/src/migration/mod.rs deleted file mode 100644 index d3f5a12faa..0000000000 --- a/runtime/paseo/src/migration/mod.rs +++ /dev/null @@ -1 +0,0 @@ - From 482e4ce79e2fd6c655a7d55c0d864ade9dd6ffc6 Mon Sep 17 00:00:00 2001 From: felixfaisal Date: Mon, 2 Sep 2024 05:46:55 +0000 Subject: [PATCH 13/21] fix: update chain_id --- runtime/paseo/Cargo.toml | 9 +++++---- runtime/paseo/src/lib.rs | 5 +++-- 2 files changed, 8 insertions(+), 6 deletions(-) diff --git a/runtime/paseo/Cargo.toml b/runtime/paseo/Cargo.toml index 184bc96951..09c035fa95 100644 --- a/runtime/paseo/Cargo.toml +++ b/runtime/paseo/Cargo.toml @@ -81,8 +81,8 @@ pallet-asset-manager = { workspace = true } pallet-assets = { workspace = true } pallet-assets-handler = { workspace = true } pallet-bitacross = { workspace = true } -pallet-bridge = { workspace = true } pallet-bridge-transfer = { workspace = true } +pallet-chain-bridge = { workspace = true } pallet-evm-assertions = { workspace = true } pallet-extrinsic-filter = { workspace = true } pallet-group = { workspace = true } @@ -161,9 +161,10 @@ runtime-benchmarks = [ "runtime-common/runtime-benchmarks", "sp-runtime/runtime-benchmarks", "xcm-builder/runtime-benchmarks", - "pallet-bridge/runtime-benchmarks", + "pallet-chain-bridge/runtime-benchmarks", "pallet-bridge-transfer/runtime-benchmarks", "pallet-extrinsic-filter/runtime-benchmarks", + "cumulus-pallet-parachain-system/runtime-benchmarks", "cumulus-pallet-xcmp-queue/runtime-benchmarks", "pallet-group/runtime-benchmarks", "pallet-identity-management/runtime-benchmarks", @@ -258,7 +259,7 @@ std = [ 'runtime-common/std', "pallet-account-fix/std", "pallet-bitacross/std", - "pallet-bridge/std", + "pallet-chain-bridge/std", "pallet-bridge-transfer/std", "pallet-evm-assertions/std", "pallet-extrinsic-filter/std", @@ -294,7 +295,7 @@ try-runtime = [ "pallet-balances/try-runtime", "pallet-bitacross/try-runtime", "pallet-bounties/try-runtime", - "pallet-bridge/try-runtime", + "pallet-chain-bridge/try-runtime", "pallet-bridge-transfer/try-runtime", "pallet-collective/try-runtime", "pallet-democracy/try-runtime", diff --git a/runtime/paseo/src/lib.rs b/runtime/paseo/src/lib.rs index 8c3cfdb6e5..7e353dd578 100644 --- a/runtime/paseo/src/lib.rs +++ b/runtime/paseo/src/lib.rs @@ -24,6 +24,7 @@ #[macro_use] extern crate frame_benchmarking; +use core_primitives::LITENTRY_PARA_ID; use cumulus_pallet_parachain_system::RelayNumberStrictlyIncreases; use frame_support::{ construct_runtime, parameter_types, @@ -69,7 +70,7 @@ use xcm_executor::XcmExecutor; pub use constants::currency::deposit; pub use core_primitives::{ opaque, AccountId, Amount, AssetId, Balance, BlockNumber, Hash, Header, Nonce, Signature, DAYS, - HOURS, MINUTES, ROCOCO_PARA_ID, SLOT_DURATION, + HOURS, MINUTES, SLOT_DURATION, }; pub use runtime_common::currency::*; @@ -1083,7 +1084,7 @@ impl FeeCalculator for TransactionPaymentAsGasPrice { parameter_types! { pub WeightPerGas: Weight = Weight::from_parts(WEIGHT_PER_GAS, 0); - pub ChainId: u64 = ROCOCO_PARA_ID.into(); + pub ChainId: u64 = LITENTRY_PARA_ID.into(); pub BlockGasLimit: U256 = U256::from( NORMAL_DISPATCH_RATIO * MAXIMUM_BLOCK_WEIGHT.ref_time() / WEIGHT_PER_GAS ); From 089f5da35170859129736607730f2ebfa228eae0 Mon Sep 17 00:00:00 2001 From: felixfaisal Date: Mon, 2 Sep 2024 06:12:12 +0000 Subject: [PATCH 14/21] fix: update build fixes --- node/src/chain_specs/paseo.rs | 2 +- runtime/paseo/src/lib.rs | 26 +- .../src/weights/cumulus_pallet_xcmp_queue.rs | 22 +- runtime/paseo/src/weights/frame_system.rs | 98 ++- runtime/paseo/src/weights/mod.rs | 4 +- .../paseo/src/weights/pallet_asset_manager.rs | 74 +- runtime/paseo/src/weights/pallet_balances.rs | 74 +- runtime/paseo/src/weights/pallet_bridge.rs | 163 ---- .../src/weights/pallet_bridge_transfer.rs | 71 +- .../paseo/src/weights/pallet_chain_bridge.rs | 159 ++++ .../paseo/src/weights/pallet_collective.rs | 272 +++---- runtime/paseo/src/weights/pallet_democracy.rs | 480 +++++------ .../src/weights/pallet_extrinsic_filter.rs | 38 +- .../src/weights/pallet_identity_management.rs | 136 ++-- .../paseo/src/weights/pallet_membership.rs | 178 ++--- runtime/paseo/src/weights/pallet_multisig.rs | 102 +-- .../src/weights/pallet_parachain_staking.rs | 744 +++++++++--------- runtime/paseo/src/weights/pallet_preimage.rs | 138 ++-- runtime/paseo/src/weights/pallet_proxy.rs | 186 +++-- runtime/paseo/src/weights/pallet_scheduler.rs | 126 +-- runtime/paseo/src/weights/pallet_session.rs | 42 +- runtime/paseo/src/weights/pallet_teebag.rs | 204 ++--- runtime/paseo/src/weights/pallet_timestamp.rs | 30 +- runtime/paseo/src/weights/pallet_treasury.rs | 104 ++- runtime/paseo/src/weights/pallet_utility.rs | 38 +- .../paseo/src/weights/pallet_vc_management.rs | 124 +-- 26 files changed, 1840 insertions(+), 1795 deletions(-) delete mode 100644 runtime/paseo/src/weights/pallet_bridge.rs create mode 100644 runtime/paseo/src/weights/pallet_chain_bridge.rs diff --git a/node/src/chain_specs/paseo.rs b/node/src/chain_specs/paseo.rs index 1ba5b59297..19cf6ec304 100644 --- a/node/src/chain_specs/paseo.rs +++ b/node/src/chain_specs/paseo.rs @@ -22,7 +22,7 @@ use paseo_parachain_runtime::{ DeveloperCommitteeMembershipConfig, ParachainInfoConfig, ParachainStakingConfig, PolkadotXcmConfig, RuntimeGenesisConfig, SessionConfig, SudoConfig, SystemConfig, TechnicalCommitteeMembershipConfig, TeebagConfig, TeebagOperationalMode, VCManagementConfig, - LITENTRY_PARA_ID, UNIT, WASM_BINARY, + UNIT, WASM_BINARY, }; use sc_service::ChainType; use sc_telemetry::TelemetryEndpoints; diff --git a/runtime/paseo/src/lib.rs b/runtime/paseo/src/lib.rs index 7e353dd578..f80bc095ec 100644 --- a/runtime/paseo/src/lib.rs +++ b/runtime/paseo/src/lib.rs @@ -268,7 +268,7 @@ impl frame_system::Config for Runtime { type OnKilledAccount = (); type DbWeight = RocksDbWeight; type BaseCallFilter = BaseCallFilter; - type SystemWeightInfo = (); + type SystemWeightInfo = weights::frame_system::WeightInfo; type BlockWeights = RuntimeBlockWeights; type BlockLength = BlockLength; type SS58Prefix = SS58Prefix; @@ -914,14 +914,14 @@ parameter_types! { pub TreasuryAccount: AccountId = TreasuryPalletId::get().into_account_truncating(); } -impl pallet_bridge::Config for Runtime { +impl pallet_chain_bridge::Config for Runtime { type RuntimeEvent = RuntimeEvent; type BridgeCommitteeOrigin = EnsureRootOrHalfCouncil; type Proposal = RuntimeCall; type BridgeChainId = BridgeChainId; type Balance = Balance; type ProposalLifetime = ProposalLifetime; - type WeightInfo = weights::pallet_bridge::WeightInfo; + type WeightInfo = weights::pallet_chain_bridge::WeightInfo; } parameter_types! { @@ -950,7 +950,7 @@ impl SortedMembers for TransferAssetsAnyone { impl pallet_bridge_transfer::Config for Runtime { type BridgeHandler = AssetsHandler; - type BridgeOrigin = pallet_bridge::EnsureBridge; + type BridgeOrigin = pallet_chain_bridge::EnsureBridge; type TransferAssetsMembers = TransferAssetsAnyone; type WeightInfo = weights::pallet_bridge_transfer::WeightInfo; } @@ -1235,7 +1235,7 @@ construct_runtime! { Assets: pallet_assets = 56, // Rococo pallets - ChainBridge: pallet_bridge = 60, + ChainBridge: pallet_chain_bridge= 60, BridgeTransfer: pallet_bridge_transfer = 61, ExtrinsicFilter: pallet_extrinsic_filter = 63, IdentityManagement: pallet_identity_management = 64, @@ -1357,6 +1357,7 @@ impl Contains for NormalModeFilter { RuntimeCall::Ethereum(_) | // AccountFix RuntimeCall::AccountFix(_) | + RuntimeCall::AssetsHandler(_) | RuntimeCall::Bitacross(_) | RuntimeCall::EvmAssertions(_) | RuntimeCall::ScoreStaking(_) @@ -1387,7 +1388,7 @@ mod benches { [cumulus_pallet_xcmp_queue, XcmpQueue] [pallet_identity_management, IdentityManagement] [pallet_vc_management, VCManagement] - [pallet_bridge,ChainBridge] + [pallet_chain_bridge,ChainBridge] [pallet_bridge_transfer,BridgeTransfer] [pallet_teebag, Teebag] ); @@ -1894,10 +1895,19 @@ impl_runtime_apis! { fn dispatch_benchmark( config: frame_benchmarking::BenchmarkConfig ) -> Result, sp_runtime::RuntimeString> { - use frame_benchmarking::{Benchmarking, BenchmarkBatch}; + use frame_benchmarking::{Benchmarking, BenchmarkBatch, BenchmarkError}; use frame_system_benchmarking::Pallet as SystemBench; - impl frame_system_benchmarking::Config for Runtime {} + impl frame_system_benchmarking::Config for Runtime { + fn setup_set_code_requirements(code: &sp_std::vec::Vec) -> Result<(), BenchmarkError> { + ParachainSystem::initialize_for_set_code_benchmark(code.len() as u32); + Ok(()) + } + + fn verify_set_code() { + System::assert_last_event(cumulus_pallet_parachain_system::Event::::ValidationFunctionStored.into()); + } + } use cumulus_pallet_session_benchmarking::Pallet as SessionBench; impl cumulus_pallet_session_benchmarking::Config for Runtime {} diff --git a/runtime/paseo/src/weights/cumulus_pallet_xcmp_queue.rs b/runtime/paseo/src/weights/cumulus_pallet_xcmp_queue.rs index 11ddda9d2c..64fd336803 100644 --- a/runtime/paseo/src/weights/cumulus_pallet_xcmp_queue.rs +++ b/runtime/paseo/src/weights/cumulus_pallet_xcmp_queue.rs @@ -17,10 +17,10 @@ //! Autogenerated weights for `cumulus_pallet_xcmp_queue` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-10-17, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-08-28, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `parachain-benchmark`, CPU: `Intel(R) Xeon(R) Platinum 8259CL CPU @ 2.50GHz` -//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("rococo-dev"), DB CACHE: 20 +//! HOSTNAME: `litentry-benchmark-server`, CPU: `Intel(R) Xeon(R) CPU E5-2686 v4 @ 2.30GHz` +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("rococo-dev")`, DB CACHE: 20 // Executed Command: // ./litentry-collator @@ -49,26 +49,26 @@ use core::marker::PhantomData; /// Weight functions for `cumulus_pallet_xcmp_queue`. pub struct WeightInfo(PhantomData); impl cumulus_pallet_xcmp_queue::WeightInfo for WeightInfo { - /// Storage: XcmpQueue QueueConfig (r:1 w:1) - /// Proof Skipped: XcmpQueue QueueConfig (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: `XcmpQueue::QueueConfig` (r:1 w:1) + /// Proof: `XcmpQueue::QueueConfig` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) fn set_config_with_u32() -> Weight { // Proof Size summary in bytes: // Measured: `109` // Estimated: `1594` - // Minimum execution time: 8_168_000 picoseconds. - Weight::from_parts(8_545_000, 0) + // Minimum execution time: 5_303_000 picoseconds. + Weight::from_parts(5_485_000, 0) .saturating_add(Weight::from_parts(0, 1594)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: XcmpQueue QueueConfig (r:1 w:1) - /// Proof Skipped: XcmpQueue QueueConfig (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: `XcmpQueue::QueueConfig` (r:1 w:1) + /// Proof: `XcmpQueue::QueueConfig` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) fn set_config_with_weight() -> Weight { // Proof Size summary in bytes: // Measured: `109` // Estimated: `1594` - // Minimum execution time: 8_244_000 picoseconds. - Weight::from_parts(8_652_000, 0) + // Minimum execution time: 5_285_000 picoseconds. + Weight::from_parts(5_585_000, 0) .saturating_add(Weight::from_parts(0, 1594)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) diff --git a/runtime/paseo/src/weights/frame_system.rs b/runtime/paseo/src/weights/frame_system.rs index beb8e20ee4..786749bc3e 100644 --- a/runtime/paseo/src/weights/frame_system.rs +++ b/runtime/paseo/src/weights/frame_system.rs @@ -17,10 +17,10 @@ //! Autogenerated weights for `frame_system` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-10-17, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-08-28, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `parachain-benchmark`, CPU: `Intel(R) Xeon(R) Platinum 8259CL CPU @ 2.50GHz` -//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("rococo-dev"), DB CACHE: 20 +//! HOSTNAME: `litentry-benchmark-server`, CPU: `Intel(R) Xeon(R) CPU E5-2686 v4 @ 2.30GHz` +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("rococo-dev")`, DB CACHE: 20 // Executed Command: // ./litentry-collator @@ -54,77 +54,99 @@ impl frame_system::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 3_096_000 picoseconds. - Weight::from_parts(3_167_000, 0) + // Minimum execution time: 2_161_000 picoseconds. + Weight::from_parts(2_227_000, 0) .saturating_add(Weight::from_parts(0, 0)) - // Standard Error: 2 - .saturating_add(Weight::from_parts(617, 0).saturating_mul(b.into())) + // Standard Error: 3 + .saturating_add(Weight::from_parts(432, 0).saturating_mul(b.into())) } /// The range of component `b` is `[0, 3932160]`. fn remark_with_event(b: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 10_656_000 picoseconds. - Weight::from_parts(10_871_000, 0) + // Minimum execution time: 7_292_000 picoseconds. + Weight::from_parts(7_481_000, 0) .saturating_add(Weight::from_parts(0, 0)) - // Standard Error: 5 - .saturating_add(Weight::from_parts(2_314, 0).saturating_mul(b.into())) + // Standard Error: 8 + .saturating_add(Weight::from_parts(2_345, 0).saturating_mul(b.into())) } - /// Storage: System Digest (r:1 w:1) - /// Proof Skipped: System Digest (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: unknown `0x3a686561707061676573` (r:0 w:1) - /// Proof Skipped: unknown `0x3a686561707061676573` (r:0 w:1) + /// Storage: `System::Digest` (r:1 w:1) + /// Proof: `System::Digest` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: UNKNOWN KEY `0x3a686561707061676573` (r:0 w:1) + /// Proof: UNKNOWN KEY `0x3a686561707061676573` (r:0 w:1) fn set_heap_pages() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `1485` - // Minimum execution time: 5_535_000 picoseconds. - Weight::from_parts(5_722_000, 0) + // Minimum execution time: 3_724_000 picoseconds. + Weight::from_parts(4_032_000, 0) .saturating_add(Weight::from_parts(0, 1485)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(2)) } - /// Storage: Skipped Metadata (r:0 w:0) - /// Proof Skipped: Skipped Metadata (max_values: None, max_size: None, mode: Measured) + /// Storage: `ParachainSystem::ValidationData` (r:1 w:0) + /// Proof: `ParachainSystem::ValidationData` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParachainSystem::UpgradeRestrictionSignal` (r:1 w:0) + /// Proof: `ParachainSystem::UpgradeRestrictionSignal` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParachainSystem::PendingValidationCode` (r:1 w:1) + /// Proof: `ParachainSystem::PendingValidationCode` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParachainSystem::HostConfiguration` (r:1 w:0) + /// Proof: `ParachainSystem::HostConfiguration` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParachainSystem::NewValidationCode` (r:0 w:1) + /// Proof: `ParachainSystem::NewValidationCode` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParachainSystem::DidSetValidationCode` (r:0 w:1) + /// Proof: `ParachainSystem::DidSetValidationCode` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + fn set_code() -> Weight { + // Proof Size summary in bytes: + // Measured: `264` + // Estimated: `1749` + // Minimum execution time: 131_530_473_000 picoseconds. + Weight::from_parts(138_435_551_000, 0) + .saturating_add(Weight::from_parts(0, 1749)) + .saturating_add(T::DbWeight::get().reads(4)) + .saturating_add(T::DbWeight::get().writes(3)) + } + /// Storage: `Skipped::Metadata` (r:0 w:0) + /// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`) /// The range of component `i` is `[0, 1000]`. fn set_storage(i: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_967_000 picoseconds. - Weight::from_parts(3_030_000, 0) + // Minimum execution time: 2_328_000 picoseconds. + Weight::from_parts(2_408_000, 0) .saturating_add(Weight::from_parts(0, 0)) - // Standard Error: 5_553 - .saturating_add(Weight::from_parts(1_090_130, 0).saturating_mul(i.into())) + // Standard Error: 7_057 + .saturating_add(Weight::from_parts(780_166, 0).saturating_mul(i.into())) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(i.into()))) } - /// Storage: Skipped Metadata (r:0 w:0) - /// Proof Skipped: Skipped Metadata (max_values: None, max_size: None, mode: Measured) + /// Storage: `Skipped::Metadata` (r:0 w:0) + /// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`) /// The range of component `i` is `[0, 1000]`. fn kill_storage(i: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_889_000 picoseconds. - Weight::from_parts(3_045_000, 0) + // Minimum execution time: 2_307_000 picoseconds. + Weight::from_parts(2_379_000, 0) .saturating_add(Weight::from_parts(0, 0)) - // Standard Error: 2_430 - .saturating_add(Weight::from_parts(811_384, 0).saturating_mul(i.into())) + // Standard Error: 3_432 + .saturating_add(Weight::from_parts(562_993, 0).saturating_mul(i.into())) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(i.into()))) } - /// Storage: Skipped Metadata (r:0 w:0) - /// Proof Skipped: Skipped Metadata (max_values: None, max_size: None, mode: Measured) + /// Storage: `Skipped::Metadata` (r:0 w:0) + /// Proof: `Skipped::Metadata` (`max_values`: None, `max_size`: None, mode: `Measured`) /// The range of component `p` is `[0, 1000]`. fn kill_prefix(p: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `110 + p * (69 ±0)` - // Estimated: `113 + p * (70 ±0)` - // Minimum execution time: 5_480_000 picoseconds. - Weight::from_parts(5_611_000, 0) - .saturating_add(Weight::from_parts(0, 113)) - // Standard Error: 9_382 - .saturating_add(Weight::from_parts(1_967_546, 0).saturating_mul(p.into())) + // Measured: `114 + p * (69 ±0)` + // Estimated: `102 + p * (70 ±0)` + // Minimum execution time: 3_949_000 picoseconds. + Weight::from_parts(4_078_000, 0) + .saturating_add(Weight::from_parts(0, 102)) + // Standard Error: 13_088 + .saturating_add(Weight::from_parts(1_249_199, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(p.into()))) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(p.into()))) .saturating_add(Weight::from_parts(0, 70).saturating_mul(p.into())) diff --git a/runtime/paseo/src/weights/mod.rs b/runtime/paseo/src/weights/mod.rs index daca9149bd..b75428447f 100644 --- a/runtime/paseo/src/weights/mod.rs +++ b/runtime/paseo/src/weights/mod.rs @@ -17,11 +17,11 @@ #![allow(clippy::unnecessary_cast)] pub mod cumulus_pallet_xcmp_queue; -// pub mod frame_system; +pub mod frame_system; pub mod pallet_asset_manager; pub mod pallet_balances; -pub mod pallet_bridge; pub mod pallet_bridge_transfer; +pub mod pallet_chain_bridge; pub mod pallet_collective; pub mod pallet_democracy; pub mod pallet_evm; diff --git a/runtime/paseo/src/weights/pallet_asset_manager.rs b/runtime/paseo/src/weights/pallet_asset_manager.rs index 252f531858..1c66f95adf 100644 --- a/runtime/paseo/src/weights/pallet_asset_manager.rs +++ b/runtime/paseo/src/weights/pallet_asset_manager.rs @@ -17,10 +17,10 @@ //! Autogenerated weights for `pallet_asset_manager` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-10-17, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-08-28, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `parachain-benchmark`, CPU: `Intel(R) Xeon(R) Platinum 8259CL CPU @ 2.50GHz` -//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("rococo-dev"), DB CACHE: 20 +//! HOSTNAME: `litentry-benchmark-server`, CPU: `Intel(R) Xeon(R) CPU E5-2686 v4 @ 2.30GHz` +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("rococo-dev")`, DB CACHE: 20 // Executed Command: // ./litentry-collator @@ -49,76 +49,76 @@ use core::marker::PhantomData; /// Weight functions for `pallet_asset_manager`. pub struct WeightInfo(PhantomData); impl pallet_asset_manager::WeightInfo for WeightInfo { - /// Storage: AssetManager AssetTypeId (r:1 w:1) - /// Proof Skipped: AssetManager AssetTypeId (max_values: None, max_size: None, mode: Measured) - /// Storage: AssetManager ForeignAssetTracker (r:1 w:1) - /// Proof Skipped: AssetManager ForeignAssetTracker (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: AssetManager AssetIdType (r:0 w:1) - /// Proof Skipped: AssetManager AssetIdType (max_values: None, max_size: None, mode: Measured) - /// Storage: AssetManager AssetIdMetadata (r:0 w:1) - /// Proof Skipped: AssetManager AssetIdMetadata (max_values: None, max_size: None, mode: Measured) + /// Storage: `AssetManager::AssetTypeId` (r:1 w:1) + /// Proof: `AssetManager::AssetTypeId` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `AssetManager::ForeignAssetTracker` (r:1 w:1) + /// Proof: `AssetManager::ForeignAssetTracker` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `AssetManager::AssetIdType` (r:0 w:1) + /// Proof: `AssetManager::AssetIdType` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `AssetManager::AssetIdMetadata` (r:0 w:1) + /// Proof: `AssetManager::AssetIdMetadata` (`max_values`: None, `max_size`: None, mode: `Measured`) fn register_foreign_asset_type() -> Weight { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 33_201_000 picoseconds. - Weight::from_parts(33_992_000, 0) + // Minimum execution time: 22_417_000 picoseconds. + Weight::from_parts(23_511_000, 0) .saturating_add(Weight::from_parts(0, 3607)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(4)) } - /// Storage: AssetManager AssetIdType (r:1 w:0) - /// Proof Skipped: AssetManager AssetIdType (max_values: None, max_size: None, mode: Measured) - /// Storage: AssetManager AssetIdMetadata (r:0 w:1) - /// Proof Skipped: AssetManager AssetIdMetadata (max_values: None, max_size: None, mode: Measured) + /// Storage: `AssetManager::AssetIdType` (r:1 w:0) + /// Proof: `AssetManager::AssetIdType` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `AssetManager::AssetIdMetadata` (r:0 w:1) + /// Proof: `AssetManager::AssetIdMetadata` (`max_values`: None, `max_size`: None, mode: `Measured`) fn update_foreign_asset_metadata() -> Weight { // Proof Size summary in bytes: // Measured: `302` // Estimated: `3767` - // Minimum execution time: 20_127_000 picoseconds. - Weight::from_parts(20_701_000, 0) + // Minimum execution time: 13_327_000 picoseconds. + Weight::from_parts(13_896_000, 0) .saturating_add(Weight::from_parts(0, 3767)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: AssetManager AssetIdType (r:1 w:0) - /// Proof Skipped: AssetManager AssetIdType (max_values: None, max_size: None, mode: Measured) - /// Storage: AssetManager AssetIdUnitsPerSecond (r:0 w:1) - /// Proof Skipped: AssetManager AssetIdUnitsPerSecond (max_values: None, max_size: None, mode: Measured) + /// Storage: `AssetManager::AssetIdType` (r:1 w:0) + /// Proof: `AssetManager::AssetIdType` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `AssetManager::AssetIdUnitsPerSecond` (r:0 w:1) + /// Proof: `AssetManager::AssetIdUnitsPerSecond` (`max_values`: None, `max_size`: None, mode: `Measured`) fn set_asset_units_per_second() -> Weight { // Proof Size summary in bytes: // Measured: `302` // Estimated: `3767` - // Minimum execution time: 19_489_000 picoseconds. - Weight::from_parts(19_879_000, 0) + // Minimum execution time: 12_746_000 picoseconds. + Weight::from_parts(13_313_000, 0) .saturating_add(Weight::from_parts(0, 3767)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: AssetManager AssetIdType (r:1 w:1) - /// Proof Skipped: AssetManager AssetIdType (max_values: None, max_size: None, mode: Measured) - /// Storage: AssetManager AssetTypeId (r:1 w:1) - /// Proof Skipped: AssetManager AssetTypeId (max_values: None, max_size: None, mode: Measured) + /// Storage: `AssetManager::AssetIdType` (r:1 w:1) + /// Proof: `AssetManager::AssetIdType` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `AssetManager::AssetTypeId` (r:1 w:1) + /// Proof: `AssetManager::AssetTypeId` (`max_values`: None, `max_size`: None, mode: `Measured`) fn add_asset_type() -> Weight { // Proof Size summary in bytes: // Measured: `325` // Estimated: `3790` - // Minimum execution time: 25_212_000 picoseconds. - Weight::from_parts(25_708_000, 0) + // Minimum execution time: 17_319_000 picoseconds. + Weight::from_parts(18_423_000, 0) .saturating_add(Weight::from_parts(0, 3790)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) } - /// Storage: AssetManager AssetTypeId (r:2 w:1) - /// Proof Skipped: AssetManager AssetTypeId (max_values: None, max_size: None, mode: Measured) - /// Storage: AssetManager AssetIdType (r:0 w:1) - /// Proof Skipped: AssetManager AssetIdType (max_values: None, max_size: None, mode: Measured) + /// Storage: `AssetManager::AssetTypeId` (r:2 w:1) + /// Proof: `AssetManager::AssetTypeId` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `AssetManager::AssetIdType` (r:0 w:1) + /// Proof: `AssetManager::AssetIdType` (`max_values`: None, `max_size`: None, mode: `Measured`) fn remove_asset_type() -> Weight { // Proof Size summary in bytes: // Measured: `482` // Estimated: `6422` - // Minimum execution time: 31_996_000 picoseconds. - Weight::from_parts(32_579_000, 0) + // Minimum execution time: 21_607_000 picoseconds. + Weight::from_parts(22_859_000, 0) .saturating_add(Weight::from_parts(0, 6422)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) diff --git a/runtime/paseo/src/weights/pallet_balances.rs b/runtime/paseo/src/weights/pallet_balances.rs index 4e4de5a3b0..33dbbb5ea0 100644 --- a/runtime/paseo/src/weights/pallet_balances.rs +++ b/runtime/paseo/src/weights/pallet_balances.rs @@ -17,10 +17,10 @@ //! Autogenerated weights for `pallet_balances` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-10-17, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-08-28, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `parachain-benchmark`, CPU: `Intel(R) Xeon(R) Platinum 8259CL CPU @ 2.50GHz` -//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("rococo-dev"), DB CACHE: 20 +//! HOSTNAME: `litentry-benchmark-server`, CPU: `Intel(R) Xeon(R) CPU E5-2686 v4 @ 2.30GHz` +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("rococo-dev")`, DB CACHE: 20 // Executed Command: // ./litentry-collator @@ -49,102 +49,102 @@ use core::marker::PhantomData; /// Weight functions for `pallet_balances`. pub struct WeightInfo(PhantomData); impl pallet_balances::WeightInfo for WeightInfo { - /// Storage: System Account (r:1 w:1) - /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + /// Storage: `System::Account` (r:1 w:1) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) fn transfer_allow_death() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `3593` - // Minimum execution time: 73_884_000 picoseconds. - Weight::from_parts(75_841_000, 0) + // Minimum execution time: 53_007_000 picoseconds. + Weight::from_parts(68_015_000, 0) .saturating_add(Weight::from_parts(0, 3593)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: System Account (r:1 w:1) - /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + /// Storage: `System::Account` (r:1 w:1) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) fn transfer_keep_alive() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `3593` - // Minimum execution time: 55_141_000 picoseconds. - Weight::from_parts(57_048_000, 0) + // Minimum execution time: 39_762_000 picoseconds. + Weight::from_parts(41_499_000, 0) .saturating_add(Weight::from_parts(0, 3593)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: System Account (r:1 w:1) - /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + /// Storage: `System::Account` (r:1 w:1) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) fn force_set_balance_creating() -> Weight { // Proof Size summary in bytes: // Measured: `140` // Estimated: `3593` - // Minimum execution time: 22_969_000 picoseconds. - Weight::from_parts(23_686_000, 0) + // Minimum execution time: 15_589_000 picoseconds. + Weight::from_parts(16_536_000, 0) .saturating_add(Weight::from_parts(0, 3593)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: System Account (r:1 w:1) - /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + /// Storage: `System::Account` (r:1 w:1) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) fn force_set_balance_killing() -> Weight { // Proof Size summary in bytes: // Measured: `140` // Estimated: `3593` - // Minimum execution time: 33_996_000 picoseconds. - Weight::from_parts(34_787_000, 0) + // Minimum execution time: 22_560_000 picoseconds. + Weight::from_parts(23_315_000, 0) .saturating_add(Weight::from_parts(0, 3593)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: System Account (r:2 w:2) - /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + /// Storage: `System::Account` (r:2 w:2) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) fn force_transfer() -> Weight { // Proof Size summary in bytes: // Measured: `103` // Estimated: `6196` - // Minimum execution time: 77_129_000 picoseconds. - Weight::from_parts(78_643_000, 0) + // Minimum execution time: 54_644_000 picoseconds. + Weight::from_parts(56_287_000, 0) .saturating_add(Weight::from_parts(0, 6196)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) } - /// Storage: System Account (r:1 w:1) - /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + /// Storage: `System::Account` (r:1 w:1) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) fn transfer_all() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `3593` - // Minimum execution time: 67_673_000 picoseconds. - Weight::from_parts(68_926_000, 0) + // Minimum execution time: 49_620_000 picoseconds. + Weight::from_parts(52_548_000, 0) .saturating_add(Weight::from_parts(0, 3593)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: System Account (r:1 w:1) - /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + /// Storage: `System::Account` (r:1 w:1) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) fn force_unreserve() -> Weight { // Proof Size summary in bytes: // Measured: `140` // Estimated: `3593` - // Minimum execution time: 26_492_000 picoseconds. - Weight::from_parts(27_038_000, 0) + // Minimum execution time: 18_255_000 picoseconds. + Weight::from_parts(18_795_000, 0) .saturating_add(Weight::from_parts(0, 3593)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: System Account (r:1000 w:1000) - /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + /// Storage: `System::Account` (r:1000 w:1000) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) /// The range of component `u` is `[1, 1000]`. fn upgrade_accounts(u: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0 + u * (136 ±0)` // Estimated: `990 + u * (2603 ±0)` - // Minimum execution time: 25_087_000 picoseconds. - Weight::from_parts(25_453_000, 0) + // Minimum execution time: 16_995_000 picoseconds. + Weight::from_parts(17_342_000, 0) .saturating_add(Weight::from_parts(0, 990)) - // Standard Error: 91_401 - .saturating_add(Weight::from_parts(22_138_510, 0).saturating_mul(u.into())) + // Standard Error: 30_882 + .saturating_add(Weight::from_parts(19_977_590, 0).saturating_mul(u.into())) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(u.into()))) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(u.into()))) .saturating_add(Weight::from_parts(0, 2603).saturating_mul(u.into())) diff --git a/runtime/paseo/src/weights/pallet_bridge.rs b/runtime/paseo/src/weights/pallet_bridge.rs deleted file mode 100644 index 6e48ad7452..0000000000 --- a/runtime/paseo/src/weights/pallet_bridge.rs +++ /dev/null @@ -1,163 +0,0 @@ -// Copyright 2020-2024 Trust Computing GmbH. -// This file is part of Litentry. -// -// Litentry is free software: you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// Litentry 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 -// GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License -// along with Litentry. If not, see . - -//! Autogenerated weights for `pallet_bridge` -//! -//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-10-17, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` -//! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `parachain-benchmark`, CPU: `Intel(R) Xeon(R) Platinum 8259CL CPU @ 2.50GHz` -//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("rococo-dev"), DB CACHE: 20 - -// Executed Command: -// ./litentry-collator -// benchmark -// pallet -// --chain=rococo-dev -// --execution=wasm -// --db-cache=20 -// --wasm-execution=compiled -// --pallet=pallet_bridge -// --extrinsic=* -// --heap-pages=4096 -// --steps=20 -// --repeat=50 -// --header=./LICENSE_HEADER -// --output=./runtime/rococo/src/weights/pallet_bridge.rs - -#![cfg_attr(rustfmt, rustfmt_skip)] -#![allow(unused_parens)] -#![allow(unused_imports)] -#![allow(missing_docs)] - -use frame_support::{traits::Get, weights::Weight}; -use core::marker::PhantomData; - -/// Weight functions for `pallet_bridge`. -pub struct WeightInfo(PhantomData); -impl pallet_bridge::WeightInfo for WeightInfo { - /// Storage: ChainBridge RelayerThreshold (r:0 w:1) - /// Proof Skipped: ChainBridge RelayerThreshold (max_values: Some(1), max_size: None, mode: Measured) - fn set_threshold() -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 10_246_000 picoseconds. - Weight::from_parts(10_609_000, 0) - .saturating_add(Weight::from_parts(0, 0)) - .saturating_add(T::DbWeight::get().writes(1)) - } - /// Storage: ChainBridge ChainNonces (r:1 w:1) - /// Proof Skipped: ChainBridge ChainNonces (max_values: None, max_size: None, mode: Measured) - fn whitelist_chain() -> Weight { - // Proof Size summary in bytes: - // Measured: `142` - // Estimated: `3607` - // Minimum execution time: 15_986_000 picoseconds. - Weight::from_parts(16_451_000, 0) - .saturating_add(Weight::from_parts(0, 3607)) - .saturating_add(T::DbWeight::get().reads(1)) - .saturating_add(T::DbWeight::get().writes(1)) - } - /// Storage: ChainBridge Relayers (r:1 w:1) - /// Proof Skipped: ChainBridge Relayers (max_values: None, max_size: None, mode: Measured) - /// Storage: ChainBridge RelayerCount (r:1 w:1) - /// Proof Skipped: ChainBridge RelayerCount (max_values: Some(1), max_size: None, mode: Measured) - fn add_relayer() -> Weight { - // Proof Size summary in bytes: - // Measured: `142` - // Estimated: `3607` - // Minimum execution time: 18_770_000 picoseconds. - Weight::from_parts(19_235_000, 0) - .saturating_add(Weight::from_parts(0, 3607)) - .saturating_add(T::DbWeight::get().reads(2)) - .saturating_add(T::DbWeight::get().writes(2)) - } - /// Storage: ChainBridge Relayers (r:1 w:1) - /// Proof Skipped: ChainBridge Relayers (max_values: None, max_size: None, mode: Measured) - /// Storage: ChainBridge RelayerCount (r:1 w:1) - /// Proof Skipped: ChainBridge RelayerCount (max_values: Some(1), max_size: None, mode: Measured) - fn remove_relayer() -> Weight { - // Proof Size summary in bytes: - // Measured: `223` - // Estimated: `3688` - // Minimum execution time: 20_653_000 picoseconds. - Weight::from_parts(21_109_000, 0) - .saturating_add(Weight::from_parts(0, 3688)) - .saturating_add(T::DbWeight::get().reads(2)) - .saturating_add(T::DbWeight::get().writes(2)) - } - /// Storage: ChainBridge Relayers (r:1 w:0) - /// Proof Skipped: ChainBridge Relayers (max_values: None, max_size: None, mode: Measured) - /// Storage: ChainBridge ChainNonces (r:1 w:0) - /// Proof Skipped: ChainBridge ChainNonces (max_values: None, max_size: None, mode: Measured) - /// Storage: ChainBridge Resources (r:1 w:0) - /// Proof Skipped: ChainBridge Resources (max_values: None, max_size: None, mode: Measured) - /// Storage: ChainBridge Votes (r:1 w:1) - /// Proof Skipped: ChainBridge Votes (max_values: None, max_size: None, mode: Measured) - /// Storage: ChainBridge RelayerThreshold (r:1 w:0) - /// Proof Skipped: ChainBridge RelayerThreshold (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: ChainBridge RelayerCount (r:1 w:0) - /// Proof Skipped: ChainBridge RelayerCount (max_values: Some(1), max_size: None, mode: Measured) - fn acknowledge_proposal() -> Weight { - // Proof Size summary in bytes: - // Measured: `340` - // Estimated: `3805` - // Minimum execution time: 52_203_000 picoseconds. - Weight::from_parts(52_854_000, 0) - .saturating_add(Weight::from_parts(0, 3805)) - .saturating_add(T::DbWeight::get().reads(6)) - .saturating_add(T::DbWeight::get().writes(1)) - } - /// Storage: ChainBridge Relayers (r:1 w:0) - /// Proof Skipped: ChainBridge Relayers (max_values: None, max_size: None, mode: Measured) - /// Storage: ChainBridge ChainNonces (r:1 w:0) - /// Proof Skipped: ChainBridge ChainNonces (max_values: None, max_size: None, mode: Measured) - /// Storage: ChainBridge Resources (r:1 w:0) - /// Proof Skipped: ChainBridge Resources (max_values: None, max_size: None, mode: Measured) - /// Storage: ChainBridge Votes (r:1 w:1) - /// Proof Skipped: ChainBridge Votes (max_values: None, max_size: None, mode: Measured) - /// Storage: ChainBridge RelayerThreshold (r:1 w:0) - /// Proof Skipped: ChainBridge RelayerThreshold (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: ChainBridge RelayerCount (r:1 w:0) - /// Proof Skipped: ChainBridge RelayerCount (max_values: Some(1), max_size: None, mode: Measured) - fn reject_proposal() -> Weight { - // Proof Size summary in bytes: - // Measured: `340` - // Estimated: `3805` - // Minimum execution time: 44_020_000 picoseconds. - Weight::from_parts(44_771_000, 0) - .saturating_add(Weight::from_parts(0, 3805)) - .saturating_add(T::DbWeight::get().reads(6)) - .saturating_add(T::DbWeight::get().writes(1)) - } - /// Storage: ChainBridge Votes (r:1 w:1) - /// Proof Skipped: ChainBridge Votes (max_values: None, max_size: None, mode: Measured) - /// Storage: ChainBridge RelayerThreshold (r:1 w:0) - /// Proof Skipped: ChainBridge RelayerThreshold (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: ChainBridge RelayerCount (r:1 w:0) - /// Proof Skipped: ChainBridge RelayerCount (max_values: Some(1), max_size: None, mode: Measured) - fn eval_vote_state() -> Weight { - // Proof Size summary in bytes: - // Measured: `484` - // Estimated: `3949` - // Minimum execution time: 19_330_000 picoseconds. - Weight::from_parts(19_813_000, 0) - .saturating_add(Weight::from_parts(0, 3949)) - .saturating_add(T::DbWeight::get().reads(3)) - .saturating_add(T::DbWeight::get().writes(1)) - } -} diff --git a/runtime/paseo/src/weights/pallet_bridge_transfer.rs b/runtime/paseo/src/weights/pallet_bridge_transfer.rs index 122e72cce0..550c4446c3 100644 --- a/runtime/paseo/src/weights/pallet_bridge_transfer.rs +++ b/runtime/paseo/src/weights/pallet_bridge_transfer.rs @@ -14,17 +14,19 @@ // You should have received a copy of the GNU General Public License // along with Litentry. If not, see . -//! Autogenerated weights for pallet_bridge_transfer +//! Autogenerated weights for `pallet_bridge_transfer` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2022-09-29, STEPS: `20`, REPEAT: 50, LOW RANGE: `[]`, HIGH RANGE: `[]` -//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("litentry-dev"), DB CACHE: 20 +//! DATE: 2024-08-28, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! WORST CASE MAP SIZE: `1000000` +//! HOSTNAME: `litentry-benchmark-server`, CPU: `Intel(R) Xeon(R) CPU E5-2686 v4 @ 2.30GHz` +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("rococo-dev")`, DB CACHE: 20 // Executed Command: -// ./target/release/litentry-collator +// ./litentry-collator // benchmark // pallet -// --chain=litentry-dev +// --chain=rococo-dev // --execution=wasm // --db-cache=20 // --wasm-execution=compiled @@ -34,36 +36,55 @@ // --steps=20 // --repeat=50 // --header=./LICENSE_HEADER -// --template=./templates/benchmark/pallet-weight-template.hbs -// --output=./pallets/bridge-transfer/src/weights.rs +// --output=./runtime/rococo/src/weights/pallet_bridge_transfer.rs #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(unused_parens)] #![allow(unused_imports)] -#![allow(clippy::unnecessary_cast)] +#![allow(missing_docs)] -use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}}; -use sp_std::marker::PhantomData; +use frame_support::{traits::Get, weights::Weight}; +use core::marker::PhantomData; -/// Weights for pallet_bridge_transfer using the Litentry node and recommended hardware. +/// Weight functions for `pallet_bridge_transfer`. pub struct WeightInfo(PhantomData); impl pallet_bridge_transfer::WeightInfo for WeightInfo { - // Storage: BridgeTransfer ExternalBalances (r:1 w:1) - // Storage: ChainBridge ChainNonces (r:1 w:1) - // Storage: ChainBridge BridgeFee (r:1 w:0) - // Storage: System Account (r:2 w:2) - // Storage: ChainBridge BridgeEvents (r:1 w:1) + /// Storage: `AssetsHandler::ResourceToAssetInfo` (r:1 w:0) + /// Proof: `AssetsHandler::ResourceToAssetInfo` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `System::Account` (r:2 w:1) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) + /// Storage: `AssetsHandler::ExternalBalances` (r:1 w:1) + /// Proof: `AssetsHandler::ExternalBalances` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ChainBridge::ChainNonces` (r:1 w:1) + /// Proof: `ChainBridge::ChainNonces` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ChainBridge::BridgeEvents` (r:1 w:1) + /// Proof: `ChainBridge::BridgeEvents` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) fn transfer_assets() -> Weight { - Weight::from_parts(59_963_000 as u64, 0) - .saturating_add(T::DbWeight::get().reads(6 as u64)) - .saturating_add(T::DbWeight::get().writes(5 as u64)) + // Proof Size summary in bytes: + // Measured: `573` + // Estimated: `6196` + // Minimum execution time: 60_812_000 picoseconds. + Weight::from_parts(62_706_000, 0) + .saturating_add(Weight::from_parts(0, 6196)) + .saturating_add(T::DbWeight::get().reads(6)) + .saturating_add(T::DbWeight::get().writes(4)) } - // Storage: BridgeTransfer MaximumIssuance (r:1 w:0) - // Storage: BridgeTransfer ExternalBalances (r:1 w:1) - // Storage: System Account (r:1 w:1) + /// Storage: `AssetsHandler::ResourceToAssetInfo` (r:1 w:0) + /// Proof: `AssetsHandler::ResourceToAssetInfo` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `AssetsHandler::MaximumIssuance` (r:1 w:0) + /// Proof: `AssetsHandler::MaximumIssuance` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `AssetsHandler::ExternalBalances` (r:1 w:1) + /// Proof: `AssetsHandler::ExternalBalances` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `System::Account` (r:1 w:1) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) fn transfer() -> Weight { - Weight::from_parts(29_134_000 as u64, 0) - .saturating_add(T::DbWeight::get().reads(3 as u64)) - .saturating_add(T::DbWeight::get().writes(2 as u64)) + // Proof Size summary in bytes: + // Measured: `328` + // Estimated: `3793` + // Minimum execution time: 35_475_000 picoseconds. + Weight::from_parts(36_847_000, 0) + .saturating_add(Weight::from_parts(0, 3793)) + .saturating_add(T::DbWeight::get().reads(4)) + .saturating_add(T::DbWeight::get().writes(2)) } } diff --git a/runtime/paseo/src/weights/pallet_chain_bridge.rs b/runtime/paseo/src/weights/pallet_chain_bridge.rs new file mode 100644 index 0000000000..7271e2d637 --- /dev/null +++ b/runtime/paseo/src/weights/pallet_chain_bridge.rs @@ -0,0 +1,159 @@ +// Copyright 2020-2024 Trust Computing GmbH. +// This file is part of Litentry. +// +// Litentry is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Litentry 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 +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Litentry. If not, see . + +//! Autogenerated weights for `pallet_chain_bridge` +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev +//! DATE: 2024-08-28, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! WORST CASE MAP SIZE: `1000000` +//! HOSTNAME: `litentry-benchmark-server`, CPU: `Intel(R) Xeon(R) CPU E5-2686 v4 @ 2.30GHz` +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("rococo-dev")`, DB CACHE: 20 + +// Executed Command: +// ./litentry-collator +// benchmark +// pallet +// --chain=rococo-dev +// --execution=wasm +// --db-cache=20 +// --wasm-execution=compiled +// --pallet=pallet_chain_bridge +// --extrinsic=* +// --heap-pages=4096 +// --steps=20 +// --repeat=50 +// --header=./LICENSE_HEADER +// --output=./runtime/rococo/src/weights/pallet_chain_bridge.rs + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] +#![allow(missing_docs)] + +use frame_support::{traits::Get, weights::Weight}; +use core::marker::PhantomData; + +/// Weight functions for `pallet_chain_bridge`. +pub struct WeightInfo(PhantomData); +impl pallet_chain_bridge::WeightInfo for WeightInfo { + /// Storage: `ChainBridge::RelayerThreshold` (r:0 w:1) + /// Proof: `ChainBridge::RelayerThreshold` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + fn set_threshold() -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 7_198_000 picoseconds. + Weight::from_parts(7_687_000, 0) + .saturating_add(Weight::from_parts(0, 0)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: `ChainBridge::ChainNonces` (r:1 w:1) + /// Proof: `ChainBridge::ChainNonces` (`max_values`: None, `max_size`: None, mode: `Measured`) + fn whitelist_chain() -> Weight { + // Proof Size summary in bytes: + // Measured: `142` + // Estimated: `3607` + // Minimum execution time: 10_444_000 picoseconds. + Weight::from_parts(10_996_000, 0) + .saturating_add(Weight::from_parts(0, 3607)) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: `ChainBridge::Relayers` (r:1 w:1) + /// Proof: `ChainBridge::Relayers` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ChainBridge::RelayerCount` (r:1 w:1) + /// Proof: `ChainBridge::RelayerCount` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + fn add_relayer() -> Weight { + // Proof Size summary in bytes: + // Measured: `142` + // Estimated: `3607` + // Minimum execution time: 12_951_000 picoseconds. + Weight::from_parts(13_847_000, 0) + .saturating_add(Weight::from_parts(0, 3607)) + .saturating_add(T::DbWeight::get().reads(2)) + .saturating_add(T::DbWeight::get().writes(2)) + } + /// Storage: `ChainBridge::Relayers` (r:1 w:1) + /// Proof: `ChainBridge::Relayers` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ChainBridge::RelayerCount` (r:1 w:1) + /// Proof: `ChainBridge::RelayerCount` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + fn remove_relayer() -> Weight { + // Proof Size summary in bytes: + // Measured: `223` + // Estimated: `3688` + // Minimum execution time: 14_662_000 picoseconds. + Weight::from_parts(15_484_000, 0) + .saturating_add(Weight::from_parts(0, 3688)) + .saturating_add(T::DbWeight::get().reads(2)) + .saturating_add(T::DbWeight::get().writes(2)) + } + /// Storage: `ChainBridge::Relayers` (r:1 w:0) + /// Proof: `ChainBridge::Relayers` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ChainBridge::ChainNonces` (r:1 w:0) + /// Proof: `ChainBridge::ChainNonces` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ChainBridge::Votes` (r:1 w:1) + /// Proof: `ChainBridge::Votes` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ChainBridge::RelayerThreshold` (r:1 w:0) + /// Proof: `ChainBridge::RelayerThreshold` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ChainBridge::RelayerCount` (r:1 w:0) + /// Proof: `ChainBridge::RelayerCount` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + fn acknowledge_proposal() -> Weight { + // Proof Size summary in bytes: + // Measured: `285` + // Estimated: `3750` + // Minimum execution time: 34_507_000 picoseconds. + Weight::from_parts(36_153_000, 0) + .saturating_add(Weight::from_parts(0, 3750)) + .saturating_add(T::DbWeight::get().reads(5)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: `ChainBridge::Relayers` (r:1 w:0) + /// Proof: `ChainBridge::Relayers` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ChainBridge::ChainNonces` (r:1 w:0) + /// Proof: `ChainBridge::ChainNonces` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ChainBridge::Votes` (r:1 w:1) + /// Proof: `ChainBridge::Votes` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ChainBridge::RelayerThreshold` (r:1 w:0) + /// Proof: `ChainBridge::RelayerThreshold` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ChainBridge::RelayerCount` (r:1 w:0) + /// Proof: `ChainBridge::RelayerCount` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + fn reject_proposal() -> Weight { + // Proof Size summary in bytes: + // Measured: `285` + // Estimated: `3750` + // Minimum execution time: 29_590_000 picoseconds. + Weight::from_parts(30_478_000, 0) + .saturating_add(Weight::from_parts(0, 3750)) + .saturating_add(T::DbWeight::get().reads(5)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: `ChainBridge::Votes` (r:1 w:1) + /// Proof: `ChainBridge::Votes` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ChainBridge::RelayerThreshold` (r:1 w:0) + /// Proof: `ChainBridge::RelayerThreshold` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ChainBridge::RelayerCount` (r:1 w:0) + /// Proof: `ChainBridge::RelayerCount` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + fn eval_vote_state() -> Weight { + // Proof Size summary in bytes: + // Measured: `451` + // Estimated: `3916` + // Minimum execution time: 14_114_000 picoseconds. + Weight::from_parts(14_930_000, 0) + .saturating_add(Weight::from_parts(0, 3916)) + .saturating_add(T::DbWeight::get().reads(3)) + .saturating_add(T::DbWeight::get().writes(1)) + } +} diff --git a/runtime/paseo/src/weights/pallet_collective.rs b/runtime/paseo/src/weights/pallet_collective.rs index 34960feeaf..b3dd85eda1 100644 --- a/runtime/paseo/src/weights/pallet_collective.rs +++ b/runtime/paseo/src/weights/pallet_collective.rs @@ -17,10 +17,10 @@ //! Autogenerated weights for `pallet_collective` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-10-17, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-08-28, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `parachain-benchmark`, CPU: `Intel(R) Xeon(R) Platinum 8259CL CPU @ 2.50GHz` -//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("rococo-dev"), DB CACHE: 20 +//! HOSTNAME: `litentry-benchmark-server`, CPU: `Intel(R) Xeon(R) CPU E5-2686 v4 @ 2.30GHz` +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("rococo-dev")`, DB CACHE: 20 // Executed Command: // ./litentry-collator @@ -49,28 +49,28 @@ use core::marker::PhantomData; /// Weight functions for `pallet_collective`. pub struct WeightInfo(PhantomData); impl pallet_collective::WeightInfo for WeightInfo { - /// Storage: Council Members (r:1 w:1) - /// Proof Skipped: Council Members (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: Council Proposals (r:1 w:0) - /// Proof Skipped: Council Proposals (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: Council Voting (r:100 w:100) - /// Proof Skipped: Council Voting (max_values: None, max_size: None, mode: Measured) - /// Storage: Council Prime (r:0 w:1) - /// Proof Skipped: Council Prime (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: `Council::Members` (r:1 w:1) + /// Proof: `Council::Members` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `Council::Proposals` (r:1 w:0) + /// Proof: `Council::Proposals` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `Council::Voting` (r:100 w:100) + /// Proof: `Council::Voting` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Council::Prime` (r:0 w:1) + /// Proof: `Council::Prime` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) /// The range of component `m` is `[0, 100]`. /// The range of component `n` is `[0, 100]`. /// The range of component `p` is `[0, 100]`. fn set_members(m: u32, _n: u32, p: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0 + m * (3232 ±0) + p * (3190 ±0)` - // Estimated: `32761 + m * (1968 ±26) + p * (4247 ±26)` - // Minimum execution time: 24_624_000 picoseconds. - Weight::from_parts(24_962_000, 0) + // Estimated: `32761 + m * (1968 ±23) + p * (4247 ±23)` + // Minimum execution time: 16_998_000 picoseconds. + Weight::from_parts(17_440_000, 0) .saturating_add(Weight::from_parts(0, 32761)) - // Standard Error: 118_897 - .saturating_add(Weight::from_parts(8_899_231, 0).saturating_mul(m.into())) - // Standard Error: 118_897 - .saturating_add(Weight::from_parts(13_070_322, 0).saturating_mul(p.into())) + // Standard Error: 157_175 + .saturating_add(Weight::from_parts(5_557_666, 0).saturating_mul(m.into())) + // Standard Error: 157_175 + .saturating_add(Weight::from_parts(9_190_914, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(p.into()))) .saturating_add(T::DbWeight::get().writes(2)) @@ -78,54 +78,54 @@ impl pallet_collective::WeightInfo for WeightInfo { .saturating_add(Weight::from_parts(0, 1968).saturating_mul(m.into())) .saturating_add(Weight::from_parts(0, 4247).saturating_mul(p.into())) } - /// Storage: Council Members (r:1 w:0) - /// Proof Skipped: Council Members (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: `Council::Members` (r:1 w:0) + /// Proof: `Council::Members` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) /// The range of component `b` is `[2, 1024]`. /// The range of component `m` is `[1, 100]`. fn execute(b: u32, m: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `103 + m * (32 ±0)` // Estimated: `1588 + m * (32 ±0)` - // Minimum execution time: 23_445_000 picoseconds. - Weight::from_parts(24_013_914, 0) + // Minimum execution time: 15_435_000 picoseconds. + Weight::from_parts(15_418_071, 0) .saturating_add(Weight::from_parts(0, 1588)) - // Standard Error: 154 - .saturating_add(Weight::from_parts(568, 0).saturating_mul(b.into())) - // Standard Error: 1_590 - .saturating_add(Weight::from_parts(15_456, 0).saturating_mul(m.into())) + // Standard Error: 83 + .saturating_add(Weight::from_parts(1_459, 0).saturating_mul(b.into())) + // Standard Error: 859 + .saturating_add(Weight::from_parts(7_413, 0).saturating_mul(m.into())) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(Weight::from_parts(0, 32).saturating_mul(m.into())) } - /// Storage: Council Members (r:1 w:0) - /// Proof Skipped: Council Members (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: Council ProposalOf (r:1 w:0) - /// Proof Skipped: Council ProposalOf (max_values: None, max_size: None, mode: Measured) + /// Storage: `Council::Members` (r:1 w:0) + /// Proof: `Council::Members` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `Council::ProposalOf` (r:1 w:0) + /// Proof: `Council::ProposalOf` (`max_values`: None, `max_size`: None, mode: `Measured`) /// The range of component `b` is `[2, 1024]`. /// The range of component `m` is `[1, 100]`. fn propose_execute(b: u32, m: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `103 + m * (32 ±0)` // Estimated: `3568 + m * (32 ±0)` - // Minimum execution time: 26_776_000 picoseconds. - Weight::from_parts(25_496_975, 0) + // Minimum execution time: 18_397_000 picoseconds. + Weight::from_parts(17_080_441, 0) .saturating_add(Weight::from_parts(0, 3568)) - // Standard Error: 56 - .saturating_add(Weight::from_parts(2_189, 0).saturating_mul(b.into())) - // Standard Error: 578 - .saturating_add(Weight::from_parts(32_732, 0).saturating_mul(m.into())) + // Standard Error: 92 + .saturating_add(Weight::from_parts(1_651, 0).saturating_mul(b.into())) + // Standard Error: 946 + .saturating_add(Weight::from_parts(27_912, 0).saturating_mul(m.into())) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(Weight::from_parts(0, 32).saturating_mul(m.into())) } - /// Storage: Council Members (r:1 w:0) - /// Proof Skipped: Council Members (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: Council ProposalOf (r:1 w:1) - /// Proof Skipped: Council ProposalOf (max_values: None, max_size: None, mode: Measured) - /// Storage: Council Proposals (r:1 w:1) - /// Proof Skipped: Council Proposals (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: Council ProposalCount (r:1 w:1) - /// Proof Skipped: Council ProposalCount (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: Council Voting (r:0 w:1) - /// Proof Skipped: Council Voting (max_values: None, max_size: None, mode: Measured) + /// Storage: `Council::Members` (r:1 w:0) + /// Proof: `Council::Members` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `Council::ProposalOf` (r:1 w:1) + /// Proof: `Council::ProposalOf` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Council::Proposals` (r:1 w:1) + /// Proof: `Council::Proposals` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `Council::ProposalCount` (r:1 w:1) + /// Proof: `Council::ProposalCount` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `Council::Voting` (r:0 w:1) + /// Proof: `Council::Voting` (`max_values`: None, `max_size`: None, mode: `Measured`) /// The range of component `b` is `[2, 1024]`. /// The range of component `m` is `[2, 100]`. /// The range of component `p` is `[1, 100]`. @@ -133,72 +133,72 @@ impl pallet_collective::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `463 + m * (32 ±0) + p * (36 ±0)` // Estimated: `3821 + m * (33 ±0) + p * (36 ±0)` - // Minimum execution time: 35_086_000 picoseconds. - Weight::from_parts(31_380_952, 0) + // Minimum execution time: 23_851_000 picoseconds. + Weight::from_parts(24_231_413, 0) .saturating_add(Weight::from_parts(0, 3821)) - // Standard Error: 304 - .saturating_add(Weight::from_parts(5_004, 0).saturating_mul(b.into())) - // Standard Error: 3_161 - .saturating_add(Weight::from_parts(36_178, 0).saturating_mul(m.into())) - // Standard Error: 3_129 - .saturating_add(Weight::from_parts(346_703, 0).saturating_mul(p.into())) + // Standard Error: 207 + .saturating_add(Weight::from_parts(2_710, 0).saturating_mul(b.into())) + // Standard Error: 2_153 + .saturating_add(Weight::from_parts(23_162, 0).saturating_mul(m.into())) + // Standard Error: 2_131 + .saturating_add(Weight::from_parts(212_594, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(4)) .saturating_add(T::DbWeight::get().writes(4)) .saturating_add(Weight::from_parts(0, 33).saturating_mul(m.into())) .saturating_add(Weight::from_parts(0, 36).saturating_mul(p.into())) } - /// Storage: Council Members (r:1 w:0) - /// Proof Skipped: Council Members (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: Council Voting (r:1 w:1) - /// Proof Skipped: Council Voting (max_values: None, max_size: None, mode: Measured) + /// Storage: `Council::Members` (r:1 w:0) + /// Proof: `Council::Members` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `Council::Voting` (r:1 w:1) + /// Proof: `Council::Voting` (`max_values`: None, `max_size`: None, mode: `Measured`) /// The range of component `m` is `[5, 100]`. fn vote(m: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `841 + m * (64 ±0)` // Estimated: `4306 + m * (64 ±0)` - // Minimum execution time: 41_221_000 picoseconds. - Weight::from_parts(45_774_322, 0) + // Minimum execution time: 26_294_000 picoseconds. + Weight::from_parts(29_486_906, 0) .saturating_add(Weight::from_parts(0, 4306)) - // Standard Error: 3_309 - .saturating_add(Weight::from_parts(45_733, 0).saturating_mul(m.into())) + // Standard Error: 1_787 + .saturating_add(Weight::from_parts(37_613, 0).saturating_mul(m.into())) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(1)) .saturating_add(Weight::from_parts(0, 64).saturating_mul(m.into())) } - /// Storage: Council Voting (r:1 w:1) - /// Proof Skipped: Council Voting (max_values: None, max_size: None, mode: Measured) - /// Storage: Council Members (r:1 w:0) - /// Proof Skipped: Council Members (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: Council Proposals (r:1 w:1) - /// Proof Skipped: Council Proposals (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: Council ProposalOf (r:0 w:1) - /// Proof Skipped: Council ProposalOf (max_values: None, max_size: None, mode: Measured) + /// Storage: `Council::Voting` (r:1 w:1) + /// Proof: `Council::Voting` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Council::Members` (r:1 w:0) + /// Proof: `Council::Members` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `Council::Proposals` (r:1 w:1) + /// Proof: `Council::Proposals` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `Council::ProposalOf` (r:0 w:1) + /// Proof: `Council::ProposalOf` (`max_values`: None, `max_size`: None, mode: `Measured`) /// The range of component `m` is `[4, 100]`. /// The range of component `p` is `[1, 100]`. fn close_early_disapproved(m: u32, p: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `468 + m * (64 ±0) + p * (35 ±0)` // Estimated: `3856 + m * (65 ±0) + p * (36 ±0)` - // Minimum execution time: 39_720_000 picoseconds. - Weight::from_parts(35_099_918, 0) + // Minimum execution time: 27_374_000 picoseconds. + Weight::from_parts(29_537_848, 0) .saturating_add(Weight::from_parts(0, 3856)) - // Standard Error: 4_106 - .saturating_add(Weight::from_parts(84_303, 0).saturating_mul(m.into())) - // Standard Error: 3_972 - .saturating_add(Weight::from_parts(327_797, 0).saturating_mul(p.into())) + // Standard Error: 1_788 + .saturating_add(Weight::from_parts(32_813, 0).saturating_mul(m.into())) + // Standard Error: 1_730 + .saturating_add(Weight::from_parts(179_325, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(3)) .saturating_add(T::DbWeight::get().writes(3)) .saturating_add(Weight::from_parts(0, 65).saturating_mul(m.into())) .saturating_add(Weight::from_parts(0, 36).saturating_mul(p.into())) } - /// Storage: Council Voting (r:1 w:1) - /// Proof Skipped: Council Voting (max_values: None, max_size: None, mode: Measured) - /// Storage: Council Members (r:1 w:0) - /// Proof Skipped: Council Members (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: Council ProposalOf (r:1 w:1) - /// Proof Skipped: Council ProposalOf (max_values: None, max_size: None, mode: Measured) - /// Storage: Council Proposals (r:1 w:1) - /// Proof Skipped: Council Proposals (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: `Council::Voting` (r:1 w:1) + /// Proof: `Council::Voting` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Council::Members` (r:1 w:0) + /// Proof: `Council::Members` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `Council::ProposalOf` (r:1 w:1) + /// Proof: `Council::ProposalOf` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Council::Proposals` (r:1 w:1) + /// Proof: `Council::Proposals` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) /// The range of component `b` is `[2, 1024]`. /// The range of component `m` is `[4, 100]`. /// The range of component `p` is `[1, 100]`. @@ -206,59 +206,59 @@ impl pallet_collective::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `778 + m * (64 ±0) + p * (39 ±0)` // Estimated: `4117 + b * (1 ±0) + m * (65 ±0) + p * (40 ±0)` - // Minimum execution time: 55_941_000 picoseconds. - Weight::from_parts(50_208_394, 0) + // Minimum execution time: 39_326_000 picoseconds. + Weight::from_parts(40_720_816, 0) .saturating_add(Weight::from_parts(0, 4117)) - // Standard Error: 499 - .saturating_add(Weight::from_parts(6_301, 0).saturating_mul(b.into())) - // Standard Error: 5_306 - .saturating_add(Weight::from_parts(38_886, 0).saturating_mul(m.into())) - // Standard Error: 5_134 - .saturating_add(Weight::from_parts(455_614, 0).saturating_mul(p.into())) + // Standard Error: 278 + .saturating_add(Weight::from_parts(3_568, 0).saturating_mul(b.into())) + // Standard Error: 2_957 + .saturating_add(Weight::from_parts(39_984, 0).saturating_mul(m.into())) + // Standard Error: 2_861 + .saturating_add(Weight::from_parts(244_445, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(4)) .saturating_add(T::DbWeight::get().writes(3)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(b.into())) .saturating_add(Weight::from_parts(0, 65).saturating_mul(m.into())) .saturating_add(Weight::from_parts(0, 40).saturating_mul(p.into())) } - /// Storage: Council Voting (r:1 w:1) - /// Proof Skipped: Council Voting (max_values: None, max_size: None, mode: Measured) - /// Storage: Council Members (r:1 w:0) - /// Proof Skipped: Council Members (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: Council Prime (r:1 w:0) - /// Proof Skipped: Council Prime (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: Council Proposals (r:1 w:1) - /// Proof Skipped: Council Proposals (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: Council ProposalOf (r:0 w:1) - /// Proof Skipped: Council ProposalOf (max_values: None, max_size: None, mode: Measured) + /// Storage: `Council::Voting` (r:1 w:1) + /// Proof: `Council::Voting` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Council::Members` (r:1 w:0) + /// Proof: `Council::Members` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `Council::Prime` (r:1 w:0) + /// Proof: `Council::Prime` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `Council::Proposals` (r:1 w:1) + /// Proof: `Council::Proposals` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `Council::ProposalOf` (r:0 w:1) + /// Proof: `Council::ProposalOf` (`max_values`: None, `max_size`: None, mode: `Measured`) /// The range of component `m` is `[4, 100]`. /// The range of component `p` is `[1, 100]`. fn close_disapproved(m: u32, p: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `488 + m * (64 ±0) + p * (35 ±0)` // Estimated: `3876 + m * (65 ±0) + p * (36 ±0)` - // Minimum execution time: 44_262_000 picoseconds. - Weight::from_parts(37_338_317, 0) + // Minimum execution time: 30_613_000 picoseconds. + Weight::from_parts(30_257_113, 0) .saturating_add(Weight::from_parts(0, 3876)) - // Standard Error: 3_148 - .saturating_add(Weight::from_parts(106_410, 0).saturating_mul(m.into())) - // Standard Error: 3_045 - .saturating_add(Weight::from_parts(323_416, 0).saturating_mul(p.into())) + // Standard Error: 1_996 + .saturating_add(Weight::from_parts(45_575, 0).saturating_mul(m.into())) + // Standard Error: 1_930 + .saturating_add(Weight::from_parts(198_080, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(4)) .saturating_add(T::DbWeight::get().writes(3)) .saturating_add(Weight::from_parts(0, 65).saturating_mul(m.into())) .saturating_add(Weight::from_parts(0, 36).saturating_mul(p.into())) } - /// Storage: Council Voting (r:1 w:1) - /// Proof Skipped: Council Voting (max_values: None, max_size: None, mode: Measured) - /// Storage: Council Members (r:1 w:0) - /// Proof Skipped: Council Members (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: Council Prime (r:1 w:0) - /// Proof Skipped: Council Prime (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: Council ProposalOf (r:1 w:1) - /// Proof Skipped: Council ProposalOf (max_values: None, max_size: None, mode: Measured) - /// Storage: Council Proposals (r:1 w:1) - /// Proof Skipped: Council Proposals (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: `Council::Voting` (r:1 w:1) + /// Proof: `Council::Voting` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Council::Members` (r:1 w:0) + /// Proof: `Council::Members` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `Council::Prime` (r:1 w:0) + /// Proof: `Council::Prime` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `Council::ProposalOf` (r:1 w:1) + /// Proof: `Council::ProposalOf` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Council::Proposals` (r:1 w:1) + /// Proof: `Council::Proposals` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) /// The range of component `b` is `[2, 1024]`. /// The range of component `m` is `[4, 100]`. /// The range of component `p` is `[1, 100]`. @@ -266,37 +266,37 @@ impl pallet_collective::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `798 + m * (64 ±0) + p * (39 ±0)` // Estimated: `4137 + b * (1 ±0) + m * (65 ±0) + p * (40 ±0)` - // Minimum execution time: 60_302_000 picoseconds. - Weight::from_parts(50_033_615, 0) + // Minimum execution time: 41_992_000 picoseconds. + Weight::from_parts(41_104_224, 0) .saturating_add(Weight::from_parts(0, 4137)) - // Standard Error: 515 - .saturating_add(Weight::from_parts(10_303, 0).saturating_mul(b.into())) - // Standard Error: 5_471 - .saturating_add(Weight::from_parts(108_478, 0).saturating_mul(m.into())) - // Standard Error: 5_294 - .saturating_add(Weight::from_parts(428_182, 0).saturating_mul(p.into())) + // Standard Error: 286 + .saturating_add(Weight::from_parts(6_229, 0).saturating_mul(b.into())) + // Standard Error: 3_038 + .saturating_add(Weight::from_parts(34_790, 0).saturating_mul(m.into())) + // Standard Error: 2_939 + .saturating_add(Weight::from_parts(257_557, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(5)) .saturating_add(T::DbWeight::get().writes(3)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(b.into())) .saturating_add(Weight::from_parts(0, 65).saturating_mul(m.into())) .saturating_add(Weight::from_parts(0, 40).saturating_mul(p.into())) } - /// Storage: Council Proposals (r:1 w:1) - /// Proof Skipped: Council Proposals (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: Council Voting (r:0 w:1) - /// Proof Skipped: Council Voting (max_values: None, max_size: None, mode: Measured) - /// Storage: Council ProposalOf (r:0 w:1) - /// Proof Skipped: Council ProposalOf (max_values: None, max_size: None, mode: Measured) + /// Storage: `Council::Proposals` (r:1 w:1) + /// Proof: `Council::Proposals` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `Council::Voting` (r:0 w:1) + /// Proof: `Council::Voting` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Council::ProposalOf` (r:0 w:1) + /// Proof: `Council::ProposalOf` (`max_values`: None, `max_size`: None, mode: `Measured`) /// The range of component `p` is `[1, 100]`. fn disapprove_proposal(p: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `259 + p * (32 ±0)` // Estimated: `1745 + p * (32 ±0)` - // Minimum execution time: 22_405_000 picoseconds. - Weight::from_parts(24_485_414, 0) + // Minimum execution time: 14_911_000 picoseconds. + Weight::from_parts(16_891_474, 0) .saturating_add(Weight::from_parts(0, 1745)) - // Standard Error: 2_398 - .saturating_add(Weight::from_parts(272_317, 0).saturating_mul(p.into())) + // Standard Error: 1_968 + .saturating_add(Weight::from_parts(182_344, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(3)) .saturating_add(Weight::from_parts(0, 32).saturating_mul(p.into())) diff --git a/runtime/paseo/src/weights/pallet_democracy.rs b/runtime/paseo/src/weights/pallet_democracy.rs index 7e5417f379..c1d05abe63 100644 --- a/runtime/paseo/src/weights/pallet_democracy.rs +++ b/runtime/paseo/src/weights/pallet_democracy.rs @@ -17,10 +17,10 @@ //! Autogenerated weights for `pallet_democracy` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-10-17, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-08-28, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `parachain-benchmark`, CPU: `Intel(R) Xeon(R) Platinum 8259CL CPU @ 2.50GHz` -//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("rococo-dev"), DB CACHE: 20 +//! HOSTNAME: `litentry-benchmark-server`, CPU: `Intel(R) Xeon(R) CPU E5-2686 v4 @ 2.30GHz` +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("rococo-dev")`, DB CACHE: 20 // Executed Command: // ./litentry-collator @@ -49,477 +49,477 @@ use core::marker::PhantomData; /// Weight functions for `pallet_democracy`. pub struct WeightInfo(PhantomData); impl pallet_democracy::WeightInfo for WeightInfo { - /// Storage: Democracy PublicPropCount (r:1 w:1) - /// Proof: Democracy PublicPropCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen) - /// Storage: Democracy PublicProps (r:1 w:1) - /// Proof: Democracy PublicProps (max_values: Some(1), max_size: Some(16702), added: 17197, mode: MaxEncodedLen) - /// Storage: Democracy Blacklist (r:1 w:0) - /// Proof: Democracy Blacklist (max_values: None, max_size: Some(3238), added: 5713, mode: MaxEncodedLen) - /// Storage: Democracy DepositOf (r:0 w:1) - /// Proof: Democracy DepositOf (max_values: None, max_size: Some(3230), added: 5705, mode: MaxEncodedLen) + /// Storage: `Democracy::PublicPropCount` (r:1 w:1) + /// Proof: `Democracy::PublicPropCount` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) + /// Storage: `Democracy::PublicProps` (r:1 w:1) + /// Proof: `Democracy::PublicProps` (`max_values`: Some(1), `max_size`: Some(16702), added: 17197, mode: `MaxEncodedLen`) + /// Storage: `Democracy::Blacklist` (r:1 w:0) + /// Proof: `Democracy::Blacklist` (`max_values`: None, `max_size`: Some(3238), added: 5713, mode: `MaxEncodedLen`) + /// Storage: `Democracy::DepositOf` (r:0 w:1) + /// Proof: `Democracy::DepositOf` (`max_values`: None, `max_size`: Some(3230), added: 5705, mode: `MaxEncodedLen`) fn propose() -> Weight { // Proof Size summary in bytes: // Measured: `4734` // Estimated: `18187` - // Minimum execution time: 68_501_000 picoseconds. - Weight::from_parts(73_004_000, 0) + // Minimum execution time: 47_135_000 picoseconds. + Weight::from_parts(50_506_000, 0) .saturating_add(Weight::from_parts(0, 18187)) .saturating_add(T::DbWeight::get().reads(3)) .saturating_add(T::DbWeight::get().writes(3)) } - /// Storage: Democracy DepositOf (r:1 w:1) - /// Proof: Democracy DepositOf (max_values: None, max_size: Some(3230), added: 5705, mode: MaxEncodedLen) + /// Storage: `Democracy::DepositOf` (r:1 w:1) + /// Proof: `Democracy::DepositOf` (`max_values`: None, `max_size`: Some(3230), added: 5705, mode: `MaxEncodedLen`) fn second() -> Weight { // Proof Size summary in bytes: // Measured: `3489` // Estimated: `6695` - // Minimum execution time: 60_988_000 picoseconds. - Weight::from_parts(67_951_000, 0) + // Minimum execution time: 40_561_000 picoseconds. + Weight::from_parts(43_857_000, 0) .saturating_add(Weight::from_parts(0, 6695)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: Democracy ReferendumInfoOf (r:1 w:1) - /// Proof: Democracy ReferendumInfoOf (max_values: None, max_size: Some(201), added: 2676, mode: MaxEncodedLen) - /// Storage: Democracy VotingOf (r:1 w:1) - /// Proof: Democracy VotingOf (max_values: None, max_size: Some(3795), added: 6270, mode: MaxEncodedLen) - /// Storage: Balances Locks (r:1 w:1) - /// Proof: Balances Locks (max_values: None, max_size: Some(1299), added: 3774, mode: MaxEncodedLen) - /// Storage: Balances Freezes (r:1 w:0) - /// Proof: Balances Freezes (max_values: None, max_size: Some(49), added: 2524, mode: MaxEncodedLen) + /// Storage: `Democracy::ReferendumInfoOf` (r:1 w:1) + /// Proof: `Democracy::ReferendumInfoOf` (`max_values`: None, `max_size`: Some(201), added: 2676, mode: `MaxEncodedLen`) + /// Storage: `Democracy::VotingOf` (r:1 w:1) + /// Proof: `Democracy::VotingOf` (`max_values`: None, `max_size`: Some(3795), added: 6270, mode: `MaxEncodedLen`) + /// Storage: `Balances::Locks` (r:1 w:1) + /// Proof: `Balances::Locks` (`max_values`: None, `max_size`: Some(1299), added: 3774, mode: `MaxEncodedLen`) + /// Storage: `Balances::Freezes` (r:1 w:0) + /// Proof: `Balances::Freezes` (`max_values`: None, `max_size`: Some(49), added: 2524, mode: `MaxEncodedLen`) fn vote_new() -> Weight { // Proof Size summary in bytes: // Measured: `3365` // Estimated: `7260` - // Minimum execution time: 81_593_000 picoseconds. - Weight::from_parts(98_345_000, 0) + // Minimum execution time: 55_662_000 picoseconds. + Weight::from_parts(62_595_000, 0) .saturating_add(Weight::from_parts(0, 7260)) .saturating_add(T::DbWeight::get().reads(4)) .saturating_add(T::DbWeight::get().writes(3)) } - /// Storage: Democracy ReferendumInfoOf (r:1 w:1) - /// Proof: Democracy ReferendumInfoOf (max_values: None, max_size: Some(201), added: 2676, mode: MaxEncodedLen) - /// Storage: Democracy VotingOf (r:1 w:1) - /// Proof: Democracy VotingOf (max_values: None, max_size: Some(3795), added: 6270, mode: MaxEncodedLen) - /// Storage: Balances Locks (r:1 w:1) - /// Proof: Balances Locks (max_values: None, max_size: Some(1299), added: 3774, mode: MaxEncodedLen) - /// Storage: Balances Freezes (r:1 w:0) - /// Proof: Balances Freezes (max_values: None, max_size: Some(49), added: 2524, mode: MaxEncodedLen) + /// Storage: `Democracy::ReferendumInfoOf` (r:1 w:1) + /// Proof: `Democracy::ReferendumInfoOf` (`max_values`: None, `max_size`: Some(201), added: 2676, mode: `MaxEncodedLen`) + /// Storage: `Democracy::VotingOf` (r:1 w:1) + /// Proof: `Democracy::VotingOf` (`max_values`: None, `max_size`: Some(3795), added: 6270, mode: `MaxEncodedLen`) + /// Storage: `Balances::Locks` (r:1 w:1) + /// Proof: `Balances::Locks` (`max_values`: None, `max_size`: Some(1299), added: 3774, mode: `MaxEncodedLen`) + /// Storage: `Balances::Freezes` (r:1 w:0) + /// Proof: `Balances::Freezes` (`max_values`: None, `max_size`: Some(49), added: 2524, mode: `MaxEncodedLen`) fn vote_existing() -> Weight { // Proof Size summary in bytes: // Measured: `3387` // Estimated: `7260` - // Minimum execution time: 90_734_000 picoseconds. - Weight::from_parts(100_906_000, 0) + // Minimum execution time: 62_188_000 picoseconds. + Weight::from_parts(67_185_000, 0) .saturating_add(Weight::from_parts(0, 7260)) .saturating_add(T::DbWeight::get().reads(4)) .saturating_add(T::DbWeight::get().writes(3)) } - /// Storage: Democracy ReferendumInfoOf (r:1 w:1) - /// Proof: Democracy ReferendumInfoOf (max_values: None, max_size: Some(201), added: 2676, mode: MaxEncodedLen) - /// Storage: Democracy Cancellations (r:1 w:1) - /// Proof: Democracy Cancellations (max_values: None, max_size: Some(33), added: 2508, mode: MaxEncodedLen) - /// Storage: Democracy MetadataOf (r:1 w:1) - /// Proof: Democracy MetadataOf (max_values: None, max_size: Some(53), added: 2528, mode: MaxEncodedLen) + /// Storage: `Democracy::ReferendumInfoOf` (r:1 w:1) + /// Proof: `Democracy::ReferendumInfoOf` (`max_values`: None, `max_size`: Some(201), added: 2676, mode: `MaxEncodedLen`) + /// Storage: `Democracy::Cancellations` (r:1 w:1) + /// Proof: `Democracy::Cancellations` (`max_values`: None, `max_size`: Some(33), added: 2508, mode: `MaxEncodedLen`) + /// Storage: `Democracy::MetadataOf` (r:1 w:1) + /// Proof: `Democracy::MetadataOf` (`max_values`: None, `max_size`: Some(53), added: 2528, mode: `MaxEncodedLen`) fn emergency_cancel() -> Weight { // Proof Size summary in bytes: // Measured: `299` // Estimated: `3666` - // Minimum execution time: 38_133_000 picoseconds. - Weight::from_parts(39_819_000, 0) + // Minimum execution time: 26_674_000 picoseconds. + Weight::from_parts(27_415_000, 0) .saturating_add(Weight::from_parts(0, 3666)) .saturating_add(T::DbWeight::get().reads(3)) .saturating_add(T::DbWeight::get().writes(3)) } - /// Storage: Democracy PublicProps (r:1 w:1) - /// Proof: Democracy PublicProps (max_values: Some(1), max_size: Some(16702), added: 17197, mode: MaxEncodedLen) - /// Storage: Democracy DepositOf (r:1 w:1) - /// Proof: Democracy DepositOf (max_values: None, max_size: Some(3230), added: 5705, mode: MaxEncodedLen) - /// Storage: System Account (r:2 w:2) - /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) - /// Storage: Democracy MetadataOf (r:3 w:1) - /// Proof: Democracy MetadataOf (max_values: None, max_size: Some(53), added: 2528, mode: MaxEncodedLen) - /// Storage: Democracy NextExternal (r:1 w:1) - /// Proof: Democracy NextExternal (max_values: Some(1), max_size: Some(132), added: 627, mode: MaxEncodedLen) - /// Storage: Democracy ReferendumInfoOf (r:1 w:1) - /// Proof: Democracy ReferendumInfoOf (max_values: None, max_size: Some(201), added: 2676, mode: MaxEncodedLen) - /// Storage: Democracy Blacklist (r:0 w:1) - /// Proof: Democracy Blacklist (max_values: None, max_size: Some(3238), added: 5713, mode: MaxEncodedLen) + /// Storage: `Democracy::PublicProps` (r:1 w:1) + /// Proof: `Democracy::PublicProps` (`max_values`: Some(1), `max_size`: Some(16702), added: 17197, mode: `MaxEncodedLen`) + /// Storage: `Democracy::DepositOf` (r:1 w:1) + /// Proof: `Democracy::DepositOf` (`max_values`: None, `max_size`: Some(3230), added: 5705, mode: `MaxEncodedLen`) + /// Storage: `System::Account` (r:2 w:2) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) + /// Storage: `Democracy::MetadataOf` (r:3 w:1) + /// Proof: `Democracy::MetadataOf` (`max_values`: None, `max_size`: Some(53), added: 2528, mode: `MaxEncodedLen`) + /// Storage: `Democracy::NextExternal` (r:1 w:1) + /// Proof: `Democracy::NextExternal` (`max_values`: Some(1), `max_size`: Some(132), added: 627, mode: `MaxEncodedLen`) + /// Storage: `Democracy::ReferendumInfoOf` (r:1 w:1) + /// Proof: `Democracy::ReferendumInfoOf` (`max_values`: None, `max_size`: Some(201), added: 2676, mode: `MaxEncodedLen`) + /// Storage: `Democracy::Blacklist` (r:0 w:1) + /// Proof: `Democracy::Blacklist` (`max_values`: None, `max_size`: Some(3238), added: 5713, mode: `MaxEncodedLen`) fn blacklist() -> Weight { // Proof Size summary in bytes: // Measured: `6182` // Estimated: `18187` - // Minimum execution time: 154_774_000 picoseconds. - Weight::from_parts(162_834_000, 0) + // Minimum execution time: 112_290_000 picoseconds. + Weight::from_parts(120_955_000, 0) .saturating_add(Weight::from_parts(0, 18187)) .saturating_add(T::DbWeight::get().reads(9)) .saturating_add(T::DbWeight::get().writes(8)) } - /// Storage: Democracy NextExternal (r:1 w:1) - /// Proof: Democracy NextExternal (max_values: Some(1), max_size: Some(132), added: 627, mode: MaxEncodedLen) - /// Storage: Democracy Blacklist (r:1 w:0) - /// Proof: Democracy Blacklist (max_values: None, max_size: Some(3238), added: 5713, mode: MaxEncodedLen) + /// Storage: `Democracy::NextExternal` (r:1 w:1) + /// Proof: `Democracy::NextExternal` (`max_values`: Some(1), `max_size`: Some(132), added: 627, mode: `MaxEncodedLen`) + /// Storage: `Democracy::Blacklist` (r:1 w:0) + /// Proof: `Democracy::Blacklist` (`max_values`: None, `max_size`: Some(3238), added: 5713, mode: `MaxEncodedLen`) fn external_propose() -> Weight { // Proof Size summary in bytes: // Measured: `3349` // Estimated: `6703` - // Minimum execution time: 18_234_000 picoseconds. - Weight::from_parts(18_660_000, 0) + // Minimum execution time: 12_980_000 picoseconds. + Weight::from_parts(13_511_000, 0) .saturating_add(Weight::from_parts(0, 6703)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: Democracy NextExternal (r:0 w:1) - /// Proof: Democracy NextExternal (max_values: Some(1), max_size: Some(132), added: 627, mode: MaxEncodedLen) + /// Storage: `Democracy::NextExternal` (r:0 w:1) + /// Proof: `Democracy::NextExternal` (`max_values`: Some(1), `max_size`: Some(132), added: 627, mode: `MaxEncodedLen`) fn external_propose_majority() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 4_748_000 picoseconds. - Weight::from_parts(4_950_000, 0) + // Minimum execution time: 3_157_000 picoseconds. + Weight::from_parts(3_417_000, 0) .saturating_add(Weight::from_parts(0, 0)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: Democracy NextExternal (r:0 w:1) - /// Proof: Democracy NextExternal (max_values: Some(1), max_size: Some(132), added: 627, mode: MaxEncodedLen) + /// Storage: `Democracy::NextExternal` (r:0 w:1) + /// Proof: `Democracy::NextExternal` (`max_values`: Some(1), `max_size`: Some(132), added: 627, mode: `MaxEncodedLen`) fn external_propose_default() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 4_868_000 picoseconds. - Weight::from_parts(5_087_000, 0) + // Minimum execution time: 3_266_000 picoseconds. + Weight::from_parts(3_510_000, 0) .saturating_add(Weight::from_parts(0, 0)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: Democracy NextExternal (r:1 w:1) - /// Proof: Democracy NextExternal (max_values: Some(1), max_size: Some(132), added: 627, mode: MaxEncodedLen) - /// Storage: Democracy ReferendumCount (r:1 w:1) - /// Proof: Democracy ReferendumCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen) - /// Storage: Democracy MetadataOf (r:1 w:2) - /// Proof: Democracy MetadataOf (max_values: None, max_size: Some(53), added: 2528, mode: MaxEncodedLen) - /// Storage: Democracy ReferendumInfoOf (r:0 w:1) - /// Proof: Democracy ReferendumInfoOf (max_values: None, max_size: Some(201), added: 2676, mode: MaxEncodedLen) + /// Storage: `Democracy::NextExternal` (r:1 w:1) + /// Proof: `Democracy::NextExternal` (`max_values`: Some(1), `max_size`: Some(132), added: 627, mode: `MaxEncodedLen`) + /// Storage: `Democracy::ReferendumCount` (r:1 w:1) + /// Proof: `Democracy::ReferendumCount` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) + /// Storage: `Democracy::MetadataOf` (r:1 w:2) + /// Proof: `Democracy::MetadataOf` (`max_values`: None, `max_size`: Some(53), added: 2528, mode: `MaxEncodedLen`) + /// Storage: `Democracy::ReferendumInfoOf` (r:0 w:1) + /// Proof: `Democracy::ReferendumInfoOf` (`max_values`: None, `max_size`: Some(201), added: 2676, mode: `MaxEncodedLen`) fn fast_track() -> Weight { // Proof Size summary in bytes: // Measured: `219` // Estimated: `3518` - // Minimum execution time: 38_631_000 picoseconds. - Weight::from_parts(39_319_000, 0) + // Minimum execution time: 27_475_000 picoseconds. + Weight::from_parts(28_199_000, 0) .saturating_add(Weight::from_parts(0, 3518)) .saturating_add(T::DbWeight::get().reads(3)) .saturating_add(T::DbWeight::get().writes(5)) } - /// Storage: Democracy NextExternal (r:1 w:1) - /// Proof: Democracy NextExternal (max_values: Some(1), max_size: Some(132), added: 627, mode: MaxEncodedLen) - /// Storage: Democracy Blacklist (r:1 w:1) - /// Proof: Democracy Blacklist (max_values: None, max_size: Some(3238), added: 5713, mode: MaxEncodedLen) - /// Storage: Democracy MetadataOf (r:1 w:1) - /// Proof: Democracy MetadataOf (max_values: None, max_size: Some(53), added: 2528, mode: MaxEncodedLen) + /// Storage: `Democracy::NextExternal` (r:1 w:1) + /// Proof: `Democracy::NextExternal` (`max_values`: Some(1), `max_size`: Some(132), added: 627, mode: `MaxEncodedLen`) + /// Storage: `Democracy::Blacklist` (r:1 w:1) + /// Proof: `Democracy::Blacklist` (`max_values`: None, `max_size`: Some(3238), added: 5713, mode: `MaxEncodedLen`) + /// Storage: `Democracy::MetadataOf` (r:1 w:1) + /// Proof: `Democracy::MetadataOf` (`max_values`: None, `max_size`: Some(53), added: 2528, mode: `MaxEncodedLen`) fn veto_external() -> Weight { // Proof Size summary in bytes: // Measured: `3452` // Estimated: `6703` - // Minimum execution time: 42_139_000 picoseconds. - Weight::from_parts(43_134_000, 0) + // Minimum execution time: 30_559_000 picoseconds. + Weight::from_parts(31_432_000, 0) .saturating_add(Weight::from_parts(0, 6703)) .saturating_add(T::DbWeight::get().reads(3)) .saturating_add(T::DbWeight::get().writes(3)) } - /// Storage: Democracy PublicProps (r:1 w:1) - /// Proof: Democracy PublicProps (max_values: Some(1), max_size: Some(16702), added: 17197, mode: MaxEncodedLen) - /// Storage: Democracy DepositOf (r:1 w:1) - /// Proof: Democracy DepositOf (max_values: None, max_size: Some(3230), added: 5705, mode: MaxEncodedLen) - /// Storage: System Account (r:2 w:2) - /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) - /// Storage: Democracy MetadataOf (r:1 w:1) - /// Proof: Democracy MetadataOf (max_values: None, max_size: Some(53), added: 2528, mode: MaxEncodedLen) + /// Storage: `Democracy::PublicProps` (r:1 w:1) + /// Proof: `Democracy::PublicProps` (`max_values`: Some(1), `max_size`: Some(16702), added: 17197, mode: `MaxEncodedLen`) + /// Storage: `Democracy::DepositOf` (r:1 w:1) + /// Proof: `Democracy::DepositOf` (`max_values`: None, `max_size`: Some(3230), added: 5705, mode: `MaxEncodedLen`) + /// Storage: `System::Account` (r:2 w:2) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) + /// Storage: `Democracy::MetadataOf` (r:1 w:1) + /// Proof: `Democracy::MetadataOf` (`max_values`: None, `max_size`: Some(53), added: 2528, mode: `MaxEncodedLen`) fn cancel_proposal() -> Weight { // Proof Size summary in bytes: // Measured: `6093` // Estimated: `18187` - // Minimum execution time: 130_460_000 picoseconds. - Weight::from_parts(140_884_000, 0) + // Minimum execution time: 93_105_000 picoseconds. + Weight::from_parts(96_978_000, 0) .saturating_add(Weight::from_parts(0, 18187)) .saturating_add(T::DbWeight::get().reads(5)) .saturating_add(T::DbWeight::get().writes(5)) } - /// Storage: Democracy MetadataOf (r:1 w:1) - /// Proof: Democracy MetadataOf (max_values: None, max_size: Some(53), added: 2528, mode: MaxEncodedLen) - /// Storage: Democracy ReferendumInfoOf (r:0 w:1) - /// Proof: Democracy ReferendumInfoOf (max_values: None, max_size: Some(201), added: 2676, mode: MaxEncodedLen) + /// Storage: `Democracy::MetadataOf` (r:1 w:1) + /// Proof: `Democracy::MetadataOf` (`max_values`: None, `max_size`: Some(53), added: 2528, mode: `MaxEncodedLen`) + /// Storage: `Democracy::ReferendumInfoOf` (r:0 w:1) + /// Proof: `Democracy::ReferendumInfoOf` (`max_values`: None, `max_size`: Some(201), added: 2676, mode: `MaxEncodedLen`) fn cancel_referendum() -> Weight { // Proof Size summary in bytes: // Measured: `204` // Estimated: `3518` - // Minimum execution time: 28_544_000 picoseconds. - Weight::from_parts(29_389_000, 0) + // Minimum execution time: 19_693_000 picoseconds. + Weight::from_parts(20_212_000, 0) .saturating_add(Weight::from_parts(0, 3518)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(2)) } - /// Storage: Democracy LowestUnbaked (r:1 w:1) - /// Proof: Democracy LowestUnbaked (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen) - /// Storage: Democracy ReferendumCount (r:1 w:0) - /// Proof: Democracy ReferendumCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen) - /// Storage: Democracy ReferendumInfoOf (r:99 w:0) - /// Proof: Democracy ReferendumInfoOf (max_values: None, max_size: Some(201), added: 2676, mode: MaxEncodedLen) + /// Storage: `Democracy::LowestUnbaked` (r:1 w:1) + /// Proof: `Democracy::LowestUnbaked` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) + /// Storage: `Democracy::ReferendumCount` (r:1 w:0) + /// Proof: `Democracy::ReferendumCount` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) + /// Storage: `Democracy::ReferendumInfoOf` (r:99 w:0) + /// Proof: `Democracy::ReferendumInfoOf` (`max_values`: None, `max_size`: Some(201), added: 2676, mode: `MaxEncodedLen`) /// The range of component `r` is `[0, 99]`. fn on_initialize_base(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `176 + r * (86 ±0)` // Estimated: `1489 + r * (2676 ±0)` - // Minimum execution time: 9_538_000 picoseconds. - Weight::from_parts(6_188_260, 0) + // Minimum execution time: 7_043_000 picoseconds. + Weight::from_parts(9_128_994, 0) .saturating_add(Weight::from_parts(0, 1489)) - // Standard Error: 28_622 - .saturating_add(Weight::from_parts(4_480_990, 0).saturating_mul(r.into())) + // Standard Error: 12_845 + .saturating_add(Weight::from_parts(3_221_856, 0).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into()))) .saturating_add(T::DbWeight::get().writes(1)) .saturating_add(Weight::from_parts(0, 2676).saturating_mul(r.into())) } - /// Storage: Democracy LowestUnbaked (r:1 w:1) - /// Proof: Democracy LowestUnbaked (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen) - /// Storage: Democracy ReferendumCount (r:1 w:0) - /// Proof: Democracy ReferendumCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen) - /// Storage: Democracy LastTabledWasExternal (r:1 w:0) - /// Proof: Democracy LastTabledWasExternal (max_values: Some(1), max_size: Some(1), added: 496, mode: MaxEncodedLen) - /// Storage: Democracy NextExternal (r:1 w:0) - /// Proof: Democracy NextExternal (max_values: Some(1), max_size: Some(132), added: 627, mode: MaxEncodedLen) - /// Storage: Democracy PublicProps (r:1 w:0) - /// Proof: Democracy PublicProps (max_values: Some(1), max_size: Some(16702), added: 17197, mode: MaxEncodedLen) - /// Storage: Democracy ReferendumInfoOf (r:99 w:0) - /// Proof: Democracy ReferendumInfoOf (max_values: None, max_size: Some(201), added: 2676, mode: MaxEncodedLen) + /// Storage: `Democracy::LowestUnbaked` (r:1 w:1) + /// Proof: `Democracy::LowestUnbaked` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) + /// Storage: `Democracy::ReferendumCount` (r:1 w:0) + /// Proof: `Democracy::ReferendumCount` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) + /// Storage: `Democracy::LastTabledWasExternal` (r:1 w:0) + /// Proof: `Democracy::LastTabledWasExternal` (`max_values`: Some(1), `max_size`: Some(1), added: 496, mode: `MaxEncodedLen`) + /// Storage: `Democracy::NextExternal` (r:1 w:0) + /// Proof: `Democracy::NextExternal` (`max_values`: Some(1), `max_size`: Some(132), added: 627, mode: `MaxEncodedLen`) + /// Storage: `Democracy::PublicProps` (r:1 w:0) + /// Proof: `Democracy::PublicProps` (`max_values`: Some(1), `max_size`: Some(16702), added: 17197, mode: `MaxEncodedLen`) + /// Storage: `Democracy::ReferendumInfoOf` (r:99 w:0) + /// Proof: `Democracy::ReferendumInfoOf` (`max_values`: None, `max_size`: Some(201), added: 2676, mode: `MaxEncodedLen`) /// The range of component `r` is `[0, 99]`. fn on_initialize_base_with_launch_period(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `176 + r * (86 ±0)` // Estimated: `18187 + r * (2676 ±0)` - // Minimum execution time: 13_664_000 picoseconds. - Weight::from_parts(13_054_634, 0) + // Minimum execution time: 10_018_000 picoseconds. + Weight::from_parts(8_772_022, 0) .saturating_add(Weight::from_parts(0, 18187)) - // Standard Error: 37_836 - .saturating_add(Weight::from_parts(4_480_067, 0).saturating_mul(r.into())) + // Standard Error: 24_683 + .saturating_add(Weight::from_parts(3_366_083, 0).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(5)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into()))) .saturating_add(T::DbWeight::get().writes(1)) .saturating_add(Weight::from_parts(0, 2676).saturating_mul(r.into())) } - /// Storage: Democracy VotingOf (r:3 w:3) - /// Proof: Democracy VotingOf (max_values: None, max_size: Some(3795), added: 6270, mode: MaxEncodedLen) - /// Storage: Democracy ReferendumInfoOf (r:99 w:99) - /// Proof: Democracy ReferendumInfoOf (max_values: None, max_size: Some(201), added: 2676, mode: MaxEncodedLen) - /// Storage: Balances Locks (r:1 w:1) - /// Proof: Balances Locks (max_values: None, max_size: Some(1299), added: 3774, mode: MaxEncodedLen) - /// Storage: Balances Freezes (r:1 w:0) - /// Proof: Balances Freezes (max_values: None, max_size: Some(49), added: 2524, mode: MaxEncodedLen) + /// Storage: `Democracy::VotingOf` (r:3 w:3) + /// Proof: `Democracy::VotingOf` (`max_values`: None, `max_size`: Some(3795), added: 6270, mode: `MaxEncodedLen`) + /// Storage: `Democracy::ReferendumInfoOf` (r:99 w:99) + /// Proof: `Democracy::ReferendumInfoOf` (`max_values`: None, `max_size`: Some(201), added: 2676, mode: `MaxEncodedLen`) + /// Storage: `Balances::Locks` (r:1 w:1) + /// Proof: `Balances::Locks` (`max_values`: None, `max_size`: Some(1299), added: 3774, mode: `MaxEncodedLen`) + /// Storage: `Balances::Freezes` (r:1 w:0) + /// Proof: `Balances::Freezes` (`max_values`: None, `max_size`: Some(49), added: 2524, mode: `MaxEncodedLen`) /// The range of component `r` is `[0, 99]`. fn delegate(r: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `726 + r * (108 ±0)` + // Measured: `727 + r * (108 ±0)` // Estimated: `19800 + r * (2676 ±0)` - // Minimum execution time: 55_326_000 picoseconds. - Weight::from_parts(44_210_870, 0) + // Minimum execution time: 39_191_000 picoseconds. + Weight::from_parts(47_705_035, 0) .saturating_add(Weight::from_parts(0, 19800)) - // Standard Error: 40_411 - .saturating_add(Weight::from_parts(6_248_306, 0).saturating_mul(r.into())) + // Standard Error: 22_056 + .saturating_add(Weight::from_parts(4_143_626, 0).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(5)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into()))) .saturating_add(T::DbWeight::get().writes(4)) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(r.into()))) .saturating_add(Weight::from_parts(0, 2676).saturating_mul(r.into())) } - /// Storage: Democracy VotingOf (r:2 w:2) - /// Proof: Democracy VotingOf (max_values: None, max_size: Some(3795), added: 6270, mode: MaxEncodedLen) - /// Storage: Democracy ReferendumInfoOf (r:99 w:99) - /// Proof: Democracy ReferendumInfoOf (max_values: None, max_size: Some(201), added: 2676, mode: MaxEncodedLen) + /// Storage: `Democracy::VotingOf` (r:2 w:2) + /// Proof: `Democracy::VotingOf` (`max_values`: None, `max_size`: Some(3795), added: 6270, mode: `MaxEncodedLen`) + /// Storage: `Democracy::ReferendumInfoOf` (r:99 w:99) + /// Proof: `Democracy::ReferendumInfoOf` (`max_values`: None, `max_size`: Some(201), added: 2676, mode: `MaxEncodedLen`) /// The range of component `r` is `[0, 99]`. fn undelegate(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `424 + r * (108 ±0)` // Estimated: `13530 + r * (2676 ±0)` - // Minimum execution time: 29_037_000 picoseconds. - Weight::from_parts(21_737_510, 0) + // Minimum execution time: 20_305_000 picoseconds. + Weight::from_parts(22_819_541, 0) .saturating_add(Weight::from_parts(0, 13530)) - // Standard Error: 36_345 - .saturating_add(Weight::from_parts(6_033_418, 0).saturating_mul(r.into())) + // Standard Error: 16_749 + .saturating_add(Weight::from_parts(4_112_400, 0).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into()))) .saturating_add(T::DbWeight::get().writes(2)) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(r.into()))) .saturating_add(Weight::from_parts(0, 2676).saturating_mul(r.into())) } - /// Storage: Democracy PublicProps (r:0 w:1) - /// Proof: Democracy PublicProps (max_values: Some(1), max_size: Some(16702), added: 17197, mode: MaxEncodedLen) + /// Storage: `Democracy::PublicProps` (r:0 w:1) + /// Proof: `Democracy::PublicProps` (`max_values`: Some(1), `max_size`: Some(16702), added: 17197, mode: `MaxEncodedLen`) fn clear_public_proposals() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 5_117_000 picoseconds. - Weight::from_parts(5_265_000, 0) + // Minimum execution time: 3_283_000 picoseconds. + Weight::from_parts(3_420_000, 0) .saturating_add(Weight::from_parts(0, 0)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: Democracy VotingOf (r:1 w:1) - /// Proof: Democracy VotingOf (max_values: None, max_size: Some(3795), added: 6270, mode: MaxEncodedLen) - /// Storage: Balances Locks (r:1 w:1) - /// Proof: Balances Locks (max_values: None, max_size: Some(1299), added: 3774, mode: MaxEncodedLen) - /// Storage: Balances Freezes (r:1 w:0) - /// Proof: Balances Freezes (max_values: None, max_size: Some(49), added: 2524, mode: MaxEncodedLen) - /// Storage: System Account (r:1 w:1) - /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + /// Storage: `Democracy::VotingOf` (r:1 w:1) + /// Proof: `Democracy::VotingOf` (`max_values`: None, `max_size`: Some(3795), added: 6270, mode: `MaxEncodedLen`) + /// Storage: `Balances::Locks` (r:1 w:1) + /// Proof: `Balances::Locks` (`max_values`: None, `max_size`: Some(1299), added: 3774, mode: `MaxEncodedLen`) + /// Storage: `Balances::Freezes` (r:1 w:0) + /// Proof: `Balances::Freezes` (`max_values`: None, `max_size`: Some(49), added: 2524, mode: `MaxEncodedLen`) + /// Storage: `System::Account` (r:1 w:1) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) /// The range of component `r` is `[0, 99]`. fn unlock_remove(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `421` // Estimated: `7260` - // Minimum execution time: 30_989_000 picoseconds. - Weight::from_parts(52_927_107, 0) + // Minimum execution time: 22_262_000 picoseconds. + Weight::from_parts(37_078_280, 0) .saturating_add(Weight::from_parts(0, 7260)) - // Standard Error: 12_137 - .saturating_add(Weight::from_parts(338_550, 0).saturating_mul(r.into())) + // Standard Error: 5_886 + .saturating_add(Weight::from_parts(152_633, 0).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(4)) .saturating_add(T::DbWeight::get().writes(3)) } - /// Storage: Democracy VotingOf (r:1 w:1) - /// Proof: Democracy VotingOf (max_values: None, max_size: Some(3795), added: 6270, mode: MaxEncodedLen) - /// Storage: Balances Locks (r:1 w:1) - /// Proof: Balances Locks (max_values: None, max_size: Some(1299), added: 3774, mode: MaxEncodedLen) - /// Storage: Balances Freezes (r:1 w:0) - /// Proof: Balances Freezes (max_values: None, max_size: Some(49), added: 2524, mode: MaxEncodedLen) - /// Storage: System Account (r:1 w:1) - /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + /// Storage: `Democracy::VotingOf` (r:1 w:1) + /// Proof: `Democracy::VotingOf` (`max_values`: None, `max_size`: Some(3795), added: 6270, mode: `MaxEncodedLen`) + /// Storage: `Balances::Locks` (r:1 w:1) + /// Proof: `Balances::Locks` (`max_values`: None, `max_size`: Some(1299), added: 3774, mode: `MaxEncodedLen`) + /// Storage: `Balances::Freezes` (r:1 w:0) + /// Proof: `Balances::Freezes` (`max_values`: None, `max_size`: Some(49), added: 2524, mode: `MaxEncodedLen`) + /// Storage: `System::Account` (r:1 w:1) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) /// The range of component `r` is `[0, 99]`. fn unlock_set(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `421 + r * (22 ±0)` // Estimated: `7260` - // Minimum execution time: 47_714_000 picoseconds. - Weight::from_parts(51_340_260, 0) + // Minimum execution time: 33_177_000 picoseconds. + Weight::from_parts(36_908_770, 0) .saturating_add(Weight::from_parts(0, 7260)) - // Standard Error: 4_665 - .saturating_add(Weight::from_parts(301_397, 0).saturating_mul(r.into())) + // Standard Error: 2_627 + .saturating_add(Weight::from_parts(151_786, 0).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(4)) .saturating_add(T::DbWeight::get().writes(3)) } - /// Storage: Democracy ReferendumInfoOf (r:1 w:1) - /// Proof: Democracy ReferendumInfoOf (max_values: None, max_size: Some(201), added: 2676, mode: MaxEncodedLen) - /// Storage: Democracy VotingOf (r:1 w:1) - /// Proof: Democracy VotingOf (max_values: None, max_size: Some(3795), added: 6270, mode: MaxEncodedLen) + /// Storage: `Democracy::ReferendumInfoOf` (r:1 w:1) + /// Proof: `Democracy::ReferendumInfoOf` (`max_values`: None, `max_size`: Some(201), added: 2676, mode: `MaxEncodedLen`) + /// Storage: `Democracy::VotingOf` (r:1 w:1) + /// Proof: `Democracy::VotingOf` (`max_values`: None, `max_size`: Some(3795), added: 6270, mode: `MaxEncodedLen`) /// The range of component `r` is `[1, 100]`. fn remove_vote(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `638 + r * (27 ±0)` // Estimated: `7260` - // Minimum execution time: 21_546_000 picoseconds. - Weight::from_parts(23_830_447, 0) + // Minimum execution time: 15_091_000 picoseconds. + Weight::from_parts(18_895_047, 0) .saturating_add(Weight::from_parts(0, 7260)) - // Standard Error: 3_456 - .saturating_add(Weight::from_parts(293_834, 0).saturating_mul(r.into())) + // Standard Error: 2_235 + .saturating_add(Weight::from_parts(143_124, 0).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) } - /// Storage: Democracy ReferendumInfoOf (r:1 w:1) - /// Proof: Democracy ReferendumInfoOf (max_values: None, max_size: Some(201), added: 2676, mode: MaxEncodedLen) - /// Storage: Democracy VotingOf (r:1 w:1) - /// Proof: Democracy VotingOf (max_values: None, max_size: Some(3795), added: 6270, mode: MaxEncodedLen) + /// Storage: `Democracy::ReferendumInfoOf` (r:1 w:1) + /// Proof: `Democracy::ReferendumInfoOf` (`max_values`: None, `max_size`: Some(201), added: 2676, mode: `MaxEncodedLen`) + /// Storage: `Democracy::VotingOf` (r:1 w:1) + /// Proof: `Democracy::VotingOf` (`max_values`: None, `max_size`: Some(3795), added: 6270, mode: `MaxEncodedLen`) /// The range of component `r` is `[1, 100]`. fn remove_other_vote(r: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `638 + r * (27 ±0)` // Estimated: `7260` - // Minimum execution time: 21_713_000 picoseconds. - Weight::from_parts(25_538_950, 0) + // Minimum execution time: 15_531_000 picoseconds. + Weight::from_parts(19_188_343, 0) .saturating_add(Weight::from_parts(0, 7260)) - // Standard Error: 5_129 - .saturating_add(Weight::from_parts(287_753, 0).saturating_mul(r.into())) + // Standard Error: 2_418 + .saturating_add(Weight::from_parts(140_473, 0).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) } - /// Storage: Democracy NextExternal (r:1 w:0) - /// Proof: Democracy NextExternal (max_values: Some(1), max_size: Some(132), added: 627, mode: MaxEncodedLen) - /// Storage: Preimage StatusFor (r:1 w:0) - /// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen) - /// Storage: Democracy MetadataOf (r:0 w:1) - /// Proof: Democracy MetadataOf (max_values: None, max_size: Some(53), added: 2528, mode: MaxEncodedLen) + /// Storage: `Democracy::NextExternal` (r:1 w:0) + /// Proof: `Democracy::NextExternal` (`max_values`: Some(1), `max_size`: Some(132), added: 627, mode: `MaxEncodedLen`) + /// Storage: `Preimage::StatusFor` (r:1 w:0) + /// Proof: `Preimage::StatusFor` (`max_values`: None, `max_size`: Some(91), added: 2566, mode: `MaxEncodedLen`) + /// Storage: `Democracy::MetadataOf` (r:0 w:1) + /// Proof: `Democracy::MetadataOf` (`max_values`: None, `max_size`: Some(53), added: 2528, mode: `MaxEncodedLen`) fn set_external_metadata() -> Weight { // Proof Size summary in bytes: // Measured: `323` // Estimated: `3556` - // Minimum execution time: 26_082_000 picoseconds. - Weight::from_parts(26_667_000, 0) + // Minimum execution time: 18_508_000 picoseconds. + Weight::from_parts(18_938_000, 0) .saturating_add(Weight::from_parts(0, 3556)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: Democracy NextExternal (r:1 w:0) - /// Proof: Democracy NextExternal (max_values: Some(1), max_size: Some(132), added: 627, mode: MaxEncodedLen) - /// Storage: Democracy MetadataOf (r:1 w:1) - /// Proof: Democracy MetadataOf (max_values: None, max_size: Some(53), added: 2528, mode: MaxEncodedLen) + /// Storage: `Democracy::NextExternal` (r:1 w:0) + /// Proof: `Democracy::NextExternal` (`max_values`: Some(1), `max_size`: Some(132), added: 627, mode: `MaxEncodedLen`) + /// Storage: `Democracy::MetadataOf` (r:1 w:1) + /// Proof: `Democracy::MetadataOf` (`max_values`: None, `max_size`: Some(53), added: 2528, mode: `MaxEncodedLen`) fn clear_external_metadata() -> Weight { // Proof Size summary in bytes: // Measured: `219` // Estimated: `3518` - // Minimum execution time: 24_174_000 picoseconds. - Weight::from_parts(24_697_000, 0) + // Minimum execution time: 16_462_000 picoseconds. + Weight::from_parts(16_989_000, 0) .saturating_add(Weight::from_parts(0, 3518)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: Democracy PublicProps (r:1 w:0) - /// Proof: Democracy PublicProps (max_values: Some(1), max_size: Some(16702), added: 17197, mode: MaxEncodedLen) - /// Storage: Preimage StatusFor (r:1 w:0) - /// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen) - /// Storage: Democracy MetadataOf (r:0 w:1) - /// Proof: Democracy MetadataOf (max_values: None, max_size: Some(53), added: 2528, mode: MaxEncodedLen) + /// Storage: `Democracy::PublicProps` (r:1 w:0) + /// Proof: `Democracy::PublicProps` (`max_values`: Some(1), `max_size`: Some(16702), added: 17197, mode: `MaxEncodedLen`) + /// Storage: `Preimage::StatusFor` (r:1 w:0) + /// Proof: `Preimage::StatusFor` (`max_values`: None, `max_size`: Some(91), added: 2566, mode: `MaxEncodedLen`) + /// Storage: `Democracy::MetadataOf` (r:0 w:1) + /// Proof: `Democracy::MetadataOf` (`max_values`: None, `max_size`: Some(53), added: 2528, mode: `MaxEncodedLen`) fn set_proposal_metadata() -> Weight { // Proof Size summary in bytes: // Measured: `4855` // Estimated: `18187` - // Minimum execution time: 60_980_000 picoseconds. - Weight::from_parts(66_004_000, 0) + // Minimum execution time: 40_830_000 picoseconds. + Weight::from_parts(43_038_000, 0) .saturating_add(Weight::from_parts(0, 18187)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: Democracy PublicProps (r:1 w:0) - /// Proof: Democracy PublicProps (max_values: Some(1), max_size: Some(16702), added: 17197, mode: MaxEncodedLen) - /// Storage: Democracy MetadataOf (r:1 w:1) - /// Proof: Democracy MetadataOf (max_values: None, max_size: Some(53), added: 2528, mode: MaxEncodedLen) + /// Storage: `Democracy::PublicProps` (r:1 w:0) + /// Proof: `Democracy::PublicProps` (`max_values`: Some(1), `max_size`: Some(16702), added: 17197, mode: `MaxEncodedLen`) + /// Storage: `Democracy::MetadataOf` (r:1 w:1) + /// Proof: `Democracy::MetadataOf` (`max_values`: None, `max_size`: Some(53), added: 2528, mode: `MaxEncodedLen`) fn clear_proposal_metadata() -> Weight { // Proof Size summary in bytes: // Measured: `4755` // Estimated: `18187` - // Minimum execution time: 55_795_000 picoseconds. - Weight::from_parts(60_205_000, 0) + // Minimum execution time: 38_130_000 picoseconds. + Weight::from_parts(40_840_000, 0) .saturating_add(Weight::from_parts(0, 18187)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: Preimage StatusFor (r:1 w:0) - /// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen) - /// Storage: Democracy MetadataOf (r:0 w:1) - /// Proof: Democracy MetadataOf (max_values: None, max_size: Some(53), added: 2528, mode: MaxEncodedLen) + /// Storage: `Preimage::StatusFor` (r:1 w:0) + /// Proof: `Preimage::StatusFor` (`max_values`: None, `max_size`: Some(91), added: 2566, mode: `MaxEncodedLen`) + /// Storage: `Democracy::MetadataOf` (r:0 w:1) + /// Proof: `Democracy::MetadataOf` (`max_values`: None, `max_size`: Some(53), added: 2528, mode: `MaxEncodedLen`) fn set_referendum_metadata() -> Weight { // Proof Size summary in bytes: // Measured: `178` // Estimated: `3556` - // Minimum execution time: 21_666_000 picoseconds. - Weight::from_parts(23_214_000, 0) + // Minimum execution time: 14_167_000 picoseconds. + Weight::from_parts(14_902_000, 0) .saturating_add(Weight::from_parts(0, 3556)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: Democracy ReferendumInfoOf (r:1 w:0) - /// Proof: Democracy ReferendumInfoOf (max_values: None, max_size: Some(201), added: 2676, mode: MaxEncodedLen) - /// Storage: Democracy MetadataOf (r:1 w:1) - /// Proof: Democracy MetadataOf (max_values: None, max_size: Some(53), added: 2528, mode: MaxEncodedLen) + /// Storage: `Democracy::ReferendumInfoOf` (r:1 w:0) + /// Proof: `Democracy::ReferendumInfoOf` (`max_values`: None, `max_size`: Some(201), added: 2676, mode: `MaxEncodedLen`) + /// Storage: `Democracy::MetadataOf` (r:1 w:1) + /// Proof: `Democracy::MetadataOf` (`max_values`: None, `max_size`: Some(53), added: 2528, mode: `MaxEncodedLen`) fn clear_referendum_metadata() -> Weight { // Proof Size summary in bytes: // Measured: `235` // Estimated: `3666` - // Minimum execution time: 26_874_000 picoseconds. - Weight::from_parts(27_807_000, 0) + // Minimum execution time: 18_959_000 picoseconds. + Weight::from_parts(19_645_000, 0) .saturating_add(Weight::from_parts(0, 3666)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(1)) diff --git a/runtime/paseo/src/weights/pallet_extrinsic_filter.rs b/runtime/paseo/src/weights/pallet_extrinsic_filter.rs index d0020f8a51..3ada00c439 100644 --- a/runtime/paseo/src/weights/pallet_extrinsic_filter.rs +++ b/runtime/paseo/src/weights/pallet_extrinsic_filter.rs @@ -17,10 +17,10 @@ //! Autogenerated weights for `pallet_extrinsic_filter` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-10-17, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-08-28, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `parachain-benchmark`, CPU: `Intel(R) Xeon(R) Platinum 8259CL CPU @ 2.50GHz` -//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("rococo-dev"), DB CACHE: 20 +//! HOSTNAME: `litentry-benchmark-server`, CPU: `Intel(R) Xeon(R) CPU E5-2686 v4 @ 2.30GHz` +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("rococo-dev")`, DB CACHE: 20 // Executed Command: // ./litentry-collator @@ -49,39 +49,39 @@ use core::marker::PhantomData; /// Weight functions for `pallet_extrinsic_filter`. pub struct WeightInfo(PhantomData); impl pallet_extrinsic_filter::WeightInfo for WeightInfo { - /// Storage: ExtrinsicFilter BlockedExtrinsics (r:1 w:1) - /// Proof Skipped: ExtrinsicFilter BlockedExtrinsics (max_values: None, max_size: None, mode: Measured) + /// Storage: `ExtrinsicFilter::BlockedExtrinsics` (r:1 w:1) + /// Proof: `ExtrinsicFilter::BlockedExtrinsics` (`max_values`: None, `max_size`: None, mode: `Measured`) /// The range of component `p` is `[1, 1024]`. /// The range of component `f` is `[1, 1024]`. fn block_extrinsics(p: u32, f: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 22_532_000 picoseconds. - Weight::from_parts(21_407_222, 0) + // Minimum execution time: 14_933_000 picoseconds. + Weight::from_parts(13_403_699, 0) .saturating_add(Weight::from_parts(0, 3607)) - // Standard Error: 134 - .saturating_add(Weight::from_parts(2_594, 0).saturating_mul(p.into())) - // Standard Error: 134 - .saturating_add(Weight::from_parts(2_945, 0).saturating_mul(f.into())) + // Standard Error: 86 + .saturating_add(Weight::from_parts(2_772, 0).saturating_mul(p.into())) + // Standard Error: 86 + .saturating_add(Weight::from_parts(2_313, 0).saturating_mul(f.into())) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: ExtrinsicFilter BlockedExtrinsics (r:1 w:1) - /// Proof Skipped: ExtrinsicFilter BlockedExtrinsics (max_values: None, max_size: None, mode: Measured) + /// Storage: `ExtrinsicFilter::BlockedExtrinsics` (r:1 w:1) + /// Proof: `ExtrinsicFilter::BlockedExtrinsics` (`max_values`: None, `max_size`: None, mode: `Measured`) /// The range of component `p` is `[1, 1024]`. /// The range of component `f` is `[1, 1024]`. fn unblock_extrinsics(p: u32, f: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `178 + f * (1 ±0) + p * (1 ±0)` // Estimated: `3644 + f * (1 ±0) + p * (1 ±0)` - // Minimum execution time: 34_403_000 picoseconds. - Weight::from_parts(23_998_401, 0) + // Minimum execution time: 24_081_000 picoseconds. + Weight::from_parts(14_828_975, 0) .saturating_add(Weight::from_parts(0, 3644)) - // Standard Error: 181 - .saturating_add(Weight::from_parts(13_204, 0).saturating_mul(p.into())) - // Standard Error: 181 - .saturating_add(Weight::from_parts(12_287, 0).saturating_mul(f.into())) + // Standard Error: 92 + .saturating_add(Weight::from_parts(10_321, 0).saturating_mul(p.into())) + // Standard Error: 92 + .saturating_add(Weight::from_parts(10_231, 0).saturating_mul(f.into())) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(f.into())) diff --git a/runtime/paseo/src/weights/pallet_identity_management.rs b/runtime/paseo/src/weights/pallet_identity_management.rs index f34c50665d..d2b0c90d35 100644 --- a/runtime/paseo/src/weights/pallet_identity_management.rs +++ b/runtime/paseo/src/weights/pallet_identity_management.rs @@ -17,10 +17,10 @@ //! Autogenerated weights for `pallet_identity_management` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-11-30, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-08-28, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `parachain-benchmark`, CPU: `Intel(R) Xeon(R) Platinum 8259CL CPU @ 2.50GHz` -//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("rococo-dev"), DB CACHE: 20 +//! HOSTNAME: `litentry-benchmark-server`, CPU: `Intel(R) Xeon(R) CPU E5-2686 v4 @ 2.30GHz` +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("rococo-dev")`, DB CACHE: 20 // Executed Command: // ./litentry-collator @@ -49,115 +49,115 @@ use core::marker::PhantomData; /// Weight functions for `pallet_identity_management`. pub struct WeightInfo(PhantomData); impl pallet_identity_management::WeightInfo for WeightInfo { - /// Storage: IdentityManagement Delegatee (r:0 w:1) - /// Proof: IdentityManagement Delegatee (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen) + /// Storage: `IdentityManagement::Delegatee` (r:0 w:1) + /// Proof: `IdentityManagement::Delegatee` (`max_values`: None, `max_size`: Some(48), added: 2523, mode: `MaxEncodedLen`) fn add_delegatee() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 13_843_000 picoseconds. - Weight::from_parts(14_244_000, 0) + // Minimum execution time: 8_549_000 picoseconds. + Weight::from_parts(8_919_000, 0) .saturating_add(Weight::from_parts(0, 0)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: IdentityManagement Delegatee (r:1 w:1) - /// Proof: IdentityManagement Delegatee (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen) + /// Storage: `IdentityManagement::Delegatee` (r:1 w:1) + /// Proof: `IdentityManagement::Delegatee` (`max_values`: None, `max_size`: Some(48), added: 2523, mode: `MaxEncodedLen`) fn remove_delegatee() -> Weight { // Proof Size summary in bytes: - // Measured: `79` + // Measured: `116` // Estimated: `3513` - // Minimum execution time: 19_880_000 picoseconds. - Weight::from_parts(20_277_000, 0) + // Minimum execution time: 12_876_000 picoseconds. + Weight::from_parts(13_453_000, 0) .saturating_add(Weight::from_parts(0, 3513)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: IMPExtrinsicWhitelist GroupControlOn (r:1 w:0) - /// Proof Skipped: IMPExtrinsicWhitelist GroupControlOn (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: `IMPExtrinsicWhitelist::GroupControlOn` (r:1 w:0) + /// Proof: `IMPExtrinsicWhitelist::GroupControlOn` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) fn link_identity() -> Weight { // Proof Size summary in bytes: - // Measured: `76` - // Estimated: `1561` - // Minimum execution time: 20_439_000 picoseconds. - Weight::from_parts(20_798_000, 0) - .saturating_add(Weight::from_parts(0, 1561)) + // Measured: `142` + // Estimated: `1627` + // Minimum execution time: 15_759_000 picoseconds. + Weight::from_parts(16_281_000, 0) + .saturating_add(Weight::from_parts(0, 1627)) .saturating_add(T::DbWeight::get().reads(1)) } - /// Storage: IMPExtrinsicWhitelist GroupControlOn (r:1 w:0) - /// Proof Skipped: IMPExtrinsicWhitelist GroupControlOn (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: `IMPExtrinsicWhitelist::GroupControlOn` (r:1 w:0) + /// Proof: `IMPExtrinsicWhitelist::GroupControlOn` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) fn deactivate_identity() -> Weight { // Proof Size summary in bytes: - // Measured: `76` - // Estimated: `1561` - // Minimum execution time: 17_116_000 picoseconds. - Weight::from_parts(17_493_000, 0) - .saturating_add(Weight::from_parts(0, 1561)) + // Measured: `142` + // Estimated: `1627` + // Minimum execution time: 11_564_000 picoseconds. + Weight::from_parts(12_013_000, 0) + .saturating_add(Weight::from_parts(0, 1627)) .saturating_add(T::DbWeight::get().reads(1)) } - /// Storage: IMPExtrinsicWhitelist GroupControlOn (r:1 w:0) - /// Proof Skipped: IMPExtrinsicWhitelist GroupControlOn (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: `IMPExtrinsicWhitelist::GroupControlOn` (r:1 w:0) + /// Proof: `IMPExtrinsicWhitelist::GroupControlOn` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) fn activate_identity() -> Weight { // Proof Size summary in bytes: - // Measured: `76` - // Estimated: `1561` - // Minimum execution time: 17_117_000 picoseconds. - Weight::from_parts(17_592_000, 0) - .saturating_add(Weight::from_parts(0, 1561)) + // Measured: `142` + // Estimated: `1627` + // Minimum execution time: 11_785_000 picoseconds. + Weight::from_parts(12_083_000, 0) + .saturating_add(Weight::from_parts(0, 1627)) .saturating_add(T::DbWeight::get().reads(1)) } - /// Storage: Teerex EnclaveIndex (r:1 w:0) - /// Proof Skipped: Teerex EnclaveIndex (max_values: None, max_size: None, mode: Measured) + /// Storage: `Teebag::EnclaveRegistry` (r:1 w:0) + /// Proof: `Teebag::EnclaveRegistry` (`max_values`: None, `max_size`: None, mode: `Measured`) fn identity_linked() -> Weight { // Proof Size summary in bytes: - // Measured: `255` - // Estimated: `3720` - // Minimum execution time: 20_155_000 picoseconds. - Weight::from_parts(20_822_000, 0) - .saturating_add(Weight::from_parts(0, 3720)) + // Measured: `347` + // Estimated: `3812` + // Minimum execution time: 12_364_000 picoseconds. + Weight::from_parts(13_195_000, 0) + .saturating_add(Weight::from_parts(0, 3812)) .saturating_add(T::DbWeight::get().reads(1)) } - /// Storage: Teerex EnclaveIndex (r:1 w:0) - /// Proof Skipped: Teerex EnclaveIndex (max_values: None, max_size: None, mode: Measured) + /// Storage: `Teebag::EnclaveRegistry` (r:1 w:0) + /// Proof: `Teebag::EnclaveRegistry` (`max_values`: None, `max_size`: None, mode: `Measured`) fn identity_deactivated() -> Weight { // Proof Size summary in bytes: - // Measured: `255` - // Estimated: `3720` - // Minimum execution time: 20_158_000 picoseconds. - Weight::from_parts(20_898_000, 0) - .saturating_add(Weight::from_parts(0, 3720)) + // Measured: `347` + // Estimated: `3812` + // Minimum execution time: 12_490_000 picoseconds. + Weight::from_parts(12_958_000, 0) + .saturating_add(Weight::from_parts(0, 3812)) .saturating_add(T::DbWeight::get().reads(1)) } - /// Storage: Teerex EnclaveIndex (r:1 w:0) - /// Proof Skipped: Teerex EnclaveIndex (max_values: None, max_size: None, mode: Measured) + /// Storage: `Teebag::EnclaveRegistry` (r:1 w:0) + /// Proof: `Teebag::EnclaveRegistry` (`max_values`: None, `max_size`: None, mode: `Measured`) fn identity_activated() -> Weight { // Proof Size summary in bytes: - // Measured: `255` - // Estimated: `3720` - // Minimum execution time: 20_057_000 picoseconds. - Weight::from_parts(20_846_000, 0) - .saturating_add(Weight::from_parts(0, 3720)) + // Measured: `347` + // Estimated: `3812` + // Minimum execution time: 12_481_000 picoseconds. + Weight::from_parts(12_928_000, 0) + .saturating_add(Weight::from_parts(0, 3812)) .saturating_add(T::DbWeight::get().reads(1)) } - /// Storage: Teerex EnclaveIndex (r:1 w:0) - /// Proof Skipped: Teerex EnclaveIndex (max_values: None, max_size: None, mode: Measured) + /// Storage: `Teebag::EnclaveRegistry` (r:1 w:0) + /// Proof: `Teebag::EnclaveRegistry` (`max_values`: None, `max_size`: None, mode: `Measured`) fn identity_networks_set() -> Weight { // Proof Size summary in bytes: - // Measured: `255` - // Estimated: `3720` - // Minimum execution time: 20_057_000 picoseconds. - Weight::from_parts(20_846_000, 0) - .saturating_add(Weight::from_parts(0, 3720)) + // Measured: `347` + // Estimated: `3812` + // Minimum execution time: 12_392_000 picoseconds. + Weight::from_parts(12_997_000, 0) + .saturating_add(Weight::from_parts(0, 3812)) .saturating_add(T::DbWeight::get().reads(1)) } - /// Storage: Teerex EnclaveIndex (r:1 w:0) - /// Proof Skipped: Teerex EnclaveIndex (max_values: None, max_size: None, mode: Measured) + /// Storage: `Teebag::EnclaveRegistry` (r:1 w:0) + /// Proof: `Teebag::EnclaveRegistry` (`max_values`: None, `max_size`: None, mode: `Measured`) fn some_error() -> Weight { // Proof Size summary in bytes: - // Measured: `255` - // Estimated: `3720` - // Minimum execution time: 20_419_000 picoseconds. - Weight::from_parts(21_055_000, 0) - .saturating_add(Weight::from_parts(0, 3720)) + // Measured: `347` + // Estimated: `3812` + // Minimum execution time: 12_290_000 picoseconds. + Weight::from_parts(12_662_000, 0) + .saturating_add(Weight::from_parts(0, 3812)) .saturating_add(T::DbWeight::get().reads(1)) } } diff --git a/runtime/paseo/src/weights/pallet_membership.rs b/runtime/paseo/src/weights/pallet_membership.rs index 90be12f750..0798959d02 100644 --- a/runtime/paseo/src/weights/pallet_membership.rs +++ b/runtime/paseo/src/weights/pallet_membership.rs @@ -17,10 +17,10 @@ //! Autogenerated weights for `pallet_membership` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-10-17, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-08-28, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `parachain-benchmark`, CPU: `Intel(R) Xeon(R) Platinum 8259CL CPU @ 2.50GHz` -//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("rococo-dev"), DB CACHE: 20 +//! HOSTNAME: `litentry-benchmark-server`, CPU: `Intel(R) Xeon(R) CPU E5-2686 v4 @ 2.30GHz` +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("rococo-dev")`, DB CACHE: 20 // Executed Command: // ./litentry-collator @@ -49,158 +49,158 @@ use core::marker::PhantomData; /// Weight functions for `pallet_membership`. pub struct WeightInfo(PhantomData); impl pallet_membership::WeightInfo for WeightInfo { - /// Storage: CouncilMembership Members (r:1 w:1) - /// Proof: CouncilMembership Members (max_values: Some(1), max_size: Some(3202), added: 3697, mode: MaxEncodedLen) - /// Storage: Council Proposals (r:1 w:0) - /// Proof Skipped: Council Proposals (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: Council Members (r:0 w:1) - /// Proof Skipped: Council Members (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: Council Prime (r:0 w:1) - /// Proof Skipped: Council Prime (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: `CouncilMembership::Members` (r:1 w:1) + /// Proof: `CouncilMembership::Members` (`max_values`: Some(1), `max_size`: Some(3202), added: 3697, mode: `MaxEncodedLen`) + /// Storage: `Council::Proposals` (r:1 w:0) + /// Proof: `Council::Proposals` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `Council::Members` (r:0 w:1) + /// Proof: `Council::Members` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `Council::Prime` (r:0 w:1) + /// Proof: `Council::Prime` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) /// The range of component `m` is `[1, 99]`. fn add_member(m: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `211 + m * (64 ±0)` // Estimated: `4687 + m * (64 ±0)` - // Minimum execution time: 23_819_000 picoseconds. - Weight::from_parts(24_057_385, 0) + // Minimum execution time: 15_544_000 picoseconds. + Weight::from_parts(16_557_881, 0) .saturating_add(Weight::from_parts(0, 4687)) - // Standard Error: 1_588 - .saturating_add(Weight::from_parts(45_968, 0).saturating_mul(m.into())) + // Standard Error: 474 + .saturating_add(Weight::from_parts(27_986, 0).saturating_mul(m.into())) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(3)) .saturating_add(Weight::from_parts(0, 64).saturating_mul(m.into())) } - /// Storage: CouncilMembership Members (r:1 w:1) - /// Proof: CouncilMembership Members (max_values: Some(1), max_size: Some(3202), added: 3697, mode: MaxEncodedLen) - /// Storage: Council Proposals (r:1 w:0) - /// Proof Skipped: Council Proposals (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: CouncilMembership Prime (r:1 w:0) - /// Proof: CouncilMembership Prime (max_values: Some(1), max_size: Some(32), added: 527, mode: MaxEncodedLen) - /// Storage: Council Members (r:0 w:1) - /// Proof Skipped: Council Members (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: Council Prime (r:0 w:1) - /// Proof Skipped: Council Prime (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: `CouncilMembership::Members` (r:1 w:1) + /// Proof: `CouncilMembership::Members` (`max_values`: Some(1), `max_size`: Some(3202), added: 3697, mode: `MaxEncodedLen`) + /// Storage: `Council::Proposals` (r:1 w:0) + /// Proof: `Council::Proposals` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `CouncilMembership::Prime` (r:1 w:0) + /// Proof: `CouncilMembership::Prime` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`) + /// Storage: `Council::Members` (r:0 w:1) + /// Proof: `Council::Members` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `Council::Prime` (r:0 w:1) + /// Proof: `Council::Prime` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) /// The range of component `m` is `[2, 100]`. fn remove_member(m: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `316 + m * (64 ±0)` // Estimated: `4687 + m * (64 ±0)` - // Minimum execution time: 27_230_000 picoseconds. - Weight::from_parts(29_007_635, 0) + // Minimum execution time: 18_073_000 picoseconds. + Weight::from_parts(19_162_325, 0) .saturating_add(Weight::from_parts(0, 4687)) - // Standard Error: 1_583 - .saturating_add(Weight::from_parts(21_863, 0).saturating_mul(m.into())) + // Standard Error: 486 + .saturating_add(Weight::from_parts(24_863, 0).saturating_mul(m.into())) .saturating_add(T::DbWeight::get().reads(3)) .saturating_add(T::DbWeight::get().writes(3)) .saturating_add(Weight::from_parts(0, 64).saturating_mul(m.into())) } - /// Storage: CouncilMembership Members (r:1 w:1) - /// Proof: CouncilMembership Members (max_values: Some(1), max_size: Some(3202), added: 3697, mode: MaxEncodedLen) - /// Storage: Council Proposals (r:1 w:0) - /// Proof Skipped: Council Proposals (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: CouncilMembership Prime (r:1 w:0) - /// Proof: CouncilMembership Prime (max_values: Some(1), max_size: Some(32), added: 527, mode: MaxEncodedLen) - /// Storage: Council Members (r:0 w:1) - /// Proof Skipped: Council Members (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: Council Prime (r:0 w:1) - /// Proof Skipped: Council Prime (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: `CouncilMembership::Members` (r:1 w:1) + /// Proof: `CouncilMembership::Members` (`max_values`: Some(1), `max_size`: Some(3202), added: 3697, mode: `MaxEncodedLen`) + /// Storage: `Council::Proposals` (r:1 w:0) + /// Proof: `Council::Proposals` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `CouncilMembership::Prime` (r:1 w:0) + /// Proof: `CouncilMembership::Prime` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`) + /// Storage: `Council::Members` (r:0 w:1) + /// Proof: `Council::Members` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `Council::Prime` (r:0 w:1) + /// Proof: `Council::Prime` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) /// The range of component `m` is `[2, 100]`. fn swap_member(m: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `316 + m * (64 ±0)` // Estimated: `4687 + m * (64 ±0)` - // Minimum execution time: 27_233_000 picoseconds. - Weight::from_parts(27_049_469, 0) + // Minimum execution time: 18_247_000 picoseconds. + Weight::from_parts(19_238_238, 0) .saturating_add(Weight::from_parts(0, 4687)) - // Standard Error: 2_713 - .saturating_add(Weight::from_parts(90_175, 0).saturating_mul(m.into())) + // Standard Error: 723 + .saturating_add(Weight::from_parts(37_571, 0).saturating_mul(m.into())) .saturating_add(T::DbWeight::get().reads(3)) .saturating_add(T::DbWeight::get().writes(3)) .saturating_add(Weight::from_parts(0, 64).saturating_mul(m.into())) } - /// Storage: CouncilMembership Members (r:1 w:1) - /// Proof: CouncilMembership Members (max_values: Some(1), max_size: Some(3202), added: 3697, mode: MaxEncodedLen) - /// Storage: Council Proposals (r:1 w:0) - /// Proof Skipped: Council Proposals (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: CouncilMembership Prime (r:1 w:0) - /// Proof: CouncilMembership Prime (max_values: Some(1), max_size: Some(32), added: 527, mode: MaxEncodedLen) - /// Storage: Council Members (r:0 w:1) - /// Proof Skipped: Council Members (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: Council Prime (r:0 w:1) - /// Proof Skipped: Council Prime (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: `CouncilMembership::Members` (r:1 w:1) + /// Proof: `CouncilMembership::Members` (`max_values`: Some(1), `max_size`: Some(3202), added: 3697, mode: `MaxEncodedLen`) + /// Storage: `Council::Proposals` (r:1 w:0) + /// Proof: `Council::Proposals` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `CouncilMembership::Prime` (r:1 w:0) + /// Proof: `CouncilMembership::Prime` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`) + /// Storage: `Council::Members` (r:0 w:1) + /// Proof: `Council::Members` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `Council::Prime` (r:0 w:1) + /// Proof: `Council::Prime` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) /// The range of component `m` is `[1, 100]`. fn reset_member(m: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `315 + m * (64 ±0)` // Estimated: `4687 + m * (64 ±0)` - // Minimum execution time: 26_858_000 picoseconds. - Weight::from_parts(28_191_552, 0) + // Minimum execution time: 18_407_000 picoseconds. + Weight::from_parts(19_739_921, 0) .saturating_add(Weight::from_parts(0, 4687)) - // Standard Error: 5_225 - .saturating_add(Weight::from_parts(245_055, 0).saturating_mul(m.into())) + // Standard Error: 1_891 + .saturating_add(Weight::from_parts(132_297, 0).saturating_mul(m.into())) .saturating_add(T::DbWeight::get().reads(3)) .saturating_add(T::DbWeight::get().writes(3)) .saturating_add(Weight::from_parts(0, 64).saturating_mul(m.into())) } - /// Storage: CouncilMembership Members (r:1 w:1) - /// Proof: CouncilMembership Members (max_values: Some(1), max_size: Some(3202), added: 3697, mode: MaxEncodedLen) - /// Storage: Council Proposals (r:1 w:0) - /// Proof Skipped: Council Proposals (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: CouncilMembership Prime (r:1 w:1) - /// Proof: CouncilMembership Prime (max_values: Some(1), max_size: Some(32), added: 527, mode: MaxEncodedLen) - /// Storage: Council Members (r:0 w:1) - /// Proof Skipped: Council Members (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: Council Prime (r:0 w:1) - /// Proof Skipped: Council Prime (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: `CouncilMembership::Members` (r:1 w:1) + /// Proof: `CouncilMembership::Members` (`max_values`: Some(1), `max_size`: Some(3202), added: 3697, mode: `MaxEncodedLen`) + /// Storage: `Council::Proposals` (r:1 w:0) + /// Proof: `Council::Proposals` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `CouncilMembership::Prime` (r:1 w:1) + /// Proof: `CouncilMembership::Prime` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`) + /// Storage: `Council::Members` (r:0 w:1) + /// Proof: `Council::Members` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `Council::Prime` (r:0 w:1) + /// Proof: `Council::Prime` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) /// The range of component `m` is `[1, 100]`. fn change_key(m: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `315 + m * (64 ±0)` // Estimated: `4687 + m * (64 ±0)` - // Minimum execution time: 27_678_000 picoseconds. - Weight::from_parts(28_977_909, 0) + // Minimum execution time: 19_205_000 picoseconds. + Weight::from_parts(20_277_093, 0) .saturating_add(Weight::from_parts(0, 4687)) - // Standard Error: 691 - .saturating_add(Weight::from_parts(42_476, 0).saturating_mul(m.into())) + // Standard Error: 1_316 + .saturating_add(Weight::from_parts(33_126, 0).saturating_mul(m.into())) .saturating_add(T::DbWeight::get().reads(3)) .saturating_add(T::DbWeight::get().writes(4)) .saturating_add(Weight::from_parts(0, 64).saturating_mul(m.into())) } - /// Storage: CouncilMembership Members (r:1 w:0) - /// Proof: CouncilMembership Members (max_values: Some(1), max_size: Some(3202), added: 3697, mode: MaxEncodedLen) - /// Storage: CouncilMembership Prime (r:0 w:1) - /// Proof: CouncilMembership Prime (max_values: Some(1), max_size: Some(32), added: 527, mode: MaxEncodedLen) - /// Storage: Council Prime (r:0 w:1) - /// Proof Skipped: Council Prime (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: `CouncilMembership::Members` (r:1 w:0) + /// Proof: `CouncilMembership::Members` (`max_values`: Some(1), `max_size`: Some(3202), added: 3697, mode: `MaxEncodedLen`) + /// Storage: `CouncilMembership::Prime` (r:0 w:1) + /// Proof: `CouncilMembership::Prime` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`) + /// Storage: `Council::Prime` (r:0 w:1) + /// Proof: `Council::Prime` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) /// The range of component `m` is `[1, 100]`. fn set_prime(m: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `107 + m * (32 ±0)` // Estimated: `4687 + m * (32 ±0)` - // Minimum execution time: 11_764_000 picoseconds. - Weight::from_parts(12_306_500, 0) + // Minimum execution time: 7_663_000 picoseconds. + Weight::from_parts(8_091_030, 0) .saturating_add(Weight::from_parts(0, 4687)) - // Standard Error: 222 - .saturating_add(Weight::from_parts(13_917, 0).saturating_mul(m.into())) + // Standard Error: 215 + .saturating_add(Weight::from_parts(12_336, 0).saturating_mul(m.into())) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(2)) .saturating_add(Weight::from_parts(0, 32).saturating_mul(m.into())) } - /// Storage: CouncilMembership Prime (r:0 w:1) - /// Proof: CouncilMembership Prime (max_values: Some(1), max_size: Some(32), added: 527, mode: MaxEncodedLen) - /// Storage: Council Prime (r:0 w:1) - /// Proof Skipped: Council Prime (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: `CouncilMembership::Prime` (r:0 w:1) + /// Proof: `CouncilMembership::Prime` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`) + /// Storage: `Council::Prime` (r:0 w:1) + /// Proof: `Council::Prime` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) /// The range of component `m` is `[1, 100]`. fn clear_prime(m: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 4_526_000 picoseconds. - Weight::from_parts(4_799_478, 0) + // Minimum execution time: 3_043_000 picoseconds. + Weight::from_parts(3_337_476, 0) .saturating_add(Weight::from_parts(0, 0)) - // Standard Error: 92 - .saturating_add(Weight::from_parts(899, 0).saturating_mul(m.into())) + // Standard Error: 111 + .saturating_add(Weight::from_parts(164, 0).saturating_mul(m.into())) .saturating_add(T::DbWeight::get().writes(2)) } } diff --git a/runtime/paseo/src/weights/pallet_multisig.rs b/runtime/paseo/src/weights/pallet_multisig.rs index a953d564ae..40fa77030a 100644 --- a/runtime/paseo/src/weights/pallet_multisig.rs +++ b/runtime/paseo/src/weights/pallet_multisig.rs @@ -17,10 +17,10 @@ //! Autogenerated weights for `pallet_multisig` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-10-17, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-08-28, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `parachain-benchmark`, CPU: `Intel(R) Xeon(R) Platinum 8259CL CPU @ 2.50GHz` -//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("rococo-dev"), DB CACHE: 20 +//! HOSTNAME: `litentry-benchmark-server`, CPU: `Intel(R) Xeon(R) CPU E5-2686 v4 @ 2.30GHz` +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("rococo-dev")`, DB CACHE: 20 // Executed Command: // ./litentry-collator @@ -54,110 +54,110 @@ impl pallet_multisig::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 18_853_000 picoseconds. - Weight::from_parts(22_999_407, 0) + // Minimum execution time: 13_018_000 picoseconds. + Weight::from_parts(16_358_007, 0) .saturating_add(Weight::from_parts(0, 0)) - // Standard Error: 43 - .saturating_add(Weight::from_parts(1_135, 0).saturating_mul(z.into())) + // Standard Error: 18 + .saturating_add(Weight::from_parts(502, 0).saturating_mul(z.into())) } - /// Storage: Multisig Multisigs (r:1 w:1) - /// Proof: Multisig Multisigs (max_values: None, max_size: Some(3346), added: 5821, mode: MaxEncodedLen) + /// Storage: `Multisig::Multisigs` (r:1 w:1) + /// Proof: `Multisig::Multisigs` (`max_values`: None, `max_size`: Some(3346), added: 5821, mode: `MaxEncodedLen`) /// The range of component `s` is `[2, 100]`. /// The range of component `z` is `[0, 10000]`. fn as_multi_create(s: u32, z: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `289 + s * (2 ±0)` // Estimated: `6811` - // Minimum execution time: 60_323_000 picoseconds. - Weight::from_parts(44_617_716, 0) + // Minimum execution time: 43_932_000 picoseconds. + Weight::from_parts(33_535_441, 0) .saturating_add(Weight::from_parts(0, 6811)) - // Standard Error: 6_665 - .saturating_add(Weight::from_parts(247_225, 0).saturating_mul(s.into())) - // Standard Error: 65 - .saturating_add(Weight::from_parts(1_915, 0).saturating_mul(z.into())) + // Standard Error: 4_217 + .saturating_add(Weight::from_parts(146_766, 0).saturating_mul(s.into())) + // Standard Error: 41 + .saturating_add(Weight::from_parts(1_557, 0).saturating_mul(z.into())) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: Multisig Multisigs (r:1 w:1) - /// Proof: Multisig Multisigs (max_values: None, max_size: Some(3346), added: 5821, mode: MaxEncodedLen) + /// Storage: `Multisig::Multisigs` (r:1 w:1) + /// Proof: `Multisig::Multisigs` (`max_values`: None, `max_size`: Some(3346), added: 5821, mode: `MaxEncodedLen`) /// The range of component `s` is `[3, 100]`. /// The range of component `z` is `[0, 10000]`. fn as_multi_approve(s: u32, z: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `315` // Estimated: `6811` - // Minimum execution time: 40_600_000 picoseconds. - Weight::from_parts(30_192_721, 0) + // Minimum execution time: 29_075_000 picoseconds. + Weight::from_parts(17_070_108, 0) .saturating_add(Weight::from_parts(0, 6811)) - // Standard Error: 4_152 - .saturating_add(Weight::from_parts(173_614, 0).saturating_mul(s.into())) - // Standard Error: 40 - .saturating_add(Weight::from_parts(1_575, 0).saturating_mul(z.into())) + // Standard Error: 1_957 + .saturating_add(Weight::from_parts(147_016, 0).saturating_mul(s.into())) + // Standard Error: 19 + .saturating_add(Weight::from_parts(1_592, 0).saturating_mul(z.into())) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: Multisig Multisigs (r:1 w:1) - /// Proof: Multisig Multisigs (max_values: None, max_size: Some(3346), added: 5821, mode: MaxEncodedLen) - /// Storage: System Account (r:1 w:1) - /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + /// Storage: `Multisig::Multisigs` (r:1 w:1) + /// Proof: `Multisig::Multisigs` (`max_values`: None, `max_size`: Some(3346), added: 5821, mode: `MaxEncodedLen`) + /// Storage: `System::Account` (r:1 w:1) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) /// The range of component `s` is `[2, 100]`. /// The range of component `z` is `[0, 10000]`. fn as_multi_complete(s: u32, z: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `421 + s * (33 ±0)` // Estimated: `6811` - // Minimum execution time: 67_111_000 picoseconds. - Weight::from_parts(46_781_350, 0) + // Minimum execution time: 49_610_000 picoseconds. + Weight::from_parts(38_076_052, 0) .saturating_add(Weight::from_parts(0, 6811)) - // Standard Error: 4_632 - .saturating_add(Weight::from_parts(324_137, 0).saturating_mul(s.into())) - // Standard Error: 45 - .saturating_add(Weight::from_parts(2_200, 0).saturating_mul(z.into())) + // Standard Error: 2_625 + .saturating_add(Weight::from_parts(176_208, 0).saturating_mul(s.into())) + // Standard Error: 25 + .saturating_add(Weight::from_parts(1_589, 0).saturating_mul(z.into())) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) } - /// Storage: Multisig Multisigs (r:1 w:1) - /// Proof: Multisig Multisigs (max_values: None, max_size: Some(3346), added: 5821, mode: MaxEncodedLen) + /// Storage: `Multisig::Multisigs` (r:1 w:1) + /// Proof: `Multisig::Multisigs` (`max_values`: None, `max_size`: Some(3346), added: 5821, mode: `MaxEncodedLen`) /// The range of component `s` is `[2, 100]`. fn approve_as_multi_create(s: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `292 + s * (2 ±0)` // Estimated: `6811` - // Minimum execution time: 43_194_000 picoseconds. - Weight::from_parts(46_632_221, 0) + // Minimum execution time: 30_004_000 picoseconds. + Weight::from_parts(32_460_826, 0) .saturating_add(Weight::from_parts(0, 6811)) - // Standard Error: 5_115 - .saturating_add(Weight::from_parts(208_635, 0).saturating_mul(s.into())) + // Standard Error: 3_414 + .saturating_add(Weight::from_parts(152_194, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: Multisig Multisigs (r:1 w:1) - /// Proof: Multisig Multisigs (max_values: None, max_size: Some(3346), added: 5821, mode: MaxEncodedLen) + /// Storage: `Multisig::Multisigs` (r:1 w:1) + /// Proof: `Multisig::Multisigs` (`max_values`: None, `max_size`: Some(3346), added: 5821, mode: `MaxEncodedLen`) /// The range of component `s` is `[2, 100]`. fn approve_as_multi_approve(s: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `315` // Estimated: `6811` - // Minimum execution time: 24_929_000 picoseconds. - Weight::from_parts(26_889_285, 0) + // Minimum execution time: 16_701_000 picoseconds. + Weight::from_parts(17_280_857, 0) .saturating_add(Weight::from_parts(0, 6811)) - // Standard Error: 3_688 - .saturating_add(Weight::from_parts(144_932, 0).saturating_mul(s.into())) + // Standard Error: 1_905 + .saturating_add(Weight::from_parts(136_920, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: Multisig Multisigs (r:1 w:1) - /// Proof: Multisig Multisigs (max_values: None, max_size: Some(3346), added: 5821, mode: MaxEncodedLen) + /// Storage: `Multisig::Multisigs` (r:1 w:1) + /// Proof: `Multisig::Multisigs` (`max_values`: None, `max_size`: Some(3346), added: 5821, mode: `MaxEncodedLen`) /// The range of component `s` is `[2, 100]`. fn cancel_as_multi(s: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `486 + s * (1 ±0)` // Estimated: `6811` - // Minimum execution time: 44_914_000 picoseconds. - Weight::from_parts(45_393_276, 0) + // Minimum execution time: 31_656_000 picoseconds. + Weight::from_parts(33_456_462, 0) .saturating_add(Weight::from_parts(0, 6811)) - // Standard Error: 4_458 - .saturating_add(Weight::from_parts(201_411, 0).saturating_mul(s.into())) + // Standard Error: 2_823 + .saturating_add(Weight::from_parts(141_836, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } diff --git a/runtime/paseo/src/weights/pallet_parachain_staking.rs b/runtime/paseo/src/weights/pallet_parachain_staking.rs index b09131e24e..357e2e3547 100644 --- a/runtime/paseo/src/weights/pallet_parachain_staking.rs +++ b/runtime/paseo/src/weights/pallet_parachain_staking.rs @@ -17,10 +17,10 @@ //! Autogenerated weights for `pallet_parachain_staking` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-10-17, STEPS: `25`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-08-28, STEPS: `25`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `parachain-benchmark`, CPU: `Intel(R) Xeon(R) Platinum 8259CL CPU @ 2.50GHz` -//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("rococo-dev"), DB CACHE: 20 +//! HOSTNAME: `litentry-benchmark-server`, CPU: `Intel(R) Xeon(R) CPU E5-2686 v4 @ 2.30GHz` +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("rococo-dev")`, DB CACHE: 20 // Executed Command: // ./litentry-collator @@ -49,572 +49,576 @@ use core::marker::PhantomData; /// Weight functions for `pallet_parachain_staking`. pub struct WeightInfo(PhantomData); impl pallet_parachain_staking::WeightInfo for WeightInfo { - /// Storage: ParachainStaking Candidates (r:1 w:1) - /// Proof Skipped: ParachainStaking Candidates (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: `ParachainStaking::Candidates` (r:1 w:1) + /// Proof: `ParachainStaking::Candidates` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) /// The range of component `x` is `[1, 100]`. fn add_candidates_whitelist(x: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `337 + x * (32 ±0)` // Estimated: `1826 + x * (32 ±0)` - // Minimum execution time: 18_935_000 picoseconds. - Weight::from_parts(22_854_413, 0) + // Minimum execution time: 12_371_000 picoseconds. + Weight::from_parts(15_519_329, 0) .saturating_add(Weight::from_parts(0, 1826)) - // Standard Error: 4_674 - .saturating_add(Weight::from_parts(186_518, 0).saturating_mul(x.into())) + // Standard Error: 3_320 + .saturating_add(Weight::from_parts(113_759, 0).saturating_mul(x.into())) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) .saturating_add(Weight::from_parts(0, 32).saturating_mul(x.into())) } - /// Storage: ParachainStaking Candidates (r:1 w:1) - /// Proof Skipped: ParachainStaking Candidates (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: `ParachainStaking::Candidates` (r:1 w:1) + /// Proof: `ParachainStaking::Candidates` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) /// The range of component `x` is `[1, 100]`. fn remove_candidates_whitelist(x: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `369 + x * (32 ±0)` // Estimated: `1859 + x * (32 ±0)` - // Minimum execution time: 18_040_000 picoseconds. - Weight::from_parts(21_361_636, 0) + // Minimum execution time: 11_880_000 picoseconds. + Weight::from_parts(15_002_167, 0) .saturating_add(Weight::from_parts(0, 1859)) - // Standard Error: 3_039 - .saturating_add(Weight::from_parts(191_134, 0).saturating_mul(x.into())) + // Standard Error: 3_213 + .saturating_add(Weight::from_parts(105_293, 0).saturating_mul(x.into())) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) .saturating_add(Weight::from_parts(0, 32).saturating_mul(x.into())) } - /// Storage: ParachainStaking InflationConfig (r:1 w:1) - /// Proof Skipped: ParachainStaking InflationConfig (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: `ParachainStaking::InflationConfig` (r:1 w:1) + /// Proof: `ParachainStaking::InflationConfig` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) fn set_staking_expectations() -> Weight { // Proof Size summary in bytes: // Measured: `466` // Estimated: `1951` - // Minimum execution time: 19_519_000 picoseconds. - Weight::from_parts(20_309_000, 0) + // Minimum execution time: 12_459_000 picoseconds. + Weight::from_parts(13_116_000, 0) .saturating_add(Weight::from_parts(0, 1951)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: ParachainStaking InflationConfig (r:1 w:1) - /// Proof Skipped: ParachainStaking InflationConfig (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: ParachainStaking Round (r:1 w:0) - /// Proof Skipped: ParachainStaking Round (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: `ParachainStaking::InflationConfig` (r:1 w:1) + /// Proof: `ParachainStaking::InflationConfig` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::Round` (r:1 w:0) + /// Proof: `ParachainStaking::Round` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) fn set_inflation() -> Weight { // Proof Size summary in bytes: // Measured: `502` // Estimated: `1987` - // Minimum execution time: 73_978_000 picoseconds. - Weight::from_parts(74_907_000, 0) + // Minimum execution time: 42_609_000 picoseconds. + Weight::from_parts(43_433_000, 0) .saturating_add(Weight::from_parts(0, 1987)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: ParachainStaking ParachainBondInfo (r:1 w:1) - /// Proof Skipped: ParachainStaking ParachainBondInfo (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: `ParachainStaking::ParachainBondInfo` (r:1 w:1) + /// Proof: `ParachainStaking::ParachainBondInfo` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) fn set_parachain_bond_account() -> Weight { // Proof Size summary in bytes: // Measured: `434` // Estimated: `1919` - // Minimum execution time: 19_450_000 picoseconds. - Weight::from_parts(20_104_000, 0) + // Minimum execution time: 12_529_000 picoseconds. + Weight::from_parts(13_080_000, 0) .saturating_add(Weight::from_parts(0, 1919)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: ParachainStaking ParachainBondInfo (r:1 w:1) - /// Proof Skipped: ParachainStaking ParachainBondInfo (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: `ParachainStaking::ParachainBondInfo` (r:1 w:1) + /// Proof: `ParachainStaking::ParachainBondInfo` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) fn set_parachain_bond_reserve_percent() -> Weight { // Proof Size summary in bytes: // Measured: `434` // Estimated: `1919` - // Minimum execution time: 18_900_000 picoseconds. - Weight::from_parts(19_444_000, 0) + // Minimum execution time: 12_215_000 picoseconds. + Weight::from_parts(13_141_000, 0) .saturating_add(Weight::from_parts(0, 1919)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: ParachainStaking TotalSelected (r:1 w:1) - /// Proof Skipped: ParachainStaking TotalSelected (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: ParachainStaking Round (r:1 w:0) - /// Proof Skipped: ParachainStaking Round (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: `ParachainStaking::TotalSelected` (r:1 w:1) + /// Proof: `ParachainStaking::TotalSelected` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::Round` (r:1 w:0) + /// Proof: `ParachainStaking::Round` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) fn set_total_selected() -> Weight { // Proof Size summary in bytes: // Measured: `442` // Estimated: `1927` - // Minimum execution time: 20_390_000 picoseconds. - Weight::from_parts(20_843_000, 0) + // Minimum execution time: 13_709_000 picoseconds. + Weight::from_parts(14_340_000, 0) .saturating_add(Weight::from_parts(0, 1927)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: ParachainStaking CollatorCommission (r:1 w:1) - /// Proof Skipped: ParachainStaking CollatorCommission (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: `ParachainStaking::CollatorCommission` (r:1 w:1) + /// Proof: `ParachainStaking::CollatorCommission` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) fn set_collator_commission() -> Weight { // Proof Size summary in bytes: // Measured: `405` // Estimated: `1890` - // Minimum execution time: 17_496_000 picoseconds. - Weight::from_parts(18_022_000, 0) + // Minimum execution time: 11_060_000 picoseconds. + Weight::from_parts(11_690_000, 0) .saturating_add(Weight::from_parts(0, 1890)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: ParachainStaking Round (r:1 w:1) - /// Proof Skipped: ParachainStaking Round (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: ParachainStaking TotalSelected (r:1 w:0) - /// Proof Skipped: ParachainStaking TotalSelected (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: ParachainStaking InflationConfig (r:1 w:1) - /// Proof Skipped: ParachainStaking InflationConfig (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: `ParachainStaking::Round` (r:1 w:1) + /// Proof: `ParachainStaking::Round` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::TotalSelected` (r:1 w:0) + /// Proof: `ParachainStaking::TotalSelected` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::InflationConfig` (r:1 w:1) + /// Proof: `ParachainStaking::InflationConfig` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) fn set_blocks_per_round() -> Weight { // Proof Size summary in bytes: // Measured: `530` // Estimated: `2015` - // Minimum execution time: 28_375_000 picoseconds. - Weight::from_parts(29_217_000, 0) + // Minimum execution time: 18_786_000 picoseconds. + Weight::from_parts(19_544_000, 0) .saturating_add(Weight::from_parts(0, 2015)) .saturating_add(T::DbWeight::get().reads(3)) .saturating_add(T::DbWeight::get().writes(2)) } - /// Storage: ParachainStaking Candidates (r:1 w:0) - /// Proof Skipped: ParachainStaking Candidates (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: ParachainStaking CandidateInfo (r:1 w:1) - /// Proof Skipped: ParachainStaking CandidateInfo (max_values: None, max_size: None, mode: Measured) - /// Storage: ParachainStaking DelegatorState (r:1 w:0) - /// Proof Skipped: ParachainStaking DelegatorState (max_values: None, max_size: None, mode: Measured) - /// Storage: ParachainStaking CandidatePool (r:1 w:1) - /// Proof Skipped: ParachainStaking CandidatePool (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: System Account (r:1 w:1) - /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) - /// Storage: ParachainStaking Total (r:1 w:1) - /// Proof Skipped: ParachainStaking Total (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: ParachainStaking TopDelegations (r:0 w:1) - /// Proof Skipped: ParachainStaking TopDelegations (max_values: None, max_size: None, mode: Measured) - /// Storage: ParachainStaking BottomDelegations (r:0 w:1) - /// Proof Skipped: ParachainStaking BottomDelegations (max_values: None, max_size: None, mode: Measured) + /// Storage: `ParachainStaking::Candidates` (r:1 w:0) + /// Proof: `ParachainStaking::Candidates` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::CandidateInfo` (r:1 w:1) + /// Proof: `ParachainStaking::CandidateInfo` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::DelegatorState` (r:1 w:0) + /// Proof: `ParachainStaking::DelegatorState` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::CandidatePool` (r:1 w:1) + /// Proof: `ParachainStaking::CandidatePool` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `System::Account` (r:1 w:1) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) + /// Storage: `ParachainStaking::Total` (r:1 w:1) + /// Proof: `ParachainStaking::Total` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::TopDelegations` (r:0 w:1) + /// Proof: `ParachainStaking::TopDelegations` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::BottomDelegations` (r:0 w:1) + /// Proof: `ParachainStaking::BottomDelegations` (`max_values`: None, `max_size`: None, mode: `Measured`) /// The range of component `x` is `[3, 1000]`. fn join_candidates(x: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `1512 + x * (80 ±0)` // Estimated: `4815 + x * (81 ±0)` - // Minimum execution time: 69_450_000 picoseconds. - Weight::from_parts(79_683_069, 0) + // Minimum execution time: 48_531_000 picoseconds. + Weight::from_parts(50_133_211, 0) .saturating_add(Weight::from_parts(0, 4815)) - // Standard Error: 3_397 - .saturating_add(Weight::from_parts(244_217, 0).saturating_mul(x.into())) + // Standard Error: 2_372 + .saturating_add(Weight::from_parts(150_172, 0).saturating_mul(x.into())) .saturating_add(T::DbWeight::get().reads(6)) .saturating_add(T::DbWeight::get().writes(6)) .saturating_add(Weight::from_parts(0, 81).saturating_mul(x.into())) } - /// Storage: ParachainStaking CandidateInfo (r:1 w:1) - /// Proof Skipped: ParachainStaking CandidateInfo (max_values: None, max_size: None, mode: Measured) - /// Storage: ParachainStaking Round (r:1 w:0) - /// Proof Skipped: ParachainStaking Round (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: ParachainStaking CandidatePool (r:1 w:1) - /// Proof Skipped: ParachainStaking CandidatePool (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: `ParachainStaking::CandidateInfo` (r:1 w:1) + /// Proof: `ParachainStaking::CandidateInfo` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::Round` (r:1 w:0) + /// Proof: `ParachainStaking::Round` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::CandidatePool` (r:1 w:1) + /// Proof: `ParachainStaking::CandidatePool` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) /// The range of component `x` is `[3, 1000]`. fn schedule_leave_candidates(x: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `1327 + x * (48 ±0)` // Estimated: `4691 + x * (49 ±0)` - // Minimum execution time: 34_474_000 picoseconds. - Weight::from_parts(41_039_462, 0) + // Minimum execution time: 22_779_000 picoseconds. + Weight::from_parts(18_073_114, 0) .saturating_add(Weight::from_parts(0, 4691)) - // Standard Error: 3_343 - .saturating_add(Weight::from_parts(168_119, 0).saturating_mul(x.into())) + // Standard Error: 2_296 + .saturating_add(Weight::from_parts(120_415, 0).saturating_mul(x.into())) .saturating_add(T::DbWeight::get().reads(3)) .saturating_add(T::DbWeight::get().writes(2)) .saturating_add(Weight::from_parts(0, 49).saturating_mul(x.into())) } - /// Storage: ParachainStaking CandidateInfo (r:1 w:1) - /// Proof Skipped: ParachainStaking CandidateInfo (max_values: None, max_size: None, mode: Measured) - /// Storage: ParachainStaking Round (r:1 w:0) - /// Proof Skipped: ParachainStaking Round (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: ParachainStaking TopDelegations (r:1 w:1) - /// Proof Skipped: ParachainStaking TopDelegations (max_values: None, max_size: None, mode: Measured) - /// Storage: System Account (r:1200 w:1200) - /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) - /// Storage: ParachainStaking DelegatorState (r:1199 w:1199) - /// Proof Skipped: ParachainStaking DelegatorState (max_values: None, max_size: None, mode: Measured) - /// Storage: ParachainStaking DelegationScheduledRequests (r:1 w:1) - /// Proof Skipped: ParachainStaking DelegationScheduledRequests (max_values: None, max_size: None, mode: Measured) - /// Storage: ParachainStaking AutoCompoundingDelegations (r:1 w:1) - /// Proof Skipped: ParachainStaking AutoCompoundingDelegations (max_values: None, max_size: None, mode: Measured) - /// Storage: ParachainStaking BottomDelegations (r:1 w:1) - /// Proof Skipped: ParachainStaking BottomDelegations (max_values: None, max_size: None, mode: Measured) - /// Storage: ParachainStaking Total (r:1 w:1) - /// Proof Skipped: ParachainStaking Total (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: `ParachainStaking::CandidateInfo` (r:1 w:1) + /// Proof: `ParachainStaking::CandidateInfo` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::Round` (r:1 w:0) + /// Proof: `ParachainStaking::Round` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::TopDelegations` (r:1 w:1) + /// Proof: `ParachainStaking::TopDelegations` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `System::Account` (r:1200 w:1200) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) + /// Storage: `ParachainStaking::DelegatorState` (r:1199 w:1199) + /// Proof: `ParachainStaking::DelegatorState` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::DelegationScheduledRequests` (r:1 w:1) + /// Proof: `ParachainStaking::DelegationScheduledRequests` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::AutoCompoundingDelegations` (r:1 w:1) + /// Proof: `ParachainStaking::AutoCompoundingDelegations` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::BottomDelegations` (r:1 w:1) + /// Proof: `ParachainStaking::BottomDelegations` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::Total` (r:1 w:1) + /// Proof: `ParachainStaking::Total` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) /// The range of component `x` is `[2, 1200]`. fn execute_leave_candidates(x: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `469 + x * (447 ±0)` // Estimated: `5094 + x * (2915 ±0)` - // Minimum execution time: 128_571_000 picoseconds. - Weight::from_parts(131_137_000, 0) + // Minimum execution time: 90_448_000 picoseconds. + Weight::from_parts(95_467_000, 0) .saturating_add(Weight::from_parts(0, 5094)) - // Standard Error: 941_692 - .saturating_add(Weight::from_parts(74_880_071, 0).saturating_mul(x.into())) + // Standard Error: 842_280 + .saturating_add(Weight::from_parts(68_676_766, 0).saturating_mul(x.into())) .saturating_add(T::DbWeight::get().reads(6)) .saturating_add(T::DbWeight::get().reads((2_u64).saturating_mul(x.into()))) .saturating_add(T::DbWeight::get().writes(5)) .saturating_add(T::DbWeight::get().writes((2_u64).saturating_mul(x.into()))) .saturating_add(Weight::from_parts(0, 2915).saturating_mul(x.into())) } - /// Storage: ParachainStaking CandidateInfo (r:1 w:1) - /// Proof Skipped: ParachainStaking CandidateInfo (max_values: None, max_size: None, mode: Measured) - /// Storage: ParachainStaking CandidatePool (r:1 w:1) - /// Proof Skipped: ParachainStaking CandidatePool (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: `ParachainStaking::CandidateInfo` (r:1 w:1) + /// Proof: `ParachainStaking::CandidateInfo` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::CandidatePool` (r:1 w:1) + /// Proof: `ParachainStaking::CandidatePool` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) /// The range of component `x` is `[3, 1000]`. fn cancel_leave_candidates(x: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `1247 + x * (48 ±0)` // Estimated: `4611 + x * (49 ±0)` - // Minimum execution time: 30_835_000 picoseconds. - Weight::from_parts(37_764_708, 0) + // Minimum execution time: 20_426_000 picoseconds. + Weight::from_parts(16_451_221, 0) .saturating_add(Weight::from_parts(0, 4611)) - // Standard Error: 2_813 - .saturating_add(Weight::from_parts(176_901, 0).saturating_mul(x.into())) + // Standard Error: 2_616 + .saturating_add(Weight::from_parts(132_896, 0).saturating_mul(x.into())) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) .saturating_add(Weight::from_parts(0, 49).saturating_mul(x.into())) } - /// Storage: ParachainStaking CandidateInfo (r:1 w:1) - /// Proof Skipped: ParachainStaking CandidateInfo (max_values: None, max_size: None, mode: Measured) - /// Storage: ParachainStaking CandidatePool (r:1 w:1) - /// Proof Skipped: ParachainStaking CandidatePool (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: `ParachainStaking::CandidateInfo` (r:1 w:1) + /// Proof: `ParachainStaking::CandidateInfo` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::CandidatePool` (r:1 w:1) + /// Proof: `ParachainStaking::CandidatePool` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) fn go_offline() -> Weight { // Proof Size summary in bytes: // Measured: `686` // Estimated: `4151` - // Minimum execution time: 29_940_000 picoseconds. - Weight::from_parts(30_604_000, 0) + // Minimum execution time: 19_979_000 picoseconds. + Weight::from_parts(21_030_000, 0) .saturating_add(Weight::from_parts(0, 4151)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) } - /// Storage: ParachainStaking CandidateInfo (r:1 w:1) - /// Proof Skipped: ParachainStaking CandidateInfo (max_values: None, max_size: None, mode: Measured) - /// Storage: ParachainStaking CandidatePool (r:1 w:1) - /// Proof Skipped: ParachainStaking CandidatePool (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: `ParachainStaking::CandidateInfo` (r:1 w:1) + /// Proof: `ParachainStaking::CandidateInfo` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::CandidatePool` (r:1 w:1) + /// Proof: `ParachainStaking::CandidatePool` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) fn go_online() -> Weight { // Proof Size summary in bytes: // Measured: `637` // Estimated: `4102` - // Minimum execution time: 29_182_000 picoseconds. - Weight::from_parts(29_953_000, 0) + // Minimum execution time: 20_087_000 picoseconds. + Weight::from_parts(20_871_000, 0) .saturating_add(Weight::from_parts(0, 4102)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) } - /// Storage: ParachainStaking CandidateInfo (r:1 w:1) - /// Proof Skipped: ParachainStaking CandidateInfo (max_values: None, max_size: None, mode: Measured) - /// Storage: System Account (r:1 w:1) - /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) - /// Storage: ParachainStaking Total (r:1 w:1) - /// Proof Skipped: ParachainStaking Total (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: ParachainStaking CandidatePool (r:1 w:1) - /// Proof Skipped: ParachainStaking CandidatePool (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: `ParachainStaking::CandidateInfo` (r:1 w:1) + /// Proof: `ParachainStaking::CandidateInfo` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `System::Account` (r:1 w:1) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) + /// Storage: `ParachainStaking::Total` (r:1 w:1) + /// Proof: `ParachainStaking::Total` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::CandidatePool` (r:1 w:1) + /// Proof: `ParachainStaking::CandidatePool` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) fn candidate_bond_more() -> Weight { // Proof Size summary in bytes: // Measured: `829` // Estimated: `4294` - // Minimum execution time: 53_816_000 picoseconds. - Weight::from_parts(54_568_000, 0) + // Minimum execution time: 37_568_000 picoseconds. + Weight::from_parts(39_038_000, 0) .saturating_add(Weight::from_parts(0, 4294)) .saturating_add(T::DbWeight::get().reads(4)) .saturating_add(T::DbWeight::get().writes(4)) } - /// Storage: ParachainStaking CandidateInfo (r:1 w:1) - /// Proof Skipped: ParachainStaking CandidateInfo (max_values: None, max_size: None, mode: Measured) - /// Storage: ParachainStaking Round (r:1 w:0) - /// Proof Skipped: ParachainStaking Round (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: `ParachainStaking::CandidateInfo` (r:1 w:1) + /// Proof: `ParachainStaking::CandidateInfo` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::Round` (r:1 w:0) + /// Proof: `ParachainStaking::Round` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) fn schedule_candidate_bond_less() -> Weight { // Proof Size summary in bytes: // Measured: `598` // Estimated: `4063` - // Minimum execution time: 27_495_000 picoseconds. - Weight::from_parts(28_152_000, 0) + // Minimum execution time: 18_568_000 picoseconds. + Weight::from_parts(19_643_000, 0) .saturating_add(Weight::from_parts(0, 4063)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: ParachainStaking CandidateInfo (r:1 w:1) - /// Proof Skipped: ParachainStaking CandidateInfo (max_values: None, max_size: None, mode: Measured) - /// Storage: ParachainStaking Round (r:1 w:0) - /// Proof Skipped: ParachainStaking Round (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: System Account (r:1 w:1) - /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) - /// Storage: ParachainStaking Total (r:1 w:1) - /// Proof Skipped: ParachainStaking Total (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: ParachainStaking CandidatePool (r:1 w:1) - /// Proof Skipped: ParachainStaking CandidatePool (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: `ParachainStaking::CandidateInfo` (r:1 w:1) + /// Proof: `ParachainStaking::CandidateInfo` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::Round` (r:1 w:0) + /// Proof: `ParachainStaking::Round` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `System::Account` (r:1 w:1) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) + /// Storage: `ParachainStaking::Total` (r:1 w:1) + /// Proof: `ParachainStaking::Total` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::CandidatePool` (r:1 w:1) + /// Proof: `ParachainStaking::CandidatePool` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) fn execute_candidate_bond_less() -> Weight { // Proof Size summary in bytes: // Measured: `918` // Estimated: `4383` - // Minimum execution time: 68_836_000 picoseconds. - Weight::from_parts(78_824_000, 0) + // Minimum execution time: 47_721_000 picoseconds. + Weight::from_parts(51_545_000, 0) .saturating_add(Weight::from_parts(0, 4383)) .saturating_add(T::DbWeight::get().reads(5)) .saturating_add(T::DbWeight::get().writes(4)) } - /// Storage: ParachainStaking CandidateInfo (r:1 w:1) - /// Proof Skipped: ParachainStaking CandidateInfo (max_values: None, max_size: None, mode: Measured) + /// Storage: `ParachainStaking::CandidateInfo` (r:1 w:1) + /// Proof: `ParachainStaking::CandidateInfo` (`max_values`: None, `max_size`: None, mode: `Measured`) fn cancel_candidate_bond_less() -> Weight { // Proof Size summary in bytes: // Measured: `582` // Estimated: `4047` - // Minimum execution time: 23_222_000 picoseconds. - Weight::from_parts(23_888_000, 0) + // Minimum execution time: 15_559_000 picoseconds. + Weight::from_parts(16_199_000, 0) .saturating_add(Weight::from_parts(0, 4047)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: ParachainStaking DelegatorState (r:1 w:1) - /// Proof Skipped: ParachainStaking DelegatorState (max_values: None, max_size: None, mode: Measured) - /// Storage: ParachainStaking Round (r:1 w:0) - /// Proof Skipped: ParachainStaking Round (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: ParachainStaking DelegationScheduledRequests (r:1 w:1) - /// Proof Skipped: ParachainStaking DelegationScheduledRequests (max_values: None, max_size: None, mode: Measured) + /// Storage: `ParachainStaking::DelegatorState` (r:1 w:1) + /// Proof: `ParachainStaking::DelegatorState` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::Round` (r:1 w:0) + /// Proof: `ParachainStaking::Round` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::DelegationScheduledRequests` (r:1 w:1) + /// Proof: `ParachainStaking::DelegationScheduledRequests` (`max_values`: None, `max_size`: None, mode: `Measured`) fn schedule_leave_delegators() -> Weight { // Proof Size summary in bytes: // Measured: `595` // Estimated: `4060` - // Minimum execution time: 32_704_000 picoseconds. - Weight::from_parts(33_765_000, 0) + // Minimum execution time: 21_772_000 picoseconds. + Weight::from_parts(22_653_000, 0) .saturating_add(Weight::from_parts(0, 4060)) .saturating_add(T::DbWeight::get().reads(3)) .saturating_add(T::DbWeight::get().writes(2)) } - /// Storage: ParachainStaking DelegatorState (r:1 w:1) - /// Proof Skipped: ParachainStaking DelegatorState (max_values: None, max_size: None, mode: Measured) - /// Storage: ParachainStaking Round (r:1 w:0) - /// Proof Skipped: ParachainStaking Round (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: ParachainStaking DelegationScheduledRequests (r:99 w:99) - /// Proof Skipped: ParachainStaking DelegationScheduledRequests (max_values: None, max_size: None, mode: Measured) - /// Storage: ParachainStaking CandidateInfo (r:99 w:99) - /// Proof Skipped: ParachainStaking CandidateInfo (max_values: None, max_size: None, mode: Measured) - /// Storage: ParachainStaking TopDelegations (r:99 w:99) - /// Proof Skipped: ParachainStaking TopDelegations (max_values: None, max_size: None, mode: Measured) - /// Storage: ParachainStaking CandidatePool (r:1 w:1) - /// Proof Skipped: ParachainStaking CandidatePool (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: System Account (r:1 w:1) - /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) - /// Storage: ParachainStaking Total (r:1 w:1) - /// Proof Skipped: ParachainStaking Total (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: ParachainStaking AutoCompoundingDelegations (r:99 w:0) - /// Proof Skipped: ParachainStaking AutoCompoundingDelegations (max_values: None, max_size: None, mode: Measured) + /// Storage: `ParachainStaking::DelegatorState` (r:1 w:1) + /// Proof: `ParachainStaking::DelegatorState` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::Round` (r:1 w:0) + /// Proof: `ParachainStaking::Round` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::DelegationScheduledRequests` (r:99 w:99) + /// Proof: `ParachainStaking::DelegationScheduledRequests` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::CandidateInfo` (r:99 w:99) + /// Proof: `ParachainStaking::CandidateInfo` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::TopDelegations` (r:99 w:99) + /// Proof: `ParachainStaking::TopDelegations` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::CandidatePool` (r:1 w:1) + /// Proof: `ParachainStaking::CandidatePool` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `System::Account` (r:1 w:1) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) + /// Storage: `ParachainStaking::Total` (r:1 w:1) + /// Proof: `ParachainStaking::Total` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::AutoCompoundingDelegations` (r:99 w:0) + /// Proof: `ParachainStaking::AutoCompoundingDelegations` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ScoreStaking::Scores` (r:1 w:0) + /// Proof: `ScoreStaking::Scores` (`max_values`: None, `max_size`: None, mode: `Measured`) /// The range of component `x` is `[2, 100]`. fn execute_leave_delegators(x: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `842 + x * (458 ±0)` - // Estimated: `4895 + x * (2852 ±0)` - // Minimum execution time: 107_084_000 picoseconds. - Weight::from_parts(110_608_000, 0) - .saturating_add(Weight::from_parts(0, 4895)) - // Standard Error: 249_345 - .saturating_add(Weight::from_parts(49_492_618, 0).saturating_mul(x.into())) - .saturating_add(T::DbWeight::get().reads(1)) + // Measured: `1008 + x * (458 ±0)` + // Estimated: `5061 + x * (2852 ±3)` + // Minimum execution time: 79_414_000 picoseconds. + Weight::from_parts(82_954_000, 0) + .saturating_add(Weight::from_parts(0, 5061)) + // Standard Error: 338_518 + .saturating_add(Weight::from_parts(44_951_389, 0).saturating_mul(x.into())) + .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().reads((4_u64).saturating_mul(x.into()))) .saturating_add(T::DbWeight::get().writes(1)) .saturating_add(T::DbWeight::get().writes((3_u64).saturating_mul(x.into()))) .saturating_add(Weight::from_parts(0, 2852).saturating_mul(x.into())) } - /// Storage: ParachainStaking DelegatorState (r:1 w:1) - /// Proof Skipped: ParachainStaking DelegatorState (max_values: None, max_size: None, mode: Measured) - /// Storage: ParachainStaking DelegationScheduledRequests (r:1 w:1) - /// Proof Skipped: ParachainStaking DelegationScheduledRequests (max_values: None, max_size: None, mode: Measured) + /// Storage: `ParachainStaking::DelegatorState` (r:1 w:1) + /// Proof: `ParachainStaking::DelegatorState` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::DelegationScheduledRequests` (r:1 w:1) + /// Proof: `ParachainStaking::DelegationScheduledRequests` (`max_values`: None, `max_size`: None, mode: `Measured`) fn cancel_leave_delegators() -> Weight { // Proof Size summary in bytes: // Measured: `720` // Estimated: `4185` - // Minimum execution time: 34_602_000 picoseconds. - Weight::from_parts(35_390_000, 0) + // Minimum execution time: 23_662_000 picoseconds. + Weight::from_parts(25_715_000, 0) .saturating_add(Weight::from_parts(0, 4185)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) } - /// Storage: ParachainStaking DelegatorState (r:1 w:1) - /// Proof Skipped: ParachainStaking DelegatorState (max_values: None, max_size: None, mode: Measured) - /// Storage: ParachainStaking DelegationScheduledRequests (r:1 w:1) - /// Proof Skipped: ParachainStaking DelegationScheduledRequests (max_values: None, max_size: None, mode: Measured) - /// Storage: ParachainStaking Round (r:1 w:0) - /// Proof Skipped: ParachainStaking Round (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: `ParachainStaking::DelegatorState` (r:1 w:1) + /// Proof: `ParachainStaking::DelegatorState` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::DelegationScheduledRequests` (r:1 w:1) + /// Proof: `ParachainStaking::DelegationScheduledRequests` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::Round` (r:1 w:0) + /// Proof: `ParachainStaking::Round` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) fn schedule_revoke_delegation() -> Weight { // Proof Size summary in bytes: // Measured: `595` // Estimated: `4060` - // Minimum execution time: 33_224_000 picoseconds. - Weight::from_parts(36_404_000, 0) + // Minimum execution time: 21_876_000 picoseconds. + Weight::from_parts(30_423_000, 0) .saturating_add(Weight::from_parts(0, 4060)) .saturating_add(T::DbWeight::get().reads(3)) .saturating_add(T::DbWeight::get().writes(2)) } - /// Storage: ParachainStaking DelegationScheduledRequests (r:1 w:0) - /// Proof Skipped: ParachainStaking DelegationScheduledRequests (max_values: None, max_size: None, mode: Measured) - /// Storage: ParachainStaking DelegatorState (r:1 w:1) - /// Proof Skipped: ParachainStaking DelegatorState (max_values: None, max_size: None, mode: Measured) - /// Storage: ParachainStaking CandidateInfo (r:1 w:1) - /// Proof Skipped: ParachainStaking CandidateInfo (max_values: None, max_size: None, mode: Measured) - /// Storage: System Account (r:1 w:1) - /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) - /// Storage: ParachainStaking TopDelegations (r:1 w:1) - /// Proof Skipped: ParachainStaking TopDelegations (max_values: None, max_size: None, mode: Measured) - /// Storage: ParachainStaking CandidatePool (r:1 w:1) - /// Proof Skipped: ParachainStaking CandidatePool (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: ParachainStaking Total (r:1 w:1) - /// Proof Skipped: ParachainStaking Total (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: `ParachainStaking::DelegationScheduledRequests` (r:1 w:0) + /// Proof: `ParachainStaking::DelegationScheduledRequests` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::DelegatorState` (r:1 w:1) + /// Proof: `ParachainStaking::DelegatorState` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::CandidateInfo` (r:1 w:1) + /// Proof: `ParachainStaking::CandidateInfo` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `System::Account` (r:1 w:1) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) + /// Storage: `ParachainStaking::TopDelegations` (r:1 w:1) + /// Proof: `ParachainStaking::TopDelegations` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::CandidatePool` (r:1 w:1) + /// Proof: `ParachainStaking::CandidatePool` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::Total` (r:1 w:1) + /// Proof: `ParachainStaking::Total` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) fn delegator_bond_more() -> Weight { // Proof Size summary in bytes: // Measured: `1217` // Estimated: `4682` - // Minimum execution time: 79_647_000 picoseconds. - Weight::from_parts(81_615_000, 0) + // Minimum execution time: 56_734_000 picoseconds. + Weight::from_parts(61_346_000, 0) .saturating_add(Weight::from_parts(0, 4682)) .saturating_add(T::DbWeight::get().reads(7)) .saturating_add(T::DbWeight::get().writes(6)) } - /// Storage: ParachainStaking DelegatorState (r:1 w:1) - /// Proof Skipped: ParachainStaking DelegatorState (max_values: None, max_size: None, mode: Measured) - /// Storage: ParachainStaking DelegationScheduledRequests (r:1 w:1) - /// Proof Skipped: ParachainStaking DelegationScheduledRequests (max_values: None, max_size: None, mode: Measured) - /// Storage: ParachainStaking Round (r:1 w:0) - /// Proof Skipped: ParachainStaking Round (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: `ParachainStaking::DelegatorState` (r:1 w:1) + /// Proof: `ParachainStaking::DelegatorState` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::DelegationScheduledRequests` (r:1 w:1) + /// Proof: `ParachainStaking::DelegationScheduledRequests` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::Round` (r:1 w:0) + /// Proof: `ParachainStaking::Round` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) fn schedule_delegator_bond_less() -> Weight { // Proof Size summary in bytes: // Measured: `595` // Estimated: `4060` - // Minimum execution time: 32_901_000 picoseconds. - Weight::from_parts(34_138_000, 0) + // Minimum execution time: 22_033_000 picoseconds. + Weight::from_parts(23_316_000, 0) .saturating_add(Weight::from_parts(0, 4060)) .saturating_add(T::DbWeight::get().reads(3)) .saturating_add(T::DbWeight::get().writes(2)) } - /// Storage: ParachainStaking DelegatorState (r:1 w:1) - /// Proof Skipped: ParachainStaking DelegatorState (max_values: None, max_size: None, mode: Measured) - /// Storage: ParachainStaking DelegationScheduledRequests (r:1 w:1) - /// Proof Skipped: ParachainStaking DelegationScheduledRequests (max_values: None, max_size: None, mode: Measured) - /// Storage: ParachainStaking Round (r:1 w:0) - /// Proof Skipped: ParachainStaking Round (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: ParachainStaking AutoCompoundingDelegations (r:1 w:0) - /// Proof Skipped: ParachainStaking AutoCompoundingDelegations (max_values: None, max_size: None, mode: Measured) - /// Storage: ParachainStaking CandidateInfo (r:1 w:1) - /// Proof Skipped: ParachainStaking CandidateInfo (max_values: None, max_size: None, mode: Measured) - /// Storage: ParachainStaking TopDelegations (r:1 w:1) - /// Proof Skipped: ParachainStaking TopDelegations (max_values: None, max_size: None, mode: Measured) - /// Storage: ParachainStaking CandidatePool (r:1 w:1) - /// Proof Skipped: ParachainStaking CandidatePool (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: System Account (r:1 w:1) - /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) - /// Storage: ParachainStaking Total (r:1 w:1) - /// Proof Skipped: ParachainStaking Total (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: `ParachainStaking::DelegatorState` (r:1 w:1) + /// Proof: `ParachainStaking::DelegatorState` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::DelegationScheduledRequests` (r:1 w:1) + /// Proof: `ParachainStaking::DelegationScheduledRequests` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::Round` (r:1 w:0) + /// Proof: `ParachainStaking::Round` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::AutoCompoundingDelegations` (r:1 w:0) + /// Proof: `ParachainStaking::AutoCompoundingDelegations` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::CandidateInfo` (r:1 w:1) + /// Proof: `ParachainStaking::CandidateInfo` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::TopDelegations` (r:1 w:1) + /// Proof: `ParachainStaking::TopDelegations` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::CandidatePool` (r:1 w:1) + /// Proof: `ParachainStaking::CandidatePool` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `System::Account` (r:1 w:1) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) + /// Storage: `ParachainStaking::Total` (r:1 w:1) + /// Proof: `ParachainStaking::Total` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ScoreStaking::Scores` (r:1 w:0) + /// Proof: `ScoreStaking::Scores` (`max_values`: None, `max_size`: None, mode: `Measured`) fn execute_revoke_delegation() -> Weight { // Proof Size summary in bytes: - // Measured: `1430` - // Estimated: `4895` - // Minimum execution time: 110_571_000 picoseconds. - Weight::from_parts(119_690_000, 0) - .saturating_add(Weight::from_parts(0, 4895)) - .saturating_add(T::DbWeight::get().reads(9)) + // Measured: `1596` + // Estimated: `5061` + // Minimum execution time: 82_289_000 picoseconds. + Weight::from_parts(85_150_000, 0) + .saturating_add(Weight::from_parts(0, 5061)) + .saturating_add(T::DbWeight::get().reads(10)) .saturating_add(T::DbWeight::get().writes(7)) } - /// Storage: ParachainStaking DelegatorState (r:1 w:1) - /// Proof Skipped: ParachainStaking DelegatorState (max_values: None, max_size: None, mode: Measured) - /// Storage: ParachainStaking DelegationScheduledRequests (r:1 w:1) - /// Proof Skipped: ParachainStaking DelegationScheduledRequests (max_values: None, max_size: None, mode: Measured) - /// Storage: ParachainStaking Round (r:1 w:0) - /// Proof Skipped: ParachainStaking Round (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: ParachainStaking CandidateInfo (r:1 w:1) - /// Proof Skipped: ParachainStaking CandidateInfo (max_values: None, max_size: None, mode: Measured) - /// Storage: System Account (r:1 w:1) - /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) - /// Storage: ParachainStaking TopDelegations (r:1 w:1) - /// Proof Skipped: ParachainStaking TopDelegations (max_values: None, max_size: None, mode: Measured) - /// Storage: ParachainStaking CandidatePool (r:1 w:1) - /// Proof Skipped: ParachainStaking CandidatePool (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: ParachainStaking Total (r:1 w:1) - /// Proof Skipped: ParachainStaking Total (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: `ParachainStaking::DelegatorState` (r:1 w:1) + /// Proof: `ParachainStaking::DelegatorState` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::DelegationScheduledRequests` (r:1 w:1) + /// Proof: `ParachainStaking::DelegationScheduledRequests` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::Round` (r:1 w:0) + /// Proof: `ParachainStaking::Round` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::CandidateInfo` (r:1 w:1) + /// Proof: `ParachainStaking::CandidateInfo` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `System::Account` (r:1 w:1) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) + /// Storage: `ParachainStaking::TopDelegations` (r:1 w:1) + /// Proof: `ParachainStaking::TopDelegations` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::CandidatePool` (r:1 w:1) + /// Proof: `ParachainStaking::CandidatePool` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::Total` (r:1 w:1) + /// Proof: `ParachainStaking::Total` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) fn execute_delegator_bond_less() -> Weight { // Proof Size summary in bytes: // Measured: `1375` // Estimated: `4840` - // Minimum execution time: 95_049_000 picoseconds. - Weight::from_parts(102_650_000, 0) + // Minimum execution time: 66_897_000 picoseconds. + Weight::from_parts(72_647_000, 0) .saturating_add(Weight::from_parts(0, 4840)) .saturating_add(T::DbWeight::get().reads(8)) .saturating_add(T::DbWeight::get().writes(7)) } - /// Storage: ParachainStaking DelegatorState (r:1 w:1) - /// Proof Skipped: ParachainStaking DelegatorState (max_values: None, max_size: None, mode: Measured) - /// Storage: ParachainStaking DelegationScheduledRequests (r:1 w:1) - /// Proof Skipped: ParachainStaking DelegationScheduledRequests (max_values: None, max_size: None, mode: Measured) + /// Storage: `ParachainStaking::DelegatorState` (r:1 w:1) + /// Proof: `ParachainStaking::DelegatorState` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::DelegationScheduledRequests` (r:1 w:1) + /// Proof: `ParachainStaking::DelegationScheduledRequests` (`max_values`: None, `max_size`: None, mode: `Measured`) fn cancel_revoke_delegation() -> Weight { // Proof Size summary in bytes: // Measured: `720` // Estimated: `4185` - // Minimum execution time: 31_569_000 picoseconds. - Weight::from_parts(32_404_000, 0) + // Minimum execution time: 22_063_000 picoseconds. + Weight::from_parts(23_092_000, 0) .saturating_add(Weight::from_parts(0, 4185)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) } - /// Storage: ParachainStaking DelegatorState (r:1 w:1) - /// Proof Skipped: ParachainStaking DelegatorState (max_values: None, max_size: None, mode: Measured) - /// Storage: ParachainStaking DelegationScheduledRequests (r:1 w:1) - /// Proof Skipped: ParachainStaking DelegationScheduledRequests (max_values: None, max_size: None, mode: Measured) + /// Storage: `ParachainStaking::DelegatorState` (r:1 w:1) + /// Proof: `ParachainStaking::DelegatorState` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::DelegationScheduledRequests` (r:1 w:1) + /// Proof: `ParachainStaking::DelegationScheduledRequests` (`max_values`: None, `max_size`: None, mode: `Measured`) fn cancel_delegator_bond_less() -> Weight { // Proof Size summary in bytes: // Measured: `753` // Estimated: `4218` - // Minimum execution time: 37_328_000 picoseconds. - Weight::from_parts(39_282_000, 0) + // Minimum execution time: 27_125_000 picoseconds. + Weight::from_parts(29_839_000, 0) .saturating_add(Weight::from_parts(0, 4218)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) } - /// Storage: ParachainStaking Round (r:1 w:1) - /// Proof Skipped: ParachainStaking Round (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: ParachainStaking Points (r:1 w:0) - /// Proof Skipped: ParachainStaking Points (max_values: None, max_size: None, mode: Measured) - /// Storage: ParachainStaking Staked (r:1 w:2) - /// Proof Skipped: ParachainStaking Staked (max_values: None, max_size: None, mode: Measured) - /// Storage: ParachainStaking InflationConfig (r:1 w:0) - /// Proof Skipped: ParachainStaking InflationConfig (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: BridgeTransfer ExternalBalances (r:1 w:0) - /// Proof Skipped: BridgeTransfer ExternalBalances (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: ParachainStaking ParachainBondInfo (r:1 w:0) - /// Proof Skipped: ParachainStaking ParachainBondInfo (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: ParachainStaking CollatorCommission (r:1 w:0) - /// Proof Skipped: ParachainStaking CollatorCommission (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: ParachainStaking CandidatePool (r:1 w:0) - /// Proof Skipped: ParachainStaking CandidatePool (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: ParachainStaking TotalSelected (r:1 w:0) - /// Proof Skipped: ParachainStaking TotalSelected (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: ParachainStaking CandidateInfo (r:99 w:0) - /// Proof Skipped: ParachainStaking CandidateInfo (max_values: None, max_size: None, mode: Measured) - /// Storage: ParachainStaking DelegationScheduledRequests (r:99 w:0) - /// Proof Skipped: ParachainStaking DelegationScheduledRequests (max_values: None, max_size: None, mode: Measured) - /// Storage: ParachainStaking TopDelegations (r:99 w:0) - /// Proof Skipped: ParachainStaking TopDelegations (max_values: None, max_size: None, mode: Measured) - /// Storage: ParachainStaking AutoCompoundingDelegations (r:99 w:0) - /// Proof Skipped: ParachainStaking AutoCompoundingDelegations (max_values: None, max_size: None, mode: Measured) - /// Storage: ParachainStaking Total (r:1 w:0) - /// Proof Skipped: ParachainStaking Total (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: ParachainStaking AwardedPts (r:2 w:1) - /// Proof Skipped: ParachainStaking AwardedPts (max_values: None, max_size: None, mode: Measured) - /// Storage: ParachainStaking AtStake (r:1 w:100) - /// Proof Skipped: ParachainStaking AtStake (max_values: None, max_size: None, mode: Measured) - /// Storage: System Account (r:1 w:1) - /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) - /// Storage: ParachainStaking SelectedCandidates (r:0 w:1) - /// Proof Skipped: ParachainStaking SelectedCandidates (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: ParachainStaking DelayedPayouts (r:0 w:1) - /// Proof Skipped: ParachainStaking DelayedPayouts (max_values: None, max_size: None, mode: Measured) + /// Storage: `ParachainStaking::Round` (r:1 w:1) + /// Proof: `ParachainStaking::Round` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::Points` (r:1 w:0) + /// Proof: `ParachainStaking::Points` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::Staked` (r:1 w:2) + /// Proof: `ParachainStaking::Staked` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::InflationConfig` (r:1 w:0) + /// Proof: `ParachainStaking::InflationConfig` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `AssetsHandler::ExternalBalances` (r:1 w:0) + /// Proof: `AssetsHandler::ExternalBalances` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::ParachainBondInfo` (r:1 w:0) + /// Proof: `ParachainStaking::ParachainBondInfo` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::CollatorCommission` (r:1 w:0) + /// Proof: `ParachainStaking::CollatorCommission` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::CandidatePool` (r:1 w:0) + /// Proof: `ParachainStaking::CandidatePool` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::TotalSelected` (r:1 w:0) + /// Proof: `ParachainStaking::TotalSelected` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::CandidateInfo` (r:99 w:0) + /// Proof: `ParachainStaking::CandidateInfo` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::DelegationScheduledRequests` (r:99 w:0) + /// Proof: `ParachainStaking::DelegationScheduledRequests` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::TopDelegations` (r:99 w:0) + /// Proof: `ParachainStaking::TopDelegations` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::AutoCompoundingDelegations` (r:99 w:0) + /// Proof: `ParachainStaking::AutoCompoundingDelegations` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::Total` (r:1 w:0) + /// Proof: `ParachainStaking::Total` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::AwardedPts` (r:2 w:1) + /// Proof: `ParachainStaking::AwardedPts` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::AtStake` (r:1 w:100) + /// Proof: `ParachainStaking::AtStake` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `System::Account` (r:1 w:1) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) + /// Storage: `ParachainStaking::SelectedCandidates` (r:0 w:1) + /// Proof: `ParachainStaking::SelectedCandidates` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::DelayedPayouts` (r:0 w:1) + /// Proof: `ParachainStaking::DelayedPayouts` (`max_values`: None, `max_size`: None, mode: `Measured`) /// The range of component `x` is `[8, 100]`. /// The range of component `y` is `[0, 5000]`. fn round_transition_on_initialize(x: u32, y: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `4314 + x * (297 ±0) + y * (47 ±0)` + // Measured: `4347 + x * (297 ±0) + y * (47 ±0)` // Estimated: `519520 + x * (2390 ±43) + y * (46 ±0)` - // Minimum execution time: 1_115_440_000 picoseconds. - Weight::from_parts(5_542_981_467, 0) + // Minimum execution time: 829_036_000 picoseconds. + Weight::from_parts(4_788_241_561, 0) .saturating_add(Weight::from_parts(0, 519520)) .saturating_add(T::DbWeight::get().reads(214)) .saturating_add(T::DbWeight::get().reads((2_u64).saturating_mul(x.into()))) @@ -622,79 +626,79 @@ impl pallet_parachain_staking::WeightInfo for WeightInf .saturating_add(Weight::from_parts(0, 2390).saturating_mul(x.into())) .saturating_add(Weight::from_parts(0, 46).saturating_mul(y.into())) } - /// Storage: ParachainStaking DelayedPayouts (r:1 w:0) - /// Proof Skipped: ParachainStaking DelayedPayouts (max_values: None, max_size: None, mode: Measured) - /// Storage: ParachainStaking Points (r:1 w:0) - /// Proof Skipped: ParachainStaking Points (max_values: None, max_size: None, mode: Measured) - /// Storage: ParachainStaking AwardedPts (r:2 w:1) - /// Proof Skipped: ParachainStaking AwardedPts (max_values: None, max_size: None, mode: Measured) - /// Storage: ParachainStaking AtStake (r:1 w:1) - /// Proof Skipped: ParachainStaking AtStake (max_values: None, max_size: None, mode: Measured) - /// Storage: System Account (r:1001 w:1001) - /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + /// Storage: `ParachainStaking::DelayedPayouts` (r:1 w:0) + /// Proof: `ParachainStaking::DelayedPayouts` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::Points` (r:1 w:0) + /// Proof: `ParachainStaking::Points` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::AwardedPts` (r:2 w:1) + /// Proof: `ParachainStaking::AwardedPts` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::AtStake` (r:1 w:1) + /// Proof: `ParachainStaking::AtStake` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `System::Account` (r:1001 w:1001) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) /// The range of component `y` is `[0, 1000]`. fn pay_one_collator_reward(y: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `399 + y * (185 ±0)` // Estimated: `6424 + y * (2603 ±0)` - // Minimum execution time: 57_443_000 picoseconds. - Weight::from_parts(58_174_000, 0) + // Minimum execution time: 41_873_000 picoseconds. + Weight::from_parts(42_692_000, 0) .saturating_add(Weight::from_parts(0, 6424)) - // Standard Error: 88_095 - .saturating_add(Weight::from_parts(24_777_782, 0).saturating_mul(y.into())) + // Standard Error: 54_978 + .saturating_add(Weight::from_parts(22_646_853, 0).saturating_mul(y.into())) .saturating_add(T::DbWeight::get().reads(6)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(y.into()))) .saturating_add(T::DbWeight::get().writes(3)) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(y.into()))) .saturating_add(Weight::from_parts(0, 2603).saturating_mul(y.into())) } - /// Storage: ParachainStaking Round (r:1 w:0) - /// Proof Skipped: ParachainStaking Round (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: `ParachainStaking::Round` (r:1 w:0) + /// Proof: `ParachainStaking::Round` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) fn base_on_initialize() -> Weight { // Proof Size summary in bytes: // Measured: `447` // Estimated: `1932` - // Minimum execution time: 7_210_000 picoseconds. - Weight::from_parts(7_485_000, 0) + // Minimum execution time: 4_640_000 picoseconds. + Weight::from_parts(4_902_000, 0) .saturating_add(Weight::from_parts(0, 1932)) .saturating_add(T::DbWeight::get().reads(1)) } - /// Storage: ParachainStaking DelegatorState (r:1 w:0) - /// Proof Skipped: ParachainStaking DelegatorState (max_values: None, max_size: None, mode: Measured) - /// Storage: ParachainStaking AutoCompoundingDelegations (r:1 w:1) - /// Proof Skipped: ParachainStaking AutoCompoundingDelegations (max_values: None, max_size: None, mode: Measured) + /// Storage: `ParachainStaking::DelegatorState` (r:1 w:0) + /// Proof: `ParachainStaking::DelegatorState` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::AutoCompoundingDelegations` (r:1 w:1) + /// Proof: `ParachainStaking::AutoCompoundingDelegations` (`max_values`: None, `max_size`: None, mode: `Measured`) /// The range of component `x` is `[0, 1000]`. /// The range of component `y` is `[0, 100]`. fn set_auto_compound(x: u32, y: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `1273 + x * (33 ±0) + y * (48 ±0)` // Estimated: `4574 + x * (34 ±0) + y * (49 ±0)` - // Minimum execution time: 55_958_000 picoseconds. - Weight::from_parts(77_348_747, 0) + // Minimum execution time: 38_548_000 picoseconds. + Weight::from_parts(43_959_261, 0) .saturating_add(Weight::from_parts(0, 4574)) - // Standard Error: 2_370 - .saturating_add(Weight::from_parts(122_993, 0).saturating_mul(x.into())) + // Standard Error: 2_369 + .saturating_add(Weight::from_parts(89_391, 0).saturating_mul(x.into())) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(1)) .saturating_add(Weight::from_parts(0, 34).saturating_mul(x.into())) .saturating_add(Weight::from_parts(0, 49).saturating_mul(y.into())) } - /// Storage: System Account (r:1 w:1) - /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) - /// Storage: ParachainStaking DelegatorState (r:1 w:1) - /// Proof Skipped: ParachainStaking DelegatorState (max_values: None, max_size: None, mode: Measured) - /// Storage: ParachainStaking CandidateInfo (r:1 w:1) - /// Proof Skipped: ParachainStaking CandidateInfo (max_values: None, max_size: None, mode: Measured) - /// Storage: ParachainStaking AutoCompoundingDelegations (r:1 w:1) - /// Proof Skipped: ParachainStaking AutoCompoundingDelegations (max_values: None, max_size: None, mode: Measured) - /// Storage: ParachainStaking BottomDelegations (r:1 w:1) - /// Proof Skipped: ParachainStaking BottomDelegations (max_values: None, max_size: None, mode: Measured) - /// Storage: ParachainStaking Total (r:1 w:1) - /// Proof Skipped: ParachainStaking Total (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: ParachainStaking TopDelegations (r:1 w:1) - /// Proof Skipped: ParachainStaking TopDelegations (max_values: None, max_size: None, mode: Measured) - /// Storage: ParachainStaking CandidatePool (r:1 w:1) - /// Proof Skipped: ParachainStaking CandidatePool (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: `System::Account` (r:1 w:1) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) + /// Storage: `ParachainStaking::DelegatorState` (r:1 w:1) + /// Proof: `ParachainStaking::DelegatorState` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::CandidateInfo` (r:1 w:1) + /// Proof: `ParachainStaking::CandidateInfo` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::AutoCompoundingDelegations` (r:1 w:1) + /// Proof: `ParachainStaking::AutoCompoundingDelegations` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::BottomDelegations` (r:1 w:1) + /// Proof: `ParachainStaking::BottomDelegations` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::Total` (r:1 w:1) + /// Proof: `ParachainStaking::Total` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::TopDelegations` (r:1 w:1) + /// Proof: `ParachainStaking::TopDelegations` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParachainStaking::CandidatePool` (r:1 w:1) + /// Proof: `ParachainStaking::CandidatePool` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) /// The range of component `x` is `[0, 1200]`. /// The range of component `y` is `[0, 1200]`. /// The range of component `z` is `[0, 100]`. @@ -702,13 +706,13 @@ impl pallet_parachain_staking::WeightInfo for WeightInf // Proof Size summary in bytes: // Measured: `0 + x * (81 ±0) + y * (33 ±0) + z * (55 ±0)` // Estimated: `21773 + x * (82 ±0) + y * (31 ±0) + z * (29 ±0)` - // Minimum execution time: 131_239_000 picoseconds. - Weight::from_parts(135_171_000, 0) + // Minimum execution time: 89_451_000 picoseconds. + Weight::from_parts(95_607_000, 0) .saturating_add(Weight::from_parts(0, 21773)) - // Standard Error: 2_862 - .saturating_add(Weight::from_parts(71_798, 0).saturating_mul(x.into())) - // Standard Error: 2_862 - .saturating_add(Weight::from_parts(94_592, 0).saturating_mul(y.into())) + // Standard Error: 1_809 + .saturating_add(Weight::from_parts(50_247, 0).saturating_mul(x.into())) + // Standard Error: 1_809 + .saturating_add(Weight::from_parts(61_589, 0).saturating_mul(y.into())) .saturating_add(T::DbWeight::get().reads(7)) .saturating_add(T::DbWeight::get().writes(7)) .saturating_add(Weight::from_parts(0, 82).saturating_mul(x.into())) diff --git a/runtime/paseo/src/weights/pallet_preimage.rs b/runtime/paseo/src/weights/pallet_preimage.rs index 967472a8e9..c34bc1508f 100644 --- a/runtime/paseo/src/weights/pallet_preimage.rs +++ b/runtime/paseo/src/weights/pallet_preimage.rs @@ -17,10 +17,10 @@ //! Autogenerated weights for `pallet_preimage` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-10-17, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-08-28, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `parachain-benchmark`, CPU: `Intel(R) Xeon(R) Platinum 8259CL CPU @ 2.50GHz` -//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("rococo-dev"), DB CACHE: 20 +//! HOSTNAME: `litentry-benchmark-server`, CPU: `Intel(R) Xeon(R) CPU E5-2686 v4 @ 2.30GHz` +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("rococo-dev")`, DB CACHE: 20 // Executed Command: // ./litentry-collator @@ -49,167 +49,167 @@ use core::marker::PhantomData; /// Weight functions for `pallet_preimage`. pub struct WeightInfo(PhantomData); impl pallet_preimage::WeightInfo for WeightInfo { - /// Storage: Preimage StatusFor (r:1 w:1) - /// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen) - /// Storage: Preimage PreimageFor (r:0 w:1) - /// Proof: Preimage PreimageFor (max_values: None, max_size: Some(4194344), added: 4196819, mode: MaxEncodedLen) + /// Storage: `Preimage::StatusFor` (r:1 w:1) + /// Proof: `Preimage::StatusFor` (`max_values`: None, `max_size`: Some(91), added: 2566, mode: `MaxEncodedLen`) + /// Storage: `Preimage::PreimageFor` (r:0 w:1) + /// Proof: `Preimage::PreimageFor` (`max_values`: None, `max_size`: Some(4194344), added: 4196819, mode: `MaxEncodedLen`) /// The range of component `s` is `[0, 4194304]`. fn note_preimage(s: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `177` // Estimated: `3556` - // Minimum execution time: 41_433_000 picoseconds. - Weight::from_parts(42_090_000, 0) + // Minimum execution time: 28_776_000 picoseconds. + Weight::from_parts(29_081_000, 0) .saturating_add(Weight::from_parts(0, 3556)) - // Standard Error: 4 - .saturating_add(Weight::from_parts(3_458, 0).saturating_mul(s.into())) + // Standard Error: 7 + .saturating_add(Weight::from_parts(3_231, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(2)) } - /// Storage: Preimage StatusFor (r:1 w:1) - /// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen) - /// Storage: Preimage PreimageFor (r:0 w:1) - /// Proof: Preimage PreimageFor (max_values: None, max_size: Some(4194344), added: 4196819, mode: MaxEncodedLen) + /// Storage: `Preimage::StatusFor` (r:1 w:1) + /// Proof: `Preimage::StatusFor` (`max_values`: None, `max_size`: Some(91), added: 2566, mode: `MaxEncodedLen`) + /// Storage: `Preimage::PreimageFor` (r:0 w:1) + /// Proof: `Preimage::PreimageFor` (`max_values`: None, `max_size`: Some(4194344), added: 4196819, mode: `MaxEncodedLen`) /// The range of component `s` is `[0, 4194304]`. fn note_requested_preimage(s: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `140` // Estimated: `3556` - // Minimum execution time: 23_563_000 picoseconds. - Weight::from_parts(23_826_000, 0) + // Minimum execution time: 15_682_000 picoseconds. + Weight::from_parts(16_044_000, 0) .saturating_add(Weight::from_parts(0, 3556)) - // Standard Error: 9 - .saturating_add(Weight::from_parts(3_534, 0).saturating_mul(s.into())) + // Standard Error: 11 + .saturating_add(Weight::from_parts(3_369, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(2)) } - /// Storage: Preimage StatusFor (r:1 w:1) - /// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen) - /// Storage: Preimage PreimageFor (r:0 w:1) - /// Proof: Preimage PreimageFor (max_values: None, max_size: Some(4194344), added: 4196819, mode: MaxEncodedLen) + /// Storage: `Preimage::StatusFor` (r:1 w:1) + /// Proof: `Preimage::StatusFor` (`max_values`: None, `max_size`: Some(91), added: 2566, mode: `MaxEncodedLen`) + /// Storage: `Preimage::PreimageFor` (r:0 w:1) + /// Proof: `Preimage::PreimageFor` (`max_values`: None, `max_size`: Some(4194344), added: 4196819, mode: `MaxEncodedLen`) /// The range of component `s` is `[0, 4194304]`. fn note_no_deposit_preimage(s: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `140` // Estimated: `3556` - // Minimum execution time: 22_126_000 picoseconds. - Weight::from_parts(22_630_000, 0) + // Minimum execution time: 14_685_000 picoseconds. + Weight::from_parts(14_901_000, 0) .saturating_add(Weight::from_parts(0, 3556)) - // Standard Error: 7 - .saturating_add(Weight::from_parts(3_475, 0).saturating_mul(s.into())) + // Standard Error: 9 + .saturating_add(Weight::from_parts(3_386, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(2)) } - /// Storage: Preimage StatusFor (r:1 w:1) - /// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen) - /// Storage: Preimage PreimageFor (r:0 w:1) - /// Proof: Preimage PreimageFor (max_values: None, max_size: Some(4194344), added: 4196819, mode: MaxEncodedLen) + /// Storage: `Preimage::StatusFor` (r:1 w:1) + /// Proof: `Preimage::StatusFor` (`max_values`: None, `max_size`: Some(91), added: 2566, mode: `MaxEncodedLen`) + /// Storage: `Preimage::PreimageFor` (r:0 w:1) + /// Proof: `Preimage::PreimageFor` (`max_values`: None, `max_size`: Some(4194344), added: 4196819, mode: `MaxEncodedLen`) fn unnote_preimage() -> Weight { // Proof Size summary in bytes: // Measured: `323` // Estimated: `3556` - // Minimum execution time: 77_583_000 picoseconds. - Weight::from_parts(82_134_000, 0) + // Minimum execution time: 50_875_000 picoseconds. + Weight::from_parts(57_436_000, 0) .saturating_add(Weight::from_parts(0, 3556)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(2)) } - /// Storage: Preimage StatusFor (r:1 w:1) - /// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen) - /// Storage: Preimage PreimageFor (r:0 w:1) - /// Proof: Preimage PreimageFor (max_values: None, max_size: Some(4194344), added: 4196819, mode: MaxEncodedLen) + /// Storage: `Preimage::StatusFor` (r:1 w:1) + /// Proof: `Preimage::StatusFor` (`max_values`: None, `max_size`: Some(91), added: 2566, mode: `MaxEncodedLen`) + /// Storage: `Preimage::PreimageFor` (r:0 w:1) + /// Proof: `Preimage::PreimageFor` (`max_values`: None, `max_size`: Some(4194344), added: 4196819, mode: `MaxEncodedLen`) fn unnote_no_deposit_preimage() -> Weight { // Proof Size summary in bytes: // Measured: `178` // Estimated: `3556` - // Minimum execution time: 54_470_000 picoseconds. - Weight::from_parts(58_016_000, 0) + // Minimum execution time: 33_855_000 picoseconds. + Weight::from_parts(39_934_000, 0) .saturating_add(Weight::from_parts(0, 3556)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(2)) } - /// Storage: Preimage StatusFor (r:1 w:1) - /// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen) + /// Storage: `Preimage::StatusFor` (r:1 w:1) + /// Proof: `Preimage::StatusFor` (`max_values`: None, `max_size`: Some(91), added: 2566, mode: `MaxEncodedLen`) fn request_preimage() -> Weight { // Proof Size summary in bytes: // Measured: `222` // Estimated: `3556` - // Minimum execution time: 48_971_000 picoseconds. - Weight::from_parts(53_088_000, 0) + // Minimum execution time: 29_810_000 picoseconds. + Weight::from_parts(36_615_000, 0) .saturating_add(Weight::from_parts(0, 3556)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: Preimage StatusFor (r:1 w:1) - /// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen) + /// Storage: `Preimage::StatusFor` (r:1 w:1) + /// Proof: `Preimage::StatusFor` (`max_values`: None, `max_size`: Some(91), added: 2566, mode: `MaxEncodedLen`) fn request_no_deposit_preimage() -> Weight { // Proof Size summary in bytes: // Measured: `178` // Estimated: `3556` - // Minimum execution time: 34_485_000 picoseconds. - Weight::from_parts(37_286_000, 0) + // Minimum execution time: 19_068_000 picoseconds. + Weight::from_parts(23_875_000, 0) .saturating_add(Weight::from_parts(0, 3556)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: Preimage StatusFor (r:1 w:1) - /// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen) + /// Storage: `Preimage::StatusFor` (r:1 w:1) + /// Proof: `Preimage::StatusFor` (`max_values`: None, `max_size`: Some(91), added: 2566, mode: `MaxEncodedLen`) fn request_unnoted_preimage() -> Weight { // Proof Size summary in bytes: // Measured: `76` // Estimated: `3556` - // Minimum execution time: 40_145_000 picoseconds. - Weight::from_parts(43_200_000, 0) + // Minimum execution time: 18_539_000 picoseconds. + Weight::from_parts(23_207_000, 0) .saturating_add(Weight::from_parts(0, 3556)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: Preimage StatusFor (r:1 w:1) - /// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen) + /// Storage: `Preimage::StatusFor` (r:1 w:1) + /// Proof: `Preimage::StatusFor` (`max_values`: None, `max_size`: Some(91), added: 2566, mode: `MaxEncodedLen`) fn request_requested_preimage() -> Weight { // Proof Size summary in bytes: // Measured: `140` // Estimated: `3556` - // Minimum execution time: 19_404_000 picoseconds. - Weight::from_parts(21_866_000, 0) + // Minimum execution time: 10_579_000 picoseconds. + Weight::from_parts(11_917_000, 0) .saturating_add(Weight::from_parts(0, 3556)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: Preimage StatusFor (r:1 w:1) - /// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen) - /// Storage: Preimage PreimageFor (r:0 w:1) - /// Proof: Preimage PreimageFor (max_values: None, max_size: Some(4194344), added: 4196819, mode: MaxEncodedLen) + /// Storage: `Preimage::StatusFor` (r:1 w:1) + /// Proof: `Preimage::StatusFor` (`max_values`: None, `max_size`: Some(91), added: 2566, mode: `MaxEncodedLen`) + /// Storage: `Preimage::PreimageFor` (r:0 w:1) + /// Proof: `Preimage::PreimageFor` (`max_values`: None, `max_size`: Some(4194344), added: 4196819, mode: `MaxEncodedLen`) fn unrequest_preimage() -> Weight { // Proof Size summary in bytes: // Measured: `178` // Estimated: `3556` - // Minimum execution time: 51_315_000 picoseconds. - Weight::from_parts(55_663_000, 0) + // Minimum execution time: 31_098_000 picoseconds. + Weight::from_parts(38_182_000, 0) .saturating_add(Weight::from_parts(0, 3556)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(2)) } - /// Storage: Preimage StatusFor (r:1 w:1) - /// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen) + /// Storage: `Preimage::StatusFor` (r:1 w:1) + /// Proof: `Preimage::StatusFor` (`max_values`: None, `max_size`: Some(91), added: 2566, mode: `MaxEncodedLen`) fn unrequest_unnoted_preimage() -> Weight { // Proof Size summary in bytes: // Measured: `140` // Estimated: `3556` - // Minimum execution time: 18_755_000 picoseconds. - Weight::from_parts(21_083_000, 0) + // Minimum execution time: 11_423_000 picoseconds. + Weight::from_parts(13_067_000, 0) .saturating_add(Weight::from_parts(0, 3556)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: Preimage StatusFor (r:1 w:1) - /// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen) + /// Storage: `Preimage::StatusFor` (r:1 w:1) + /// Proof: `Preimage::StatusFor` (`max_values`: None, `max_size`: Some(91), added: 2566, mode: `MaxEncodedLen`) fn unrequest_multi_referenced_preimage() -> Weight { // Proof Size summary in bytes: // Measured: `140` // Estimated: `3556` - // Minimum execution time: 18_516_000 picoseconds. - Weight::from_parts(19_962_000, 0) + // Minimum execution time: 10_892_000 picoseconds. + Weight::from_parts(12_065_000, 0) .saturating_add(Weight::from_parts(0, 3556)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) diff --git a/runtime/paseo/src/weights/pallet_proxy.rs b/runtime/paseo/src/weights/pallet_proxy.rs index 56a78bd262..8b3aac0722 100644 --- a/runtime/paseo/src/weights/pallet_proxy.rs +++ b/runtime/paseo/src/weights/pallet_proxy.rs @@ -17,10 +17,10 @@ //! Autogenerated weights for `pallet_proxy` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-10-17, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-08-28, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `parachain-benchmark`, CPU: `Intel(R) Xeon(R) Platinum 8259CL CPU @ 2.50GHz` -//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("rococo-dev"), DB CACHE: 20 +//! HOSTNAME: `litentry-benchmark-server`, CPU: `Intel(R) Xeon(R) CPU E5-2686 v4 @ 2.30GHz` +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("rococo-dev")`, DB CACHE: 20 // Executed Command: // ./litentry-collator @@ -49,176 +49,174 @@ use core::marker::PhantomData; /// Weight functions for `pallet_proxy`. pub struct WeightInfo(PhantomData); impl pallet_proxy::WeightInfo for WeightInfo { - /// Storage: Proxy Proxies (r:1 w:0) - /// Proof: Proxy Proxies (max_values: None, max_size: Some(1241), added: 3716, mode: MaxEncodedLen) + /// Storage: `Proxy::Proxies` (r:1 w:0) + /// Proof: `Proxy::Proxies` (`max_values`: None, `max_size`: Some(1241), added: 3716, mode: `MaxEncodedLen`) /// The range of component `p` is `[1, 31]`. fn proxy(p: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `161 + p * (37 ±0)` + // Measured: `227 + p * (37 ±0)` // Estimated: `4706` - // Minimum execution time: 21_822_000 picoseconds. - Weight::from_parts(24_219_925, 0) + // Minimum execution time: 14_852_000 picoseconds. + Weight::from_parts(15_496_268, 0) .saturating_add(Weight::from_parts(0, 4706)) - // Standard Error: 7_971 - .saturating_add(Weight::from_parts(929, 0).saturating_mul(p.into())) + // Standard Error: 3_760 + .saturating_add(Weight::from_parts(61_031, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(1)) } - /// Storage: Proxy Proxies (r:1 w:0) - /// Proof: Proxy Proxies (max_values: None, max_size: Some(1241), added: 3716, mode: MaxEncodedLen) - /// Storage: Proxy Announcements (r:1 w:1) - /// Proof: Proxy Announcements (max_values: None, max_size: Some(2233), added: 4708, mode: MaxEncodedLen) - /// Storage: System Account (r:1 w:1) - /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + /// Storage: `Proxy::Proxies` (r:1 w:0) + /// Proof: `Proxy::Proxies` (`max_values`: None, `max_size`: Some(1241), added: 3716, mode: `MaxEncodedLen`) + /// Storage: `Proxy::Announcements` (r:1 w:1) + /// Proof: `Proxy::Announcements` (`max_values`: None, `max_size`: Some(2233), added: 4708, mode: `MaxEncodedLen`) + /// Storage: `System::Account` (r:1 w:1) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) /// The range of component `a` is `[0, 31]`. /// The range of component `p` is `[1, 31]`. fn proxy_announced(a: u32, p: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `451 + a * (68 ±0) + p * (37 ±0)` + // Measured: `517 + a * (68 ±0) + p * (37 ±0)` // Estimated: `5698` - // Minimum execution time: 50_263_000 picoseconds. - Weight::from_parts(48_891_760, 0) + // Minimum execution time: 36_109_000 picoseconds. + Weight::from_parts(40_625_859, 0) .saturating_add(Weight::from_parts(0, 5698)) - // Standard Error: 10_810 - .saturating_add(Weight::from_parts(274_273, 0).saturating_mul(a.into())) - // Standard Error: 11_177 - .saturating_add(Weight::from_parts(107_749, 0).saturating_mul(p.into())) + // Standard Error: 12_274 + .saturating_add(Weight::from_parts(63_550, 0).saturating_mul(a.into())) + // Standard Error: 12_690 + .saturating_add(Weight::from_parts(22_123, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(3)) .saturating_add(T::DbWeight::get().writes(2)) } - /// Storage: Proxy Announcements (r:1 w:1) - /// Proof: Proxy Announcements (max_values: None, max_size: Some(2233), added: 4708, mode: MaxEncodedLen) - /// Storage: System Account (r:1 w:1) - /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + /// Storage: `Proxy::Announcements` (r:1 w:1) + /// Proof: `Proxy::Announcements` (`max_values`: None, `max_size`: Some(2233), added: 4708, mode: `MaxEncodedLen`) + /// Storage: `System::Account` (r:1 w:1) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) /// The range of component `a` is `[0, 31]`. /// The range of component `p` is `[1, 31]`. fn remove_announcement(a: u32, p: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `366 + a * (68 ±0)` + // Measured: `432 + a * (68 ±0)` // Estimated: `5698` - // Minimum execution time: 32_330_000 picoseconds. - Weight::from_parts(35_755_184, 0) + // Minimum execution time: 23_471_000 picoseconds. + Weight::from_parts(24_712_512, 0) .saturating_add(Weight::from_parts(0, 5698)) - // Standard Error: 8_423 - .saturating_add(Weight::from_parts(107_724, 0).saturating_mul(a.into())) - // Standard Error: 8_709 - .saturating_add(Weight::from_parts(11_662, 0).saturating_mul(p.into())) + // Standard Error: 6_956 + .saturating_add(Weight::from_parts(142_549, 0).saturating_mul(a.into())) + // Standard Error: 7_192 + .saturating_add(Weight::from_parts(10_000, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) } - /// Storage: Proxy Announcements (r:1 w:1) - /// Proof: Proxy Announcements (max_values: None, max_size: Some(2233), added: 4708, mode: MaxEncodedLen) - /// Storage: System Account (r:1 w:1) - /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + /// Storage: `Proxy::Announcements` (r:1 w:1) + /// Proof: `Proxy::Announcements` (`max_values`: None, `max_size`: Some(2233), added: 4708, mode: `MaxEncodedLen`) + /// Storage: `System::Account` (r:1 w:1) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) /// The range of component `a` is `[0, 31]`. /// The range of component `p` is `[1, 31]`. - fn reject_announcement(a: u32, p: u32, ) -> Weight { + fn reject_announcement(a: u32, _p: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `366 + a * (68 ±0)` + // Measured: `432 + a * (68 ±0)` // Estimated: `5698` - // Minimum execution time: 32_899_000 picoseconds. - Weight::from_parts(33_709_865, 0) + // Minimum execution time: 23_177_000 picoseconds. + Weight::from_parts(26_786_710, 0) .saturating_add(Weight::from_parts(0, 5698)) - // Standard Error: 6_137 - .saturating_add(Weight::from_parts(178_682, 0).saturating_mul(a.into())) - // Standard Error: 6_346 - .saturating_add(Weight::from_parts(26_520, 0).saturating_mul(p.into())) + // Standard Error: 6_878 + .saturating_add(Weight::from_parts(74_968, 0).saturating_mul(a.into())) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) } - /// Storage: Proxy Proxies (r:1 w:0) - /// Proof: Proxy Proxies (max_values: None, max_size: Some(1241), added: 3716, mode: MaxEncodedLen) - /// Storage: Proxy Announcements (r:1 w:1) - /// Proof: Proxy Announcements (max_values: None, max_size: Some(2233), added: 4708, mode: MaxEncodedLen) - /// Storage: System Account (r:1 w:1) - /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + /// Storage: `Proxy::Proxies` (r:1 w:0) + /// Proof: `Proxy::Proxies` (`max_values`: None, `max_size`: Some(1241), added: 3716, mode: `MaxEncodedLen`) + /// Storage: `Proxy::Announcements` (r:1 w:1) + /// Proof: `Proxy::Announcements` (`max_values`: None, `max_size`: Some(2233), added: 4708, mode: `MaxEncodedLen`) + /// Storage: `System::Account` (r:1 w:1) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) /// The range of component `a` is `[0, 31]`. /// The range of component `p` is `[1, 31]`. fn announce(a: u32, p: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `383 + a * (68 ±0) + p * (37 ±0)` + // Measured: `449 + a * (68 ±0) + p * (37 ±0)` // Estimated: `5698` - // Minimum execution time: 45_300_000 picoseconds. - Weight::from_parts(44_589_976, 0) + // Minimum execution time: 31_607_000 picoseconds. + Weight::from_parts(32_110_068, 0) .saturating_add(Weight::from_parts(0, 5698)) - // Standard Error: 8_943 - .saturating_add(Weight::from_parts(224_292, 0).saturating_mul(a.into())) - // Standard Error: 9_246 - .saturating_add(Weight::from_parts(79_467, 0).saturating_mul(p.into())) + // Standard Error: 5_438 + .saturating_add(Weight::from_parts(166_689, 0).saturating_mul(a.into())) + // Standard Error: 5_623 + .saturating_add(Weight::from_parts(57_727, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(3)) .saturating_add(T::DbWeight::get().writes(2)) } - /// Storage: Proxy Proxies (r:1 w:1) - /// Proof: Proxy Proxies (max_values: None, max_size: Some(1241), added: 3716, mode: MaxEncodedLen) + /// Storage: `Proxy::Proxies` (r:1 w:1) + /// Proof: `Proxy::Proxies` (`max_values`: None, `max_size`: Some(1241), added: 3716, mode: `MaxEncodedLen`) /// The range of component `p` is `[1, 31]`. fn add_proxy(p: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `161 + p * (37 ±0)` + // Measured: `227 + p * (37 ±0)` // Estimated: `4706` - // Minimum execution time: 33_880_000 picoseconds. - Weight::from_parts(35_554_943, 0) + // Minimum execution time: 23_415_000 picoseconds. + Weight::from_parts(24_296_550, 0) .saturating_add(Weight::from_parts(0, 4706)) - // Standard Error: 6_212 - .saturating_add(Weight::from_parts(29_857, 0).saturating_mul(p.into())) + // Standard Error: 3_820 + .saturating_add(Weight::from_parts(65_159, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: Proxy Proxies (r:1 w:1) - /// Proof: Proxy Proxies (max_values: None, max_size: Some(1241), added: 3716, mode: MaxEncodedLen) + /// Storage: `Proxy::Proxies` (r:1 w:1) + /// Proof: `Proxy::Proxies` (`max_values`: None, `max_size`: Some(1241), added: 3716, mode: `MaxEncodedLen`) /// The range of component `p` is `[1, 31]`. fn remove_proxy(p: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `161 + p * (37 ±0)` + // Measured: `227 + p * (37 ±0)` // Estimated: `4706` - // Minimum execution time: 33_732_000 picoseconds. - Weight::from_parts(35_168_099, 0) + // Minimum execution time: 23_627_000 picoseconds. + Weight::from_parts(24_584_721, 0) .saturating_add(Weight::from_parts(0, 4706)) - // Standard Error: 1_950 - .saturating_add(Weight::from_parts(46_083, 0).saturating_mul(p.into())) + // Standard Error: 2_510 + .saturating_add(Weight::from_parts(79_889, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: Proxy Proxies (r:1 w:1) - /// Proof: Proxy Proxies (max_values: None, max_size: Some(1241), added: 3716, mode: MaxEncodedLen) + /// Storage: `Proxy::Proxies` (r:1 w:1) + /// Proof: `Proxy::Proxies` (`max_values`: None, `max_size`: Some(1241), added: 3716, mode: `MaxEncodedLen`) /// The range of component `p` is `[1, 31]`. fn remove_proxies(p: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `161 + p * (37 ±0)` + // Measured: `227 + p * (37 ±0)` // Estimated: `4706` - // Minimum execution time: 29_415_000 picoseconds. - Weight::from_parts(31_124_083, 0) + // Minimum execution time: 20_903_000 picoseconds. + Weight::from_parts(21_695_859, 0) .saturating_add(Weight::from_parts(0, 4706)) - // Standard Error: 3_457 - .saturating_add(Weight::from_parts(21_133, 0).saturating_mul(p.into())) + // Standard Error: 2_780 + .saturating_add(Weight::from_parts(68_100, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: Proxy Proxies (r:1 w:1) - /// Proof: Proxy Proxies (max_values: None, max_size: Some(1241), added: 3716, mode: MaxEncodedLen) + /// Storage: `Proxy::Proxies` (r:1 w:1) + /// Proof: `Proxy::Proxies` (`max_values`: None, `max_size`: Some(1241), added: 3716, mode: `MaxEncodedLen`) /// The range of component `p` is `[1, 31]`. fn create_pure(p: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `173` + // Measured: `239` // Estimated: `4706` - // Minimum execution time: 36_274_000 picoseconds. - Weight::from_parts(37_226_498, 0) + // Minimum execution time: 24_812_000 picoseconds. + Weight::from_parts(26_101_401, 0) .saturating_add(Weight::from_parts(0, 4706)) - // Standard Error: 5_148 - .saturating_add(Weight::from_parts(32_411, 0).saturating_mul(p.into())) + // Standard Error: 2_911 + .saturating_add(Weight::from_parts(25_085, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: Proxy Proxies (r:1 w:1) - /// Proof: Proxy Proxies (max_values: None, max_size: Some(1241), added: 3716, mode: MaxEncodedLen) + /// Storage: `Proxy::Proxies` (r:1 w:1) + /// Proof: `Proxy::Proxies` (`max_values`: None, `max_size`: Some(1241), added: 3716, mode: `MaxEncodedLen`) /// The range of component `p` is `[0, 30]`. fn kill_pure(p: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `198 + p * (37 ±0)` + // Measured: `264 + p * (37 ±0)` // Estimated: `4706` - // Minimum execution time: 31_134_000 picoseconds. - Weight::from_parts(31_461_750, 0) + // Minimum execution time: 21_522_000 picoseconds. + Weight::from_parts(22_686_604, 0) .saturating_add(Weight::from_parts(0, 4706)) - // Standard Error: 13_764 - .saturating_add(Weight::from_parts(197_174, 0).saturating_mul(p.into())) + // Standard Error: 6_847 + .saturating_add(Weight::from_parts(65_146, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } diff --git a/runtime/paseo/src/weights/pallet_scheduler.rs b/runtime/paseo/src/weights/pallet_scheduler.rs index cedb804851..3e81d948a2 100644 --- a/runtime/paseo/src/weights/pallet_scheduler.rs +++ b/runtime/paseo/src/weights/pallet_scheduler.rs @@ -17,10 +17,10 @@ //! Autogenerated weights for `pallet_scheduler` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-10-17, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-08-28, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `parachain-benchmark`, CPU: `Intel(R) Xeon(R) Platinum 8259CL CPU @ 2.50GHz` -//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("rococo-dev"), DB CACHE: 20 +//! HOSTNAME: `litentry-benchmark-server`, CPU: `Intel(R) Xeon(R) CPU E5-2686 v4 @ 2.30GHz` +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("rococo-dev")`, DB CACHE: 20 // Executed Command: // ./litentry-collator @@ -49,30 +49,30 @@ use core::marker::PhantomData; /// Weight functions for `pallet_scheduler`. pub struct WeightInfo(PhantomData); impl pallet_scheduler::WeightInfo for WeightInfo { - /// Storage: Scheduler IncompleteSince (r:1 w:1) - /// Proof: Scheduler IncompleteSince (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen) + /// Storage: `Scheduler::IncompleteSince` (r:1 w:1) + /// Proof: `Scheduler::IncompleteSince` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) fn service_agendas_base() -> Weight { // Proof Size summary in bytes: // Measured: `31` // Estimated: `1489` - // Minimum execution time: 5_456_000 picoseconds. - Weight::from_parts(5_680_000, 0) + // Minimum execution time: 3_869_000 picoseconds. + Weight::from_parts(4_010_000, 0) .saturating_add(Weight::from_parts(0, 1489)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: Scheduler Agenda (r:1 w:1) - /// Proof: Scheduler Agenda (max_values: None, max_size: Some(38963), added: 41438, mode: MaxEncodedLen) + /// Storage: `Scheduler::Agenda` (r:1 w:1) + /// Proof: `Scheduler::Agenda` (`max_values`: None, `max_size`: Some(38963), added: 41438, mode: `MaxEncodedLen`) /// The range of component `s` is `[0, 50]`. fn service_agenda_base(s: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `78 + s * (177 ±0)` // Estimated: `42428` - // Minimum execution time: 4_748_000 picoseconds. - Weight::from_parts(7_596_766, 0) + // Minimum execution time: 3_440_000 picoseconds. + Weight::from_parts(5_369_165, 0) .saturating_add(Weight::from_parts(0, 42428)) - // Standard Error: 2_307 - .saturating_add(Weight::from_parts(1_067_723, 0).saturating_mul(s.into())) + // Standard Error: 3_419 + .saturating_add(Weight::from_parts(818_093, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } @@ -80,36 +80,36 @@ impl pallet_scheduler::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 7_980_000 picoseconds. - Weight::from_parts(8_186_000, 0) + // Minimum execution time: 5_651_000 picoseconds. + Weight::from_parts(5_887_000, 0) .saturating_add(Weight::from_parts(0, 0)) } - /// Storage: Preimage PreimageFor (r:1 w:1) - /// Proof: Preimage PreimageFor (max_values: None, max_size: Some(4194344), added: 4196819, mode: Measured) - /// Storage: Preimage StatusFor (r:1 w:1) - /// Proof: Preimage StatusFor (max_values: None, max_size: Some(91), added: 2566, mode: MaxEncodedLen) + /// Storage: `Preimage::PreimageFor` (r:1 w:1) + /// Proof: `Preimage::PreimageFor` (`max_values`: None, `max_size`: Some(4194344), added: 4196819, mode: `Measured`) + /// Storage: `Preimage::StatusFor` (r:1 w:1) + /// Proof: `Preimage::StatusFor` (`max_values`: None, `max_size`: Some(91), added: 2566, mode: `MaxEncodedLen`) /// The range of component `s` is `[128, 4194304]`. fn service_task_fetched(s: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `213 + s * (1 ±0)` // Estimated: `3677 + s * (1 ±0)` - // Minimum execution time: 28_200_000 picoseconds. - Weight::from_parts(28_629_000, 0) + // Minimum execution time: 19_927_000 picoseconds. + Weight::from_parts(20_384_000, 0) .saturating_add(Weight::from_parts(0, 3677)) - // Standard Error: 8 - .saturating_add(Weight::from_parts(2_076, 0).saturating_mul(s.into())) + // Standard Error: 19 + .saturating_add(Weight::from_parts(1_763, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(s.into())) } - /// Storage: Scheduler Lookup (r:0 w:1) - /// Proof: Scheduler Lookup (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen) + /// Storage: `Scheduler::Lookup` (r:0 w:1) + /// Proof: `Scheduler::Lookup` (`max_values`: None, `max_size`: Some(48), added: 2523, mode: `MaxEncodedLen`) fn service_task_named() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 9_782_000 picoseconds. - Weight::from_parts(10_002_000, 0) + // Minimum execution time: 6_855_000 picoseconds. + Weight::from_parts(7_307_000, 0) .saturating_add(Weight::from_parts(0, 0)) .saturating_add(T::DbWeight::get().writes(1)) } @@ -117,89 +117,89 @@ impl pallet_scheduler::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 7_907_000 picoseconds. - Weight::from_parts(8_091_000, 0) + // Minimum execution time: 5_769_000 picoseconds. + Weight::from_parts(6_026_000, 0) .saturating_add(Weight::from_parts(0, 0)) } fn execute_dispatch_signed() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 3_681_000 picoseconds. - Weight::from_parts(3_839_000, 0) + // Minimum execution time: 2_738_000 picoseconds. + Weight::from_parts(2_845_000, 0) .saturating_add(Weight::from_parts(0, 0)) } fn execute_dispatch_unsigned() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 3_721_000 picoseconds. - Weight::from_parts(3_872_000, 0) + // Minimum execution time: 2_722_000 picoseconds. + Weight::from_parts(2_850_000, 0) .saturating_add(Weight::from_parts(0, 0)) } - /// Storage: Scheduler Agenda (r:1 w:1) - /// Proof: Scheduler Agenda (max_values: None, max_size: Some(38963), added: 41438, mode: MaxEncodedLen) + /// Storage: `Scheduler::Agenda` (r:1 w:1) + /// Proof: `Scheduler::Agenda` (`max_values`: None, `max_size`: Some(38963), added: 41438, mode: `MaxEncodedLen`) /// The range of component `s` is `[0, 49]`. fn schedule(s: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `78 + s * (177 ±0)` // Estimated: `42428` - // Minimum execution time: 18_535_000 picoseconds. - Weight::from_parts(21_300_382, 0) + // Minimum execution time: 11_643_000 picoseconds. + Weight::from_parts(14_146_402, 0) .saturating_add(Weight::from_parts(0, 42428)) - // Standard Error: 3_644 - .saturating_add(Weight::from_parts(1_151_489, 0).saturating_mul(s.into())) + // Standard Error: 4_946 + .saturating_add(Weight::from_parts(869_859, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: Scheduler Agenda (r:1 w:1) - /// Proof: Scheduler Agenda (max_values: None, max_size: Some(38963), added: 41438, mode: MaxEncodedLen) - /// Storage: Scheduler Lookup (r:0 w:1) - /// Proof: Scheduler Lookup (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen) + /// Storage: `Scheduler::Agenda` (r:1 w:1) + /// Proof: `Scheduler::Agenda` (`max_values`: None, `max_size`: Some(38963), added: 41438, mode: `MaxEncodedLen`) + /// Storage: `Scheduler::Lookup` (r:0 w:1) + /// Proof: `Scheduler::Lookup` (`max_values`: None, `max_size`: Some(48), added: 2523, mode: `MaxEncodedLen`) /// The range of component `s` is `[1, 50]`. fn cancel(s: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `78 + s * (177 ±0)` // Estimated: `42428` - // Minimum execution time: 24_780_000 picoseconds. - Weight::from_parts(25_316_813, 0) + // Minimum execution time: 16_273_000 picoseconds. + Weight::from_parts(14_733_434, 0) .saturating_add(Weight::from_parts(0, 42428)) - // Standard Error: 9_036 - .saturating_add(Weight::from_parts(1_968_882, 0).saturating_mul(s.into())) + // Standard Error: 8_832 + .saturating_add(Weight::from_parts(1_568_387, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(2)) } - /// Storage: Scheduler Lookup (r:1 w:1) - /// Proof: Scheduler Lookup (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen) - /// Storage: Scheduler Agenda (r:1 w:1) - /// Proof: Scheduler Agenda (max_values: None, max_size: Some(38963), added: 41438, mode: MaxEncodedLen) + /// Storage: `Scheduler::Lookup` (r:1 w:1) + /// Proof: `Scheduler::Lookup` (`max_values`: None, `max_size`: Some(48), added: 2523, mode: `MaxEncodedLen`) + /// Storage: `Scheduler::Agenda` (r:1 w:1) + /// Proof: `Scheduler::Agenda` (`max_values`: None, `max_size`: Some(38963), added: 41438, mode: `MaxEncodedLen`) /// The range of component `s` is `[0, 49]`. fn schedule_named(s: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `230 + s * (186 ±0)` // Estimated: `42428` - // Minimum execution time: 22_646_000 picoseconds. - Weight::from_parts(26_448_036, 0) + // Minimum execution time: 15_357_000 picoseconds. + Weight::from_parts(20_257_339, 0) .saturating_add(Weight::from_parts(0, 42428)) - // Standard Error: 4_324 - .saturating_add(Weight::from_parts(1_228_658, 0).saturating_mul(s.into())) + // Standard Error: 8_159 + .saturating_add(Weight::from_parts(854_396, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) } - /// Storage: Scheduler Lookup (r:1 w:1) - /// Proof: Scheduler Lookup (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen) - /// Storage: Scheduler Agenda (r:1 w:1) - /// Proof: Scheduler Agenda (max_values: None, max_size: Some(38963), added: 41438, mode: MaxEncodedLen) + /// Storage: `Scheduler::Lookup` (r:1 w:1) + /// Proof: `Scheduler::Lookup` (`max_values`: None, `max_size`: Some(48), added: 2523, mode: `MaxEncodedLen`) + /// Storage: `Scheduler::Agenda` (r:1 w:1) + /// Proof: `Scheduler::Agenda` (`max_values`: None, `max_size`: Some(38963), added: 41438, mode: `MaxEncodedLen`) /// The range of component `s` is `[1, 50]`. fn cancel_named(s: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `282 + s * (185 ±0)` // Estimated: `42428` - // Minimum execution time: 26_463_000 picoseconds. - Weight::from_parts(27_007_292, 0) + // Minimum execution time: 18_198_000 picoseconds. + Weight::from_parts(17_254_480, 0) .saturating_add(Weight::from_parts(0, 42428)) - // Standard Error: 8_452 - .saturating_add(Weight::from_parts(2_015_442, 0).saturating_mul(s.into())) + // Standard Error: 8_061 + .saturating_add(Weight::from_parts(1_591_237, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) } diff --git a/runtime/paseo/src/weights/pallet_session.rs b/runtime/paseo/src/weights/pallet_session.rs index bbd70fb8a9..bbe6be4004 100644 --- a/runtime/paseo/src/weights/pallet_session.rs +++ b/runtime/paseo/src/weights/pallet_session.rs @@ -17,10 +17,10 @@ //! Autogenerated weights for `pallet_session` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-10-17, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-08-28, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `parachain-benchmark`, CPU: `Intel(R) Xeon(R) Platinum 8259CL CPU @ 2.50GHz` -//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("rococo-dev"), DB CACHE: 20 +//! HOSTNAME: `litentry-benchmark-server`, CPU: `Intel(R) Xeon(R) CPU E5-2686 v4 @ 2.30GHz` +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("rococo-dev")`, DB CACHE: 20 // Executed Command: // ./litentry-collator @@ -49,31 +49,31 @@ use core::marker::PhantomData; /// Weight functions for `pallet_session`. pub struct WeightInfo(PhantomData); impl pallet_session::WeightInfo for WeightInfo { - /// Storage: Session NextKeys (r:1 w:1) - /// Proof Skipped: Session NextKeys (max_values: None, max_size: None, mode: Measured) - /// Storage: Session KeyOwner (r:1 w:1) - /// Proof Skipped: Session KeyOwner (max_values: None, max_size: None, mode: Measured) + /// Storage: `Session::NextKeys` (r:1 w:1) + /// Proof: `Session::NextKeys` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Session::KeyOwner` (r:1 w:1) + /// Proof: `Session::KeyOwner` (`max_values`: None, `max_size`: None, mode: `Measured`) fn set_keys() -> Weight { // Proof Size summary in bytes: - // Measured: `270` - // Estimated: `3735` - // Minimum execution time: 21_515_000 picoseconds. - Weight::from_parts(22_122_000, 0) - .saturating_add(Weight::from_parts(0, 3735)) + // Measured: `271` + // Estimated: `3736` + // Minimum execution time: 15_933_000 picoseconds. + Weight::from_parts(16_633_000, 0) + .saturating_add(Weight::from_parts(0, 3736)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) } - /// Storage: Session NextKeys (r:1 w:1) - /// Proof Skipped: Session NextKeys (max_values: None, max_size: None, mode: Measured) - /// Storage: Session KeyOwner (r:0 w:1) - /// Proof Skipped: Session KeyOwner (max_values: None, max_size: None, mode: Measured) + /// Storage: `Session::NextKeys` (r:1 w:1) + /// Proof: `Session::NextKeys` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Session::KeyOwner` (r:0 w:1) + /// Proof: `Session::KeyOwner` (`max_values`: None, `max_size`: None, mode: `Measured`) fn purge_keys() -> Weight { // Proof Size summary in bytes: - // Measured: `242` - // Estimated: `3707` - // Minimum execution time: 15_976_000 picoseconds. - Weight::from_parts(16_449_000, 0) - .saturating_add(Weight::from_parts(0, 3707)) + // Measured: `243` + // Estimated: `3708` + // Minimum execution time: 11_374_000 picoseconds. + Weight::from_parts(11_780_000, 0) + .saturating_add(Weight::from_parts(0, 3708)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(2)) } diff --git a/runtime/paseo/src/weights/pallet_teebag.rs b/runtime/paseo/src/weights/pallet_teebag.rs index d03dd76b8f..9501805770 100644 --- a/runtime/paseo/src/weights/pallet_teebag.rs +++ b/runtime/paseo/src/weights/pallet_teebag.rs @@ -17,10 +17,10 @@ //! Autogenerated weights for `pallet_teebag` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2024-07-31, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-08-28, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` //! HOSTNAME: `litentry-benchmark-server`, CPU: `Intel(R) Xeon(R) CPU E5-2686 v4 @ 2.30GHz` -//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("rococo-dev"), DB CACHE: 20 +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("rococo-dev")`, DB CACHE: 20 // Executed Command: // ./litentry-collator @@ -49,170 +49,170 @@ use core::marker::PhantomData; /// Weight functions for `pallet_teebag`. pub struct WeightInfo(PhantomData); impl pallet_teebag::WeightInfo for WeightInfo { - /// Storage: Teebag EnclaveRegistry (r:1 w:1) - /// Proof Skipped: Teebag EnclaveRegistry (max_values: None, max_size: None, mode: Measured) - /// Storage: Teebag EnclaveIdentifier (r:1 w:1) - /// Proof Skipped: Teebag EnclaveIdentifier (max_values: None, max_size: None, mode: Measured) + /// Storage: `Teebag::EnclaveRegistry` (r:1 w:1) + /// Proof: `Teebag::EnclaveRegistry` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Teebag::EnclaveIdentifier` (r:1 w:1) + /// Proof: `Teebag::EnclaveIdentifier` (`max_values`: None, `max_size`: None, mode: `Measured`) fn force_add_enclave() -> Weight { // Proof Size summary in bytes: // Measured: `213` // Estimated: `3678` - // Minimum execution time: 30_593_000 picoseconds. - Weight::from_parts(31_441_000, 0) + // Minimum execution time: 14_943_000 picoseconds. + Weight::from_parts(15_537_000, 0) .saturating_add(Weight::from_parts(0, 3678)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) } - /// Storage: Teebag EnclaveRegistry (r:1 w:1) - /// Proof Skipped: Teebag EnclaveRegistry (max_values: None, max_size: None, mode: Measured) - /// Storage: Teebag EnclaveIdentifier (r:1 w:1) - /// Proof Skipped: Teebag EnclaveIdentifier (max_values: None, max_size: None, mode: Measured) + /// Storage: `Teebag::EnclaveRegistry` (r:1 w:1) + /// Proof: `Teebag::EnclaveRegistry` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Teebag::EnclaveIdentifier` (r:1 w:1) + /// Proof: `Teebag::EnclaveIdentifier` (`max_values`: None, `max_size`: None, mode: `Measured`) fn force_remove_enclave() -> Weight { // Proof Size summary in bytes: // Measured: `541` // Estimated: `4006` - // Minimum execution time: 37_504_000 picoseconds. - Weight::from_parts(38_236_000, 0) + // Minimum execution time: 18_467_000 picoseconds. + Weight::from_parts(19_230_000, 0) .saturating_add(Weight::from_parts(0, 4006)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) } - /// Storage: Teebag EnclaveRegistry (r:4 w:3) - /// Proof Skipped: Teebag EnclaveRegistry (max_values: None, max_size: None, mode: Measured) - /// Storage: Teebag EnclaveIdentifier (r:1 w:1) - /// Proof Skipped: Teebag EnclaveIdentifier (max_values: None, max_size: None, mode: Measured) + /// Storage: `Teebag::EnclaveRegistry` (r:4 w:3) + /// Proof: `Teebag::EnclaveRegistry` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Teebag::EnclaveIdentifier` (r:1 w:1) + /// Proof: `Teebag::EnclaveIdentifier` (`max_values`: None, `max_size`: None, mode: `Measured`) fn force_remove_enclave_by_mrenclave() -> Weight { // Proof Size summary in bytes: // Measured: `720` // Estimated: `11610` - // Minimum execution time: 85_940_000 picoseconds. - Weight::from_parts(87_419_000, 0) + // Minimum execution time: 46_203_000 picoseconds. + Weight::from_parts(47_696_000, 0) .saturating_add(Weight::from_parts(0, 11610)) .saturating_add(T::DbWeight::get().reads(5)) .saturating_add(T::DbWeight::get().writes(4)) } - /// Storage: Teebag EnclaveRegistry (r:4 w:3) - /// Proof Skipped: Teebag EnclaveRegistry (max_values: None, max_size: None, mode: Measured) - /// Storage: Teebag EnclaveIdentifier (r:1 w:1) - /// Proof Skipped: Teebag EnclaveIdentifier (max_values: None, max_size: None, mode: Measured) + /// Storage: `Teebag::EnclaveRegistry` (r:4 w:3) + /// Proof: `Teebag::EnclaveRegistry` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Teebag::EnclaveIdentifier` (r:1 w:1) + /// Proof: `Teebag::EnclaveIdentifier` (`max_values`: None, `max_size`: None, mode: `Measured`) fn force_remove_enclave_by_worker_type() -> Weight { // Proof Size summary in bytes: // Measured: `720` // Estimated: `11610` - // Minimum execution time: 86_021_000 picoseconds. - Weight::from_parts(87_344_000, 0) + // Minimum execution time: 46_312_000 picoseconds. + Weight::from_parts(50_255_000, 0) .saturating_add(Weight::from_parts(0, 11610)) .saturating_add(T::DbWeight::get().reads(5)) .saturating_add(T::DbWeight::get().writes(4)) } - /// Storage: Teebag AuthorizedEnclave (r:1 w:1) - /// Proof Skipped: Teebag AuthorizedEnclave (max_values: None, max_size: None, mode: Measured) + /// Storage: `Teebag::AuthorizedEnclave` (r:1 w:1) + /// Proof: `Teebag::AuthorizedEnclave` (`max_values`: None, `max_size`: None, mode: `Measured`) fn force_add_authorized_enclave() -> Weight { // Proof Size summary in bytes: // Measured: `383` // Estimated: `3848` - // Minimum execution time: 27_204_000 picoseconds. - Weight::from_parts(27_934_000, 0) + // Minimum execution time: 12_701_000 picoseconds. + Weight::from_parts(13_163_000, 0) .saturating_add(Weight::from_parts(0, 3848)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: Teebag AuthorizedEnclave (r:1 w:1) - /// Proof Skipped: Teebag AuthorizedEnclave (max_values: None, max_size: None, mode: Measured) - /// Storage: Teebag EnclaveRegistry (r:1 w:0) - /// Proof Skipped: Teebag EnclaveRegistry (max_values: None, max_size: None, mode: Measured) + /// Storage: `Teebag::AuthorizedEnclave` (r:1 w:1) + /// Proof: `Teebag::AuthorizedEnclave` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Teebag::EnclaveRegistry` (r:1 w:0) + /// Proof: `Teebag::EnclaveRegistry` (`max_values`: None, `max_size`: None, mode: `Measured`) fn force_remove_authorized_enclave() -> Weight { // Proof Size summary in bytes: // Measured: `415` // Estimated: `3880` - // Minimum execution time: 38_033_000 picoseconds. - Weight::from_parts(38_965_000, 0) + // Minimum execution time: 17_704_000 picoseconds. + Weight::from_parts(18_234_000, 0) .saturating_add(Weight::from_parts(0, 3880)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: Timestamp Now (r:1 w:0) - /// Proof: Timestamp Now (max_values: Some(1), max_size: Some(8), added: 503, mode: MaxEncodedLen) - /// Storage: Teebag Mode (r:1 w:0) - /// Proof Skipped: Teebag Mode (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: Teebag AuthorizedEnclave (r:1 w:1) - /// Proof Skipped: Teebag AuthorizedEnclave (max_values: None, max_size: None, mode: Measured) - /// Storage: Teebag EnclaveRegistry (r:1 w:1) - /// Proof Skipped: Teebag EnclaveRegistry (max_values: None, max_size: None, mode: Measured) - /// Storage: Teebag EnclaveIdentifier (r:1 w:1) - /// Proof Skipped: Teebag EnclaveIdentifier (max_values: None, max_size: None, mode: Measured) + /// Storage: `Timestamp::Now` (r:1 w:0) + /// Proof: `Timestamp::Now` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `MaxEncodedLen`) + /// Storage: `Teebag::Mode` (r:1 w:0) + /// Proof: `Teebag::Mode` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `Teebag::AuthorizedEnclave` (r:1 w:1) + /// Proof: `Teebag::AuthorizedEnclave` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Teebag::EnclaveRegistry` (r:1 w:1) + /// Proof: `Teebag::EnclaveRegistry` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Teebag::EnclaveIdentifier` (r:1 w:1) + /// Proof: `Teebag::EnclaveIdentifier` (`max_values`: None, `max_size`: None, mode: `Measured`) fn register_enclave_with_ias_attestation() -> Weight { // Proof Size summary in bytes: // Measured: `427` // Estimated: `3892` - // Minimum execution time: 2_226_497_000 picoseconds. - Weight::from_parts(2_253_466_000, 0) + // Minimum execution time: 1_571_568_000 picoseconds. + Weight::from_parts(1_649_222_000, 0) .saturating_add(Weight::from_parts(0, 3892)) .saturating_add(T::DbWeight::get().reads(5)) .saturating_add(T::DbWeight::get().writes(3)) } - /// Storage: Timestamp Now (r:1 w:0) - /// Proof: Timestamp Now (max_values: Some(1), max_size: Some(8), added: 503, mode: MaxEncodedLen) - /// Storage: Teebag QuotingEnclaveRegistry (r:1 w:0) - /// Proof Skipped: Teebag QuotingEnclaveRegistry (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: Teebag TcbInfo (r:1 w:0) - /// Proof Skipped: Teebag TcbInfo (max_values: None, max_size: None, mode: Measured) - /// Storage: Teebag Mode (r:1 w:0) - /// Proof Skipped: Teebag Mode (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: Teebag AuthorizedEnclave (r:1 w:1) - /// Proof Skipped: Teebag AuthorizedEnclave (max_values: None, max_size: None, mode: Measured) - /// Storage: Teebag EnclaveRegistry (r:1 w:1) - /// Proof Skipped: Teebag EnclaveRegistry (max_values: None, max_size: None, mode: Measured) - /// Storage: Teebag EnclaveIdentifier (r:1 w:1) - /// Proof Skipped: Teebag EnclaveIdentifier (max_values: None, max_size: None, mode: Measured) + /// Storage: `Timestamp::Now` (r:1 w:0) + /// Proof: `Timestamp::Now` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `MaxEncodedLen`) + /// Storage: `Teebag::QuotingEnclaveRegistry` (r:1 w:0) + /// Proof: `Teebag::QuotingEnclaveRegistry` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `Teebag::TcbInfo` (r:1 w:0) + /// Proof: `Teebag::TcbInfo` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Teebag::Mode` (r:1 w:0) + /// Proof: `Teebag::Mode` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `Teebag::AuthorizedEnclave` (r:1 w:1) + /// Proof: `Teebag::AuthorizedEnclave` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Teebag::EnclaveRegistry` (r:1 w:1) + /// Proof: `Teebag::EnclaveRegistry` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Teebag::EnclaveIdentifier` (r:1 w:1) + /// Proof: `Teebag::EnclaveIdentifier` (`max_values`: None, `max_size`: None, mode: `Measured`) fn register_enclave_with_dcap_attestation() -> Weight { // Proof Size summary in bytes: // Measured: `644` // Estimated: `4109` - // Minimum execution time: 4_929_967_000 picoseconds. - Weight::from_parts(4_950_124_000, 0) + // Minimum execution time: 3_397_776_000 picoseconds. + Weight::from_parts(4_248_064_000, 0) .saturating_add(Weight::from_parts(0, 4109)) .saturating_add(T::DbWeight::get().reads(7)) .saturating_add(T::DbWeight::get().writes(3)) } - /// Storage: Teebag EnclaveRegistry (r:1 w:1) - /// Proof Skipped: Teebag EnclaveRegistry (max_values: None, max_size: None, mode: Measured) - /// Storage: Teebag EnclaveIdentifier (r:1 w:1) - /// Proof Skipped: Teebag EnclaveIdentifier (max_values: None, max_size: None, mode: Measured) + /// Storage: `Teebag::EnclaveRegistry` (r:1 w:1) + /// Proof: `Teebag::EnclaveRegistry` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Teebag::EnclaveIdentifier` (r:1 w:1) + /// Proof: `Teebag::EnclaveIdentifier` (`max_values`: None, `max_size`: None, mode: `Measured`) fn unregister_enclave() -> Weight { // Proof Size summary in bytes: // Measured: `458` // Estimated: `3923` - // Minimum execution time: 37_905_000 picoseconds. - Weight::from_parts(39_228_000, 0) + // Minimum execution time: 19_744_000 picoseconds. + Weight::from_parts(22_575_000, 0) .saturating_add(Weight::from_parts(0, 3923)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) } - /// Storage: Timestamp Now (r:1 w:0) - /// Proof: Timestamp Now (max_values: Some(1), max_size: Some(8), added: 503, mode: MaxEncodedLen) - /// Storage: Teebag QuotingEnclaveRegistry (r:0 w:1) - /// Proof Skipped: Teebag QuotingEnclaveRegistry (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: `Timestamp::Now` (r:1 w:0) + /// Proof: `Timestamp::Now` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `MaxEncodedLen`) + /// Storage: `Teebag::QuotingEnclaveRegistry` (r:0 w:1) + /// Proof: `Teebag::QuotingEnclaveRegistry` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) fn register_quoting_enclave() -> Weight { // Proof Size summary in bytes: // Measured: `94` // Estimated: `1493` - // Minimum execution time: 2_458_437_000 picoseconds. - Weight::from_parts(2_484_116_000, 0) + // Minimum execution time: 1_654_144_000 picoseconds. + Weight::from_parts(1_720_747_000, 0) .saturating_add(Weight::from_parts(0, 1493)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: Timestamp Now (r:1 w:0) - /// Proof: Timestamp Now (max_values: Some(1), max_size: Some(8), added: 503, mode: MaxEncodedLen) - /// Storage: Teebag TcbInfo (r:0 w:1) - /// Proof Skipped: Teebag TcbInfo (max_values: None, max_size: None, mode: Measured) + /// Storage: `Timestamp::Now` (r:1 w:0) + /// Proof: `Timestamp::Now` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `MaxEncodedLen`) + /// Storage: `Teebag::TcbInfo` (r:0 w:1) + /// Proof: `Teebag::TcbInfo` (`max_values`: None, `max_size`: None, mode: `Measured`) fn register_tcb_info() -> Weight { // Proof Size summary in bytes: // Measured: `94` // Estimated: `1493` - // Minimum execution time: 2_683_839_000 picoseconds. - Weight::from_parts(2_712_843_000, 0) + // Minimum execution time: 1_811_473_000 picoseconds. + Weight::from_parts(2_399_065_000, 0) .saturating_add(Weight::from_parts(0, 1493)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) @@ -221,39 +221,39 @@ impl pallet_teebag::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 15_138_000 picoseconds. - Weight::from_parts(15_618_000, 0) + // Minimum execution time: 7_031_000 picoseconds. + Weight::from_parts(7_338_000, 0) .saturating_add(Weight::from_parts(0, 0)) } - /// Storage: Teebag EnclaveRegistry (r:1 w:0) - /// Proof Skipped: Teebag EnclaveRegistry (max_values: None, max_size: None, mode: Measured) - /// Storage: Timestamp Now (r:1 w:0) - /// Proof: Timestamp Now (max_values: Some(1), max_size: Some(8), added: 503, mode: MaxEncodedLen) + /// Storage: `Teebag::EnclaveRegistry` (r:1 w:0) + /// Proof: `Teebag::EnclaveRegistry` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Timestamp::Now` (r:1 w:0) + /// Proof: `Timestamp::Now` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `MaxEncodedLen`) fn parentchain_block_processed() -> Weight { // Proof Size summary in bytes: // Measured: `407` // Estimated: `3872` - // Minimum execution time: 32_150_000 picoseconds. - Weight::from_parts(33_017_000, 0) + // Minimum execution time: 15_448_000 picoseconds. + Weight::from_parts(15_950_000, 0) .saturating_add(Weight::from_parts(0, 3872)) .saturating_add(T::DbWeight::get().reads(2)) } - /// Storage: Teebag EnclaveRegistry (r:1 w:0) - /// Proof Skipped: Teebag EnclaveRegistry (max_values: None, max_size: None, mode: Measured) - /// Storage: Timestamp Now (r:1 w:0) - /// Proof: Timestamp Now (max_values: Some(1), max_size: Some(8), added: 503, mode: MaxEncodedLen) - /// Storage: Teebag EnclaveIdentifier (r:1 w:0) - /// Proof Skipped: Teebag EnclaveIdentifier (max_values: None, max_size: None, mode: Measured) - /// Storage: Teebag SidechainBlockFinalizationCandidate (r:1 w:1) - /// Proof Skipped: Teebag SidechainBlockFinalizationCandidate (max_values: None, max_size: None, mode: Measured) - /// Storage: Teebag LatestSidechainBlockConfirmation (r:0 w:1) - /// Proof Skipped: Teebag LatestSidechainBlockConfirmation (max_values: None, max_size: None, mode: Measured) + /// Storage: `Teebag::EnclaveRegistry` (r:1 w:0) + /// Proof: `Teebag::EnclaveRegistry` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Timestamp::Now` (r:1 w:0) + /// Proof: `Timestamp::Now` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `MaxEncodedLen`) + /// Storage: `Teebag::EnclaveIdentifier` (r:1 w:0) + /// Proof: `Teebag::EnclaveIdentifier` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Teebag::SidechainBlockFinalizationCandidate` (r:1 w:1) + /// Proof: `Teebag::SidechainBlockFinalizationCandidate` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Teebag::LatestSidechainBlockConfirmation` (r:0 w:1) + /// Proof: `Teebag::LatestSidechainBlockConfirmation` (`max_values`: None, `max_size`: None, mode: `Measured`) fn sidechain_block_imported() -> Weight { // Proof Size summary in bytes: // Measured: `528` // Estimated: `3993` - // Minimum execution time: 47_699_000 picoseconds. - Weight::from_parts(48_615_000, 0) + // Minimum execution time: 24_642_000 picoseconds. + Weight::from_parts(25_438_000, 0) .saturating_add(Weight::from_parts(0, 3993)) .saturating_add(T::DbWeight::get().reads(4)) .saturating_add(T::DbWeight::get().writes(2)) diff --git a/runtime/paseo/src/weights/pallet_timestamp.rs b/runtime/paseo/src/weights/pallet_timestamp.rs index 6aaf72bd60..323233f684 100644 --- a/runtime/paseo/src/weights/pallet_timestamp.rs +++ b/runtime/paseo/src/weights/pallet_timestamp.rs @@ -17,10 +17,10 @@ //! Autogenerated weights for `pallet_timestamp` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-10-17, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-08-28, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `parachain-benchmark`, CPU: `Intel(R) Xeon(R) Platinum 8259CL CPU @ 2.50GHz` -//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("rococo-dev"), DB CACHE: 20 +//! HOSTNAME: `litentry-benchmark-server`, CPU: `Intel(R) Xeon(R) CPU E5-2686 v4 @ 2.30GHz` +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("rococo-dev")`, DB CACHE: 20 // Executed Command: // ./litentry-collator @@ -49,28 +49,24 @@ use core::marker::PhantomData; /// Weight functions for `pallet_timestamp`. pub struct WeightInfo(PhantomData); impl pallet_timestamp::WeightInfo for WeightInfo { - /// Storage: Timestamp Now (r:1 w:1) - /// Proof: Timestamp Now (max_values: Some(1), max_size: Some(8), added: 503, mode: MaxEncodedLen) - /// Storage: Teerex HeartbeatTimeout (r:1 w:0) - /// Proof Skipped: Teerex HeartbeatTimeout (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: Teerex EnclaveRegistry (r:1 w:0) - /// Proof Skipped: Teerex EnclaveRegistry (max_values: None, max_size: None, mode: Measured) + /// Storage: `Timestamp::Now` (r:1 w:1) + /// Proof: `Timestamp::Now` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `MaxEncodedLen`) fn set() -> Weight { // Proof Size summary in bytes: - // Measured: `197` - // Estimated: `3662` - // Minimum execution time: 18_036_000 picoseconds. - Weight::from_parts(18_600_000, 0) - .saturating_add(Weight::from_parts(0, 3662)) - .saturating_add(T::DbWeight::get().reads(3)) + // Measured: `42` + // Estimated: `1493` + // Minimum execution time: 6_526_000 picoseconds. + Weight::from_parts(6_951_000, 0) + .saturating_add(Weight::from_parts(0, 1493)) + .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } fn on_finalize() -> Weight { // Proof Size summary in bytes: // Measured: `94` // Estimated: `0` - // Minimum execution time: 6_082_000 picoseconds. - Weight::from_parts(6_334_000, 0) + // Minimum execution time: 4_045_000 picoseconds. + Weight::from_parts(4_268_000, 0) .saturating_add(Weight::from_parts(0, 0)) } } diff --git a/runtime/paseo/src/weights/pallet_treasury.rs b/runtime/paseo/src/weights/pallet_treasury.rs index e9b15b993d..69feb64575 100644 --- a/runtime/paseo/src/weights/pallet_treasury.rs +++ b/runtime/paseo/src/weights/pallet_treasury.rs @@ -17,10 +17,10 @@ //! Autogenerated weights for `pallet_treasury` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-10-17, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-08-28, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `parachain-benchmark`, CPU: `Intel(R) Xeon(R) Platinum 8259CL CPU @ 2.50GHz` -//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("rococo-dev"), DB CACHE: 20 +//! HOSTNAME: `litentry-benchmark-server`, CPU: `Intel(R) Xeon(R) CPU E5-2686 v4 @ 2.30GHz` +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("rococo-dev")`, DB CACHE: 20 // Executed Command: // ./litentry-collator @@ -49,104 +49,102 @@ use core::marker::PhantomData; /// Weight functions for `pallet_treasury`. pub struct WeightInfo(PhantomData); impl pallet_treasury::WeightInfo for WeightInfo { - /// Storage: Treasury ProposalCount (r:1 w:1) - /// Proof: Treasury ProposalCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen) - /// Storage: Treasury Approvals (r:1 w:1) - /// Proof: Treasury Approvals (max_values: Some(1), max_size: Some(402), added: 897, mode: MaxEncodedLen) - /// Storage: Treasury Proposals (r:0 w:1) - /// Proof: Treasury Proposals (max_values: None, max_size: Some(108), added: 2583, mode: MaxEncodedLen) + /// Storage: `Treasury::ProposalCount` (r:1 w:1) + /// Proof: `Treasury::ProposalCount` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) + /// Storage: `Treasury::Approvals` (r:1 w:1) + /// Proof: `Treasury::Approvals` (`max_values`: Some(1), `max_size`: Some(402), added: 897, mode: `MaxEncodedLen`) + /// Storage: `Treasury::Proposals` (r:0 w:1) + /// Proof: `Treasury::Proposals` (`max_values`: None, `max_size`: Some(108), added: 2583, mode: `MaxEncodedLen`) fn spend() -> Weight { // Proof Size summary in bytes: // Measured: `80` // Estimated: `1887` - // Minimum execution time: 22_391_000 picoseconds. - Weight::from_parts(22_904_000, 0) + // Minimum execution time: 15_111_000 picoseconds. + Weight::from_parts(15_455_000, 0) .saturating_add(Weight::from_parts(0, 1887)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(3)) } - /// Storage: Treasury ProposalCount (r:1 w:1) - /// Proof: Treasury ProposalCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen) - /// Storage: Treasury Proposals (r:0 w:1) - /// Proof: Treasury Proposals (max_values: None, max_size: Some(108), added: 2583, mode: MaxEncodedLen) + /// Storage: `Treasury::ProposalCount` (r:1 w:1) + /// Proof: `Treasury::ProposalCount` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) + /// Storage: `Treasury::Proposals` (r:0 w:1) + /// Proof: `Treasury::Proposals` (`max_values`: None, `max_size`: Some(108), added: 2583, mode: `MaxEncodedLen`) fn propose_spend() -> Weight { // Proof Size summary in bytes: // Measured: `181` // Estimated: `1489` - // Minimum execution time: 39_338_000 picoseconds. - Weight::from_parts(40_451_000, 0) + // Minimum execution time: 27_711_000 picoseconds. + Weight::from_parts(28_843_000, 0) .saturating_add(Weight::from_parts(0, 1489)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(2)) } - /// Storage: Treasury Proposals (r:1 w:1) - /// Proof: Treasury Proposals (max_values: None, max_size: Some(108), added: 2583, mode: MaxEncodedLen) - /// Storage: System Account (r:2 w:2) - /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + /// Storage: `Treasury::Proposals` (r:1 w:1) + /// Proof: `Treasury::Proposals` (`max_values`: None, `max_size`: Some(108), added: 2583, mode: `MaxEncodedLen`) + /// Storage: `System::Account` (r:2 w:2) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) fn reject_proposal() -> Weight { // Proof Size summary in bytes: // Measured: `442` // Estimated: `6196` - // Minimum execution time: 60_263_000 picoseconds. - Weight::from_parts(61_113_000, 0) + // Minimum execution time: 43_181_000 picoseconds. + Weight::from_parts(44_547_000, 0) .saturating_add(Weight::from_parts(0, 6196)) .saturating_add(T::DbWeight::get().reads(3)) .saturating_add(T::DbWeight::get().writes(3)) } - /// Storage: Treasury Proposals (r:1 w:0) - /// Proof: Treasury Proposals (max_values: None, max_size: Some(108), added: 2583, mode: MaxEncodedLen) - /// Storage: Treasury Approvals (r:1 w:1) - /// Proof: Treasury Approvals (max_values: Some(1), max_size: Some(402), added: 897, mode: MaxEncodedLen) + /// Storage: `Treasury::Proposals` (r:1 w:0) + /// Proof: `Treasury::Proposals` (`max_values`: None, `max_size`: Some(108), added: 2583, mode: `MaxEncodedLen`) + /// Storage: `Treasury::Approvals` (r:1 w:1) + /// Proof: `Treasury::Approvals` (`max_values`: Some(1), `max_size`: Some(402), added: 897, mode: `MaxEncodedLen`) /// The range of component `p` is `[0, 99]`. fn approve_proposal(p: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `486 + p * (9 ±0)` // Estimated: `3573` - // Minimum execution time: 14_906_000 picoseconds. - Weight::from_parts(17_983_887, 0) + // Minimum execution time: 9_814_000 picoseconds. + Weight::from_parts(12_878_486, 0) .saturating_add(Weight::from_parts(0, 3573)) - // Standard Error: 3_770 - .saturating_add(Weight::from_parts(172_549, 0).saturating_mul(p.into())) + // Standard Error: 1_792 + .saturating_add(Weight::from_parts(107_787, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: Treasury Approvals (r:1 w:1) - /// Proof: Treasury Approvals (max_values: Some(1), max_size: Some(402), added: 897, mode: MaxEncodedLen) + /// Storage: `Treasury::Approvals` (r:1 w:1) + /// Proof: `Treasury::Approvals` (`max_values`: Some(1), `max_size`: Some(402), added: 897, mode: `MaxEncodedLen`) fn remove_approval() -> Weight { // Proof Size summary in bytes: // Measured: `165` // Estimated: `1887` - // Minimum execution time: 11_656_000 picoseconds. - Weight::from_parts(12_011_000, 0) + // Minimum execution time: 7_677_000 picoseconds. + Weight::from_parts(7_922_000, 0) .saturating_add(Weight::from_parts(0, 1887)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: System Account (r:201 w:201) - /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) - /// Storage: Treasury Deactivated (r:1 w:1) - /// Proof: Treasury Deactivated (max_values: Some(1), max_size: Some(16), added: 511, mode: MaxEncodedLen) - /// Storage: Balances InactiveIssuance (r:1 w:1) - /// Proof: Balances InactiveIssuance (max_values: Some(1), max_size: Some(16), added: 511, mode: MaxEncodedLen) - /// Storage: Treasury Approvals (r:1 w:1) - /// Proof: Treasury Approvals (max_values: Some(1), max_size: Some(402), added: 897, mode: MaxEncodedLen) - /// Storage: Treasury Proposals (r:100 w:100) - /// Proof: Treasury Proposals (max_values: None, max_size: Some(108), added: 2583, mode: MaxEncodedLen) - /// Storage: Bounties BountyApprovals (r:1 w:1) - /// Proof: Bounties BountyApprovals (max_values: Some(1), max_size: Some(402), added: 897, mode: MaxEncodedLen) + /// Storage: `System::Account` (r:201 w:201) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) + /// Storage: `Treasury::Deactivated` (r:1 w:1) + /// Proof: `Treasury::Deactivated` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `MaxEncodedLen`) + /// Storage: `Treasury::Approvals` (r:1 w:1) + /// Proof: `Treasury::Approvals` (`max_values`: Some(1), `max_size`: Some(402), added: 897, mode: `MaxEncodedLen`) + /// Storage: `Treasury::Proposals` (r:100 w:100) + /// Proof: `Treasury::Proposals` (`max_values`: None, `max_size`: Some(108), added: 2583, mode: `MaxEncodedLen`) + /// Storage: `Bounties::BountyApprovals` (r:1 w:1) + /// Proof: `Bounties::BountyApprovals` (`max_values`: Some(1), `max_size`: Some(402), added: 897, mode: `MaxEncodedLen`) /// The range of component `p` is `[0, 100]`. fn on_initialize_proposals(p: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `149 + p * (252 ±0)` // Estimated: `3593 + p * (5206 ±0)` - // Minimum execution time: 45_523_000 picoseconds. - Weight::from_parts(93_057_917, 0) + // Minimum execution time: 31_474_000 picoseconds. + Weight::from_parts(32_241_000, 0) .saturating_add(Weight::from_parts(0, 3593)) - // Standard Error: 182_147 - .saturating_add(Weight::from_parts(54_962_246, 0).saturating_mul(p.into())) - .saturating_add(T::DbWeight::get().reads(5)) + // Standard Error: 222_050 + .saturating_add(Weight::from_parts(53_985_901, 0).saturating_mul(p.into())) + .saturating_add(T::DbWeight::get().reads(4)) .saturating_add(T::DbWeight::get().reads((3_u64).saturating_mul(p.into()))) - .saturating_add(T::DbWeight::get().writes(5)) + .saturating_add(T::DbWeight::get().writes(4)) .saturating_add(T::DbWeight::get().writes((3_u64).saturating_mul(p.into()))) .saturating_add(Weight::from_parts(0, 5206).saturating_mul(p.into())) } diff --git a/runtime/paseo/src/weights/pallet_utility.rs b/runtime/paseo/src/weights/pallet_utility.rs index 477b911611..2426e338cc 100644 --- a/runtime/paseo/src/weights/pallet_utility.rs +++ b/runtime/paseo/src/weights/pallet_utility.rs @@ -17,10 +17,10 @@ //! Autogenerated weights for `pallet_utility` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-10-17, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-08-28, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `parachain-benchmark`, CPU: `Intel(R) Xeon(R) Platinum 8259CL CPU @ 2.50GHz` -//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("rococo-dev"), DB CACHE: 20 +//! HOSTNAME: `litentry-benchmark-server`, CPU: `Intel(R) Xeon(R) CPU E5-2686 v4 @ 2.30GHz` +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("rococo-dev")`, DB CACHE: 20 // Executed Command: // ./litentry-collator @@ -54,18 +54,18 @@ impl pallet_utility::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 10_307_000 picoseconds. - Weight::from_parts(36_977_209, 0) + // Minimum execution time: 6_462_000 picoseconds. + Weight::from_parts(6_692_000, 0) .saturating_add(Weight::from_parts(0, 0)) - // Standard Error: 40_489 - .saturating_add(Weight::from_parts(7_773_419, 0).saturating_mul(c.into())) + // Standard Error: 21_648 + .saturating_add(Weight::from_parts(6_706_710, 0).saturating_mul(c.into())) } fn as_derivative() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_956_000 picoseconds. - Weight::from_parts(7_237_000, 0) + // Minimum execution time: 4_500_000 picoseconds. + Weight::from_parts(4_824_000, 0) .saturating_add(Weight::from_parts(0, 0)) } /// The range of component `c` is `[0, 1000]`. @@ -73,18 +73,18 @@ impl pallet_utility::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 10_202_000 picoseconds. - Weight::from_parts(10_311_000, 0) + // Minimum execution time: 6_600_000 picoseconds. + Weight::from_parts(7_067_000, 0) .saturating_add(Weight::from_parts(0, 0)) - // Standard Error: 36_725 - .saturating_add(Weight::from_parts(8_385_209, 0).saturating_mul(c.into())) + // Standard Error: 21_698 + .saturating_add(Weight::from_parts(6_985_924, 0).saturating_mul(c.into())) } fn dispatch_as() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 12_851_000 picoseconds. - Weight::from_parts(13_230_000, 0) + // Minimum execution time: 8_567_000 picoseconds. + Weight::from_parts(9_046_000, 0) .saturating_add(Weight::from_parts(0, 0)) } /// The range of component `c` is `[0, 1000]`. @@ -92,10 +92,10 @@ impl pallet_utility::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 10_042_000 picoseconds. - Weight::from_parts(26_429_449, 0) + // Minimum execution time: 6_552_000 picoseconds. + Weight::from_parts(6_747_000, 0) .saturating_add(Weight::from_parts(0, 0)) - // Standard Error: 69_016 - .saturating_add(Weight::from_parts(7_675_740, 0).saturating_mul(c.into())) + // Standard Error: 22_937 + .saturating_add(Weight::from_parts(6_700_953, 0).saturating_mul(c.into())) } } diff --git a/runtime/paseo/src/weights/pallet_vc_management.rs b/runtime/paseo/src/weights/pallet_vc_management.rs index 6ede65a8ae..3c9323f0c2 100644 --- a/runtime/paseo/src/weights/pallet_vc_management.rs +++ b/runtime/paseo/src/weights/pallet_vc_management.rs @@ -17,10 +17,10 @@ //! Autogenerated weights for `pallet_vc_management` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2024-01-19, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-08-28, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `parachain-benchmark`, CPU: `Intel(R) Xeon(R) Platinum 8259CL CPU @ 2.50GHz` -//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("rococo-dev"), DB CACHE: 20 +//! HOSTNAME: `litentry-benchmark-server`, CPU: `Intel(R) Xeon(R) CPU E5-2686 v4 @ 2.30GHz` +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("rococo-dev")`, DB CACHE: 20 // Executed Command: // ./litentry-collator @@ -49,128 +49,128 @@ use core::marker::PhantomData; /// Weight functions for `pallet_vc_management`. pub struct WeightInfo(PhantomData); impl pallet_vc_management::WeightInfo for WeightInfo { - /// Storage: VCManagement Delegatee (r:0 w:1) - /// Proof: VCManagement Delegatee (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen) + /// Storage: `VCManagement::Delegatee` (r:0 w:1) + /// Proof: `VCManagement::Delegatee` (`max_values`: None, `max_size`: Some(48), added: 2523, mode: `MaxEncodedLen`) fn add_delegatee() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 12_994_000 picoseconds. - Weight::from_parts(13_371_000, 0) + // Minimum execution time: 8_151_000 picoseconds. + Weight::from_parts(8_591_000, 0) .saturating_add(Weight::from_parts(0, 0)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: VCManagement Delegatee (r:1 w:1) - /// Proof: VCManagement Delegatee (max_values: None, max_size: Some(48), added: 2523, mode: MaxEncodedLen) + /// Storage: `VCManagement::Delegatee` (r:1 w:1) + /// Proof: `VCManagement::Delegatee` (`max_values`: None, `max_size`: Some(48), added: 2523, mode: `MaxEncodedLen`) fn remove_delegatee() -> Weight { // Proof Size summary in bytes: // Measured: `113` // Estimated: `3513` - // Minimum execution time: 18_939_000 picoseconds. - Weight::from_parts(19_373_000, 0) + // Minimum execution time: 12_524_000 picoseconds. + Weight::from_parts(12_831_000, 0) .saturating_add(Weight::from_parts(0, 3513)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: VCMPExtrinsicWhitelist GroupControlOn (r:1 w:0) - /// Proof Skipped: VCMPExtrinsicWhitelist GroupControlOn (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: `VCMPExtrinsicWhitelist::GroupControlOn` (r:1 w:0) + /// Proof: `VCMPExtrinsicWhitelist::GroupControlOn` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) fn request_vc() -> Weight { // Proof Size summary in bytes: - // Measured: `42` - // Estimated: `1527` - // Minimum execution time: 15_031_000 picoseconds. - Weight::from_parts(16_267_000, 0) - .saturating_add(Weight::from_parts(0, 1527)) + // Measured: `6` + // Estimated: `1491` + // Minimum execution time: 9_407_000 picoseconds. + Weight::from_parts(9_800_000, 0) + .saturating_add(Weight::from_parts(0, 1491)) .saturating_add(T::DbWeight::get().reads(1)) } - /// Storage: Teerex EnclaveIndex (r:1 w:0) - /// Proof Skipped: Teerex EnclaveIndex (max_values: None, max_size: None, mode: Measured) + /// Storage: `Teebag::EnclaveRegistry` (r:1 w:0) + /// Proof: `Teebag::EnclaveRegistry` (`max_values`: None, `max_size`: None, mode: `Measured`) fn vc_issued() -> Weight { // Proof Size summary in bytes: - // Measured: `255` - // Estimated: `3720` - // Minimum execution time: 19_878_000 picoseconds. - Weight::from_parts(20_219_000, 0) - .saturating_add(Weight::from_parts(0, 3720)) + // Measured: `347` + // Estimated: `3812` + // Minimum execution time: 12_659_000 picoseconds. + Weight::from_parts(13_134_000, 0) + .saturating_add(Weight::from_parts(0, 3812)) .saturating_add(T::DbWeight::get().reads(1)) } - /// Storage: Teerex EnclaveIndex (r:1 w:0) - /// Proof Skipped: Teerex EnclaveIndex (max_values: None, max_size: None, mode: Measured) + /// Storage: `Teebag::EnclaveRegistry` (r:1 w:0) + /// Proof: `Teebag::EnclaveRegistry` (`max_values`: None, `max_size`: None, mode: `Measured`) fn some_error() -> Weight { // Proof Size summary in bytes: - // Measured: `255` - // Estimated: `3720` - // Minimum execution time: 20_075_000 picoseconds. - Weight::from_parts(20_681_000, 0) - .saturating_add(Weight::from_parts(0, 3720)) + // Measured: `347` + // Estimated: `3812` + // Minimum execution time: 12_419_000 picoseconds. + Weight::from_parts(12_933_000, 0) + .saturating_add(Weight::from_parts(0, 3812)) .saturating_add(T::DbWeight::get().reads(1)) } - /// Storage: VCManagement Admin (r:1 w:1) - /// Proof: VCManagement Admin (max_values: Some(1), max_size: Some(32), added: 527, mode: MaxEncodedLen) + /// Storage: `VCManagement::Admin` (r:1 w:1) + /// Proof: `VCManagement::Admin` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`) fn set_admin() -> Weight { // Proof Size summary in bytes: // Measured: `61` // Estimated: `1517` - // Minimum execution time: 16_327_000 picoseconds. - Weight::from_parts(16_714_000, 0) + // Minimum execution time: 10_226_000 picoseconds. + Weight::from_parts(10_824_000, 0) .saturating_add(Weight::from_parts(0, 1517)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: VCManagement Admin (r:1 w:0) - /// Proof: VCManagement Admin (max_values: Some(1), max_size: Some(32), added: 527, mode: MaxEncodedLen) - /// Storage: VCManagement SchemaRegistryIndex (r:1 w:1) - /// Proof: VCManagement SchemaRegistryIndex (max_values: Some(1), max_size: Some(8), added: 503, mode: MaxEncodedLen) - /// Storage: VCManagement SchemaRegistry (r:0 w:1) - /// Proof: VCManagement SchemaRegistry (max_values: None, max_size: Some(2621), added: 5096, mode: MaxEncodedLen) + /// Storage: `VCManagement::Admin` (r:1 w:0) + /// Proof: `VCManagement::Admin` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`) + /// Storage: `VCManagement::SchemaRegistryIndex` (r:1 w:1) + /// Proof: `VCManagement::SchemaRegistryIndex` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `MaxEncodedLen`) + /// Storage: `VCManagement::SchemaRegistry` (r:0 w:1) + /// Proof: `VCManagement::SchemaRegistry` (`max_values`: None, `max_size`: Some(2621), added: 5096, mode: `MaxEncodedLen`) fn add_schema() -> Weight { // Proof Size summary in bytes: // Measured: `61` // Estimated: `1517` - // Minimum execution time: 20_968_000 picoseconds. - Weight::from_parts(21_334_000, 0) + // Minimum execution time: 13_987_000 picoseconds. + Weight::from_parts(14_507_000, 0) .saturating_add(Weight::from_parts(0, 1517)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) } - /// Storage: VCManagement Admin (r:1 w:0) - /// Proof: VCManagement Admin (max_values: Some(1), max_size: Some(32), added: 527, mode: MaxEncodedLen) - /// Storage: VCManagement SchemaRegistry (r:1 w:1) - /// Proof: VCManagement SchemaRegistry (max_values: None, max_size: Some(2621), added: 5096, mode: MaxEncodedLen) + /// Storage: `VCManagement::Admin` (r:1 w:0) + /// Proof: `VCManagement::Admin` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`) + /// Storage: `VCManagement::SchemaRegistry` (r:1 w:1) + /// Proof: `VCManagement::SchemaRegistry` (`max_values`: None, `max_size`: Some(2621), added: 5096, mode: `MaxEncodedLen`) fn disable_schema() -> Weight { // Proof Size summary in bytes: // Measured: `179` // Estimated: `6086` - // Minimum execution time: 21_697_000 picoseconds. - Weight::from_parts(22_113_000, 0) + // Minimum execution time: 14_696_000 picoseconds. + Weight::from_parts(15_262_000, 0) .saturating_add(Weight::from_parts(0, 6086)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: VCManagement Admin (r:1 w:0) - /// Proof: VCManagement Admin (max_values: Some(1), max_size: Some(32), added: 527, mode: MaxEncodedLen) - /// Storage: VCManagement SchemaRegistry (r:1 w:1) - /// Proof: VCManagement SchemaRegistry (max_values: None, max_size: Some(2621), added: 5096, mode: MaxEncodedLen) + /// Storage: `VCManagement::Admin` (r:1 w:0) + /// Proof: `VCManagement::Admin` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`) + /// Storage: `VCManagement::SchemaRegistry` (r:1 w:1) + /// Proof: `VCManagement::SchemaRegistry` (`max_values`: None, `max_size`: Some(2621), added: 5096, mode: `MaxEncodedLen`) fn activate_schema() -> Weight { // Proof Size summary in bytes: // Measured: `179` // Estimated: `6086` - // Minimum execution time: 21_328_000 picoseconds. - Weight::from_parts(21_743_000, 0) + // Minimum execution time: 14_553_000 picoseconds. + Weight::from_parts(15_289_000, 0) .saturating_add(Weight::from_parts(0, 6086)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: VCManagement Admin (r:1 w:0) - /// Proof: VCManagement Admin (max_values: Some(1), max_size: Some(32), added: 527, mode: MaxEncodedLen) - /// Storage: VCManagement SchemaRegistry (r:1 w:1) - /// Proof: VCManagement SchemaRegistry (max_values: None, max_size: Some(2621), added: 5096, mode: MaxEncodedLen) + /// Storage: `VCManagement::Admin` (r:1 w:0) + /// Proof: `VCManagement::Admin` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`) + /// Storage: `VCManagement::SchemaRegistry` (r:1 w:1) + /// Proof: `VCManagement::SchemaRegistry` (`max_values`: None, `max_size`: Some(2621), added: 5096, mode: `MaxEncodedLen`) fn revoke_schema() -> Weight { // Proof Size summary in bytes: // Measured: `179` // Estimated: `6086` - // Minimum execution time: 22_141_000 picoseconds. - Weight::from_parts(22_502_000, 0) + // Minimum execution time: 15_129_000 picoseconds. + Weight::from_parts(15_648_000, 0) .saturating_add(Weight::from_parts(0, 6086)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(1)) From 43ce77dcea2e1c611ab56fc084a2397e9813d246 Mon Sep 17 00:00:00 2001 From: felixfaisal Date: Mon, 2 Sep 2024 06:18:15 +0000 Subject: [PATCH 15/21] fix: update lock file --- Cargo.lock | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Cargo.lock b/Cargo.lock index 52fce26182..29bec94a98 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -8504,8 +8504,8 @@ dependencies = [ "pallet-balances", "pallet-bitacross", "pallet-bounties", - "pallet-bridge", "pallet-bridge-transfer", + "pallet-chain-bridge", "pallet-collective", "pallet-democracy", "pallet-ethereum", From d5fe2d597251df80ce539f6598618ec4c167b17e Mon Sep 17 00:00:00 2001 From: Kai <7630809+Kailai-Wang@users.noreply.github.com> Date: Tue, 3 Sep 2024 06:23:49 +0200 Subject: [PATCH 16/21] Try to fix paseo CI (#3036) * fix paseo chain spec * add paseo --- Makefile | 4 + .../litentry/generate_parachain_artefacts.sh | 4 +- docker/paseo-parachain-launch-config.yml | 11 +- docker/pnpm-lock.yaml | 131 +++++++------- node/res/chain_specs/paseo-plain.json | 171 ++++++++++++++++++ node/res/chain_specs/paseo.json | 147 +++++++++++++++ node/src/chain_specs/paseo.rs | 30 +-- node/src/command.rs | 3 +- primitives/core/src/lib.rs | 1 + scripts/clean-local-docker.sh | 2 +- .../litentry/generate_parachain_artefacts.sh | 4 +- 11 files changed, 411 insertions(+), 97 deletions(-) create mode 100644 node/res/chain_specs/paseo-plain.json create mode 100644 node/res/chain_specs/paseo.json diff --git a/Makefile b/Makefile index 5dc2c8593a..22bcec3b01 100644 --- a/Makefile +++ b/Makefile @@ -144,6 +144,10 @@ clean-docker-litentry: clean-docker-rococo: @./scripts/clean-local-docker.sh rococo +.PHONY: clean-docker-paseo ## Clean up paseo docker images, containers, volumes, etc +clean-docker-paseo: + @./scripts/clean-local-docker.sh paseo + .PHONY: clean-binary ## Kill started polkadot and litentry-collator binaries clean-binary: @./scripts/clean-local-binary.sh diff --git a/bitacross-worker/scripts/litentry/generate_parachain_artefacts.sh b/bitacross-worker/scripts/litentry/generate_parachain_artefacts.sh index e24bc4f940..aabb45ef06 100755 --- a/bitacross-worker/scripts/litentry/generate_parachain_artefacts.sh +++ b/bitacross-worker/scripts/litentry/generate_parachain_artefacts.sh @@ -6,8 +6,8 @@ DESTDIR="$ROOTDIR/tee-worker/docker/litentry" # generate files cd "$ROOTDIR" -make generate-docker-compose-rococo +make generate-docker-compose-paseo # copy files over to `DESTDIR` mkdir -p "$DESTDIR" -cp docker/generated-rococo/* "$DESTDIR/" \ No newline at end of file +cp docker/generated-paseo/* "$DESTDIR/" \ No newline at end of file diff --git a/docker/paseo-parachain-launch-config.yml b/docker/paseo-parachain-launch-config.yml index eb710c325d..bd52d4f4b2 100644 --- a/docker/paseo-parachain-launch-config.yml +++ b/docker/paseo-parachain-launch-config.yml @@ -4,7 +4,10 @@ # # Relaychain Configuration relaychain: - image: parity/polkadot:v0.9.42 + image: parity/polkadot:v1.1.0 + # TODO: `rococo-local` is used here as `paseo` has only "raw" chain spec which can't be further + # manipulated by parachain-launch + # we might need to switch to other launch tools chain: rococo-local env: RUST_LOG: parachain::candidate-backing=trace,parachain::candidate-selection=trace,parachain::pvf=trace,parachain::collator-protocol=trace,parachain::provisioner=trace @@ -13,10 +16,10 @@ relaychain: - --execution=wasm nodes: - name: alice - rpcPort: ${AliceRPCPort:-9936} + rpcPort: ${AliceRPCPort:-9946} port: ${AlicePort:-30336} - name: bob - rpcPort: ${BobRPCPort:-9937} + rpcPort: ${BobRPCPort:-9947} port: ${BobPort:-30337} # Parachain Configuration @@ -40,5 +43,5 @@ parachains: nodes: - flags: - --alice - rpcPort: ${CollatorRPCPort:-9933} + rpcPort: ${CollatorRPCPort:-9944} port: ${CollatorPort:-30333} diff --git a/docker/pnpm-lock.yaml b/docker/pnpm-lock.yaml index b69a146c7b..2a41c32d29 100644 --- a/docker/pnpm-lock.yaml +++ b/docker/pnpm-lock.yaml @@ -11,8 +11,8 @@ dependencies: packages: - /@noble/curves@1.4.2: - resolution: {integrity: sha512-TavHr8qycMChk8UwMld0ZDRvatedkzWfH8IiaeGCfymOP5i0hSCozz9vHOL0nkwk7HRMlFnAiKpS2jrUmSybcw==} + /@noble/curves@1.5.0: + resolution: {integrity: sha512-J5EKamIHnKPyClwVrzmaf5wSdQXgdHcPZIZLu3bwnbeCx8/7NPK5q2ZBWF+5FvYGByjiQQsJYX6jfgB2wDPn3A==} dependencies: '@noble/hashes': 1.4.0 dev: false @@ -22,6 +22,11 @@ packages: engines: {node: '>= 16'} dev: false + /@noble/hashes@1.5.0: + resolution: {integrity: sha512-1j6kQFb7QRru7eKN3ZDvRcP13rugwdxZqCjbiAVZfIJwgj2A65UmT4TgARXGlXgnRkORLTDTrO19ZErt7+QXgA==} + engines: {node: ^14.21.3 || >=16} + dev: false + /@open-web3/parachain-launch@2.0.0: resolution: {integrity: sha512-Blerkp6dFTGoddlOeRysEh4CH4ClVEJ7SQh5nSNytwVd8AhrqNAnWlMmnqjZ5FHK2djXMAi4wowEychnetuA7Q==} hasBin: true @@ -80,7 +85,7 @@ packages: resolution: {integrity: sha512-N4vdrZopbsw8k57uG58ofO7nLXM4Ai7835XqakN27MkjXMp5H830A1KJE0L9sGQR7ukOCDEIHHcwXVrzmJ/PBg==} requiresBuild: true dependencies: - '@noble/hashes': 1.4.0 + '@noble/hashes': 1.5.0 '@polkadot-api/utils': 0.0.1-492c132563ea6b40ae1fc5470dec4cd18768d182.1.0 '@scure/base': 1.1.7 scale-ts: 1.6.0 @@ -109,7 +114,7 @@ packages: '@polkadot/types-augment': 10.13.1 '@polkadot/types-codec': 10.13.1 '@polkadot/util': 12.6.2 - tslib: 2.6.3 + tslib: 2.7.0 transitivePeerDependencies: - bufferutil - supports-color @@ -124,7 +129,7 @@ packages: '@polkadot/types': 10.13.1 '@polkadot/util': 12.6.2 rxjs: 7.8.1 - tslib: 2.6.3 + tslib: 2.7.0 transitivePeerDependencies: - bufferutil - supports-color @@ -144,7 +149,7 @@ packages: '@polkadot/util': 12.6.2 '@polkadot/util-crypto': 12.6.2(@polkadot/util@12.6.2) rxjs: 7.8.1 - tslib: 2.6.3 + tslib: 2.7.0 transitivePeerDependencies: - bufferutil - supports-color @@ -171,7 +176,7 @@ packages: '@polkadot/util-crypto': 12.6.2(@polkadot/util@12.6.2) eventemitter3: 5.0.1 rxjs: 7.8.1 - tslib: 2.6.3 + tslib: 2.7.0 transitivePeerDependencies: - bufferutil - supports-color @@ -187,7 +192,7 @@ packages: dependencies: '@polkadot/util': 12.6.2 '@polkadot/util-crypto': 12.6.2(@polkadot/util@12.6.2) - tslib: 2.6.3 + tslib: 2.7.0 dev: false /@polkadot/networks@12.6.2: @@ -195,8 +200,8 @@ packages: engines: {node: '>=18'} dependencies: '@polkadot/util': 12.6.2 - '@substrate/ss58-registry': 1.49.0 - tslib: 2.6.3 + '@substrate/ss58-registry': 1.50.0 + tslib: 2.7.0 dev: false /@polkadot/rpc-augment@10.13.1: @@ -207,7 +212,7 @@ packages: '@polkadot/types': 10.13.1 '@polkadot/types-codec': 10.13.1 '@polkadot/util': 12.6.2 - tslib: 2.6.3 + tslib: 2.7.0 transitivePeerDependencies: - bufferutil - supports-color @@ -223,7 +228,7 @@ packages: '@polkadot/types': 10.13.1 '@polkadot/util': 12.6.2 rxjs: 7.8.1 - tslib: 2.6.3 + tslib: 2.7.0 transitivePeerDependencies: - bufferutil - supports-color @@ -244,8 +249,8 @@ packages: '@polkadot/x-ws': 12.6.2 eventemitter3: 5.0.1 mock-socket: 9.3.1 - nock: 13.5.4 - tslib: 2.6.3 + nock: 13.5.5 + tslib: 2.7.0 optionalDependencies: '@substrate/connect': 0.8.8 transitivePeerDependencies: @@ -261,7 +266,7 @@ packages: '@polkadot/types': 10.13.1 '@polkadot/types-codec': 10.13.1 '@polkadot/util': 12.6.2 - tslib: 2.6.3 + tslib: 2.7.0 dev: false /@polkadot/types-codec@10.13.1: @@ -270,7 +275,7 @@ packages: dependencies: '@polkadot/util': 12.6.2 '@polkadot/x-bigint': 12.6.2 - tslib: 2.6.3 + tslib: 2.7.0 dev: false /@polkadot/types-create@10.13.1: @@ -279,7 +284,7 @@ packages: dependencies: '@polkadot/types-codec': 10.13.1 '@polkadot/util': 12.6.2 - tslib: 2.6.3 + tslib: 2.7.0 dev: false /@polkadot/types-known@10.13.1: @@ -291,7 +296,7 @@ packages: '@polkadot/types-codec': 10.13.1 '@polkadot/types-create': 10.13.1 '@polkadot/util': 12.6.2 - tslib: 2.6.3 + tslib: 2.7.0 dev: false /@polkadot/types-support@10.13.1: @@ -299,7 +304,7 @@ packages: engines: {node: '>=18'} dependencies: '@polkadot/util': 12.6.2 - tslib: 2.6.3 + tslib: 2.7.0 dev: false /@polkadot/types@10.13.1: @@ -313,7 +318,7 @@ packages: '@polkadot/util': 12.6.2 '@polkadot/util-crypto': 12.6.2(@polkadot/util@12.6.2) rxjs: 7.8.1 - tslib: 2.6.3 + tslib: 2.7.0 dev: false /@polkadot/util-crypto@12.6.2(@polkadot/util@12.6.2): @@ -322,8 +327,8 @@ packages: peerDependencies: '@polkadot/util': 12.6.2 dependencies: - '@noble/curves': 1.4.2 - '@noble/hashes': 1.4.0 + '@noble/curves': 1.5.0 + '@noble/hashes': 1.5.0 '@polkadot/networks': 12.6.2 '@polkadot/util': 12.6.2 '@polkadot/wasm-crypto': 7.3.2(@polkadot/util@12.6.2)(@polkadot/x-randomvalues@12.6.2) @@ -331,7 +336,7 @@ packages: '@polkadot/x-bigint': 12.6.2 '@polkadot/x-randomvalues': 12.6.2(@polkadot/util@12.6.2)(@polkadot/wasm-util@7.3.2) '@scure/base': 1.1.7 - tslib: 2.6.3 + tslib: 2.7.0 dev: false /@polkadot/util@12.6.2: @@ -344,7 +349,7 @@ packages: '@polkadot/x-textencoder': 12.6.2 '@types/bn.js': 5.1.5 bn.js: 5.2.1 - tslib: 2.6.3 + tslib: 2.7.0 dev: false /@polkadot/wasm-bridge@7.3.2(@polkadot/util@12.6.2)(@polkadot/x-randomvalues@12.6.2): @@ -357,7 +362,7 @@ packages: '@polkadot/util': 12.6.2 '@polkadot/wasm-util': 7.3.2(@polkadot/util@12.6.2) '@polkadot/x-randomvalues': 12.6.2(@polkadot/util@12.6.2)(@polkadot/wasm-util@7.3.2) - tslib: 2.6.3 + tslib: 2.7.0 dev: false /@polkadot/wasm-crypto-asmjs@7.3.2(@polkadot/util@12.6.2): @@ -367,7 +372,7 @@ packages: '@polkadot/util': '*' dependencies: '@polkadot/util': 12.6.2 - tslib: 2.6.3 + tslib: 2.7.0 dev: false /@polkadot/wasm-crypto-init@7.3.2(@polkadot/util@12.6.2)(@polkadot/x-randomvalues@12.6.2): @@ -383,7 +388,7 @@ packages: '@polkadot/wasm-crypto-wasm': 7.3.2(@polkadot/util@12.6.2) '@polkadot/wasm-util': 7.3.2(@polkadot/util@12.6.2) '@polkadot/x-randomvalues': 12.6.2(@polkadot/util@12.6.2)(@polkadot/wasm-util@7.3.2) - tslib: 2.6.3 + tslib: 2.7.0 dev: false /@polkadot/wasm-crypto-wasm@7.3.2(@polkadot/util@12.6.2): @@ -394,7 +399,7 @@ packages: dependencies: '@polkadot/util': 12.6.2 '@polkadot/wasm-util': 7.3.2(@polkadot/util@12.6.2) - tslib: 2.6.3 + tslib: 2.7.0 dev: false /@polkadot/wasm-crypto@7.3.2(@polkadot/util@12.6.2)(@polkadot/x-randomvalues@12.6.2): @@ -411,7 +416,7 @@ packages: '@polkadot/wasm-crypto-wasm': 7.3.2(@polkadot/util@12.6.2) '@polkadot/wasm-util': 7.3.2(@polkadot/util@12.6.2) '@polkadot/x-randomvalues': 12.6.2(@polkadot/util@12.6.2)(@polkadot/wasm-util@7.3.2) - tslib: 2.6.3 + tslib: 2.7.0 dev: false /@polkadot/wasm-util@7.3.2(@polkadot/util@12.6.2): @@ -421,7 +426,7 @@ packages: '@polkadot/util': '*' dependencies: '@polkadot/util': 12.6.2 - tslib: 2.6.3 + tslib: 2.7.0 dev: false /@polkadot/x-bigint@12.6.2: @@ -429,7 +434,7 @@ packages: engines: {node: '>=18'} dependencies: '@polkadot/x-global': 12.6.2 - tslib: 2.6.3 + tslib: 2.7.0 dev: false /@polkadot/x-fetch@12.6.2: @@ -438,14 +443,14 @@ packages: dependencies: '@polkadot/x-global': 12.6.2 node-fetch: 3.3.2 - tslib: 2.6.3 + tslib: 2.7.0 dev: false /@polkadot/x-global@12.6.2: resolution: {integrity: sha512-a8d6m+PW98jmsYDtAWp88qS4dl8DyqUBsd0S+WgyfSMtpEXu6v9nXDgPZgwF5xdDvXhm+P0ZfVkVTnIGrScb5g==} engines: {node: '>=18'} dependencies: - tslib: 2.6.3 + tslib: 2.7.0 dev: false /@polkadot/x-randomvalues@12.6.2(@polkadot/util@12.6.2)(@polkadot/wasm-util@7.3.2): @@ -458,7 +463,7 @@ packages: '@polkadot/util': 12.6.2 '@polkadot/wasm-util': 7.3.2(@polkadot/util@12.6.2) '@polkadot/x-global': 12.6.2 - tslib: 2.6.3 + tslib: 2.7.0 dev: false /@polkadot/x-textdecoder@12.6.2: @@ -466,7 +471,7 @@ packages: engines: {node: '>=18'} dependencies: '@polkadot/x-global': 12.6.2 - tslib: 2.6.3 + tslib: 2.7.0 dev: false /@polkadot/x-textencoder@12.6.2: @@ -474,7 +479,7 @@ packages: engines: {node: '>=18'} dependencies: '@polkadot/x-global': 12.6.2 - tslib: 2.6.3 + tslib: 2.7.0 dev: false /@polkadot/x-ws@12.6.2: @@ -482,7 +487,7 @@ packages: engines: {node: '>=18'} dependencies: '@polkadot/x-global': 12.6.2 - tslib: 2.6.3 + tslib: 2.7.0 ws: 8.18.0 transitivePeerDependencies: - bufferutil @@ -499,8 +504,8 @@ packages: dev: false optional: true - /@substrate/connect-known-chains@1.2.0: - resolution: {integrity: sha512-BgcTHKteSAcEQs5ySNTYOO6ODQHVHwPgDrjYQhL0r8ZygY4cyXa5e2O//3tXNJiDopFHdqO8FBAy2Gbht0i0PA==} + /@substrate/connect-known-chains@1.3.0: + resolution: {integrity: sha512-BHcWdhOsnHtoWuS4LpFpH3MbLAhm1amq4hvl5ctI47KNZcZJcEPAF4zmeaTMuvj+UJ7LEFooy46Mn7zok47MwA==} requiresBuild: true dev: false optional: true @@ -510,7 +515,7 @@ packages: requiresBuild: true dependencies: '@substrate/connect-extension-protocol': 2.0.0 - '@substrate/connect-known-chains': 1.2.0 + '@substrate/connect-known-chains': 1.3.0 '@substrate/light-client-extension-helpers': 0.0.4(smoldot@2.0.22) smoldot: 2.0.22 transitivePeerDependencies: @@ -530,26 +535,26 @@ packages: '@polkadot-api/json-rpc-provider-proxy': 0.0.1-492c132563ea6b40ae1fc5470dec4cd18768d182.1.0 '@polkadot-api/substrate-client': 0.0.1-492c132563ea6b40ae1fc5470dec4cd18768d182.1.0 '@substrate/connect-extension-protocol': 2.0.0 - '@substrate/connect-known-chains': 1.2.0 + '@substrate/connect-known-chains': 1.3.0 rxjs: 7.8.1 smoldot: 2.0.22 dev: false optional: true - /@substrate/ss58-registry@1.49.0: - resolution: {integrity: sha512-leW6Ix4LD7XgvxT7+aobPWSw+WvPcN2Rxof1rmd0mNC5t2n99k1N7UNEvz7YEFSOUeHWmKIY7F5q8KeIqYoHfA==} + /@substrate/ss58-registry@1.50.0: + resolution: {integrity: sha512-mkmlMlcC+MSd9rA+PN8ljGAm5fVZskvVwkXIsbx4NFwaT8kt38r7e9cyDWscG3z2Zn40POviZvEMrJSk+r2SgQ==} dev: false /@types/bn.js@5.1.5: resolution: {integrity: sha512-V46N0zwKRF5Q00AZ6hWtN0T8gGmDUaUzLWQvHFo5yThtVwK/VCenFY3wXVbOvNfajEpsTfQM4IN9k/d6gUVX3A==} dependencies: - '@types/node': 20.14.12 + '@types/node': 22.5.2 dev: false - /@types/node@20.14.12: - resolution: {integrity: sha512-r7wNXakLeSsGT0H1AU863vS2wa5wBOK4bWMjZz2wj+8nBx+m5PeIn0k8AloSLpRuiwdRQZwarZqHE4FNArPuJQ==} + /@types/node@22.5.2: + resolution: {integrity: sha512-acJsPTEqYqulZS/Yp/S3GgeE6GZ0qYODUR8aVr/DkhHQ8l9nd4j5x1/ZJy9/gHrRlFMqkO6i0I3E27Alu4jjPg==} dependencies: - undici-types: 6.13.0 + undici-types: 6.19.8 dev: false /ansi-regex@5.0.1: @@ -608,8 +613,8 @@ packages: engines: {node: '>= 12'} dev: false - /debug@4.3.5: - resolution: {integrity: sha512-pt0bNEmneDIvdL1Xsd9oDQ/wrQRkXDT4AUWlNZNPKvW5x/jyO9VFXkJUP07vQ2upmw5PlaITaPKc31jK13V+jg==} + /debug@4.3.6: + resolution: {integrity: sha512-O/09Bd4Z1fBrU4VzkhFqVgpPzaGbw6Sm9FEkBT1A/YBXQFGuuSxa1dN2nxgxS34JmKXqYx8CZAwEVoJFImUXIg==} engines: {node: '>=6.0'} peerDependencies: supports-color: '*' @@ -624,8 +629,8 @@ packages: resolution: {integrity: sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==} dev: false - /escalade@3.1.2: - resolution: {integrity: sha512-ErCHMCae19vR8vQGe50xIsVomy19rg6gFu3+r3jkEO46suLMWBksvVyoGgQV+jOfl84ZSOSlmv6Gxa89PmTGmA==} + /escalade@3.2.0: + resolution: {integrity: sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==} engines: {node: '>=6'} dev: false @@ -697,8 +702,8 @@ packages: engines: {node: '>= 0.10'} dev: false - /is-core-module@2.15.0: - resolution: {integrity: sha512-Dd+Lb2/zvk9SKy1TGCt1wFJFo/MWBPMX5x7KcvLajWTGuomczdQX61PvY5yK6SVACwpoexWo81IfFyoKY2QnTA==} + /is-core-module@2.15.1: + resolution: {integrity: sha512-z0vtXSwucUJtANQWldhbtbt7BnL0vxiFjIdDLAatwhDYty2bad6s+rijD6Ri4YuYJubLzIJLUidCh09e1djEVQ==} engines: {node: '>= 0.4'} dependencies: hasown: 2.0.2 @@ -732,11 +737,11 @@ packages: resolution: {integrity: sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==} dev: false - /nock@13.5.4: - resolution: {integrity: sha512-yAyTfdeNJGGBFxWdzSKCBYxs5FxLbCg5X5Q4ets974hcQzG1+qCxvIyOo4j2Ry6MUlhWVMX4OoYDefAIIwupjw==} + /nock@13.5.5: + resolution: {integrity: sha512-XKYnqUrCwXC8DGG1xX4YH5yNIrlh9c065uaMZZHUoeUUINTOyt+x/G+ezYk0Ft6ExSREVIs+qBJDK503viTfFA==} engines: {node: '>= 10.13'} dependencies: - debug: 4.3.5 + debug: 4.3.6 json-stringify-safe: 5.0.1 propagate: 2.0.1 transitivePeerDependencies: @@ -798,7 +803,7 @@ packages: resolution: {integrity: sha512-oKWePCxqpd6FlLvGV1VU0x7bkPmmCNolxzjMf4NczoDnQcIWrAF+cPtZn5i6n+RfD2d9i0tzpKnG6Yk168yIyw==} hasBin: true dependencies: - is-core-module: 2.15.0 + is-core-module: 2.15.1 path-parse: 1.0.7 supports-preserve-symlinks-flag: 1.0.0 dev: false @@ -806,7 +811,7 @@ packages: /rxjs@7.8.1: resolution: {integrity: sha512-AA3TVj+0A2iuIoQkWEK/tqFjBq2j+6PO6Y0zJcvzLAFhEFIO3HL0vls9hWLncZbAAbK0mar7oZ4V079I/qPMxg==} dependencies: - tslib: 2.6.3 + tslib: 2.7.0 dev: false /scale-ts@1.6.0: @@ -857,12 +862,12 @@ packages: engines: {node: '>= 0.4'} dev: false - /tslib@2.6.3: - resolution: {integrity: sha512-xNvxJEOUiWPGhUuUdQgAJPKOOJfGnIyKySOc09XkKsgdUV/3E2zvwZYdejjmRgPCgcym1juLH3226yA7sEFJKQ==} + /tslib@2.7.0: + resolution: {integrity: sha512-gLXCKdN1/j47AiHiOkJN69hJmcbGTHI0ImLmbYLHykhgeN0jVGola9yVjFgzCUklsZQMW55o+dW7IXv3RCXDzA==} dev: false - /undici-types@6.13.0: - resolution: {integrity: sha512-xtFJHudx8S2DSoujjMd1WeWvn7KKWFRESZTMeL1RptAYERu29D6jphMjjY+vn96jvN3kVPDNxU/E13VTaXj6jg==} + /undici-types@6.19.8: + resolution: {integrity: sha512-ve2KP6f/JnbPBFyobGHuerC9g1FYGn/F8n1LWTwNxCEzd6IfqTwUQcNXgEtmmQ6DlRrC1hrSrBnCZPokRrDHjw==} dev: false /web-streams-polyfill@3.3.3: @@ -917,7 +922,7 @@ packages: engines: {node: '>=12'} dependencies: cliui: 8.0.1 - escalade: 3.1.2 + escalade: 3.2.0 get-caller-file: 2.0.5 require-directory: 2.1.1 string-width: 4.2.3 diff --git a/node/res/chain_specs/paseo-plain.json b/node/res/chain_specs/paseo-plain.json new file mode 100644 index 0000000000..566baeb67f --- /dev/null +++ b/node/res/chain_specs/paseo-plain.json @@ -0,0 +1,171 @@ +{ + "name": "Litentry-paseo", + "id": "litentry-paseo", + "chainType": "Live", + "bootNodes": [ + "/ip4/127.0.0.1/tcp/30333/p2p/12D3KooWAkLyq5ktkfGK3HHaWTnqqa26x2LYTsDVj4zu5dLDQ1NA" + ], + "telemetryEndpoints": [ + [ + "/dns/telemetry.polkadot.io/tcp/443/x-parity-wss/%2Fsubmit%2F", + 0 + ] + ], + "protocolId": "litentry-paseo", + "properties": { + "ss58Format": 131, + "tokenDecimals": 18, + "tokenSymbol": "LIT" + }, + "relayChain": "paseo", + "paraId": 2106, + "codeSubstitutes": {}, + "genesis": { + "runtime": { + "system": { + "code": "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" + }, + "balances": { + "balances": [ + [ + "5GKVBdNwNY6H7uqKtx3gks3t9aSpjG6uHEsFYKWUJtexxkyQ", + 1000000000000000000000 + ], + [ + "5HEdcZvZ2h9hZyCwsxrPhU2uL1B418bxiN8LV6mYzrdAfP6h", + 1000000000000000000000 + ], + [ + "5CSfg3iY5H1rRFY3Qpez9Jy1dMvmvurxCGsEPptsx556sEY9", + 1000000000000000000000 + ], + [ + "5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY", + 1000000000000000000000 + ] + ] + }, + "vesting": { + "vesting": [] + }, + "transactionPayment": { + "multiplier": "1000000000000000000" + }, + "treasury": {}, + "democracy": {}, + "council": { + "members": [] + }, + "councilMembership": { + "members": [ + "5GKVBdNwNY6H7uqKtx3gks3t9aSpjG6uHEsFYKWUJtexxkyQ", + "5HEdcZvZ2h9hZyCwsxrPhU2uL1B418bxiN8LV6mYzrdAfP6h" + ] + }, + "technicalCommittee": { + "members": [] + }, + "technicalCommitteeMembership": { + "members": [ + "5GKVBdNwNY6H7uqKtx3gks3t9aSpjG6uHEsFYKWUJtexxkyQ", + "5HEdcZvZ2h9hZyCwsxrPhU2uL1B418bxiN8LV6mYzrdAfP6h" + ] + }, + "parachainSystem": {}, + "parachainInfo": { + "parachainId": 2106 + }, + "session": { + "keys": [ + [ + "5GKVBdNwNY6H7uqKtx3gks3t9aSpjG6uHEsFYKWUJtexxkyQ", + "5GKVBdNwNY6H7uqKtx3gks3t9aSpjG6uHEsFYKWUJtexxkyQ", + { + "aura": "5HbqsE314k9KV1duWVhpygMdSbyypHdJzM9Gb3Z1qxXndo3Y" + } + ], + [ + "5HEdcZvZ2h9hZyCwsxrPhU2uL1B418bxiN8LV6mYzrdAfP6h", + "5HEdcZvZ2h9hZyCwsxrPhU2uL1B418bxiN8LV6mYzrdAfP6h", + { + "aura": "5Eyg6FJdntWt73fxXJTZManoxs3R1ZAgYS9XyQc1nRD1pNdU" + } + ] + ] + }, + "aura": { + "authorities": [] + }, + "auraExt": {}, + "parachainStaking": { + "candidates": [ + [ + "5GKVBdNwNY6H7uqKtx3gks3t9aSpjG6uHEsFYKWUJtexxkyQ", + 50000000000000000000 + ], + [ + "5HEdcZvZ2h9hZyCwsxrPhU2uL1B418bxiN8LV6mYzrdAfP6h", + 50000000000000000000 + ] + ], + "delegations": [], + "inflationConfig": { + "expect": { + "min": 0, + "ideal": 0, + "max": 0 + }, + "annual": { + "min": 0, + "ideal": 0, + "max": 0 + }, + "round": { + "min": 0, + "ideal": 0, + "max": 0 + } + } + }, + "polkadotXcm": { + "safeXcmVersion": 3 + }, + "assets": { + "assets": [], + "metadata": [], + "accounts": [] + }, + "vcManagement": { + "admin": "5CSfg3iY5H1rRFY3Qpez9Jy1dMvmvurxCGsEPptsx556sEY9" + }, + "bitacross": { + "admin": "5CSfg3iY5H1rRFY3Qpez9Jy1dMvmvurxCGsEPptsx556sEY9" + }, + "developerCommittee": { + "members": [] + }, + "developerCommitteeMembership": { + "members": [ + "5GKVBdNwNY6H7uqKtx3gks3t9aSpjG6uHEsFYKWUJtexxkyQ", + "5HEdcZvZ2h9hZyCwsxrPhU2uL1B418bxiN8LV6mYzrdAfP6h" + ] + }, + "scoreStaking": { + "state": "Stopped", + "marker": null + }, + "teebag": { + "allowSgxDebugMode": true, + "admin": "5CSfg3iY5H1rRFY3Qpez9Jy1dMvmvurxCGsEPptsx556sEY9", + "mode": "Development" + }, + "evm": { + "accounts": {} + }, + "ethereum": {}, + "sudo": { + "key": "5CSfg3iY5H1rRFY3Qpez9Jy1dMvmvurxCGsEPptsx556sEY9" + } + } + } +} \ No newline at end of file diff --git a/node/res/chain_specs/paseo.json b/node/res/chain_specs/paseo.json new file mode 100644 index 0000000000..90ea5895b4 --- /dev/null +++ b/node/res/chain_specs/paseo.json @@ -0,0 +1,147 @@ +{ + "name": "Litentry-paseo", + "id": "litentry-paseo", + "chainType": "Live", + "bootNodes": [ + "/ip4/127.0.0.1/tcp/30333/p2p/12D3KooWAkLyq5ktkfGK3HHaWTnqqa26x2LYTsDVj4zu5dLDQ1NA" + ], + "telemetryEndpoints": [ + [ + "/dns/telemetry.polkadot.io/tcp/443/x-parity-wss/%2Fsubmit%2F", + 0 + ] + ], + "protocolId": "litentry-paseo", + "properties": { + "ss58Format": 131, + "tokenDecimals": 18, + "tokenSymbol": "LIT" + }, + "relayChain": "paseo", + "paraId": 2106, + "codeSubstitutes": {}, + "genesis": { + "raw": { + "top": { + "0x0d715f2646c8f85767b5d2764bb2782604a74d81251e398fd8a0a4d55023bb3f": "0x3a080000", + "0x0d715f2646c8f85767b5d2764bb278264e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0x132f230c804b4243426eed4751ea81274e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0x132f230c804b4243426eed4751ea8127f39a107f2d8d3854c9aba9b021f43d9c": "0x00", + "0x149b1b9a56c9e56b2f825a1f8b8037854e7b9012096b41c4eb3aaf947f6ea429": "0x0400", + "0x149b1b9a56c9e56b2f825a1f8b803785ba7fb8745735dc3be2a2c61a72c39e78": "0x08bc36f40fcf0e5f8f5245195f4c522a5f1ea85b1c279eedc22437de0568bc1f2ae4bf56759cdc730c2826898a78ef72ef7e9d8a0fd688ec43439b853c6663ab3a", + "0x176584309a63dc1b42609612c59200064e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0x1809d78346727a0ef58c0fa03bafa3234e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0x1da53b775b270400e7e61ed5cbc5a1464e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0x2013754dd003840aea66b349f8241e254e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0x2013754dd003840aea66b349f8241e2582fbce236236c63b34351052f96f6751": "0x00", + "0x2013754dd003840aea66b349f8241e25a44704b568d21667356a5a050c118746f52c63705dbee9f60000000000000000000000000000000000000000000000000000000000000000": "0xabca7b7b8c7943ad2be42b9c05af7acdc928aaeba89e400c37753e892ffc0595", + "0x2013754dd003840aea66b349f8241e25b1ef0b108928f2a3c149728bbd19fb48": "0x00", + "0x2013754dd003840aea66b349f8241e25c8c156f8164e0465c74b8972ea68b4b3": "0x00000000000000000000000000000000000000000000000000000000000000001dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d493470000000000000000000000000000000000000000329f3350a3f4a6e86e886725067a5fd4c6c0d6b924da48b2c7b1b7e0df05ff7556e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b42156e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b4210000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000c0e1e400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "0x20a91688f20780fdac59f9fd352f5b664e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0x26aa394eea5630e07c48ae0c9558cef734abf5cb34d6244378cddbf18e849d96": "0x000000000284d71700", + "0x26aa394eea5630e07c48ae0c9558cef74e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0x26aa394eea5630e07c48ae0c9558cef75684a022a34dd8bfa2baaf44f172b710": "0x01", + "0x26aa394eea5630e07c48ae0c9558cef78a42f33323cb5ced3b44dd825fda9fcc": "0x4545454545454545454545454545454545454545454545454545454545454545", + "0x26aa394eea5630e07c48ae0c9558cef7a44704b568d21667356a5a050c118746b4def25cfda6ef3a00000000": "0x4545454545454545454545454545454545454545454545454545454545454545", + "0x26aa394eea5630e07c48ae0c9558cef7a7fd6c28836b9a28522dc924110cf439": "0x01", + "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da90bf3bc2a48921453b26660ad162aa24ce4bf56759cdc730c2826898a78ef72ef7e9d8a0fd688ec43439b853c6663ab3a": "0x000000000200000001000000000000000000182daffee57f3300000000000000000088b116afe3b502000000000000000000000000000000000000000000000000000000000000000000000000000080", + "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da92ea70a296234763089df1bdca890f7df10c00cc300d38d0648ff2ff2dd38109de8f0b310ae8dabfcc06b7faaf74f632e": "0x000000000000000001000000000000000000a0dec5adc9353600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080", + "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da95ecffd7b6c0f78751baa9d281e0bfa3a6d6f646c70792f74727372790000000000000000000000000000000000000000": "0x0000000000000000010000000000000000008a5d784563010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080", + "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9de1e86a9a8c739864cf3cc5ec2bea59fd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d": "0x000000000000000001000000000000000000a0dec5adc9353600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080", + "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9eb13acb64102120d2a1556c83f8a5bd6bc36f40fcf0e5f8f5245195f4c522a5f1ea85b1c279eedc22437de0568bc1f2a": "0x000000000200000001000000000000000000182daffee57f3300000000000000000088b116afe3b502000000000000000000000000000000000000000000000000000000000000000000000000000080", + "0x26aa394eea5630e07c48ae0c9558cef7f9cce9c888469bb1a0dceaa129672ef8": "0xc18f3c706173656f2d70617261636861696e", + "0x2c5de123c468aef7f3ac2ab3a76f87ce4e7b9012096b41c4eb3aaf947f6ea429": "0x0400", + "0x3a63": "0x", + "0x3a636f6465": "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", + "0x3a657468657265756d5f736368656d61": "0x03", + "0x3a65787472696e7369635f696e646578": "0x00000000", + "0x3c311d57d4daf52904616cf69648081e4e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0x3c311d57d4daf52904616cf69648081e5e0621c4869aa60c02be9adcc98a0d1d": "0x08f4ecbccdeb0fc5ccf6801dc387b08a7ed2162225918fd9c961b13748e233e26380de876202a9e09c7e7d08cd8c0a77a1c22ec19de1177d87c40a5fb6eb7abf19", + "0x3db7a24cfdc9de785974746c14a99df94e7b9012096b41c4eb3aaf947f6ea429": "0x0400", + "0x3f1467a096bcd71a5b6a0c8155e20810308ce9615de0775a82f8a94dc3d285a1": "0x01", + "0x3f1467a096bcd71a5b6a0c8155e208103f2edf3bdf381debe331ab7446addfdc": "0x000064a7b3b6e00d0000000000000000", + "0x3f1467a096bcd71a5b6a0c8155e208104e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0x43cdcd39d5edb1d16e24fa028edde0de4e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0x45323df7cc47150b3930e2666b0aa3134e7b9012096b41c4eb3aaf947f6ea429": "0x0200", + "0x48b814eb25e6dfbed503da2a403f10874e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0x4ae7e256f92e5888372d72f3e4db10034e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0x4c95267b13bd6714f8b80b2306b261314e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0x502b02a7d36ff0a682afc41baceb2fc64e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0x502b02a7d36ff0a682afc41baceb2fc6a257afd8b1a01000326aea09f9b12f69": "0x01", + "0x502b02a7d36ff0a682afc41baceb2fc6a29c2ba8f2ce8c73fe173478c1f00656": "0x01", + "0x502b02a7d36ff0a682afc41baceb2fc6ad108d599f52eaf38db78295e5d07707": "0x10c00cc300d38d0648ff2ff2dd38109de8f0b310ae8dabfcc06b7faaf74f632e", + "0x57f8dc2f5ab09467896f47300f0424384e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0x57f8dc2f5ab09467896f47300f0424385e0621c4869aa60c02be9adcc98a0d1d": "0x08f4ecbccdeb0fc5ccf6801dc387b08a7ed2162225918fd9c961b13748e233e26380de876202a9e09c7e7d08cd8c0a77a1c22ec19de1177d87c40a5fb6eb7abf19", + "0x585a02b77f684d3fa671291e594eced44e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0x5c0409d1bd2b4daa2f6d66063b089b534e7b9012096b41c4eb3aaf947f6ea429": "0x0400", + "0x5c0409d1bd2b4daa2f6d66063b089b53ba7fb8745735dc3be2a2c61a72c39e78": "0x08bc36f40fcf0e5f8f5245195f4c522a5f1ea85b1c279eedc22437de0568bc1f2ae4bf56759cdc730c2826898a78ef72ef7e9d8a0fd688ec43439b853c6663ab3a", + "0x5c0d1176a568c1f92944340dbfed9e9c4e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0x5c0d1176a568c1f92944340dbfed9e9c530ebca703c85910e7164cb7d1c9e47b": "0x10c00cc300d38d0648ff2ff2dd38109de8f0b310ae8dabfcc06b7faaf74f632e", + "0x5d020e04fce8e1fd3acafafa866d412a4e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0x5d020e04fce8e1fd3acafafa866d412aad108d599f52eaf38db78295e5d07707": "0x10c00cc300d38d0648ff2ff2dd38109de8f0b310ae8dabfcc06b7faaf74f632e", + "0x5f27b51b5ec208ee9cb25b55d8728243308ce9615de0775a82f8a94dc3d285a1": "0x01", + "0x5f27b51b5ec208ee9cb25b55d87282434e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0x682a59d51ab9e48a8c8cc418ff9708d24e7b9012096b41c4eb3aaf947f6ea429": "0x0100", + "0x6d9c173c52ab3d1061f02370b4dfa0f94e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0x7474449cca95dc5d0c00e71735a6d17d4e7b9012096b41c4eb3aaf947f6ea429": "0x0100", + "0x79e2fe5d327165001f8232643023ed8b4e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0x7b3237373ffdfeb1cab4222e3b520d6b4e7b9012096b41c4eb3aaf947f6ea429": "0x0300", + "0x7c215a8bceb5e4dcd92f78e36a5fd0ff4e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0x870930725e6219b94fedf76d5e910fdd4e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0x89d041e470d40ab4773fa0052683d90e4e7b9012096b41c4eb3aaf947f6ea429": "0x0400", + "0x89d041e470d40ab4773fa0052683d90eba7fb8745735dc3be2a2c61a72c39e78": "0x08bc36f40fcf0e5f8f5245195f4c522a5f1ea85b1c279eedc22437de0568bc1f2ae4bf56759cdc730c2826898a78ef72ef7e9d8a0fd688ec43439b853c6663ab3a", + "0x89d139e01a5eb2256f222e5fc5dbe6b34e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0x955f62effb30e1a33b76e09cb9c31a224e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0xa37f719efab16103103a0c8c2c784ce14e7b9012096b41c4eb3aaf947f6ea429": "0x0400", + "0xa686a3043d0adcf2fa655e57bc595a7813792e785168f725b60e2969c7fc2552": "0x01000000000000000a000000", + "0xa686a3043d0adcf2fa655e57bc595a781d7912799a6cf05f0394865bd5bb61bd": "0x000000000000000000000000000000000000000000000000000000000000000000", + "0xa686a3043d0adcf2fa655e57bc595a7824ddcec36ac09d628a4e7c4cd8dd4a77": "0x04e4bf56759cdc730c2826898a78ef72ef7e9d8a0fd688ec43439b853c6663ab3a", + "0xa686a3043d0adcf2fa655e57bc595a783f481165c2bc3528b2bef85925ffa0f6409202229d9070e3e4bf56759cdc730c2826898a78ef72ef7e9d8a0fd688ec43439b853c6663ab3a": "0x0000000000000000000000000000000000", + "0xa686a3043d0adcf2fa655e57bc595a783f481165c2bc3528b2bef85925ffa0f6790578e7ee868b3bbc36f40fcf0e5f8f5245195f4c522a5f1ea85b1c279eedc22437de0568bc1f2a": "0x0000000000000000000000000000000000", + "0xa686a3043d0adcf2fa655e57bc595a784e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0xa686a3043d0adcf2fa655e57bc595a7874c6bdda44177fd8b580beed8d6ad3d8": "0x08bc36f40fcf0e5f8f5245195f4c522a5f1ea85b1c279eedc22437de0568bc1f2a000088b116afe3b50200000000000000e4bf56759cdc730c2826898a78ef72ef7e9d8a0fd688ec43439b853c6663ab3a000088b116afe3b50200000000000000", + "0xa686a3043d0adcf2fa655e57bc595a787cd445632a893b0f7773ad9cadf5de9b5153cb1f00942ff401000000": "0x000010632d5ec76b0500000000000000", + "0xa686a3043d0adcf2fa655e57bc595a78948ece45793d7f15c9c0b9574ddbc665": "0x08bc36f40fcf0e5f8f5245195f4c522a5f1ea85b1c279eedc22437de0568bc1f2ae4bf56759cdc730c2826898a78ef72ef7e9d8a0fd688ec43439b853c6663ab3a", + "0xa686a3043d0adcf2fa655e57bc595a78a51b75ece67873166481cf418694a240": "0x00000000", + "0xa686a3043d0adcf2fa655e57bc595a78aaf946a086076d5237bd605fb947f4f9": "0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "0xa686a3043d0adcf2fa655e57bc595a78b04fdd244df45a2531025a7d5a188b05409202229d9070e3e4bf56759cdc730c2826898a78ef72ef7e9d8a0fd688ec43439b853c6663ab3a": "0x0000000000000000000000000000000000", + "0xa686a3043d0adcf2fa655e57bc595a78b04fdd244df45a2531025a7d5a188b05790578e7ee868b3bbc36f40fcf0e5f8f5245195f4c522a5f1ea85b1c279eedc22437de0568bc1f2a": "0x0000000000000000000000000000000000", + "0xa686a3043d0adcf2fa655e57bc595a78c370c440b9c53607144c90c9d0378e01": "0x01000000", + "0xa686a3043d0adcf2fa655e57bc595a78c386892ab22602cf48f173ddd47baba9409202229d9070e3e4bf56759cdc730c2826898a78ef72ef7e9d8a0fd688ec43439b853c6663ab3a": "0x000088b116afe3b5020000000000000000000000000088b116afe3b5020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001010000", + "0xa686a3043d0adcf2fa655e57bc595a78c386892ab22602cf48f173ddd47baba9790578e7ee868b3bbc36f40fcf0e5f8f5245195f4c522a5f1ea85b1c279eedc22437de0568bc1f2a": "0x000088b116afe3b5020000000000000000000000000088b116afe3b5020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001010000", + "0xa686a3043d0adcf2fa655e57bc595a78f2ea452256cacfadf13b115a94c4029c5153cb1f00942ff401000000409202229d9070e3e4bf56759cdc730c2826898a78ef72ef7e9d8a0fd688ec43439b853c6663ab3a": "0x000088b116afe3b5020000000000000000000088b116afe3b50200000000000000", + "0xa686a3043d0adcf2fa655e57bc595a78f43d6436dec51f09c3b71287a8fc9d48": "0x000010632d5ec76b0500000000000000", + "0xaebd463ed9925c488c112434d61debc04e7b9012096b41c4eb3aaf947f6ea429": "0x0400", + "0xaebd463ed9925c488c112434d61debc0ba7fb8745735dc3be2a2c61a72c39e78": "0x08bc36f40fcf0e5f8f5245195f4c522a5f1ea85b1c279eedc22437de0568bc1f2ae4bf56759cdc730c2826898a78ef72ef7e9d8a0fd688ec43439b853c6663ab3a", + "0xb8806b89e4f9af656f87b35e6112ee1b4e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0xb8806b89e4f9af656f87b35e6112ee1bad108d599f52eaf38db78295e5d07707": "0x10c00cc300d38d0648ff2ff2dd38109de8f0b310ae8dabfcc06b7faaf74f632e", + "0xc2261276cc9d1f8598ea4b6a74b15c2f4e7b9012096b41c4eb3aaf947f6ea429": "0x0100", + "0xc2261276cc9d1f8598ea4b6a74b15c2f57c875e4cff74148e4628f264b974c80": "0x00000ad88ffc89d8d800000000000000", + "0xc8a37308d23eae777e1e0856b44b17544e7b9012096b41c4eb3aaf947f6ea429": "0x0400", + "0xc8a37308d23eae777e1e0856b44b1754ba7fb8745735dc3be2a2c61a72c39e78": "0x08bc36f40fcf0e5f8f5245195f4c522a5f1ea85b1c279eedc22437de0568bc1f2ae4bf56759cdc730c2826898a78ef72ef7e9d8a0fd688ec43439b853c6663ab3a", + "0xcd5c1f6df63bc97f4a8ce37f14a50ca74e7b9012096b41c4eb3aaf947f6ea429": "0x0200", + "0xcec5070d609dd3497f72bde07fc96ba04c014e6bf8b8c2c011e7290b85696bb3409202229d9070e3e4bf56759cdc730c2826898a78ef72ef7e9d8a0fd688ec43439b853c6663ab3a": "0x80de876202a9e09c7e7d08cd8c0a77a1c22ec19de1177d87c40a5fb6eb7abf19", + "0xcec5070d609dd3497f72bde07fc96ba04c014e6bf8b8c2c011e7290b85696bb3790578e7ee868b3bbc36f40fcf0e5f8f5245195f4c522a5f1ea85b1c279eedc22437de0568bc1f2a": "0xf4ecbccdeb0fc5ccf6801dc387b08a7ed2162225918fd9c961b13748e233e263", + "0xcec5070d609dd3497f72bde07fc96ba04e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa195028bc737b1924f8956175726180f4ecbccdeb0fc5ccf6801dc387b08a7ed2162225918fd9c961b13748e233e263": "0xbc36f40fcf0e5f8f5245195f4c522a5f1ea85b1c279eedc22437de0568bc1f2a", + "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa1950740ce7e0bc507d73617572618080de876202a9e09c7e7d08cd8c0a77a1c22ec19de1177d87c40a5fb6eb7abf19": "0xe4bf56759cdc730c2826898a78ef72ef7e9d8a0fd688ec43439b853c6663ab3a", + "0xcec5070d609dd3497f72bde07fc96ba088dcde934c658227ee1dfafcd6e16903": "0x08bc36f40fcf0e5f8f5245195f4c522a5f1ea85b1c279eedc22437de0568bc1f2ae4bf56759cdc730c2826898a78ef72ef7e9d8a0fd688ec43439b853c6663ab3a", + "0xcec5070d609dd3497f72bde07fc96ba0e0cdd062e6eaf24295ad4ccfc41d4609": "0x08bc36f40fcf0e5f8f5245195f4c522a5f1ea85b1c279eedc22437de0568bc1f2af4ecbccdeb0fc5ccf6801dc387b08a7ed2162225918fd9c961b13748e233e263e4bf56759cdc730c2826898a78ef72ef7e9d8a0fd688ec43439b853c6663ab3a80de876202a9e09c7e7d08cd8c0a77a1c22ec19de1177d87c40a5fb6eb7abf19", + "0xd57bce545fb382c34570e5dfbf338f5e4e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0xd5e1a2fa16732ce6906189438c0a82c64e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0xd8f314b7f4e6b095f0f8ee4656a448254e7b9012096b41c4eb3aaf947f6ea429": "0x0100", + "0xd9cc2b5cf8be525e21fb8c140f007a564e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0xe38f185207498abb5c213d0fb059b3d84e7b9012096b41c4eb3aaf947f6ea429": "0x0100", + "0xe38f185207498abb5c213d0fb059b3d86323ae84c43568be0d1394d5d0d522c4": "0x03000000", + "0xed25f63942de25ac5253ba64b5eb64d14e7b9012096b41c4eb3aaf947f6ea429": "0x0400", + "0xed25f63942de25ac5253ba64b5eb64d1ba7fb8745735dc3be2a2c61a72c39e78": "0x08bc36f40fcf0e5f8f5245195f4c522a5f1ea85b1c279eedc22437de0568bc1f2ae4bf56759cdc730c2826898a78ef72ef7e9d8a0fd688ec43439b853c6663ab3a", + "0xf0c365c3cf59d671eb72da0e7a4113c44e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0xf2794c22e353e9a839f12faab03a911b4e7b9012096b41c4eb3aaf947f6ea429": "0x0100", + "0xf2794c22e353e9a839f12faab03a911b7f17cdfbfa73331856cca0acddd7842e": "0x00000000", + "0xf2794c22e353e9a839f12faab03a911bbdcb0c5143a8617ed38ae3810dd45bc6": "0x00000000", + "0xf2794c22e353e9a839f12faab03a911be2f6cb0456905c189bcb0458f9440f13": "0x00000000" + }, + "childrenDefault": {} + } + } +} \ No newline at end of file diff --git a/node/src/chain_specs/paseo.rs b/node/src/chain_specs/paseo.rs index 19cf6ec304..0ab53795af 100644 --- a/node/src/chain_specs/paseo.rs +++ b/node/src/chain_specs/paseo.rs @@ -15,7 +15,7 @@ // along with Litentry. If not, see . use super::*; -use core_primitives::LITENTRY_PARA_ID; +use core_primitives::PASEO_PARA_ID; use cumulus_primitives_core::ParaId; use paseo_parachain_runtime::{ AccountId, AuraId, Balance, BalancesConfig, BitacrossConfig, CouncilMembershipConfig, @@ -35,7 +35,7 @@ pub type ChainSpec = sc_service::GenericChainSpec Option { parachain_properties("LIT", 18, 131) @@ -94,7 +94,7 @@ pub fn get_chain_spec_dev(is_standalone: bool) -> ChainSpec { ], vec![get_account_id_from_seed::("Alice")], vec![get_account_id_from_seed::("Alice")], - LITENTRY_PARA_ID.into(), + PASEO_PARA_ID.into(), ) }, Vec::new(), @@ -102,23 +102,7 @@ pub fn get_chain_spec_dev(is_standalone: bool) -> ChainSpec { Some("litentry-paseo"), None, default_parachain_properties(), - Extensions { relay_chain: "rococo-local".into(), para_id: LITENTRY_PARA_ID }, - ) -} - -pub fn get_chain_spec_staging() -> ChainSpec { - // Staging keys are derivative keys based on a single master secret phrase: - // - // root: $SECRET - // account: $SECRET//collator// - // aura: $SECRET//collator////aura - get_chain_spec_from_genesis_info( - include_bytes!("../../res/genesis_info/staging.json"), - "Litentry-paseo-staging", - "litentry-paseo-staging", - ChainType::Local, - "rococo-local".into(), - LITENTRY_PARA_ID.into(), + Extensions { relay_chain: "paseo".into(), para_id: PASEO_PARA_ID }, ) } @@ -128,8 +112,8 @@ pub fn get_chain_spec_prod() -> ChainSpec { "Litentry-paseo", "litentry-paseo", ChainType::Live, - "rococo".into(), - LITENTRY_PARA_ID.into(), + "paseo".into(), + PASEO_PARA_ID.into(), ) } @@ -183,7 +167,7 @@ fn get_chain_spec_from_genesis_info( ) .expect("Invalid telemetry URL; qed."), ), - Some("litentry-rococo"), + Some("litentry-paseo"), None, default_parachain_properties(), Extensions { relay_chain: relay_chain_name, para_id: para_id.into() }, diff --git a/node/src/command.rs b/node/src/command.rs index c6c6d9fa04..a7f9028899 100644 --- a/node/src/command.rs +++ b/node/src/command.rs @@ -104,9 +104,8 @@ fn load_spec(id: &str) -> std::result::Result, St )?), // Paseo "paseo-dev" => Box::new(chain_specs::paseo::get_chain_spec_dev(false)), - "paseo-staging" => Box::new(chain_specs::paseo::get_chain_spec_staging()), "paseo" => Box::new(chain_specs::paseo::ChainSpec::from_json_bytes( - &include_bytes!("../res/chain_specs/rococo.json")[..], + &include_bytes!("../res/chain_specs/paseo.json")[..], )?), // Generate res/chain_specs/litentry.json "generate-litentry" => Box::new(chain_specs::litentry::get_chain_spec_prod()), diff --git a/primitives/core/src/lib.rs b/primitives/core/src/lib.rs index a4ab8e4f39..2eaf3729fa 100644 --- a/primitives/core/src/lib.rs +++ b/primitives/core/src/lib.rs @@ -83,6 +83,7 @@ mod constants { pub const LITENTRY_PARA_ID: u32 = 2013; pub const ROCOCO_PARA_ID: u32 = 2106; // will be replaced by paseo + pub const PASEO_PARA_ID: u32 = 2106; // will be replaced by paseo /// This determines the average expected block time that we are targeting. /// Blocks will be produced at a minimum duration defined by `SLOT_DURATION`. diff --git a/scripts/clean-local-docker.sh b/scripts/clean-local-docker.sh index e959e845c1..4cb0f300a6 100755 --- a/scripts/clean-local-docker.sh +++ b/scripts/clean-local-docker.sh @@ -3,7 +3,7 @@ # no `set -e` here as we allow commands to fail in this script function usage() { - echo "Usage: $0 litentry|rococo" + echo "Usage: $0 litentry|rococo|paseo" } [ $# -ne 1 ] && (usage; exit 1) diff --git a/tee-worker/scripts/litentry/generate_parachain_artefacts.sh b/tee-worker/scripts/litentry/generate_parachain_artefacts.sh index e24bc4f940..aabb45ef06 100755 --- a/tee-worker/scripts/litentry/generate_parachain_artefacts.sh +++ b/tee-worker/scripts/litentry/generate_parachain_artefacts.sh @@ -6,8 +6,8 @@ DESTDIR="$ROOTDIR/tee-worker/docker/litentry" # generate files cd "$ROOTDIR" -make generate-docker-compose-rococo +make generate-docker-compose-paseo # copy files over to `DESTDIR` mkdir -p "$DESTDIR" -cp docker/generated-rococo/* "$DESTDIR/" \ No newline at end of file +cp docker/generated-paseo/* "$DESTDIR/" \ No newline at end of file From b477ccde4b28c5f5ec9898bab30929cad19be650 Mon Sep 17 00:00:00 2001 From: felixfaisal Date: Mon, 9 Sep 2024 04:59:08 +0000 Subject: [PATCH 17/21] fix: add paseo network into launch setup --- Makefile | 11 +++++++---- scripts/launch-network.sh | 2 +- 2 files changed, 8 insertions(+), 5 deletions(-) diff --git a/Makefile b/Makefile index efbfc6f2d4..171a9a24c6 100644 --- a/Makefile +++ b/Makefile @@ -76,6 +76,10 @@ launch-network-rococo: launch-network-litentry: @./scripts/launch-network.sh litentry +.PHONY: launch-network-paseo ## Launch a local litentry network with relaychain network +launch-network-paseo: + @./scripts/launch-network.sh paseo + # run tests .PHONY: test-cargo-all ## cargo test --all @@ -94,10 +98,9 @@ test-ts-litentry: launch-network-litentry test-ts-rococo: launch-network-rococo @./scripts/run-ts-test.sh rococo bridge evm - -.PHONY: test-ts-binary-paseo ## Run paseo ts tests with binary without clean-up -test-ts-binary-paseo: launch-binary-paseo - @./scripts/run-ts-test.sh paseo no_bridge evm +.PHONY: test-ts-paseo ## Run paseo ts tests without clean-up +test-ts-paseo: launch-network-paseo + @./scripts/run-ts-test.sh paseo bridge evm # clean up diff --git a/scripts/launch-network.sh b/scripts/launch-network.sh index 6a15939051..e9a3163e1c 100755 --- a/scripts/launch-network.sh +++ b/scripts/launch-network.sh @@ -6,7 +6,7 @@ set -eo pipefail function usage() { - echo "Usage: $0 litentry|rococo" + echo "Usage: $0 litentry|rococo|paseo" } function print_divider() { From 23a3a7a348c9c0171d9cf0f43ee18eb93e89de4f Mon Sep 17 00:00:00 2001 From: felixfaisal Date: Mon, 9 Sep 2024 07:13:22 +0000 Subject: [PATCH 18/21] refactor: clean up makefile --- Makefile | 8 -------- 1 file changed, 8 deletions(-) diff --git a/Makefile b/Makefile index 171a9a24c6..09953b06a2 100644 --- a/Makefile +++ b/Makefile @@ -103,23 +103,16 @@ test-ts-paseo: launch-network-paseo @./scripts/run-ts-test.sh paseo bridge evm # clean up - .PHONY: clean-network ## Clean up the network launched by 'launch-network' clean-network: @./scripts/clean-network.sh -.PHONY: generate-docker-compose-paseo ## Generate docker-compose files for rococo local network -generate-docker-compose-paseo: - @./scripts/generate-docker-files.sh paseo - # update dependencies - .PHONY: update-ts-dep ## update ts-tests dependencies update-ts-dep: @cd ts-tests && pnpm dlx npm-check-updates -u && pnpm install # format - .PHONY: fmt ## (cargo, taplo, ts, solidity) fmt fmt: fmt-cargo fmt-taplo fmt-ts fmt-contract @@ -151,7 +144,6 @@ githooks: git config core.hooksPath .githooks # clippy - .PHONY: clippy ## cargo clippy clippy: SKIP_WASM_BUILD=1 cargo clippy --workspace --all-targets --all-features -- -D warnings From 835848747af14cd249a0e114fc21ca48f7b31b52 Mon Sep 17 00:00:00 2001 From: felixfaisal Date: Mon, 16 Sep 2024 05:57:34 +0000 Subject: [PATCH 19/21] refactor: remove parachain-launch config for paseo --- docker/paseo-parachain-launch-config.yml | 47 ------------------------ 1 file changed, 47 deletions(-) delete mode 100644 docker/paseo-parachain-launch-config.yml diff --git a/docker/paseo-parachain-launch-config.yml b/docker/paseo-parachain-launch-config.yml deleted file mode 100644 index bd52d4f4b2..0000000000 --- a/docker/paseo-parachain-launch-config.yml +++ /dev/null @@ -1,47 +0,0 @@ -# A parachain-launch (https://github.com/open-web3-stack/parachain-launch) config -# used in dev env -# contains 2 relaychain nodes + 1 parachain node -# -# Relaychain Configuration -relaychain: - image: parity/polkadot:v1.1.0 - # TODO: `rococo-local` is used here as `paseo` has only "raw" chain spec which can't be further - # manipulated by parachain-launch - # we might need to switch to other launch tools - chain: rococo-local - env: - RUST_LOG: parachain::candidate-backing=trace,parachain::candidate-selection=trace,parachain::pvf=trace,parachain::collator-protocol=trace,parachain::provisioner=trace - flags: - - --rpc-methods=unsafe - - --execution=wasm - nodes: - - name: alice - rpcPort: ${AliceRPCPort:-9946} - port: ${AlicePort:-30336} - - name: bob - rpcPort: ${BobRPCPort:-9947} - port: ${BobPort:-30337} - -# Parachain Configuration -parachains: -- image: litentry/litentry-parachain:latest - chain: paseo-dev - id: 2106 - parachain: true - flags: - - --rpc-methods=unsafe - - --force-authoring - - --execution=wasm - - --state-pruning=archive - - --blocks-pruning=archive - - --enable-evm-rpc - relaychainFlags: - - --execution=wasm - env: - RUST_LOG: sc_basic_authorship=trace,cumulus-consensus=trace,cumulus-collator=trace,collator_protocol=trace,collation_generation=trace,aura=debug - volumePath: /data - nodes: - - flags: - - --alice - rpcPort: ${CollatorRPCPort:-9944} - port: ${CollatorPort:-30333} From 22cfe31aba1361cb02fb52ff7fb23877b200a9fc Mon Sep 17 00:00:00 2001 From: Yang Date: Mon, 16 Sep 2024 09:49:58 +0000 Subject: [PATCH 20/21] add paseo benchmark option --- .github/workflows/benchmark-runtime-weights.yml | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/.github/workflows/benchmark-runtime-weights.yml b/.github/workflows/benchmark-runtime-weights.yml index 72a52416d0..e7574a8ed7 100644 --- a/.github/workflows/benchmark-runtime-weights.yml +++ b/.github/workflows/benchmark-runtime-weights.yml @@ -19,6 +19,11 @@ on: description: rococo required: true default: true + paseo: + type: boolean + description: paseo + required: true + default: true pallets: description: pallets to benchmark, * for all, or comma listed (e.g. frame-system,pallet-proxy) default: "*" @@ -84,6 +89,9 @@ jobs: if [ "${{ github.event.inputs.rococo }}" = "true" ]; then chain="$chain rococo" fi + if [ "${{ github.event.inputs.paseo }}" = "true" ]; then + chain="$chain paseo" + fi if [ "$chain" = "" ]; then echo "::error::Please select at least one chain." exit 1 From a7ef62f496a0effc71b4729a702e1620243c594b Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Mon, 16 Sep 2024 17:42:13 +0200 Subject: [PATCH 21/21] [benchmarking bot] Auto commit generated weights files (#3065) Co-authored-by: BillyWooo --- .../src/weights/cumulus_pallet_xcmp_queue.rs | 16 +- runtime/paseo/src/weights/frame_system.rs | 56 +++--- .../paseo/src/weights/pallet_asset_manager.rs | 28 +-- runtime/paseo/src/weights/pallet_balances.rs | 44 ++-- .../src/weights/pallet_bridge_transfer.rs | 16 +- .../paseo/src/weights/pallet_chain_bridge.rs | 36 ++-- .../paseo/src/weights/pallet_collective.rs | 134 ++++++------ runtime/paseo/src/weights/pallet_democracy.rs | 152 +++++++------- .../src/weights/pallet_extrinsic_filter.rs | 32 +-- .../src/weights/pallet_identity_management.rs | 48 ++--- .../paseo/src/weights/pallet_membership.rs | 64 +++--- runtime/paseo/src/weights/pallet_multisig.rs | 76 +++---- .../src/weights/pallet_parachain_staking.rs | 190 +++++++++--------- runtime/paseo/src/weights/pallet_preimage.rs | 68 +++---- runtime/paseo/src/weights/pallet_proxy.rs | 100 ++++----- runtime/paseo/src/weights/pallet_scheduler.rs | 80 ++++---- runtime/paseo/src/weights/pallet_session.rs | 16 +- runtime/paseo/src/weights/pallet_teebag.rs | 64 +++--- runtime/paseo/src/weights/pallet_timestamp.rs | 16 +- runtime/paseo/src/weights/pallet_treasury.rs | 40 ++-- runtime/paseo/src/weights/pallet_utility.rs | 40 ++-- .../paseo/src/weights/pallet_vc_management.rs | 48 ++--- 22 files changed, 682 insertions(+), 682 deletions(-) diff --git a/runtime/paseo/src/weights/cumulus_pallet_xcmp_queue.rs b/runtime/paseo/src/weights/cumulus_pallet_xcmp_queue.rs index 64fd336803..cf315860f4 100644 --- a/runtime/paseo/src/weights/cumulus_pallet_xcmp_queue.rs +++ b/runtime/paseo/src/weights/cumulus_pallet_xcmp_queue.rs @@ -17,16 +17,16 @@ //! Autogenerated weights for `cumulus_pallet_xcmp_queue` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2024-08-28, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-09-16, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` //! HOSTNAME: `litentry-benchmark-server`, CPU: `Intel(R) Xeon(R) CPU E5-2686 v4 @ 2.30GHz` -//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("rococo-dev")`, DB CACHE: 20 +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("paseo-dev")`, DB CACHE: 20 // Executed Command: // ./litentry-collator // benchmark // pallet -// --chain=rococo-dev +// --chain=paseo-dev // --execution=wasm // --db-cache=20 // --wasm-execution=compiled @@ -36,7 +36,7 @@ // --steps=20 // --repeat=50 // --header=./LICENSE_HEADER -// --output=./runtime/rococo/src/weights/cumulus_pallet_xcmp_queue.rs +// --output=./runtime/paseo/src/weights/cumulus_pallet_xcmp_queue.rs #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(unused_parens)] @@ -55,8 +55,8 @@ impl cumulus_pallet_xcmp_queue::WeightInfo for WeightIn // Proof Size summary in bytes: // Measured: `109` // Estimated: `1594` - // Minimum execution time: 5_303_000 picoseconds. - Weight::from_parts(5_485_000, 0) + // Minimum execution time: 10_466_000 picoseconds. + Weight::from_parts(10_877_000, 0) .saturating_add(Weight::from_parts(0, 1594)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) @@ -67,8 +67,8 @@ impl cumulus_pallet_xcmp_queue::WeightInfo for WeightIn // Proof Size summary in bytes: // Measured: `109` // Estimated: `1594` - // Minimum execution time: 5_285_000 picoseconds. - Weight::from_parts(5_585_000, 0) + // Minimum execution time: 10_551_000 picoseconds. + Weight::from_parts(10_885_000, 0) .saturating_add(Weight::from_parts(0, 1594)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) diff --git a/runtime/paseo/src/weights/frame_system.rs b/runtime/paseo/src/weights/frame_system.rs index 786749bc3e..e59025a7de 100644 --- a/runtime/paseo/src/weights/frame_system.rs +++ b/runtime/paseo/src/weights/frame_system.rs @@ -17,16 +17,16 @@ //! Autogenerated weights for `frame_system` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2024-08-28, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-09-16, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` //! HOSTNAME: `litentry-benchmark-server`, CPU: `Intel(R) Xeon(R) CPU E5-2686 v4 @ 2.30GHz` -//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("rococo-dev")`, DB CACHE: 20 +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("paseo-dev")`, DB CACHE: 20 // Executed Command: // ./litentry-collator // benchmark // pallet -// --chain=rococo-dev +// --chain=paseo-dev // --execution=wasm // --db-cache=20 // --wasm-execution=compiled @@ -36,7 +36,7 @@ // --steps=20 // --repeat=50 // --header=./LICENSE_HEADER -// --output=./runtime/rococo/src/weights/frame_system.rs +// --output=./runtime/paseo/src/weights/frame_system.rs #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(unused_parens)] @@ -54,22 +54,22 @@ impl frame_system::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_161_000 picoseconds. - Weight::from_parts(2_227_000, 0) + // Minimum execution time: 4_180_000 picoseconds. + Weight::from_parts(1_882_999, 0) .saturating_add(Weight::from_parts(0, 0)) - // Standard Error: 3 - .saturating_add(Weight::from_parts(432, 0).saturating_mul(b.into())) + // Standard Error: 0 + .saturating_add(Weight::from_parts(624, 0).saturating_mul(b.into())) } /// The range of component `b` is `[0, 3932160]`. fn remark_with_event(b: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 7_292_000 picoseconds. - Weight::from_parts(7_481_000, 0) + // Minimum execution time: 13_302_000 picoseconds. + Weight::from_parts(28_084_556, 0) .saturating_add(Weight::from_parts(0, 0)) - // Standard Error: 8 - .saturating_add(Weight::from_parts(2_345, 0).saturating_mul(b.into())) + // Standard Error: 0 + .saturating_add(Weight::from_parts(2_419, 0).saturating_mul(b.into())) } /// Storage: `System::Digest` (r:1 w:1) /// Proof: `System::Digest` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) @@ -79,8 +79,8 @@ impl frame_system::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `1485` - // Minimum execution time: 3_724_000 picoseconds. - Weight::from_parts(4_032_000, 0) + // Minimum execution time: 7_924_000 picoseconds. + Weight::from_parts(8_365_000, 0) .saturating_add(Weight::from_parts(0, 1485)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(2)) @@ -101,8 +101,8 @@ impl frame_system::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `264` // Estimated: `1749` - // Minimum execution time: 131_530_473_000 picoseconds. - Weight::from_parts(138_435_551_000, 0) + // Minimum execution time: 156_074_200_000 picoseconds. + Weight::from_parts(162_289_887_000, 0) .saturating_add(Weight::from_parts(0, 1749)) .saturating_add(T::DbWeight::get().reads(4)) .saturating_add(T::DbWeight::get().writes(3)) @@ -114,11 +114,11 @@ impl frame_system::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_328_000 picoseconds. - Weight::from_parts(2_408_000, 0) + // Minimum execution time: 4_398_000 picoseconds. + Weight::from_parts(4_622_000, 0) .saturating_add(Weight::from_parts(0, 0)) - // Standard Error: 7_057 - .saturating_add(Weight::from_parts(780_166, 0).saturating_mul(i.into())) + // Standard Error: 4_633 + .saturating_add(Weight::from_parts(1_186_804, 0).saturating_mul(i.into())) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(i.into()))) } /// Storage: `Skipped::Metadata` (r:0 w:0) @@ -128,11 +128,11 @@ impl frame_system::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_307_000 picoseconds. - Weight::from_parts(2_379_000, 0) + // Minimum execution time: 4_651_000 picoseconds. + Weight::from_parts(4_826_000, 0) .saturating_add(Weight::from_parts(0, 0)) - // Standard Error: 3_432 - .saturating_add(Weight::from_parts(562_993, 0).saturating_mul(i.into())) + // Standard Error: 1_859 + .saturating_add(Weight::from_parts(843_362, 0).saturating_mul(i.into())) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(i.into()))) } /// Storage: `Skipped::Metadata` (r:0 w:0) @@ -142,11 +142,11 @@ impl frame_system::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `114 + p * (69 ±0)` // Estimated: `102 + p * (70 ±0)` - // Minimum execution time: 3_949_000 picoseconds. - Weight::from_parts(4_078_000, 0) + // Minimum execution time: 8_370_000 picoseconds. + Weight::from_parts(8_560_000, 0) .saturating_add(Weight::from_parts(0, 102)) - // Standard Error: 13_088 - .saturating_add(Weight::from_parts(1_249_199, 0).saturating_mul(p.into())) + // Standard Error: 1_852 + .saturating_add(Weight::from_parts(1_719_124, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(p.into()))) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(p.into()))) .saturating_add(Weight::from_parts(0, 70).saturating_mul(p.into())) diff --git a/runtime/paseo/src/weights/pallet_asset_manager.rs b/runtime/paseo/src/weights/pallet_asset_manager.rs index 1c66f95adf..0494b456b5 100644 --- a/runtime/paseo/src/weights/pallet_asset_manager.rs +++ b/runtime/paseo/src/weights/pallet_asset_manager.rs @@ -17,16 +17,16 @@ //! Autogenerated weights for `pallet_asset_manager` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2024-08-28, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-09-16, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` //! HOSTNAME: `litentry-benchmark-server`, CPU: `Intel(R) Xeon(R) CPU E5-2686 v4 @ 2.30GHz` -//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("rococo-dev")`, DB CACHE: 20 +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("paseo-dev")`, DB CACHE: 20 // Executed Command: // ./litentry-collator // benchmark // pallet -// --chain=rococo-dev +// --chain=paseo-dev // --execution=wasm // --db-cache=20 // --wasm-execution=compiled @@ -36,7 +36,7 @@ // --steps=20 // --repeat=50 // --header=./LICENSE_HEADER -// --output=./runtime/rococo/src/weights/pallet_asset_manager.rs +// --output=./runtime/paseo/src/weights/pallet_asset_manager.rs #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(unused_parens)] @@ -61,8 +61,8 @@ impl pallet_asset_manager::WeightInfo for WeightInfo // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 22_417_000 picoseconds. - Weight::from_parts(23_511_000, 0) + // Minimum execution time: 41_217_000 picoseconds. + Weight::from_parts(41_824_000, 0) .saturating_add(Weight::from_parts(0, 3607)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(4)) @@ -75,8 +75,8 @@ impl pallet_asset_manager::WeightInfo for WeightInfo // Proof Size summary in bytes: // Measured: `302` // Estimated: `3767` - // Minimum execution time: 13_327_000 picoseconds. - Weight::from_parts(13_896_000, 0) + // Minimum execution time: 25_284_000 picoseconds. + Weight::from_parts(26_090_000, 0) .saturating_add(Weight::from_parts(0, 3767)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) @@ -89,8 +89,8 @@ impl pallet_asset_manager::WeightInfo for WeightInfo // Proof Size summary in bytes: // Measured: `302` // Estimated: `3767` - // Minimum execution time: 12_746_000 picoseconds. - Weight::from_parts(13_313_000, 0) + // Minimum execution time: 24_358_000 picoseconds. + Weight::from_parts(24_831_000, 0) .saturating_add(Weight::from_parts(0, 3767)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) @@ -103,8 +103,8 @@ impl pallet_asset_manager::WeightInfo for WeightInfo // Proof Size summary in bytes: // Measured: `325` // Estimated: `3790` - // Minimum execution time: 17_319_000 picoseconds. - Weight::from_parts(18_423_000, 0) + // Minimum execution time: 32_370_000 picoseconds. + Weight::from_parts(32_874_000, 0) .saturating_add(Weight::from_parts(0, 3790)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) @@ -117,8 +117,8 @@ impl pallet_asset_manager::WeightInfo for WeightInfo // Proof Size summary in bytes: // Measured: `482` // Estimated: `6422` - // Minimum execution time: 21_607_000 picoseconds. - Weight::from_parts(22_859_000, 0) + // Minimum execution time: 40_265_000 picoseconds. + Weight::from_parts(41_196_000, 0) .saturating_add(Weight::from_parts(0, 6422)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) diff --git a/runtime/paseo/src/weights/pallet_balances.rs b/runtime/paseo/src/weights/pallet_balances.rs index 33dbbb5ea0..acb697df06 100644 --- a/runtime/paseo/src/weights/pallet_balances.rs +++ b/runtime/paseo/src/weights/pallet_balances.rs @@ -17,16 +17,16 @@ //! Autogenerated weights for `pallet_balances` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2024-08-28, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-09-16, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` //! HOSTNAME: `litentry-benchmark-server`, CPU: `Intel(R) Xeon(R) CPU E5-2686 v4 @ 2.30GHz` -//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("rococo-dev")`, DB CACHE: 20 +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("paseo-dev")`, DB CACHE: 20 // Executed Command: // ./litentry-collator // benchmark // pallet -// --chain=rococo-dev +// --chain=paseo-dev // --execution=wasm // --db-cache=20 // --wasm-execution=compiled @@ -36,7 +36,7 @@ // --steps=20 // --repeat=50 // --header=./LICENSE_HEADER -// --output=./runtime/rococo/src/weights/pallet_balances.rs +// --output=./runtime/paseo/src/weights/pallet_balances.rs #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(unused_parens)] @@ -55,8 +55,8 @@ impl pallet_balances::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `3593` - // Minimum execution time: 53_007_000 picoseconds. - Weight::from_parts(68_015_000, 0) + // Minimum execution time: 88_266_000 picoseconds. + Weight::from_parts(89_761_000, 0) .saturating_add(Weight::from_parts(0, 3593)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) @@ -67,8 +67,8 @@ impl pallet_balances::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `3593` - // Minimum execution time: 39_762_000 picoseconds. - Weight::from_parts(41_499_000, 0) + // Minimum execution time: 67_486_000 picoseconds. + Weight::from_parts(68_340_000, 0) .saturating_add(Weight::from_parts(0, 3593)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) @@ -79,8 +79,8 @@ impl pallet_balances::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `140` // Estimated: `3593` - // Minimum execution time: 15_589_000 picoseconds. - Weight::from_parts(16_536_000, 0) + // Minimum execution time: 29_252_000 picoseconds. + Weight::from_parts(29_951_000, 0) .saturating_add(Weight::from_parts(0, 3593)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) @@ -91,8 +91,8 @@ impl pallet_balances::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `140` // Estimated: `3593` - // Minimum execution time: 22_560_000 picoseconds. - Weight::from_parts(23_315_000, 0) + // Minimum execution time: 41_242_000 picoseconds. + Weight::from_parts(42_100_000, 0) .saturating_add(Weight::from_parts(0, 3593)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) @@ -103,8 +103,8 @@ impl pallet_balances::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `103` // Estimated: `6196` - // Minimum execution time: 54_644_000 picoseconds. - Weight::from_parts(56_287_000, 0) + // Minimum execution time: 95_247_000 picoseconds. + Weight::from_parts(96_397_000, 0) .saturating_add(Weight::from_parts(0, 6196)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) @@ -115,8 +115,8 @@ impl pallet_balances::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `3593` - // Minimum execution time: 49_620_000 picoseconds. - Weight::from_parts(52_548_000, 0) + // Minimum execution time: 83_195_000 picoseconds. + Weight::from_parts(84_373_000, 0) .saturating_add(Weight::from_parts(0, 3593)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) @@ -127,8 +127,8 @@ impl pallet_balances::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `140` // Estimated: `3593` - // Minimum execution time: 18_255_000 picoseconds. - Weight::from_parts(18_795_000, 0) + // Minimum execution time: 34_257_000 picoseconds. + Weight::from_parts(35_205_000, 0) .saturating_add(Weight::from_parts(0, 3593)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) @@ -140,11 +140,11 @@ impl pallet_balances::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `0 + u * (136 ±0)` // Estimated: `990 + u * (2603 ±0)` - // Minimum execution time: 16_995_000 picoseconds. - Weight::from_parts(17_342_000, 0) + // Minimum execution time: 32_046_000 picoseconds. + Weight::from_parts(32_411_000, 0) .saturating_add(Weight::from_parts(0, 990)) - // Standard Error: 30_882 - .saturating_add(Weight::from_parts(19_977_590, 0).saturating_mul(u.into())) + // Standard Error: 22_067 + .saturating_add(Weight::from_parts(23_410_622, 0).saturating_mul(u.into())) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(u.into()))) .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(u.into()))) .saturating_add(Weight::from_parts(0, 2603).saturating_mul(u.into())) diff --git a/runtime/paseo/src/weights/pallet_bridge_transfer.rs b/runtime/paseo/src/weights/pallet_bridge_transfer.rs index 550c4446c3..2c40c5f263 100644 --- a/runtime/paseo/src/weights/pallet_bridge_transfer.rs +++ b/runtime/paseo/src/weights/pallet_bridge_transfer.rs @@ -17,16 +17,16 @@ //! Autogenerated weights for `pallet_bridge_transfer` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2024-08-28, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-09-16, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` //! HOSTNAME: `litentry-benchmark-server`, CPU: `Intel(R) Xeon(R) CPU E5-2686 v4 @ 2.30GHz` -//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("rococo-dev")`, DB CACHE: 20 +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("paseo-dev")`, DB CACHE: 20 // Executed Command: // ./litentry-collator // benchmark // pallet -// --chain=rococo-dev +// --chain=paseo-dev // --execution=wasm // --db-cache=20 // --wasm-execution=compiled @@ -36,7 +36,7 @@ // --steps=20 // --repeat=50 // --header=./LICENSE_HEADER -// --output=./runtime/rococo/src/weights/pallet_bridge_transfer.rs +// --output=./runtime/paseo/src/weights/pallet_bridge_transfer.rs #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(unused_parens)] @@ -63,8 +63,8 @@ impl pallet_bridge_transfer::WeightInfo for WeightInfo< // Proof Size summary in bytes: // Measured: `573` // Estimated: `6196` - // Minimum execution time: 60_812_000 picoseconds. - Weight::from_parts(62_706_000, 0) + // Minimum execution time: 107_543_000 picoseconds. + Weight::from_parts(108_493_000, 0) .saturating_add(Weight::from_parts(0, 6196)) .saturating_add(T::DbWeight::get().reads(6)) .saturating_add(T::DbWeight::get().writes(4)) @@ -81,8 +81,8 @@ impl pallet_bridge_transfer::WeightInfo for WeightInfo< // Proof Size summary in bytes: // Measured: `328` // Estimated: `3793` - // Minimum execution time: 35_475_000 picoseconds. - Weight::from_parts(36_847_000, 0) + // Minimum execution time: 65_660_000 picoseconds. + Weight::from_parts(66_501_000, 0) .saturating_add(Weight::from_parts(0, 3793)) .saturating_add(T::DbWeight::get().reads(4)) .saturating_add(T::DbWeight::get().writes(2)) diff --git a/runtime/paseo/src/weights/pallet_chain_bridge.rs b/runtime/paseo/src/weights/pallet_chain_bridge.rs index 7271e2d637..98f01fd018 100644 --- a/runtime/paseo/src/weights/pallet_chain_bridge.rs +++ b/runtime/paseo/src/weights/pallet_chain_bridge.rs @@ -17,16 +17,16 @@ //! Autogenerated weights for `pallet_chain_bridge` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2024-08-28, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-09-16, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` //! HOSTNAME: `litentry-benchmark-server`, CPU: `Intel(R) Xeon(R) CPU E5-2686 v4 @ 2.30GHz` -//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("rococo-dev")`, DB CACHE: 20 +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("paseo-dev")`, DB CACHE: 20 // Executed Command: // ./litentry-collator // benchmark // pallet -// --chain=rococo-dev +// --chain=paseo-dev // --execution=wasm // --db-cache=20 // --wasm-execution=compiled @@ -36,7 +36,7 @@ // --steps=20 // --repeat=50 // --header=./LICENSE_HEADER -// --output=./runtime/rococo/src/weights/pallet_chain_bridge.rs +// --output=./runtime/paseo/src/weights/pallet_chain_bridge.rs #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(unused_parens)] @@ -55,8 +55,8 @@ impl pallet_chain_bridge::WeightInfo for WeightInfo // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 7_198_000 picoseconds. - Weight::from_parts(7_687_000, 0) + // Minimum execution time: 14_549_000 picoseconds. + Weight::from_parts(15_004_000, 0) .saturating_add(Weight::from_parts(0, 0)) .saturating_add(T::DbWeight::get().writes(1)) } @@ -66,8 +66,8 @@ impl pallet_chain_bridge::WeightInfo for WeightInfo // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 10_444_000 picoseconds. - Weight::from_parts(10_996_000, 0) + // Minimum execution time: 20_130_000 picoseconds. + Weight::from_parts(20_575_000, 0) .saturating_add(Weight::from_parts(0, 3607)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) @@ -80,8 +80,8 @@ impl pallet_chain_bridge::WeightInfo for WeightInfo // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 12_951_000 picoseconds. - Weight::from_parts(13_847_000, 0) + // Minimum execution time: 24_303_000 picoseconds. + Weight::from_parts(24_817_000, 0) .saturating_add(Weight::from_parts(0, 3607)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) @@ -94,8 +94,8 @@ impl pallet_chain_bridge::WeightInfo for WeightInfo // Proof Size summary in bytes: // Measured: `223` // Estimated: `3688` - // Minimum execution time: 14_662_000 picoseconds. - Weight::from_parts(15_484_000, 0) + // Minimum execution time: 26_908_000 picoseconds. + Weight::from_parts(27_510_000, 0) .saturating_add(Weight::from_parts(0, 3688)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) @@ -114,8 +114,8 @@ impl pallet_chain_bridge::WeightInfo for WeightInfo // Proof Size summary in bytes: // Measured: `285` // Estimated: `3750` - // Minimum execution time: 34_507_000 picoseconds. - Weight::from_parts(36_153_000, 0) + // Minimum execution time: 60_811_000 picoseconds. + Weight::from_parts(62_026_000, 0) .saturating_add(Weight::from_parts(0, 3750)) .saturating_add(T::DbWeight::get().reads(5)) .saturating_add(T::DbWeight::get().writes(1)) @@ -134,8 +134,8 @@ impl pallet_chain_bridge::WeightInfo for WeightInfo // Proof Size summary in bytes: // Measured: `285` // Estimated: `3750` - // Minimum execution time: 29_590_000 picoseconds. - Weight::from_parts(30_478_000, 0) + // Minimum execution time: 51_496_000 picoseconds. + Weight::from_parts(52_238_000, 0) .saturating_add(Weight::from_parts(0, 3750)) .saturating_add(T::DbWeight::get().reads(5)) .saturating_add(T::DbWeight::get().writes(1)) @@ -150,8 +150,8 @@ impl pallet_chain_bridge::WeightInfo for WeightInfo // Proof Size summary in bytes: // Measured: `451` // Estimated: `3916` - // Minimum execution time: 14_114_000 picoseconds. - Weight::from_parts(14_930_000, 0) + // Minimum execution time: 26_973_000 picoseconds. + Weight::from_parts(27_761_000, 0) .saturating_add(Weight::from_parts(0, 3916)) .saturating_add(T::DbWeight::get().reads(3)) .saturating_add(T::DbWeight::get().writes(1)) diff --git a/runtime/paseo/src/weights/pallet_collective.rs b/runtime/paseo/src/weights/pallet_collective.rs index b3dd85eda1..8b93a64265 100644 --- a/runtime/paseo/src/weights/pallet_collective.rs +++ b/runtime/paseo/src/weights/pallet_collective.rs @@ -17,16 +17,16 @@ //! Autogenerated weights for `pallet_collective` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2024-08-28, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-09-16, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` //! HOSTNAME: `litentry-benchmark-server`, CPU: `Intel(R) Xeon(R) CPU E5-2686 v4 @ 2.30GHz` -//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("rococo-dev")`, DB CACHE: 20 +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("paseo-dev")`, DB CACHE: 20 // Executed Command: // ./litentry-collator // benchmark // pallet -// --chain=rococo-dev +// --chain=paseo-dev // --execution=wasm // --db-cache=20 // --wasm-execution=compiled @@ -36,7 +36,7 @@ // --steps=20 // --repeat=50 // --header=./LICENSE_HEADER -// --output=./runtime/rococo/src/weights/pallet_collective.rs +// --output=./runtime/paseo/src/weights/pallet_collective.rs #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(unused_parens)] @@ -63,14 +63,14 @@ impl pallet_collective::WeightInfo for WeightInfo { fn set_members(m: u32, _n: u32, p: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `0 + m * (3232 ±0) + p * (3190 ±0)` - // Estimated: `32761 + m * (1968 ±23) + p * (4247 ±23)` - // Minimum execution time: 16_998_000 picoseconds. - Weight::from_parts(17_440_000, 0) + // Estimated: `32761 + m * (1968 ±26) + p * (4247 ±26)` + // Minimum execution time: 31_979_000 picoseconds. + Weight::from_parts(32_568_000, 0) .saturating_add(Weight::from_parts(0, 32761)) - // Standard Error: 157_175 - .saturating_add(Weight::from_parts(5_557_666, 0).saturating_mul(m.into())) - // Standard Error: 157_175 - .saturating_add(Weight::from_parts(9_190_914, 0).saturating_mul(p.into())) + // Standard Error: 110_743 + .saturating_add(Weight::from_parts(8_043_155, 0).saturating_mul(m.into())) + // Standard Error: 110_743 + .saturating_add(Weight::from_parts(12_956_095, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(p.into()))) .saturating_add(T::DbWeight::get().writes(2)) @@ -86,13 +86,13 @@ impl pallet_collective::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `103 + m * (32 ±0)` // Estimated: `1588 + m * (32 ±0)` - // Minimum execution time: 15_435_000 picoseconds. - Weight::from_parts(15_418_071, 0) + // Minimum execution time: 28_918_000 picoseconds. + Weight::from_parts(26_932_710, 0) .saturating_add(Weight::from_parts(0, 1588)) - // Standard Error: 83 - .saturating_add(Weight::from_parts(1_459, 0).saturating_mul(b.into())) - // Standard Error: 859 - .saturating_add(Weight::from_parts(7_413, 0).saturating_mul(m.into())) + // Standard Error: 38 + .saturating_add(Weight::from_parts(2_681, 0).saturating_mul(b.into())) + // Standard Error: 392 + .saturating_add(Weight::from_parts(34_776, 0).saturating_mul(m.into())) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(Weight::from_parts(0, 32).saturating_mul(m.into())) } @@ -106,13 +106,13 @@ impl pallet_collective::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `103 + m * (32 ±0)` // Estimated: `3568 + m * (32 ±0)` - // Minimum execution time: 18_397_000 picoseconds. - Weight::from_parts(17_080_441, 0) + // Minimum execution time: 34_207_000 picoseconds. + Weight::from_parts(33_135_008, 0) .saturating_add(Weight::from_parts(0, 3568)) - // Standard Error: 92 - .saturating_add(Weight::from_parts(1_651, 0).saturating_mul(b.into())) - // Standard Error: 946 - .saturating_add(Weight::from_parts(27_912, 0).saturating_mul(m.into())) + // Standard Error: 46 + .saturating_add(Weight::from_parts(2_673, 0).saturating_mul(b.into())) + // Standard Error: 477 + .saturating_add(Weight::from_parts(50_244, 0).saturating_mul(m.into())) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(Weight::from_parts(0, 32).saturating_mul(m.into())) } @@ -133,15 +133,15 @@ impl pallet_collective::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `463 + m * (32 ±0) + p * (36 ±0)` // Estimated: `3821 + m * (33 ±0) + p * (36 ±0)` - // Minimum execution time: 23_851_000 picoseconds. - Weight::from_parts(24_231_413, 0) + // Minimum execution time: 44_363_000 picoseconds. + Weight::from_parts(46_952_681, 0) .saturating_add(Weight::from_parts(0, 3821)) - // Standard Error: 207 - .saturating_add(Weight::from_parts(2_710, 0).saturating_mul(b.into())) - // Standard Error: 2_153 - .saturating_add(Weight::from_parts(23_162, 0).saturating_mul(m.into())) - // Standard Error: 2_131 - .saturating_add(Weight::from_parts(212_594, 0).saturating_mul(p.into())) + // Standard Error: 146 + .saturating_add(Weight::from_parts(2_854, 0).saturating_mul(b.into())) + // Standard Error: 1_519 + .saturating_add(Weight::from_parts(20_591, 0).saturating_mul(m.into())) + // Standard Error: 1_504 + .saturating_add(Weight::from_parts(212_269, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(4)) .saturating_add(T::DbWeight::get().writes(4)) .saturating_add(Weight::from_parts(0, 33).saturating_mul(m.into())) @@ -156,11 +156,11 @@ impl pallet_collective::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `841 + m * (64 ±0)` // Estimated: `4306 + m * (64 ±0)` - // Minimum execution time: 26_294_000 picoseconds. - Weight::from_parts(29_486_906, 0) + // Minimum execution time: 39_728_000 picoseconds. + Weight::from_parts(41_075_964, 0) .saturating_add(Weight::from_parts(0, 4306)) - // Standard Error: 1_787 - .saturating_add(Weight::from_parts(37_613, 0).saturating_mul(m.into())) + // Standard Error: 948 + .saturating_add(Weight::from_parts(64_721, 0).saturating_mul(m.into())) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(1)) .saturating_add(Weight::from_parts(0, 64).saturating_mul(m.into())) @@ -179,13 +179,13 @@ impl pallet_collective::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `468 + m * (64 ±0) + p * (35 ±0)` // Estimated: `3856 + m * (65 ±0) + p * (36 ±0)` - // Minimum execution time: 27_374_000 picoseconds. - Weight::from_parts(29_537_848, 0) + // Minimum execution time: 49_323_000 picoseconds. + Weight::from_parts(49_256_266, 0) .saturating_add(Weight::from_parts(0, 3856)) - // Standard Error: 1_788 - .saturating_add(Weight::from_parts(32_813, 0).saturating_mul(m.into())) - // Standard Error: 1_730 - .saturating_add(Weight::from_parts(179_325, 0).saturating_mul(p.into())) + // Standard Error: 1_250 + .saturating_add(Weight::from_parts(49_447, 0).saturating_mul(m.into())) + // Standard Error: 1_209 + .saturating_add(Weight::from_parts(189_204, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(3)) .saturating_add(T::DbWeight::get().writes(3)) .saturating_add(Weight::from_parts(0, 65).saturating_mul(m.into())) @@ -206,15 +206,15 @@ impl pallet_collective::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `778 + m * (64 ±0) + p * (39 ±0)` // Estimated: `4117 + b * (1 ±0) + m * (65 ±0) + p * (40 ±0)` - // Minimum execution time: 39_326_000 picoseconds. - Weight::from_parts(40_720_816, 0) + // Minimum execution time: 70_167_000 picoseconds. + Weight::from_parts(69_219_752, 0) .saturating_add(Weight::from_parts(0, 4117)) - // Standard Error: 278 - .saturating_add(Weight::from_parts(3_568, 0).saturating_mul(b.into())) - // Standard Error: 2_957 - .saturating_add(Weight::from_parts(39_984, 0).saturating_mul(m.into())) - // Standard Error: 2_861 - .saturating_add(Weight::from_parts(244_445, 0).saturating_mul(p.into())) + // Standard Error: 251 + .saturating_add(Weight::from_parts(3_867, 0).saturating_mul(b.into())) + // Standard Error: 2_674 + .saturating_add(Weight::from_parts(54_261, 0).saturating_mul(m.into())) + // Standard Error: 2_587 + .saturating_add(Weight::from_parts(265_689, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(4)) .saturating_add(T::DbWeight::get().writes(3)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(b.into())) @@ -237,13 +237,13 @@ impl pallet_collective::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `488 + m * (64 ±0) + p * (35 ±0)` // Estimated: `3876 + m * (65 ±0) + p * (36 ±0)` - // Minimum execution time: 30_613_000 picoseconds. - Weight::from_parts(30_257_113, 0) + // Minimum execution time: 54_186_000 picoseconds. + Weight::from_parts(53_082_756, 0) .saturating_add(Weight::from_parts(0, 3876)) - // Standard Error: 1_996 - .saturating_add(Weight::from_parts(45_575, 0).saturating_mul(m.into())) - // Standard Error: 1_930 - .saturating_add(Weight::from_parts(198_080, 0).saturating_mul(p.into())) + // Standard Error: 1_542 + .saturating_add(Weight::from_parts(57_192, 0).saturating_mul(m.into())) + // Standard Error: 1_492 + .saturating_add(Weight::from_parts(190_362, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(4)) .saturating_add(T::DbWeight::get().writes(3)) .saturating_add(Weight::from_parts(0, 65).saturating_mul(m.into())) @@ -266,15 +266,15 @@ impl pallet_collective::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `798 + m * (64 ±0) + p * (39 ±0)` // Estimated: `4137 + b * (1 ±0) + m * (65 ±0) + p * (40 ±0)` - // Minimum execution time: 41_992_000 picoseconds. - Weight::from_parts(41_104_224, 0) + // Minimum execution time: 73_683_000 picoseconds. + Weight::from_parts(75_884_596, 0) .saturating_add(Weight::from_parts(0, 4137)) - // Standard Error: 286 - .saturating_add(Weight::from_parts(6_229, 0).saturating_mul(b.into())) - // Standard Error: 3_038 - .saturating_add(Weight::from_parts(34_790, 0).saturating_mul(m.into())) - // Standard Error: 2_939 - .saturating_add(Weight::from_parts(257_557, 0).saturating_mul(p.into())) + // Standard Error: 269 + .saturating_add(Weight::from_parts(4_317, 0).saturating_mul(b.into())) + // Standard Error: 2_865 + .saturating_add(Weight::from_parts(42_875, 0).saturating_mul(m.into())) + // Standard Error: 2_772 + .saturating_add(Weight::from_parts(250_159, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(5)) .saturating_add(T::DbWeight::get().writes(3)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(b.into())) @@ -292,11 +292,11 @@ impl pallet_collective::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `259 + p * (32 ±0)` // Estimated: `1745 + p * (32 ±0)` - // Minimum execution time: 14_911_000 picoseconds. - Weight::from_parts(16_891_474, 0) + // Minimum execution time: 27_515_000 picoseconds. + Weight::from_parts(30_240_970, 0) .saturating_add(Weight::from_parts(0, 1745)) - // Standard Error: 1_968 - .saturating_add(Weight::from_parts(182_344, 0).saturating_mul(p.into())) + // Standard Error: 1_331 + .saturating_add(Weight::from_parts(189_694, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(3)) .saturating_add(Weight::from_parts(0, 32).saturating_mul(p.into())) diff --git a/runtime/paseo/src/weights/pallet_democracy.rs b/runtime/paseo/src/weights/pallet_democracy.rs index c1d05abe63..92aa095e45 100644 --- a/runtime/paseo/src/weights/pallet_democracy.rs +++ b/runtime/paseo/src/weights/pallet_democracy.rs @@ -17,16 +17,16 @@ //! Autogenerated weights for `pallet_democracy` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2024-08-28, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-09-16, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` //! HOSTNAME: `litentry-benchmark-server`, CPU: `Intel(R) Xeon(R) CPU E5-2686 v4 @ 2.30GHz` -//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("rococo-dev")`, DB CACHE: 20 +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("paseo-dev")`, DB CACHE: 20 // Executed Command: // ./litentry-collator // benchmark // pallet -// --chain=rococo-dev +// --chain=paseo-dev // --execution=wasm // --db-cache=20 // --wasm-execution=compiled @@ -36,7 +36,7 @@ // --steps=20 // --repeat=50 // --header=./LICENSE_HEADER -// --output=./runtime/rococo/src/weights/pallet_democracy.rs +// --output=./runtime/paseo/src/weights/pallet_democracy.rs #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(unused_parens)] @@ -61,8 +61,8 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `4734` // Estimated: `18187` - // Minimum execution time: 47_135_000 picoseconds. - Weight::from_parts(50_506_000, 0) + // Minimum execution time: 70_861_000 picoseconds. + Weight::from_parts(72_295_000, 0) .saturating_add(Weight::from_parts(0, 18187)) .saturating_add(T::DbWeight::get().reads(3)) .saturating_add(T::DbWeight::get().writes(3)) @@ -73,8 +73,8 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `3489` // Estimated: `6695` - // Minimum execution time: 40_561_000 picoseconds. - Weight::from_parts(43_857_000, 0) + // Minimum execution time: 63_414_000 picoseconds. + Weight::from_parts(64_342_000, 0) .saturating_add(Weight::from_parts(0, 6695)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) @@ -91,8 +91,8 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `3365` // Estimated: `7260` - // Minimum execution time: 55_662_000 picoseconds. - Weight::from_parts(62_595_000, 0) + // Minimum execution time: 84_298_000 picoseconds. + Weight::from_parts(89_267_000, 0) .saturating_add(Weight::from_parts(0, 7260)) .saturating_add(T::DbWeight::get().reads(4)) .saturating_add(T::DbWeight::get().writes(3)) @@ -109,8 +109,8 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `3387` // Estimated: `7260` - // Minimum execution time: 62_188_000 picoseconds. - Weight::from_parts(67_185_000, 0) + // Minimum execution time: 92_351_000 picoseconds. + Weight::from_parts(94_657_000, 0) .saturating_add(Weight::from_parts(0, 7260)) .saturating_add(T::DbWeight::get().reads(4)) .saturating_add(T::DbWeight::get().writes(3)) @@ -125,8 +125,8 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `299` // Estimated: `3666` - // Minimum execution time: 26_674_000 picoseconds. - Weight::from_parts(27_415_000, 0) + // Minimum execution time: 48_991_000 picoseconds. + Weight::from_parts(49_854_000, 0) .saturating_add(Weight::from_parts(0, 3666)) .saturating_add(T::DbWeight::get().reads(3)) .saturating_add(T::DbWeight::get().writes(3)) @@ -149,8 +149,8 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `6182` // Estimated: `18187` - // Minimum execution time: 112_290_000 picoseconds. - Weight::from_parts(120_955_000, 0) + // Minimum execution time: 175_905_000 picoseconds. + Weight::from_parts(177_694_000, 0) .saturating_add(Weight::from_parts(0, 18187)) .saturating_add(T::DbWeight::get().reads(9)) .saturating_add(T::DbWeight::get().writes(8)) @@ -163,8 +163,8 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `3349` // Estimated: `6703` - // Minimum execution time: 12_980_000 picoseconds. - Weight::from_parts(13_511_000, 0) + // Minimum execution time: 24_875_000 picoseconds. + Weight::from_parts(26_003_000, 0) .saturating_add(Weight::from_parts(0, 6703)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(1)) @@ -175,8 +175,8 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 3_157_000 picoseconds. - Weight::from_parts(3_417_000, 0) + // Minimum execution time: 7_136_000 picoseconds. + Weight::from_parts(7_533_000, 0) .saturating_add(Weight::from_parts(0, 0)) .saturating_add(T::DbWeight::get().writes(1)) } @@ -186,8 +186,8 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 3_266_000 picoseconds. - Weight::from_parts(3_510_000, 0) + // Minimum execution time: 6_980_000 picoseconds. + Weight::from_parts(7_326_000, 0) .saturating_add(Weight::from_parts(0, 0)) .saturating_add(T::DbWeight::get().writes(1)) } @@ -203,8 +203,8 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `219` // Estimated: `3518` - // Minimum execution time: 27_475_000 picoseconds. - Weight::from_parts(28_199_000, 0) + // Minimum execution time: 49_145_000 picoseconds. + Weight::from_parts(50_095_000, 0) .saturating_add(Weight::from_parts(0, 3518)) .saturating_add(T::DbWeight::get().reads(3)) .saturating_add(T::DbWeight::get().writes(5)) @@ -219,8 +219,8 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `3452` // Estimated: `6703` - // Minimum execution time: 30_559_000 picoseconds. - Weight::from_parts(31_432_000, 0) + // Minimum execution time: 53_997_000 picoseconds. + Weight::from_parts(54_874_000, 0) .saturating_add(Weight::from_parts(0, 6703)) .saturating_add(T::DbWeight::get().reads(3)) .saturating_add(T::DbWeight::get().writes(3)) @@ -237,8 +237,8 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `6093` // Estimated: `18187` - // Minimum execution time: 93_105_000 picoseconds. - Weight::from_parts(96_978_000, 0) + // Minimum execution time: 145_331_000 picoseconds. + Weight::from_parts(147_080_000, 0) .saturating_add(Weight::from_parts(0, 18187)) .saturating_add(T::DbWeight::get().reads(5)) .saturating_add(T::DbWeight::get().writes(5)) @@ -251,8 +251,8 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `204` // Estimated: `3518` - // Minimum execution time: 19_693_000 picoseconds. - Weight::from_parts(20_212_000, 0) + // Minimum execution time: 35_370_000 picoseconds. + Weight::from_parts(36_302_000, 0) .saturating_add(Weight::from_parts(0, 3518)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(2)) @@ -268,11 +268,11 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `176 + r * (86 ±0)` // Estimated: `1489 + r * (2676 ±0)` - // Minimum execution time: 7_043_000 picoseconds. - Weight::from_parts(9_128_994, 0) + // Minimum execution time: 12_292_000 picoseconds. + Weight::from_parts(15_844_255, 0) .saturating_add(Weight::from_parts(0, 1489)) - // Standard Error: 12_845 - .saturating_add(Weight::from_parts(3_221_856, 0).saturating_mul(r.into())) + // Standard Error: 14_722 + .saturating_add(Weight::from_parts(5_284_828, 0).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into()))) .saturating_add(T::DbWeight::get().writes(1)) @@ -295,11 +295,11 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `176 + r * (86 ±0)` // Estimated: `18187 + r * (2676 ±0)` - // Minimum execution time: 10_018_000 picoseconds. - Weight::from_parts(8_772_022, 0) + // Minimum execution time: 17_455_000 picoseconds. + Weight::from_parts(21_145_565, 0) .saturating_add(Weight::from_parts(0, 18187)) - // Standard Error: 24_683 - .saturating_add(Weight::from_parts(3_366_083, 0).saturating_mul(r.into())) + // Standard Error: 12_754 + .saturating_add(Weight::from_parts(5_345_592, 0).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(5)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into()))) .saturating_add(T::DbWeight::get().writes(1)) @@ -318,11 +318,11 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `727 + r * (108 ±0)` // Estimated: `19800 + r * (2676 ±0)` - // Minimum execution time: 39_191_000 picoseconds. - Weight::from_parts(47_705_035, 0) + // Minimum execution time: 70_865_000 picoseconds. + Weight::from_parts(80_252_956, 0) .saturating_add(Weight::from_parts(0, 19800)) - // Standard Error: 22_056 - .saturating_add(Weight::from_parts(4_143_626, 0).saturating_mul(r.into())) + // Standard Error: 14_121 + .saturating_add(Weight::from_parts(6_767_212, 0).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(5)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into()))) .saturating_add(T::DbWeight::get().writes(4)) @@ -338,11 +338,11 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `424 + r * (108 ±0)` // Estimated: `13530 + r * (2676 ±0)` - // Minimum execution time: 20_305_000 picoseconds. - Weight::from_parts(22_819_541, 0) + // Minimum execution time: 38_249_000 picoseconds. + Weight::from_parts(39_058_346, 0) .saturating_add(Weight::from_parts(0, 13530)) - // Standard Error: 16_749 - .saturating_add(Weight::from_parts(4_112_400, 0).saturating_mul(r.into())) + // Standard Error: 18_293 + .saturating_add(Weight::from_parts(6_737_090, 0).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into()))) .saturating_add(T::DbWeight::get().writes(2)) @@ -355,8 +355,8 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 3_283_000 picoseconds. - Weight::from_parts(3_420_000, 0) + // Minimum execution time: 7_090_000 picoseconds. + Weight::from_parts(7_556_000, 0) .saturating_add(Weight::from_parts(0, 0)) .saturating_add(T::DbWeight::get().writes(1)) } @@ -373,11 +373,11 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `421` // Estimated: `7260` - // Minimum execution time: 22_262_000 picoseconds. - Weight::from_parts(37_078_280, 0) + // Minimum execution time: 40_638_000 picoseconds. + Weight::from_parts(61_182_119, 0) .saturating_add(Weight::from_parts(0, 7260)) - // Standard Error: 5_886 - .saturating_add(Weight::from_parts(152_633, 0).saturating_mul(r.into())) + // Standard Error: 7_322 + .saturating_add(Weight::from_parts(94_470, 0).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(4)) .saturating_add(T::DbWeight::get().writes(3)) } @@ -394,11 +394,11 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `421 + r * (22 ±0)` // Estimated: `7260` - // Minimum execution time: 33_177_000 picoseconds. - Weight::from_parts(36_908_770, 0) + // Minimum execution time: 60_690_000 picoseconds. + Weight::from_parts(62_455_511, 0) .saturating_add(Weight::from_parts(0, 7260)) - // Standard Error: 2_627 - .saturating_add(Weight::from_parts(151_786, 0).saturating_mul(r.into())) + // Standard Error: 1_726 + .saturating_add(Weight::from_parts(88_743, 0).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(4)) .saturating_add(T::DbWeight::get().writes(3)) } @@ -411,11 +411,11 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `638 + r * (27 ±0)` // Estimated: `7260` - // Minimum execution time: 15_091_000 picoseconds. - Weight::from_parts(18_895_047, 0) + // Minimum execution time: 30_303_000 picoseconds. + Weight::from_parts(34_473_981, 0) .saturating_add(Weight::from_parts(0, 7260)) - // Standard Error: 2_235 - .saturating_add(Weight::from_parts(143_124, 0).saturating_mul(r.into())) + // Standard Error: 2_106 + .saturating_add(Weight::from_parts(118_853, 0).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) } @@ -428,11 +428,11 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `638 + r * (27 ±0)` // Estimated: `7260` - // Minimum execution time: 15_531_000 picoseconds. - Weight::from_parts(19_188_343, 0) + // Minimum execution time: 30_438_000 picoseconds. + Weight::from_parts(34_361_749, 0) .saturating_add(Weight::from_parts(0, 7260)) - // Standard Error: 2_418 - .saturating_add(Weight::from_parts(140_473, 0).saturating_mul(r.into())) + // Standard Error: 1_661 + .saturating_add(Weight::from_parts(122_925, 0).saturating_mul(r.into())) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) } @@ -446,8 +446,8 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `323` // Estimated: `3556` - // Minimum execution time: 18_508_000 picoseconds. - Weight::from_parts(18_938_000, 0) + // Minimum execution time: 33_455_000 picoseconds. + Weight::from_parts(33_963_000, 0) .saturating_add(Weight::from_parts(0, 3556)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(1)) @@ -460,8 +460,8 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `219` // Estimated: `3518` - // Minimum execution time: 16_462_000 picoseconds. - Weight::from_parts(16_989_000, 0) + // Minimum execution time: 30_931_000 picoseconds. + Weight::from_parts(31_991_000, 0) .saturating_add(Weight::from_parts(0, 3518)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(1)) @@ -476,8 +476,8 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `4855` // Estimated: `18187` - // Minimum execution time: 40_830_000 picoseconds. - Weight::from_parts(43_038_000, 0) + // Minimum execution time: 64_724_000 picoseconds. + Weight::from_parts(65_737_000, 0) .saturating_add(Weight::from_parts(0, 18187)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(1)) @@ -490,8 +490,8 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `4755` // Estimated: `18187` - // Minimum execution time: 38_130_000 picoseconds. - Weight::from_parts(40_840_000, 0) + // Minimum execution time: 60_379_000 picoseconds. + Weight::from_parts(61_269_000, 0) .saturating_add(Weight::from_parts(0, 18187)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(1)) @@ -504,8 +504,8 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `178` // Estimated: `3556` - // Minimum execution time: 14_167_000 picoseconds. - Weight::from_parts(14_902_000, 0) + // Minimum execution time: 27_270_000 picoseconds. + Weight::from_parts(27_950_000, 0) .saturating_add(Weight::from_parts(0, 3556)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) @@ -518,8 +518,8 @@ impl pallet_democracy::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `235` // Estimated: `3666` - // Minimum execution time: 18_959_000 picoseconds. - Weight::from_parts(19_645_000, 0) + // Minimum execution time: 36_252_000 picoseconds. + Weight::from_parts(36_847_000, 0) .saturating_add(Weight::from_parts(0, 3666)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(1)) diff --git a/runtime/paseo/src/weights/pallet_extrinsic_filter.rs b/runtime/paseo/src/weights/pallet_extrinsic_filter.rs index 3ada00c439..089262aa83 100644 --- a/runtime/paseo/src/weights/pallet_extrinsic_filter.rs +++ b/runtime/paseo/src/weights/pallet_extrinsic_filter.rs @@ -17,16 +17,16 @@ //! Autogenerated weights for `pallet_extrinsic_filter` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2024-08-28, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-09-16, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` //! HOSTNAME: `litentry-benchmark-server`, CPU: `Intel(R) Xeon(R) CPU E5-2686 v4 @ 2.30GHz` -//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("rococo-dev")`, DB CACHE: 20 +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("paseo-dev")`, DB CACHE: 20 // Executed Command: // ./litentry-collator // benchmark // pallet -// --chain=rococo-dev +// --chain=paseo-dev // --execution=wasm // --db-cache=20 // --wasm-execution=compiled @@ -36,7 +36,7 @@ // --steps=20 // --repeat=50 // --header=./LICENSE_HEADER -// --output=./runtime/rococo/src/weights/pallet_extrinsic_filter.rs +// --output=./runtime/paseo/src/weights/pallet_extrinsic_filter.rs #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(unused_parens)] @@ -57,13 +57,13 @@ impl pallet_extrinsic_filter::WeightInfo for WeightInfo // Proof Size summary in bytes: // Measured: `142` // Estimated: `3607` - // Minimum execution time: 14_933_000 picoseconds. - Weight::from_parts(13_403_699, 0) + // Minimum execution time: 28_206_000 picoseconds. + Weight::from_parts(25_306_744, 0) .saturating_add(Weight::from_parts(0, 3607)) - // Standard Error: 86 - .saturating_add(Weight::from_parts(2_772, 0).saturating_mul(p.into())) - // Standard Error: 86 - .saturating_add(Weight::from_parts(2_313, 0).saturating_mul(f.into())) + // Standard Error: 39 + .saturating_add(Weight::from_parts(4_381, 0).saturating_mul(p.into())) + // Standard Error: 39 + .saturating_add(Weight::from_parts(4_055, 0).saturating_mul(f.into())) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } @@ -75,13 +75,13 @@ impl pallet_extrinsic_filter::WeightInfo for WeightInfo // Proof Size summary in bytes: // Measured: `178 + f * (1 ±0) + p * (1 ±0)` // Estimated: `3644 + f * (1 ±0) + p * (1 ±0)` - // Minimum execution time: 24_081_000 picoseconds. - Weight::from_parts(14_828_975, 0) + // Minimum execution time: 43_394_000 picoseconds. + Weight::from_parts(27_857_933, 0) .saturating_add(Weight::from_parts(0, 3644)) - // Standard Error: 92 - .saturating_add(Weight::from_parts(10_321, 0).saturating_mul(p.into())) - // Standard Error: 92 - .saturating_add(Weight::from_parts(10_231, 0).saturating_mul(f.into())) + // Standard Error: 58 + .saturating_add(Weight::from_parts(17_491, 0).saturating_mul(p.into())) + // Standard Error: 58 + .saturating_add(Weight::from_parts(16_713, 0).saturating_mul(f.into())) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(f.into())) diff --git a/runtime/paseo/src/weights/pallet_identity_management.rs b/runtime/paseo/src/weights/pallet_identity_management.rs index d2b0c90d35..60db9abcce 100644 --- a/runtime/paseo/src/weights/pallet_identity_management.rs +++ b/runtime/paseo/src/weights/pallet_identity_management.rs @@ -17,16 +17,16 @@ //! Autogenerated weights for `pallet_identity_management` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2024-08-28, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-09-16, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` //! HOSTNAME: `litentry-benchmark-server`, CPU: `Intel(R) Xeon(R) CPU E5-2686 v4 @ 2.30GHz` -//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("rococo-dev")`, DB CACHE: 20 +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("paseo-dev")`, DB CACHE: 20 // Executed Command: // ./litentry-collator // benchmark // pallet -// --chain=rococo-dev +// --chain=paseo-dev // --execution=wasm // --db-cache=20 // --wasm-execution=compiled @@ -36,7 +36,7 @@ // --steps=20 // --repeat=50 // --header=./LICENSE_HEADER -// --output=./runtime/rococo/src/weights/pallet_identity_management.rs +// --output=./runtime/paseo/src/weights/pallet_identity_management.rs #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(unused_parens)] @@ -55,8 +55,8 @@ impl pallet_identity_management::WeightInfo for WeightI // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 8_549_000 picoseconds. - Weight::from_parts(8_919_000, 0) + // Minimum execution time: 16_872_000 picoseconds. + Weight::from_parts(17_536_000, 0) .saturating_add(Weight::from_parts(0, 0)) .saturating_add(T::DbWeight::get().writes(1)) } @@ -66,8 +66,8 @@ impl pallet_identity_management::WeightInfo for WeightI // Proof Size summary in bytes: // Measured: `116` // Estimated: `3513` - // Minimum execution time: 12_876_000 picoseconds. - Weight::from_parts(13_453_000, 0) + // Minimum execution time: 24_861_000 picoseconds. + Weight::from_parts(25_605_000, 0) .saturating_add(Weight::from_parts(0, 3513)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) @@ -78,8 +78,8 @@ impl pallet_identity_management::WeightInfo for WeightI // Proof Size summary in bytes: // Measured: `142` // Estimated: `1627` - // Minimum execution time: 15_759_000 picoseconds. - Weight::from_parts(16_281_000, 0) + // Minimum execution time: 29_392_000 picoseconds. + Weight::from_parts(30_216_000, 0) .saturating_add(Weight::from_parts(0, 1627)) .saturating_add(T::DbWeight::get().reads(1)) } @@ -89,8 +89,8 @@ impl pallet_identity_management::WeightInfo for WeightI // Proof Size summary in bytes: // Measured: `142` // Estimated: `1627` - // Minimum execution time: 11_564_000 picoseconds. - Weight::from_parts(12_013_000, 0) + // Minimum execution time: 22_045_000 picoseconds. + Weight::from_parts(22_505_000, 0) .saturating_add(Weight::from_parts(0, 1627)) .saturating_add(T::DbWeight::get().reads(1)) } @@ -100,8 +100,8 @@ impl pallet_identity_management::WeightInfo for WeightI // Proof Size summary in bytes: // Measured: `142` // Estimated: `1627` - // Minimum execution time: 11_785_000 picoseconds. - Weight::from_parts(12_083_000, 0) + // Minimum execution time: 22_117_000 picoseconds. + Weight::from_parts(22_622_000, 0) .saturating_add(Weight::from_parts(0, 1627)) .saturating_add(T::DbWeight::get().reads(1)) } @@ -111,8 +111,8 @@ impl pallet_identity_management::WeightInfo for WeightI // Proof Size summary in bytes: // Measured: `347` // Estimated: `3812` - // Minimum execution time: 12_364_000 picoseconds. - Weight::from_parts(13_195_000, 0) + // Minimum execution time: 23_504_000 picoseconds. + Weight::from_parts(24_337_000, 0) .saturating_add(Weight::from_parts(0, 3812)) .saturating_add(T::DbWeight::get().reads(1)) } @@ -122,8 +122,8 @@ impl pallet_identity_management::WeightInfo for WeightI // Proof Size summary in bytes: // Measured: `347` // Estimated: `3812` - // Minimum execution time: 12_490_000 picoseconds. - Weight::from_parts(12_958_000, 0) + // Minimum execution time: 23_678_000 picoseconds. + Weight::from_parts(24_172_000, 0) .saturating_add(Weight::from_parts(0, 3812)) .saturating_add(T::DbWeight::get().reads(1)) } @@ -133,8 +133,8 @@ impl pallet_identity_management::WeightInfo for WeightI // Proof Size summary in bytes: // Measured: `347` // Estimated: `3812` - // Minimum execution time: 12_481_000 picoseconds. - Weight::from_parts(12_928_000, 0) + // Minimum execution time: 23_852_000 picoseconds. + Weight::from_parts(24_564_000, 0) .saturating_add(Weight::from_parts(0, 3812)) .saturating_add(T::DbWeight::get().reads(1)) } @@ -144,8 +144,8 @@ impl pallet_identity_management::WeightInfo for WeightI // Proof Size summary in bytes: // Measured: `347` // Estimated: `3812` - // Minimum execution time: 12_392_000 picoseconds. - Weight::from_parts(12_997_000, 0) + // Minimum execution time: 23_598_000 picoseconds. + Weight::from_parts(24_153_000, 0) .saturating_add(Weight::from_parts(0, 3812)) .saturating_add(T::DbWeight::get().reads(1)) } @@ -155,8 +155,8 @@ impl pallet_identity_management::WeightInfo for WeightI // Proof Size summary in bytes: // Measured: `347` // Estimated: `3812` - // Minimum execution time: 12_290_000 picoseconds. - Weight::from_parts(12_662_000, 0) + // Minimum execution time: 23_499_000 picoseconds. + Weight::from_parts(24_126_000, 0) .saturating_add(Weight::from_parts(0, 3812)) .saturating_add(T::DbWeight::get().reads(1)) } diff --git a/runtime/paseo/src/weights/pallet_membership.rs b/runtime/paseo/src/weights/pallet_membership.rs index 0798959d02..1c5bcd178a 100644 --- a/runtime/paseo/src/weights/pallet_membership.rs +++ b/runtime/paseo/src/weights/pallet_membership.rs @@ -17,16 +17,16 @@ //! Autogenerated weights for `pallet_membership` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2024-08-28, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-09-16, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` //! HOSTNAME: `litentry-benchmark-server`, CPU: `Intel(R) Xeon(R) CPU E5-2686 v4 @ 2.30GHz` -//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("rococo-dev")`, DB CACHE: 20 +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("paseo-dev")`, DB CACHE: 20 // Executed Command: // ./litentry-collator // benchmark // pallet -// --chain=rococo-dev +// --chain=paseo-dev // --execution=wasm // --db-cache=20 // --wasm-execution=compiled @@ -36,7 +36,7 @@ // --steps=20 // --repeat=50 // --header=./LICENSE_HEADER -// --output=./runtime/rococo/src/weights/pallet_membership.rs +// --output=./runtime/paseo/src/weights/pallet_membership.rs #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(unused_parens)] @@ -62,11 +62,11 @@ impl pallet_membership::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `211 + m * (64 ±0)` // Estimated: `4687 + m * (64 ±0)` - // Minimum execution time: 15_544_000 picoseconds. - Weight::from_parts(16_557_881, 0) + // Minimum execution time: 30_263_000 picoseconds. + Weight::from_parts(31_061_117, 0) .saturating_add(Weight::from_parts(0, 4687)) - // Standard Error: 474 - .saturating_add(Weight::from_parts(27_986, 0).saturating_mul(m.into())) + // Standard Error: 414 + .saturating_add(Weight::from_parts(58_997, 0).saturating_mul(m.into())) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(3)) .saturating_add(Weight::from_parts(0, 64).saturating_mul(m.into())) @@ -86,11 +86,11 @@ impl pallet_membership::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `316 + m * (64 ±0)` // Estimated: `4687 + m * (64 ±0)` - // Minimum execution time: 18_073_000 picoseconds. - Weight::from_parts(19_162_325, 0) + // Minimum execution time: 35_493_000 picoseconds. + Weight::from_parts(36_312_125, 0) .saturating_add(Weight::from_parts(0, 4687)) - // Standard Error: 486 - .saturating_add(Weight::from_parts(24_863, 0).saturating_mul(m.into())) + // Standard Error: 408 + .saturating_add(Weight::from_parts(48_425, 0).saturating_mul(m.into())) .saturating_add(T::DbWeight::get().reads(3)) .saturating_add(T::DbWeight::get().writes(3)) .saturating_add(Weight::from_parts(0, 64).saturating_mul(m.into())) @@ -110,11 +110,11 @@ impl pallet_membership::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `316 + m * (64 ±0)` // Estimated: `4687 + m * (64 ±0)` - // Minimum execution time: 18_247_000 picoseconds. - Weight::from_parts(19_238_238, 0) + // Minimum execution time: 35_733_000 picoseconds. + Weight::from_parts(37_003_580, 0) .saturating_add(Weight::from_parts(0, 4687)) - // Standard Error: 723 - .saturating_add(Weight::from_parts(37_571, 0).saturating_mul(m.into())) + // Standard Error: 781 + .saturating_add(Weight::from_parts(79_313, 0).saturating_mul(m.into())) .saturating_add(T::DbWeight::get().reads(3)) .saturating_add(T::DbWeight::get().writes(3)) .saturating_add(Weight::from_parts(0, 64).saturating_mul(m.into())) @@ -134,11 +134,11 @@ impl pallet_membership::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `315 + m * (64 ±0)` // Estimated: `4687 + m * (64 ±0)` - // Minimum execution time: 18_407_000 picoseconds. - Weight::from_parts(19_739_921, 0) + // Minimum execution time: 35_931_000 picoseconds. + Weight::from_parts(38_097_122, 0) .saturating_add(Weight::from_parts(0, 4687)) - // Standard Error: 1_891 - .saturating_add(Weight::from_parts(132_297, 0).saturating_mul(m.into())) + // Standard Error: 1_052 + .saturating_add(Weight::from_parts(244_042, 0).saturating_mul(m.into())) .saturating_add(T::DbWeight::get().reads(3)) .saturating_add(T::DbWeight::get().writes(3)) .saturating_add(Weight::from_parts(0, 64).saturating_mul(m.into())) @@ -158,11 +158,11 @@ impl pallet_membership::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `315 + m * (64 ±0)` // Estimated: `4687 + m * (64 ±0)` - // Minimum execution time: 19_205_000 picoseconds. - Weight::from_parts(20_277_093, 0) + // Minimum execution time: 37_678_000 picoseconds. + Weight::from_parts(38_773_279, 0) .saturating_add(Weight::from_parts(0, 4687)) - // Standard Error: 1_316 - .saturating_add(Weight::from_parts(33_126, 0).saturating_mul(m.into())) + // Standard Error: 584 + .saturating_add(Weight::from_parts(62_637, 0).saturating_mul(m.into())) .saturating_add(T::DbWeight::get().reads(3)) .saturating_add(T::DbWeight::get().writes(4)) .saturating_add(Weight::from_parts(0, 64).saturating_mul(m.into())) @@ -178,11 +178,11 @@ impl pallet_membership::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `107 + m * (32 ±0)` // Estimated: `4687 + m * (32 ±0)` - // Minimum execution time: 7_663_000 picoseconds. - Weight::from_parts(8_091_030, 0) + // Minimum execution time: 14_864_000 picoseconds. + Weight::from_parts(15_640_370, 0) .saturating_add(Weight::from_parts(0, 4687)) - // Standard Error: 215 - .saturating_add(Weight::from_parts(12_336, 0).saturating_mul(m.into())) + // Standard Error: 276 + .saturating_add(Weight::from_parts(25_149, 0).saturating_mul(m.into())) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(2)) .saturating_add(Weight::from_parts(0, 32).saturating_mul(m.into())) @@ -196,11 +196,11 @@ impl pallet_membership::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 3_043_000 picoseconds. - Weight::from_parts(3_337_476, 0) + // Minimum execution time: 6_441_000 picoseconds. + Weight::from_parts(6_893_898, 0) .saturating_add(Weight::from_parts(0, 0)) - // Standard Error: 111 - .saturating_add(Weight::from_parts(164, 0).saturating_mul(m.into())) + // Standard Error: 157 + .saturating_add(Weight::from_parts(1_908, 0).saturating_mul(m.into())) .saturating_add(T::DbWeight::get().writes(2)) } } diff --git a/runtime/paseo/src/weights/pallet_multisig.rs b/runtime/paseo/src/weights/pallet_multisig.rs index 40fa77030a..21882c1131 100644 --- a/runtime/paseo/src/weights/pallet_multisig.rs +++ b/runtime/paseo/src/weights/pallet_multisig.rs @@ -17,16 +17,16 @@ //! Autogenerated weights for `pallet_multisig` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2024-08-28, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-09-16, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` //! HOSTNAME: `litentry-benchmark-server`, CPU: `Intel(R) Xeon(R) CPU E5-2686 v4 @ 2.30GHz` -//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("rococo-dev")`, DB CACHE: 20 +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("paseo-dev")`, DB CACHE: 20 // Executed Command: // ./litentry-collator // benchmark // pallet -// --chain=rococo-dev +// --chain=paseo-dev // --execution=wasm // --db-cache=20 // --wasm-execution=compiled @@ -36,7 +36,7 @@ // --steps=20 // --repeat=50 // --header=./LICENSE_HEADER -// --output=./runtime/rococo/src/weights/pallet_multisig.rs +// --output=./runtime/paseo/src/weights/pallet_multisig.rs #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(unused_parens)] @@ -54,11 +54,11 @@ impl pallet_multisig::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 13_018_000 picoseconds. - Weight::from_parts(16_358_007, 0) + // Minimum execution time: 21_524_000 picoseconds. + Weight::from_parts(22_431_788, 0) .saturating_add(Weight::from_parts(0, 0)) - // Standard Error: 18 - .saturating_add(Weight::from_parts(502, 0).saturating_mul(z.into())) + // Standard Error: 5 + .saturating_add(Weight::from_parts(811, 0).saturating_mul(z.into())) } /// Storage: `Multisig::Multisigs` (r:1 w:1) /// Proof: `Multisig::Multisigs` (`max_values`: None, `max_size`: Some(3346), added: 5821, mode: `MaxEncodedLen`) @@ -68,13 +68,13 @@ impl pallet_multisig::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `289 + s * (2 ±0)` // Estimated: `6811` - // Minimum execution time: 43_932_000 picoseconds. - Weight::from_parts(33_535_441, 0) + // Minimum execution time: 70_325_000 picoseconds. + Weight::from_parts(62_623_337, 0) .saturating_add(Weight::from_parts(0, 6811)) - // Standard Error: 4_217 - .saturating_add(Weight::from_parts(146_766, 0).saturating_mul(s.into())) - // Standard Error: 41 - .saturating_add(Weight::from_parts(1_557, 0).saturating_mul(z.into())) + // Standard Error: 735 + .saturating_add(Weight::from_parts(90_173, 0).saturating_mul(s.into())) + // Standard Error: 7 + .saturating_add(Weight::from_parts(1_876, 0).saturating_mul(z.into())) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } @@ -86,13 +86,13 @@ impl pallet_multisig::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `315` // Estimated: `6811` - // Minimum execution time: 29_075_000 picoseconds. - Weight::from_parts(17_070_108, 0) + // Minimum execution time: 46_182_000 picoseconds. + Weight::from_parts(36_379_690, 0) .saturating_add(Weight::from_parts(0, 6811)) - // Standard Error: 1_957 - .saturating_add(Weight::from_parts(147_016, 0).saturating_mul(s.into())) - // Standard Error: 19 - .saturating_add(Weight::from_parts(1_592, 0).saturating_mul(z.into())) + // Standard Error: 745 + .saturating_add(Weight::from_parts(113_766, 0).saturating_mul(s.into())) + // Standard Error: 7 + .saturating_add(Weight::from_parts(2_023, 0).saturating_mul(z.into())) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } @@ -106,13 +106,13 @@ impl pallet_multisig::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `421 + s * (33 ±0)` // Estimated: `6811` - // Minimum execution time: 49_610_000 picoseconds. - Weight::from_parts(38_076_052, 0) + // Minimum execution time: 81_402_000 picoseconds. + Weight::from_parts(70_429_405, 0) .saturating_add(Weight::from_parts(0, 6811)) - // Standard Error: 2_625 - .saturating_add(Weight::from_parts(176_208, 0).saturating_mul(s.into())) - // Standard Error: 25 - .saturating_add(Weight::from_parts(1_589, 0).saturating_mul(z.into())) + // Standard Error: 1_477 + .saturating_add(Weight::from_parts(113_884, 0).saturating_mul(s.into())) + // Standard Error: 14 + .saturating_add(Weight::from_parts(2_056, 0).saturating_mul(z.into())) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) } @@ -123,11 +123,11 @@ impl pallet_multisig::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `292 + s * (2 ±0)` // Estimated: `6811` - // Minimum execution time: 30_004_000 picoseconds. - Weight::from_parts(32_460_826, 0) + // Minimum execution time: 56_357_000 picoseconds. + Weight::from_parts(57_912_089, 0) .saturating_add(Weight::from_parts(0, 6811)) - // Standard Error: 3_414 - .saturating_add(Weight::from_parts(152_194, 0).saturating_mul(s.into())) + // Standard Error: 822 + .saturating_add(Weight::from_parts(125_944, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } @@ -138,11 +138,11 @@ impl pallet_multisig::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `315` // Estimated: `6811` - // Minimum execution time: 16_701_000 picoseconds. - Weight::from_parts(17_280_857, 0) + // Minimum execution time: 33_457_000 picoseconds. + Weight::from_parts(34_998_592, 0) .saturating_add(Weight::from_parts(0, 6811)) - // Standard Error: 1_905 - .saturating_add(Weight::from_parts(136_920, 0).saturating_mul(s.into())) + // Standard Error: 853 + .saturating_add(Weight::from_parts(114_866, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } @@ -153,11 +153,11 @@ impl pallet_multisig::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `486 + s * (1 ±0)` // Estimated: `6811` - // Minimum execution time: 31_656_000 picoseconds. - Weight::from_parts(33_456_462, 0) + // Minimum execution time: 58_309_000 picoseconds. + Weight::from_parts(59_974_537, 0) .saturating_add(Weight::from_parts(0, 6811)) - // Standard Error: 2_823 - .saturating_add(Weight::from_parts(141_836, 0).saturating_mul(s.into())) + // Standard Error: 806 + .saturating_add(Weight::from_parts(113_520, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } diff --git a/runtime/paseo/src/weights/pallet_parachain_staking.rs b/runtime/paseo/src/weights/pallet_parachain_staking.rs index 357e2e3547..18a41787db 100644 --- a/runtime/paseo/src/weights/pallet_parachain_staking.rs +++ b/runtime/paseo/src/weights/pallet_parachain_staking.rs @@ -17,16 +17,16 @@ //! Autogenerated weights for `pallet_parachain_staking` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2024-08-28, STEPS: `25`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-09-16, STEPS: `25`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` //! HOSTNAME: `litentry-benchmark-server`, CPU: `Intel(R) Xeon(R) CPU E5-2686 v4 @ 2.30GHz` -//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("rococo-dev")`, DB CACHE: 20 +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("paseo-dev")`, DB CACHE: 20 // Executed Command: // ./litentry-collator // benchmark // pallet -// --chain=rococo-dev +// --chain=paseo-dev // --execution=wasm // --db-cache=20 // --wasm-execution=compiled @@ -36,7 +36,7 @@ // --steps=25 // --repeat=20 // --header=./LICENSE_HEADER -// --output=./runtime/rococo/src/weights/pallet_parachain_staking.rs +// --output=./runtime/paseo/src/weights/pallet_parachain_staking.rs #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(unused_parens)] @@ -56,11 +56,11 @@ impl pallet_parachain_staking::WeightInfo for WeightInf // Proof Size summary in bytes: // Measured: `337 + x * (32 ±0)` // Estimated: `1826 + x * (32 ±0)` - // Minimum execution time: 12_371_000 picoseconds. - Weight::from_parts(15_519_329, 0) + // Minimum execution time: 22_654_000 picoseconds. + Weight::from_parts(26_893_850, 0) .saturating_add(Weight::from_parts(0, 1826)) - // Standard Error: 3_320 - .saturating_add(Weight::from_parts(113_759, 0).saturating_mul(x.into())) + // Standard Error: 2_277 + .saturating_add(Weight::from_parts(85_977, 0).saturating_mul(x.into())) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) .saturating_add(Weight::from_parts(0, 32).saturating_mul(x.into())) @@ -72,11 +72,11 @@ impl pallet_parachain_staking::WeightInfo for WeightInf // Proof Size summary in bytes: // Measured: `369 + x * (32 ±0)` // Estimated: `1859 + x * (32 ±0)` - // Minimum execution time: 11_880_000 picoseconds. - Weight::from_parts(15_002_167, 0) + // Minimum execution time: 22_516_000 picoseconds. + Weight::from_parts(26_280_130, 0) .saturating_add(Weight::from_parts(0, 1859)) - // Standard Error: 3_213 - .saturating_add(Weight::from_parts(105_293, 0).saturating_mul(x.into())) + // Standard Error: 2_135 + .saturating_add(Weight::from_parts(81_414, 0).saturating_mul(x.into())) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) .saturating_add(Weight::from_parts(0, 32).saturating_mul(x.into())) @@ -87,8 +87,8 @@ impl pallet_parachain_staking::WeightInfo for WeightInf // Proof Size summary in bytes: // Measured: `466` // Estimated: `1951` - // Minimum execution time: 12_459_000 picoseconds. - Weight::from_parts(13_116_000, 0) + // Minimum execution time: 24_108_000 picoseconds. + Weight::from_parts(24_607_000, 0) .saturating_add(Weight::from_parts(0, 1951)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) @@ -101,8 +101,8 @@ impl pallet_parachain_staking::WeightInfo for WeightInf // Proof Size summary in bytes: // Measured: `502` // Estimated: `1987` - // Minimum execution time: 42_609_000 picoseconds. - Weight::from_parts(43_433_000, 0) + // Minimum execution time: 77_514_000 picoseconds. + Weight::from_parts(78_105_000, 0) .saturating_add(Weight::from_parts(0, 1987)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(1)) @@ -113,8 +113,8 @@ impl pallet_parachain_staking::WeightInfo for WeightInf // Proof Size summary in bytes: // Measured: `434` // Estimated: `1919` - // Minimum execution time: 12_529_000 picoseconds. - Weight::from_parts(13_080_000, 0) + // Minimum execution time: 23_482_000 picoseconds. + Weight::from_parts(24_398_000, 0) .saturating_add(Weight::from_parts(0, 1919)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) @@ -125,8 +125,8 @@ impl pallet_parachain_staking::WeightInfo for WeightInf // Proof Size summary in bytes: // Measured: `434` // Estimated: `1919` - // Minimum execution time: 12_215_000 picoseconds. - Weight::from_parts(13_141_000, 0) + // Minimum execution time: 23_416_000 picoseconds. + Weight::from_parts(23_962_000, 0) .saturating_add(Weight::from_parts(0, 1919)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) @@ -139,8 +139,8 @@ impl pallet_parachain_staking::WeightInfo for WeightInf // Proof Size summary in bytes: // Measured: `442` // Estimated: `1927` - // Minimum execution time: 13_709_000 picoseconds. - Weight::from_parts(14_340_000, 0) + // Minimum execution time: 25_502_000 picoseconds. + Weight::from_parts(26_296_000, 0) .saturating_add(Weight::from_parts(0, 1927)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(1)) @@ -151,8 +151,8 @@ impl pallet_parachain_staking::WeightInfo for WeightInf // Proof Size summary in bytes: // Measured: `405` // Estimated: `1890` - // Minimum execution time: 11_060_000 picoseconds. - Weight::from_parts(11_690_000, 0) + // Minimum execution time: 21_695_000 picoseconds. + Weight::from_parts(22_114_000, 0) .saturating_add(Weight::from_parts(0, 1890)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) @@ -167,8 +167,8 @@ impl pallet_parachain_staking::WeightInfo for WeightInf // Proof Size summary in bytes: // Measured: `530` // Estimated: `2015` - // Minimum execution time: 18_786_000 picoseconds. - Weight::from_parts(19_544_000, 0) + // Minimum execution time: 35_476_000 picoseconds. + Weight::from_parts(36_428_000, 0) .saturating_add(Weight::from_parts(0, 2015)) .saturating_add(T::DbWeight::get().reads(3)) .saturating_add(T::DbWeight::get().writes(2)) @@ -194,11 +194,11 @@ impl pallet_parachain_staking::WeightInfo for WeightInf // Proof Size summary in bytes: // Measured: `1512 + x * (80 ±0)` // Estimated: `4815 + x * (81 ±0)` - // Minimum execution time: 48_531_000 picoseconds. - Weight::from_parts(50_133_211, 0) + // Minimum execution time: 90_030_000 picoseconds. + Weight::from_parts(84_487_906, 0) .saturating_add(Weight::from_parts(0, 4815)) - // Standard Error: 2_372 - .saturating_add(Weight::from_parts(150_172, 0).saturating_mul(x.into())) + // Standard Error: 4_146 + .saturating_add(Weight::from_parts(254_405, 0).saturating_mul(x.into())) .saturating_add(T::DbWeight::get().reads(6)) .saturating_add(T::DbWeight::get().writes(6)) .saturating_add(Weight::from_parts(0, 81).saturating_mul(x.into())) @@ -214,11 +214,11 @@ impl pallet_parachain_staking::WeightInfo for WeightInf // Proof Size summary in bytes: // Measured: `1327 + x * (48 ±0)` // Estimated: `4691 + x * (49 ±0)` - // Minimum execution time: 22_779_000 picoseconds. - Weight::from_parts(18_073_114, 0) + // Minimum execution time: 42_768_000 picoseconds. + Weight::from_parts(28_532_400, 0) .saturating_add(Weight::from_parts(0, 4691)) - // Standard Error: 2_296 - .saturating_add(Weight::from_parts(120_415, 0).saturating_mul(x.into())) + // Standard Error: 3_904 + .saturating_add(Weight::from_parts(184_184, 0).saturating_mul(x.into())) .saturating_add(T::DbWeight::get().reads(3)) .saturating_add(T::DbWeight::get().writes(2)) .saturating_add(Weight::from_parts(0, 49).saturating_mul(x.into())) @@ -246,11 +246,11 @@ impl pallet_parachain_staking::WeightInfo for WeightInf // Proof Size summary in bytes: // Measured: `469 + x * (447 ±0)` // Estimated: `5094 + x * (2915 ±0)` - // Minimum execution time: 90_448_000 picoseconds. - Weight::from_parts(95_467_000, 0) + // Minimum execution time: 147_094_000 picoseconds. + Weight::from_parts(148_865_000, 0) .saturating_add(Weight::from_parts(0, 5094)) - // Standard Error: 842_280 - .saturating_add(Weight::from_parts(68_676_766, 0).saturating_mul(x.into())) + // Standard Error: 1_125_892 + .saturating_add(Weight::from_parts(92_244_624, 0).saturating_mul(x.into())) .saturating_add(T::DbWeight::get().reads(6)) .saturating_add(T::DbWeight::get().reads((2_u64).saturating_mul(x.into()))) .saturating_add(T::DbWeight::get().writes(5)) @@ -266,11 +266,11 @@ impl pallet_parachain_staking::WeightInfo for WeightInf // Proof Size summary in bytes: // Measured: `1247 + x * (48 ±0)` // Estimated: `4611 + x * (49 ±0)` - // Minimum execution time: 20_426_000 picoseconds. - Weight::from_parts(16_451_221, 0) + // Minimum execution time: 39_575_000 picoseconds. + Weight::from_parts(23_078_827, 0) .saturating_add(Weight::from_parts(0, 4611)) - // Standard Error: 2_616 - .saturating_add(Weight::from_parts(132_896, 0).saturating_mul(x.into())) + // Standard Error: 3_921 + .saturating_add(Weight::from_parts(212_652, 0).saturating_mul(x.into())) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) .saturating_add(Weight::from_parts(0, 49).saturating_mul(x.into())) @@ -283,8 +283,8 @@ impl pallet_parachain_staking::WeightInfo for WeightInf // Proof Size summary in bytes: // Measured: `686` // Estimated: `4151` - // Minimum execution time: 19_979_000 picoseconds. - Weight::from_parts(21_030_000, 0) + // Minimum execution time: 40_257_000 picoseconds. + Weight::from_parts(41_003_000, 0) .saturating_add(Weight::from_parts(0, 4151)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) @@ -297,8 +297,8 @@ impl pallet_parachain_staking::WeightInfo for WeightInf // Proof Size summary in bytes: // Measured: `637` // Estimated: `4102` - // Minimum execution time: 20_087_000 picoseconds. - Weight::from_parts(20_871_000, 0) + // Minimum execution time: 39_512_000 picoseconds. + Weight::from_parts(40_166_000, 0) .saturating_add(Weight::from_parts(0, 4102)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) @@ -315,8 +315,8 @@ impl pallet_parachain_staking::WeightInfo for WeightInf // Proof Size summary in bytes: // Measured: `829` // Estimated: `4294` - // Minimum execution time: 37_568_000 picoseconds. - Weight::from_parts(39_038_000, 0) + // Minimum execution time: 70_532_000 picoseconds. + Weight::from_parts(71_179_000, 0) .saturating_add(Weight::from_parts(0, 4294)) .saturating_add(T::DbWeight::get().reads(4)) .saturating_add(T::DbWeight::get().writes(4)) @@ -329,8 +329,8 @@ impl pallet_parachain_staking::WeightInfo for WeightInf // Proof Size summary in bytes: // Measured: `598` // Estimated: `4063` - // Minimum execution time: 18_568_000 picoseconds. - Weight::from_parts(19_643_000, 0) + // Minimum execution time: 37_511_000 picoseconds. + Weight::from_parts(38_256_000, 0) .saturating_add(Weight::from_parts(0, 4063)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(1)) @@ -349,8 +349,8 @@ impl pallet_parachain_staking::WeightInfo for WeightInf // Proof Size summary in bytes: // Measured: `918` // Estimated: `4383` - // Minimum execution time: 47_721_000 picoseconds. - Weight::from_parts(51_545_000, 0) + // Minimum execution time: 85_418_000 picoseconds. + Weight::from_parts(87_051_000, 0) .saturating_add(Weight::from_parts(0, 4383)) .saturating_add(T::DbWeight::get().reads(5)) .saturating_add(T::DbWeight::get().writes(4)) @@ -361,8 +361,8 @@ impl pallet_parachain_staking::WeightInfo for WeightInf // Proof Size summary in bytes: // Measured: `582` // Estimated: `4047` - // Minimum execution time: 15_559_000 picoseconds. - Weight::from_parts(16_199_000, 0) + // Minimum execution time: 30_726_000 picoseconds. + Weight::from_parts(31_591_000, 0) .saturating_add(Weight::from_parts(0, 4047)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) @@ -377,8 +377,8 @@ impl pallet_parachain_staking::WeightInfo for WeightInf // Proof Size summary in bytes: // Measured: `595` // Estimated: `4060` - // Minimum execution time: 21_772_000 picoseconds. - Weight::from_parts(22_653_000, 0) + // Minimum execution time: 43_210_000 picoseconds. + Weight::from_parts(43_908_000, 0) .saturating_add(Weight::from_parts(0, 4060)) .saturating_add(T::DbWeight::get().reads(3)) .saturating_add(T::DbWeight::get().writes(2)) @@ -407,12 +407,12 @@ impl pallet_parachain_staking::WeightInfo for WeightInf fn execute_leave_delegators(x: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `1008 + x * (458 ±0)` - // Estimated: `5061 + x * (2852 ±3)` - // Minimum execution time: 79_414_000 picoseconds. - Weight::from_parts(82_954_000, 0) + // Estimated: `5061 + x * (2852 ±0)` + // Minimum execution time: 132_556_000 picoseconds. + Weight::from_parts(133_648_000, 0) .saturating_add(Weight::from_parts(0, 5061)) - // Standard Error: 338_518 - .saturating_add(Weight::from_parts(44_951_389, 0).saturating_mul(x.into())) + // Standard Error: 114_942 + .saturating_add(Weight::from_parts(53_889_767, 0).saturating_mul(x.into())) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().reads((4_u64).saturating_mul(x.into()))) .saturating_add(T::DbWeight::get().writes(1)) @@ -427,8 +427,8 @@ impl pallet_parachain_staking::WeightInfo for WeightInf // Proof Size summary in bytes: // Measured: `720` // Estimated: `4185` - // Minimum execution time: 23_662_000 picoseconds. - Weight::from_parts(25_715_000, 0) + // Minimum execution time: 44_417_000 picoseconds. + Weight::from_parts(45_214_000, 0) .saturating_add(Weight::from_parts(0, 4185)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) @@ -443,8 +443,8 @@ impl pallet_parachain_staking::WeightInfo for WeightInf // Proof Size summary in bytes: // Measured: `595` // Estimated: `4060` - // Minimum execution time: 21_876_000 picoseconds. - Weight::from_parts(30_423_000, 0) + // Minimum execution time: 41_138_000 picoseconds. + Weight::from_parts(41_929_000, 0) .saturating_add(Weight::from_parts(0, 4060)) .saturating_add(T::DbWeight::get().reads(3)) .saturating_add(T::DbWeight::get().writes(2)) @@ -467,8 +467,8 @@ impl pallet_parachain_staking::WeightInfo for WeightInf // Proof Size summary in bytes: // Measured: `1217` // Estimated: `4682` - // Minimum execution time: 56_734_000 picoseconds. - Weight::from_parts(61_346_000, 0) + // Minimum execution time: 102_918_000 picoseconds. + Weight::from_parts(104_033_000, 0) .saturating_add(Weight::from_parts(0, 4682)) .saturating_add(T::DbWeight::get().reads(7)) .saturating_add(T::DbWeight::get().writes(6)) @@ -483,8 +483,8 @@ impl pallet_parachain_staking::WeightInfo for WeightInf // Proof Size summary in bytes: // Measured: `595` // Estimated: `4060` - // Minimum execution time: 22_033_000 picoseconds. - Weight::from_parts(23_316_000, 0) + // Minimum execution time: 41_403_000 picoseconds. + Weight::from_parts(42_283_000, 0) .saturating_add(Weight::from_parts(0, 4060)) .saturating_add(T::DbWeight::get().reads(3)) .saturating_add(T::DbWeight::get().writes(2)) @@ -513,8 +513,8 @@ impl pallet_parachain_staking::WeightInfo for WeightInf // Proof Size summary in bytes: // Measured: `1596` // Estimated: `5061` - // Minimum execution time: 82_289_000 picoseconds. - Weight::from_parts(85_150_000, 0) + // Minimum execution time: 136_936_000 picoseconds. + Weight::from_parts(139_923_000, 0) .saturating_add(Weight::from_parts(0, 5061)) .saturating_add(T::DbWeight::get().reads(10)) .saturating_add(T::DbWeight::get().writes(7)) @@ -539,8 +539,8 @@ impl pallet_parachain_staking::WeightInfo for WeightInf // Proof Size summary in bytes: // Measured: `1375` // Estimated: `4840` - // Minimum execution time: 66_897_000 picoseconds. - Weight::from_parts(72_647_000, 0) + // Minimum execution time: 112_783_000 picoseconds. + Weight::from_parts(118_548_000, 0) .saturating_add(Weight::from_parts(0, 4840)) .saturating_add(T::DbWeight::get().reads(8)) .saturating_add(T::DbWeight::get().writes(7)) @@ -553,8 +553,8 @@ impl pallet_parachain_staking::WeightInfo for WeightInf // Proof Size summary in bytes: // Measured: `720` // Estimated: `4185` - // Minimum execution time: 22_063_000 picoseconds. - Weight::from_parts(23_092_000, 0) + // Minimum execution time: 40_392_000 picoseconds. + Weight::from_parts(40_932_000, 0) .saturating_add(Weight::from_parts(0, 4185)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) @@ -567,8 +567,8 @@ impl pallet_parachain_staking::WeightInfo for WeightInf // Proof Size summary in bytes: // Measured: `753` // Estimated: `4218` - // Minimum execution time: 27_125_000 picoseconds. - Weight::from_parts(29_839_000, 0) + // Minimum execution time: 45_274_000 picoseconds. + Weight::from_parts(47_107_000, 0) .saturating_add(Weight::from_parts(0, 4218)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) @@ -617,8 +617,8 @@ impl pallet_parachain_staking::WeightInfo for WeightInf // Proof Size summary in bytes: // Measured: `4347 + x * (297 ±0) + y * (47 ±0)` // Estimated: `519520 + x * (2390 ±43) + y * (46 ±0)` - // Minimum execution time: 829_036_000 picoseconds. - Weight::from_parts(4_788_241_561, 0) + // Minimum execution time: 1_374_024_000 picoseconds. + Weight::from_parts(5_629_143_864, 0) .saturating_add(Weight::from_parts(0, 519520)) .saturating_add(T::DbWeight::get().reads(214)) .saturating_add(T::DbWeight::get().reads((2_u64).saturating_mul(x.into()))) @@ -641,11 +641,11 @@ impl pallet_parachain_staking::WeightInfo for WeightInf // Proof Size summary in bytes: // Measured: `399 + y * (185 ±0)` // Estimated: `6424 + y * (2603 ±0)` - // Minimum execution time: 41_873_000 picoseconds. - Weight::from_parts(42_692_000, 0) + // Minimum execution time: 77_115_000 picoseconds. + Weight::from_parts(77_687_000, 0) .saturating_add(Weight::from_parts(0, 6424)) - // Standard Error: 54_978 - .saturating_add(Weight::from_parts(22_646_853, 0).saturating_mul(y.into())) + // Standard Error: 34_517 + .saturating_add(Weight::from_parts(26_327_391, 0).saturating_mul(y.into())) .saturating_add(T::DbWeight::get().reads(6)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(y.into()))) .saturating_add(T::DbWeight::get().writes(3)) @@ -658,8 +658,8 @@ impl pallet_parachain_staking::WeightInfo for WeightInf // Proof Size summary in bytes: // Measured: `447` // Estimated: `1932` - // Minimum execution time: 4_640_000 picoseconds. - Weight::from_parts(4_902_000, 0) + // Minimum execution time: 8_692_000 picoseconds. + Weight::from_parts(9_072_000, 0) .saturating_add(Weight::from_parts(0, 1932)) .saturating_add(T::DbWeight::get().reads(1)) } @@ -673,11 +673,11 @@ impl pallet_parachain_staking::WeightInfo for WeightInf // Proof Size summary in bytes: // Measured: `1273 + x * (33 ±0) + y * (48 ±0)` // Estimated: `4574 + x * (34 ±0) + y * (49 ±0)` - // Minimum execution time: 38_548_000 picoseconds. - Weight::from_parts(43_959_261, 0) + // Minimum execution time: 47_751_000 picoseconds. + Weight::from_parts(62_800_278, 0) .saturating_add(Weight::from_parts(0, 4574)) - // Standard Error: 2_369 - .saturating_add(Weight::from_parts(89_391, 0).saturating_mul(x.into())) + // Standard Error: 2_463 + .saturating_add(Weight::from_parts(125_768, 0).saturating_mul(x.into())) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(1)) .saturating_add(Weight::from_parts(0, 34).saturating_mul(x.into())) @@ -706,13 +706,13 @@ impl pallet_parachain_staking::WeightInfo for WeightInf // Proof Size summary in bytes: // Measured: `0 + x * (81 ±0) + y * (33 ±0) + z * (55 ±0)` // Estimated: `21773 + x * (82 ±0) + y * (31 ±0) + z * (29 ±0)` - // Minimum execution time: 89_451_000 picoseconds. - Weight::from_parts(95_607_000, 0) + // Minimum execution time: 135_330_000 picoseconds. + Weight::from_parts(137_714_000, 0) .saturating_add(Weight::from_parts(0, 21773)) - // Standard Error: 1_809 - .saturating_add(Weight::from_parts(50_247, 0).saturating_mul(x.into())) - // Standard Error: 1_809 - .saturating_add(Weight::from_parts(61_589, 0).saturating_mul(y.into())) + // Standard Error: 2_897 + .saturating_add(Weight::from_parts(78_961, 0).saturating_mul(x.into())) + // Standard Error: 2_897 + .saturating_add(Weight::from_parts(87_803, 0).saturating_mul(y.into())) .saturating_add(T::DbWeight::get().reads(7)) .saturating_add(T::DbWeight::get().writes(7)) .saturating_add(Weight::from_parts(0, 82).saturating_mul(x.into())) diff --git a/runtime/paseo/src/weights/pallet_preimage.rs b/runtime/paseo/src/weights/pallet_preimage.rs index c34bc1508f..97c9334a79 100644 --- a/runtime/paseo/src/weights/pallet_preimage.rs +++ b/runtime/paseo/src/weights/pallet_preimage.rs @@ -17,16 +17,16 @@ //! Autogenerated weights for `pallet_preimage` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2024-08-28, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-09-16, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` //! HOSTNAME: `litentry-benchmark-server`, CPU: `Intel(R) Xeon(R) CPU E5-2686 v4 @ 2.30GHz` -//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("rococo-dev")`, DB CACHE: 20 +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("paseo-dev")`, DB CACHE: 20 // Executed Command: // ./litentry-collator // benchmark // pallet -// --chain=rococo-dev +// --chain=paseo-dev // --execution=wasm // --db-cache=20 // --wasm-execution=compiled @@ -36,7 +36,7 @@ // --steps=20 // --repeat=50 // --header=./LICENSE_HEADER -// --output=./runtime/rococo/src/weights/pallet_preimage.rs +// --output=./runtime/paseo/src/weights/pallet_preimage.rs #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(unused_parens)] @@ -58,11 +58,11 @@ impl pallet_preimage::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `177` // Estimated: `3556` - // Minimum execution time: 28_776_000 picoseconds. - Weight::from_parts(29_081_000, 0) + // Minimum execution time: 50_808_000 picoseconds. + Weight::from_parts(51_507_000, 0) .saturating_add(Weight::from_parts(0, 3556)) - // Standard Error: 7 - .saturating_add(Weight::from_parts(3_231, 0).saturating_mul(s.into())) + // Standard Error: 9 + .saturating_add(Weight::from_parts(3_211, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(2)) } @@ -75,11 +75,11 @@ impl pallet_preimage::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `140` // Estimated: `3556` - // Minimum execution time: 15_682_000 picoseconds. - Weight::from_parts(16_044_000, 0) + // Minimum execution time: 30_018_000 picoseconds. + Weight::from_parts(30_641_000, 0) .saturating_add(Weight::from_parts(0, 3556)) - // Standard Error: 11 - .saturating_add(Weight::from_parts(3_369, 0).saturating_mul(s.into())) + // Standard Error: 2 + .saturating_add(Weight::from_parts(3_174, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(2)) } @@ -92,11 +92,11 @@ impl pallet_preimage::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `140` // Estimated: `3556` - // Minimum execution time: 14_685_000 picoseconds. - Weight::from_parts(14_901_000, 0) + // Minimum execution time: 28_109_000 picoseconds. + Weight::from_parts(28_380_000, 0) .saturating_add(Weight::from_parts(0, 3556)) - // Standard Error: 9 - .saturating_add(Weight::from_parts(3_386, 0).saturating_mul(s.into())) + // Standard Error: 10 + .saturating_add(Weight::from_parts(3_292, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(2)) } @@ -108,8 +108,8 @@ impl pallet_preimage::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `323` // Estimated: `3556` - // Minimum execution time: 50_875_000 picoseconds. - Weight::from_parts(57_436_000, 0) + // Minimum execution time: 72_077_000 picoseconds. + Weight::from_parts(78_329_000, 0) .saturating_add(Weight::from_parts(0, 3556)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(2)) @@ -122,8 +122,8 @@ impl pallet_preimage::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `178` // Estimated: `3556` - // Minimum execution time: 33_855_000 picoseconds. - Weight::from_parts(39_934_000, 0) + // Minimum execution time: 48_919_000 picoseconds. + Weight::from_parts(52_692_000, 0) .saturating_add(Weight::from_parts(0, 3556)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(2)) @@ -134,8 +134,8 @@ impl pallet_preimage::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `222` // Estimated: `3556` - // Minimum execution time: 29_810_000 picoseconds. - Weight::from_parts(36_615_000, 0) + // Minimum execution time: 41_111_000 picoseconds. + Weight::from_parts(46_538_000, 0) .saturating_add(Weight::from_parts(0, 3556)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) @@ -146,8 +146,8 @@ impl pallet_preimage::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `178` // Estimated: `3556` - // Minimum execution time: 19_068_000 picoseconds. - Weight::from_parts(23_875_000, 0) + // Minimum execution time: 23_341_000 picoseconds. + Weight::from_parts(27_948_000, 0) .saturating_add(Weight::from_parts(0, 3556)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) @@ -158,8 +158,8 @@ impl pallet_preimage::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `76` // Estimated: `3556` - // Minimum execution time: 18_539_000 picoseconds. - Weight::from_parts(23_207_000, 0) + // Minimum execution time: 24_480_000 picoseconds. + Weight::from_parts(25_698_000, 0) .saturating_add(Weight::from_parts(0, 3556)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) @@ -170,8 +170,8 @@ impl pallet_preimage::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `140` // Estimated: `3556` - // Minimum execution time: 10_579_000 picoseconds. - Weight::from_parts(11_917_000, 0) + // Minimum execution time: 15_903_000 picoseconds. + Weight::from_parts(16_611_000, 0) .saturating_add(Weight::from_parts(0, 3556)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) @@ -184,8 +184,8 @@ impl pallet_preimage::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `178` // Estimated: `3556` - // Minimum execution time: 31_098_000 picoseconds. - Weight::from_parts(38_182_000, 0) + // Minimum execution time: 38_315_000 picoseconds. + Weight::from_parts(47_499_000, 0) .saturating_add(Weight::from_parts(0, 3556)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(2)) @@ -196,8 +196,8 @@ impl pallet_preimage::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `140` // Estimated: `3556` - // Minimum execution time: 11_423_000 picoseconds. - Weight::from_parts(13_067_000, 0) + // Minimum execution time: 15_624_000 picoseconds. + Weight::from_parts(16_184_000, 0) .saturating_add(Weight::from_parts(0, 3556)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) @@ -208,8 +208,8 @@ impl pallet_preimage::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `140` // Estimated: `3556` - // Minimum execution time: 10_892_000 picoseconds. - Weight::from_parts(12_065_000, 0) + // Minimum execution time: 15_674_000 picoseconds. + Weight::from_parts(16_321_000, 0) .saturating_add(Weight::from_parts(0, 3556)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) diff --git a/runtime/paseo/src/weights/pallet_proxy.rs b/runtime/paseo/src/weights/pallet_proxy.rs index 8b3aac0722..27b4dd41c4 100644 --- a/runtime/paseo/src/weights/pallet_proxy.rs +++ b/runtime/paseo/src/weights/pallet_proxy.rs @@ -17,16 +17,16 @@ //! Autogenerated weights for `pallet_proxy` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2024-08-28, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-09-16, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` //! HOSTNAME: `litentry-benchmark-server`, CPU: `Intel(R) Xeon(R) CPU E5-2686 v4 @ 2.30GHz` -//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("rococo-dev")`, DB CACHE: 20 +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("paseo-dev")`, DB CACHE: 20 // Executed Command: // ./litentry-collator // benchmark // pallet -// --chain=rococo-dev +// --chain=paseo-dev // --execution=wasm // --db-cache=20 // --wasm-execution=compiled @@ -36,7 +36,7 @@ // --steps=20 // --repeat=50 // --header=./LICENSE_HEADER -// --output=./runtime/rococo/src/weights/pallet_proxy.rs +// --output=./runtime/paseo/src/weights/pallet_proxy.rs #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(unused_parens)] @@ -56,11 +56,11 @@ impl pallet_proxy::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `227 + p * (37 ±0)` // Estimated: `4706` - // Minimum execution time: 14_852_000 picoseconds. - Weight::from_parts(15_496_268, 0) + // Minimum execution time: 28_068_000 picoseconds. + Weight::from_parts(29_038_981, 0) .saturating_add(Weight::from_parts(0, 4706)) - // Standard Error: 3_760 - .saturating_add(Weight::from_parts(61_031, 0).saturating_mul(p.into())) + // Standard Error: 1_451 + .saturating_add(Weight::from_parts(56_043, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(1)) } /// Storage: `Proxy::Proxies` (r:1 w:0) @@ -75,13 +75,13 @@ impl pallet_proxy::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `517 + a * (68 ±0) + p * (37 ±0)` // Estimated: `5698` - // Minimum execution time: 36_109_000 picoseconds. - Weight::from_parts(40_625_859, 0) + // Minimum execution time: 62_758_000 picoseconds. + Weight::from_parts(62_910_767, 0) .saturating_add(Weight::from_parts(0, 5698)) - // Standard Error: 12_274 - .saturating_add(Weight::from_parts(63_550, 0).saturating_mul(a.into())) - // Standard Error: 12_690 - .saturating_add(Weight::from_parts(22_123, 0).saturating_mul(p.into())) + // Standard Error: 3_433 + .saturating_add(Weight::from_parts(321_361, 0).saturating_mul(a.into())) + // Standard Error: 3_550 + .saturating_add(Weight::from_parts(36_466, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(3)) .saturating_add(T::DbWeight::get().writes(2)) } @@ -95,13 +95,13 @@ impl pallet_proxy::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `432 + a * (68 ±0)` // Estimated: `5698` - // Minimum execution time: 23_471_000 picoseconds. - Weight::from_parts(24_712_512, 0) + // Minimum execution time: 42_224_000 picoseconds. + Weight::from_parts(44_250_223, 0) .saturating_add(Weight::from_parts(0, 5698)) - // Standard Error: 6_956 - .saturating_add(Weight::from_parts(142_549, 0).saturating_mul(a.into())) - // Standard Error: 7_192 - .saturating_add(Weight::from_parts(10_000, 0).saturating_mul(p.into())) + // Standard Error: 2_217 + .saturating_add(Weight::from_parts(195_483, 0).saturating_mul(a.into())) + // Standard Error: 2_292 + .saturating_add(Weight::from_parts(736, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) } @@ -115,11 +115,11 @@ impl pallet_proxy::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `432 + a * (68 ±0)` // Estimated: `5698` - // Minimum execution time: 23_177_000 picoseconds. - Weight::from_parts(26_786_710, 0) + // Minimum execution time: 41_826_000 picoseconds. + Weight::from_parts(43_174_969, 0) .saturating_add(Weight::from_parts(0, 5698)) - // Standard Error: 6_878 - .saturating_add(Weight::from_parts(74_968, 0).saturating_mul(a.into())) + // Standard Error: 2_565 + .saturating_add(Weight::from_parts(250_645, 0).saturating_mul(a.into())) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) } @@ -135,13 +135,13 @@ impl pallet_proxy::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `449 + a * (68 ±0) + p * (37 ±0)` // Estimated: `5698` - // Minimum execution time: 31_607_000 picoseconds. - Weight::from_parts(32_110_068, 0) + // Minimum execution time: 56_561_000 picoseconds. + Weight::from_parts(55_724_861, 0) .saturating_add(Weight::from_parts(0, 5698)) - // Standard Error: 5_438 - .saturating_add(Weight::from_parts(166_689, 0).saturating_mul(a.into())) - // Standard Error: 5_623 - .saturating_add(Weight::from_parts(57_727, 0).saturating_mul(p.into())) + // Standard Error: 3_032 + .saturating_add(Weight::from_parts(258_289, 0).saturating_mul(a.into())) + // Standard Error: 3_135 + .saturating_add(Weight::from_parts(56_614, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(3)) .saturating_add(T::DbWeight::get().writes(2)) } @@ -152,11 +152,11 @@ impl pallet_proxy::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `227 + p * (37 ±0)` // Estimated: `4706` - // Minimum execution time: 23_415_000 picoseconds. - Weight::from_parts(24_296_550, 0) + // Minimum execution time: 41_213_000 picoseconds. + Weight::from_parts(42_122_630, 0) .saturating_add(Weight::from_parts(0, 4706)) - // Standard Error: 3_820 - .saturating_add(Weight::from_parts(65_159, 0).saturating_mul(p.into())) + // Standard Error: 2_396 + .saturating_add(Weight::from_parts(94_516, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } @@ -167,11 +167,11 @@ impl pallet_proxy::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `227 + p * (37 ±0)` // Estimated: `4706` - // Minimum execution time: 23_627_000 picoseconds. - Weight::from_parts(24_584_721, 0) + // Minimum execution time: 41_338_000 picoseconds. + Weight::from_parts(42_838_678, 0) .saturating_add(Weight::from_parts(0, 4706)) - // Standard Error: 2_510 - .saturating_add(Weight::from_parts(79_889, 0).saturating_mul(p.into())) + // Standard Error: 2_566 + .saturating_add(Weight::from_parts(73_194, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } @@ -182,11 +182,11 @@ impl pallet_proxy::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `227 + p * (37 ±0)` // Estimated: `4706` - // Minimum execution time: 20_903_000 picoseconds. - Weight::from_parts(21_695_859, 0) + // Minimum execution time: 36_643_000 picoseconds. + Weight::from_parts(37_704_386, 0) .saturating_add(Weight::from_parts(0, 4706)) - // Standard Error: 2_780 - .saturating_add(Weight::from_parts(68_100, 0).saturating_mul(p.into())) + // Standard Error: 2_058 + .saturating_add(Weight::from_parts(81_689, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } @@ -197,11 +197,11 @@ impl pallet_proxy::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `239` // Estimated: `4706` - // Minimum execution time: 24_812_000 picoseconds. - Weight::from_parts(26_101_401, 0) + // Minimum execution time: 45_453_000 picoseconds. + Weight::from_parts(46_635_056, 0) .saturating_add(Weight::from_parts(0, 4706)) - // Standard Error: 2_911 - .saturating_add(Weight::from_parts(25_085, 0).saturating_mul(p.into())) + // Standard Error: 1_906 + .saturating_add(Weight::from_parts(17_080, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } @@ -212,11 +212,11 @@ impl pallet_proxy::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `264 + p * (37 ±0)` // Estimated: `4706` - // Minimum execution time: 21_522_000 picoseconds. - Weight::from_parts(22_686_604, 0) + // Minimum execution time: 39_279_000 picoseconds. + Weight::from_parts(40_644_439, 0) .saturating_add(Weight::from_parts(0, 4706)) - // Standard Error: 6_847 - .saturating_add(Weight::from_parts(65_146, 0).saturating_mul(p.into())) + // Standard Error: 2_009 + .saturating_add(Weight::from_parts(97_802, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } diff --git a/runtime/paseo/src/weights/pallet_scheduler.rs b/runtime/paseo/src/weights/pallet_scheduler.rs index 3e81d948a2..7e20e13e5d 100644 --- a/runtime/paseo/src/weights/pallet_scheduler.rs +++ b/runtime/paseo/src/weights/pallet_scheduler.rs @@ -17,16 +17,16 @@ //! Autogenerated weights for `pallet_scheduler` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2024-08-28, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-09-16, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` //! HOSTNAME: `litentry-benchmark-server`, CPU: `Intel(R) Xeon(R) CPU E5-2686 v4 @ 2.30GHz` -//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("rococo-dev")`, DB CACHE: 20 +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("paseo-dev")`, DB CACHE: 20 // Executed Command: // ./litentry-collator // benchmark // pallet -// --chain=rococo-dev +// --chain=paseo-dev // --execution=wasm // --db-cache=20 // --wasm-execution=compiled @@ -36,7 +36,7 @@ // --steps=20 // --repeat=50 // --header=./LICENSE_HEADER -// --output=./runtime/rococo/src/weights/pallet_scheduler.rs +// --output=./runtime/paseo/src/weights/pallet_scheduler.rs #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(unused_parens)] @@ -55,8 +55,8 @@ impl pallet_scheduler::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `31` // Estimated: `1489` - // Minimum execution time: 3_869_000 picoseconds. - Weight::from_parts(4_010_000, 0) + // Minimum execution time: 7_502_000 picoseconds. + Weight::from_parts(7_737_000, 0) .saturating_add(Weight::from_parts(0, 1489)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) @@ -68,11 +68,11 @@ impl pallet_scheduler::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `78 + s * (177 ±0)` // Estimated: `42428` - // Minimum execution time: 3_440_000 picoseconds. - Weight::from_parts(5_369_165, 0) + // Minimum execution time: 6_997_000 picoseconds. + Weight::from_parts(11_366_456, 0) .saturating_add(Weight::from_parts(0, 42428)) - // Standard Error: 3_419 - .saturating_add(Weight::from_parts(818_093, 0).saturating_mul(s.into())) + // Standard Error: 3_284 + .saturating_add(Weight::from_parts(1_156_071, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } @@ -80,8 +80,8 @@ impl pallet_scheduler::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 5_651_000 picoseconds. - Weight::from_parts(5_887_000, 0) + // Minimum execution time: 11_220_000 picoseconds. + Weight::from_parts(11_631_000, 0) .saturating_add(Weight::from_parts(0, 0)) } /// Storage: `Preimage::PreimageFor` (r:1 w:1) @@ -93,11 +93,11 @@ impl pallet_scheduler::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `213 + s * (1 ±0)` // Estimated: `3677 + s * (1 ±0)` - // Minimum execution time: 19_927_000 picoseconds. - Weight::from_parts(20_384_000, 0) + // Minimum execution time: 36_915_000 picoseconds. + Weight::from_parts(37_353_000, 0) .saturating_add(Weight::from_parts(0, 3677)) - // Standard Error: 19 - .saturating_add(Weight::from_parts(1_763, 0).saturating_mul(s.into())) + // Standard Error: 12 + .saturating_add(Weight::from_parts(1_911, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) .saturating_add(Weight::from_parts(0, 1).saturating_mul(s.into())) @@ -108,8 +108,8 @@ impl pallet_scheduler::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_855_000 picoseconds. - Weight::from_parts(7_307_000, 0) + // Minimum execution time: 13_796_000 picoseconds. + Weight::from_parts(14_377_000, 0) .saturating_add(Weight::from_parts(0, 0)) .saturating_add(T::DbWeight::get().writes(1)) } @@ -117,24 +117,24 @@ impl pallet_scheduler::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 5_769_000 picoseconds. - Weight::from_parts(6_026_000, 0) + // Minimum execution time: 11_387_000 picoseconds. + Weight::from_parts(11_655_000, 0) .saturating_add(Weight::from_parts(0, 0)) } fn execute_dispatch_signed() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_738_000 picoseconds. - Weight::from_parts(2_845_000, 0) + // Minimum execution time: 5_585_000 picoseconds. + Weight::from_parts(5_954_000, 0) .saturating_add(Weight::from_parts(0, 0)) } fn execute_dispatch_unsigned() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_722_000 picoseconds. - Weight::from_parts(2_850_000, 0) + // Minimum execution time: 5_569_000 picoseconds. + Weight::from_parts(5_925_000, 0) .saturating_add(Weight::from_parts(0, 0)) } /// Storage: `Scheduler::Agenda` (r:1 w:1) @@ -144,11 +144,11 @@ impl pallet_scheduler::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `78 + s * (177 ±0)` // Estimated: `42428` - // Minimum execution time: 11_643_000 picoseconds. - Weight::from_parts(14_146_402, 0) + // Minimum execution time: 24_403_000 picoseconds. + Weight::from_parts(28_973_616, 0) .saturating_add(Weight::from_parts(0, 42428)) - // Standard Error: 4_946 - .saturating_add(Weight::from_parts(869_859, 0).saturating_mul(s.into())) + // Standard Error: 3_540 + .saturating_add(Weight::from_parts(1_206_342, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } @@ -161,11 +161,11 @@ impl pallet_scheduler::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `78 + s * (177 ±0)` // Estimated: `42428` - // Minimum execution time: 16_273_000 picoseconds. - Weight::from_parts(14_733_434, 0) + // Minimum execution time: 32_321_000 picoseconds. + Weight::from_parts(30_450_250, 0) .saturating_add(Weight::from_parts(0, 42428)) - // Standard Error: 8_832 - .saturating_add(Weight::from_parts(1_568_387, 0).saturating_mul(s.into())) + // Standard Error: 2_667 + .saturating_add(Weight::from_parts(2_096_916, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(2)) } @@ -178,11 +178,11 @@ impl pallet_scheduler::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `230 + s * (186 ±0)` // Estimated: `42428` - // Minimum execution time: 15_357_000 picoseconds. - Weight::from_parts(20_257_339, 0) + // Minimum execution time: 30_790_000 picoseconds. + Weight::from_parts(36_168_463, 0) .saturating_add(Weight::from_parts(0, 42428)) - // Standard Error: 8_159 - .saturating_add(Weight::from_parts(854_396, 0).saturating_mul(s.into())) + // Standard Error: 4_468 + .saturating_add(Weight::from_parts(1_275_736, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) } @@ -195,11 +195,11 @@ impl pallet_scheduler::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `282 + s * (185 ±0)` // Estimated: `42428` - // Minimum execution time: 18_198_000 picoseconds. - Weight::from_parts(17_254_480, 0) + // Minimum execution time: 34_788_000 picoseconds. + Weight::from_parts(33_786_761, 0) .saturating_add(Weight::from_parts(0, 42428)) - // Standard Error: 8_061 - .saturating_add(Weight::from_parts(1_591_237, 0).saturating_mul(s.into())) + // Standard Error: 3_069 + .saturating_add(Weight::from_parts(2_157_543, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) } diff --git a/runtime/paseo/src/weights/pallet_session.rs b/runtime/paseo/src/weights/pallet_session.rs index bbe6be4004..c5d30394b4 100644 --- a/runtime/paseo/src/weights/pallet_session.rs +++ b/runtime/paseo/src/weights/pallet_session.rs @@ -17,16 +17,16 @@ //! Autogenerated weights for `pallet_session` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2024-08-28, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-09-16, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` //! HOSTNAME: `litentry-benchmark-server`, CPU: `Intel(R) Xeon(R) CPU E5-2686 v4 @ 2.30GHz` -//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("rococo-dev")`, DB CACHE: 20 +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("paseo-dev")`, DB CACHE: 20 // Executed Command: // ./litentry-collator // benchmark // pallet -// --chain=rococo-dev +// --chain=paseo-dev // --execution=wasm // --db-cache=20 // --wasm-execution=compiled @@ -36,7 +36,7 @@ // --steps=20 // --repeat=50 // --header=./LICENSE_HEADER -// --output=./runtime/rococo/src/weights/pallet_session.rs +// --output=./runtime/paseo/src/weights/pallet_session.rs #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(unused_parens)] @@ -57,8 +57,8 @@ impl pallet_session::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `271` // Estimated: `3736` - // Minimum execution time: 15_933_000 picoseconds. - Weight::from_parts(16_633_000, 0) + // Minimum execution time: 29_128_000 picoseconds. + Weight::from_parts(29_789_000, 0) .saturating_add(Weight::from_parts(0, 3736)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) @@ -71,8 +71,8 @@ impl pallet_session::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `243` // Estimated: `3708` - // Minimum execution time: 11_374_000 picoseconds. - Weight::from_parts(11_780_000, 0) + // Minimum execution time: 21_549_000 picoseconds. + Weight::from_parts(22_112_000, 0) .saturating_add(Weight::from_parts(0, 3708)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(2)) diff --git a/runtime/paseo/src/weights/pallet_teebag.rs b/runtime/paseo/src/weights/pallet_teebag.rs index 9501805770..98ece26601 100644 --- a/runtime/paseo/src/weights/pallet_teebag.rs +++ b/runtime/paseo/src/weights/pallet_teebag.rs @@ -17,16 +17,16 @@ //! Autogenerated weights for `pallet_teebag` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2024-08-28, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-09-16, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` //! HOSTNAME: `litentry-benchmark-server`, CPU: `Intel(R) Xeon(R) CPU E5-2686 v4 @ 2.30GHz` -//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("rococo-dev")`, DB CACHE: 20 +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("paseo-dev")`, DB CACHE: 20 // Executed Command: // ./litentry-collator // benchmark // pallet -// --chain=rococo-dev +// --chain=paseo-dev // --execution=wasm // --db-cache=20 // --wasm-execution=compiled @@ -36,7 +36,7 @@ // --steps=20 // --repeat=50 // --header=./LICENSE_HEADER -// --output=./runtime/rococo/src/weights/pallet_teebag.rs +// --output=./runtime/paseo/src/weights/pallet_teebag.rs #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(unused_parens)] @@ -57,8 +57,8 @@ impl pallet_teebag::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `213` // Estimated: `3678` - // Minimum execution time: 14_943_000 picoseconds. - Weight::from_parts(15_537_000, 0) + // Minimum execution time: 28_584_000 picoseconds. + Weight::from_parts(29_273_000, 0) .saturating_add(Weight::from_parts(0, 3678)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) @@ -71,8 +71,8 @@ impl pallet_teebag::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `541` // Estimated: `4006` - // Minimum execution time: 18_467_000 picoseconds. - Weight::from_parts(19_230_000, 0) + // Minimum execution time: 35_243_000 picoseconds. + Weight::from_parts(36_142_000, 0) .saturating_add(Weight::from_parts(0, 4006)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) @@ -85,8 +85,8 @@ impl pallet_teebag::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `720` // Estimated: `11610` - // Minimum execution time: 46_203_000 picoseconds. - Weight::from_parts(47_696_000, 0) + // Minimum execution time: 83_651_000 picoseconds. + Weight::from_parts(84_822_000, 0) .saturating_add(Weight::from_parts(0, 11610)) .saturating_add(T::DbWeight::get().reads(5)) .saturating_add(T::DbWeight::get().writes(4)) @@ -99,8 +99,8 @@ impl pallet_teebag::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `720` // Estimated: `11610` - // Minimum execution time: 46_312_000 picoseconds. - Weight::from_parts(50_255_000, 0) + // Minimum execution time: 83_181_000 picoseconds. + Weight::from_parts(84_893_000, 0) .saturating_add(Weight::from_parts(0, 11610)) .saturating_add(T::DbWeight::get().reads(5)) .saturating_add(T::DbWeight::get().writes(4)) @@ -111,8 +111,8 @@ impl pallet_teebag::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `383` // Estimated: `3848` - // Minimum execution time: 12_701_000 picoseconds. - Weight::from_parts(13_163_000, 0) + // Minimum execution time: 24_613_000 picoseconds. + Weight::from_parts(25_577_000, 0) .saturating_add(Weight::from_parts(0, 3848)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) @@ -125,8 +125,8 @@ impl pallet_teebag::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `415` // Estimated: `3880` - // Minimum execution time: 17_704_000 picoseconds. - Weight::from_parts(18_234_000, 0) + // Minimum execution time: 36_110_000 picoseconds. + Weight::from_parts(36_794_000, 0) .saturating_add(Weight::from_parts(0, 3880)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(1)) @@ -145,8 +145,8 @@ impl pallet_teebag::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `427` // Estimated: `3892` - // Minimum execution time: 1_571_568_000 picoseconds. - Weight::from_parts(1_649_222_000, 0) + // Minimum execution time: 2_560_292_000 picoseconds. + Weight::from_parts(2_579_017_000, 0) .saturating_add(Weight::from_parts(0, 3892)) .saturating_add(T::DbWeight::get().reads(5)) .saturating_add(T::DbWeight::get().writes(3)) @@ -169,8 +169,8 @@ impl pallet_teebag::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `644` // Estimated: `4109` - // Minimum execution time: 3_397_776_000 picoseconds. - Weight::from_parts(4_248_064_000, 0) + // Minimum execution time: 4_615_785_000 picoseconds. + Weight::from_parts(4_626_005_000, 0) .saturating_add(Weight::from_parts(0, 4109)) .saturating_add(T::DbWeight::get().reads(7)) .saturating_add(T::DbWeight::get().writes(3)) @@ -183,8 +183,8 @@ impl pallet_teebag::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `458` // Estimated: `3923` - // Minimum execution time: 19_744_000 picoseconds. - Weight::from_parts(22_575_000, 0) + // Minimum execution time: 36_416_000 picoseconds. + Weight::from_parts(37_001_000, 0) .saturating_add(Weight::from_parts(0, 3923)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) @@ -197,8 +197,8 @@ impl pallet_teebag::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `94` // Estimated: `1493` - // Minimum execution time: 1_654_144_000 picoseconds. - Weight::from_parts(1_720_747_000, 0) + // Minimum execution time: 2_302_811_000 picoseconds. + Weight::from_parts(2_325_140_000, 0) .saturating_add(Weight::from_parts(0, 1493)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) @@ -211,8 +211,8 @@ impl pallet_teebag::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `94` // Estimated: `1493` - // Minimum execution time: 1_811_473_000 picoseconds. - Weight::from_parts(2_399_065_000, 0) + // Minimum execution time: 2_511_912_000 picoseconds. + Weight::from_parts(2_535_270_000, 0) .saturating_add(Weight::from_parts(0, 1493)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) @@ -221,8 +221,8 @@ impl pallet_teebag::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 7_031_000 picoseconds. - Weight::from_parts(7_338_000, 0) + // Minimum execution time: 13_562_000 picoseconds. + Weight::from_parts(14_076_000, 0) .saturating_add(Weight::from_parts(0, 0)) } /// Storage: `Teebag::EnclaveRegistry` (r:1 w:0) @@ -233,8 +233,8 @@ impl pallet_teebag::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `407` // Estimated: `3872` - // Minimum execution time: 15_448_000 picoseconds. - Weight::from_parts(15_950_000, 0) + // Minimum execution time: 29_184_000 picoseconds. + Weight::from_parts(29_809_000, 0) .saturating_add(Weight::from_parts(0, 3872)) .saturating_add(T::DbWeight::get().reads(2)) } @@ -252,8 +252,8 @@ impl pallet_teebag::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `528` // Estimated: `3993` - // Minimum execution time: 24_642_000 picoseconds. - Weight::from_parts(25_438_000, 0) + // Minimum execution time: 44_031_000 picoseconds. + Weight::from_parts(45_148_000, 0) .saturating_add(Weight::from_parts(0, 3993)) .saturating_add(T::DbWeight::get().reads(4)) .saturating_add(T::DbWeight::get().writes(2)) diff --git a/runtime/paseo/src/weights/pallet_timestamp.rs b/runtime/paseo/src/weights/pallet_timestamp.rs index 323233f684..49ca034892 100644 --- a/runtime/paseo/src/weights/pallet_timestamp.rs +++ b/runtime/paseo/src/weights/pallet_timestamp.rs @@ -17,16 +17,16 @@ //! Autogenerated weights for `pallet_timestamp` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2024-08-28, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-09-16, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` //! HOSTNAME: `litentry-benchmark-server`, CPU: `Intel(R) Xeon(R) CPU E5-2686 v4 @ 2.30GHz` -//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("rococo-dev")`, DB CACHE: 20 +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("paseo-dev")`, DB CACHE: 20 // Executed Command: // ./litentry-collator // benchmark // pallet -// --chain=rococo-dev +// --chain=paseo-dev // --execution=wasm // --db-cache=20 // --wasm-execution=compiled @@ -36,7 +36,7 @@ // --steps=20 // --repeat=50 // --header=./LICENSE_HEADER -// --output=./runtime/rococo/src/weights/pallet_timestamp.rs +// --output=./runtime/paseo/src/weights/pallet_timestamp.rs #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(unused_parens)] @@ -55,8 +55,8 @@ impl pallet_timestamp::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `42` // Estimated: `1493` - // Minimum execution time: 6_526_000 picoseconds. - Weight::from_parts(6_951_000, 0) + // Minimum execution time: 13_225_000 picoseconds. + Weight::from_parts(13_534_000, 0) .saturating_add(Weight::from_parts(0, 1493)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) @@ -65,8 +65,8 @@ impl pallet_timestamp::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `94` // Estimated: `0` - // Minimum execution time: 4_045_000 picoseconds. - Weight::from_parts(4_268_000, 0) + // Minimum execution time: 7_324_000 picoseconds. + Weight::from_parts(7_573_000, 0) .saturating_add(Weight::from_parts(0, 0)) } } diff --git a/runtime/paseo/src/weights/pallet_treasury.rs b/runtime/paseo/src/weights/pallet_treasury.rs index 69feb64575..1b89ae4e2d 100644 --- a/runtime/paseo/src/weights/pallet_treasury.rs +++ b/runtime/paseo/src/weights/pallet_treasury.rs @@ -17,16 +17,16 @@ //! Autogenerated weights for `pallet_treasury` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2024-08-28, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-09-16, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` //! HOSTNAME: `litentry-benchmark-server`, CPU: `Intel(R) Xeon(R) CPU E5-2686 v4 @ 2.30GHz` -//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("rococo-dev")`, DB CACHE: 20 +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("paseo-dev")`, DB CACHE: 20 // Executed Command: // ./litentry-collator // benchmark // pallet -// --chain=rococo-dev +// --chain=paseo-dev // --execution=wasm // --db-cache=20 // --wasm-execution=compiled @@ -36,7 +36,7 @@ // --steps=20 // --repeat=50 // --header=./LICENSE_HEADER -// --output=./runtime/rococo/src/weights/pallet_treasury.rs +// --output=./runtime/paseo/src/weights/pallet_treasury.rs #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(unused_parens)] @@ -59,8 +59,8 @@ impl pallet_treasury::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `80` // Estimated: `1887` - // Minimum execution time: 15_111_000 picoseconds. - Weight::from_parts(15_455_000, 0) + // Minimum execution time: 28_955_000 picoseconds. + Weight::from_parts(29_697_000, 0) .saturating_add(Weight::from_parts(0, 1887)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(3)) @@ -73,8 +73,8 @@ impl pallet_treasury::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `181` // Estimated: `1489` - // Minimum execution time: 27_711_000 picoseconds. - Weight::from_parts(28_843_000, 0) + // Minimum execution time: 49_043_000 picoseconds. + Weight::from_parts(50_153_000, 0) .saturating_add(Weight::from_parts(0, 1489)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(2)) @@ -87,8 +87,8 @@ impl pallet_treasury::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `442` // Estimated: `6196` - // Minimum execution time: 43_181_000 picoseconds. - Weight::from_parts(44_547_000, 0) + // Minimum execution time: 71_840_000 picoseconds. + Weight::from_parts(73_078_000, 0) .saturating_add(Weight::from_parts(0, 6196)) .saturating_add(T::DbWeight::get().reads(3)) .saturating_add(T::DbWeight::get().writes(3)) @@ -102,11 +102,11 @@ impl pallet_treasury::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `486 + p * (9 ±0)` // Estimated: `3573` - // Minimum execution time: 9_814_000 picoseconds. - Weight::from_parts(12_878_486, 0) + // Minimum execution time: 19_575_000 picoseconds. + Weight::from_parts(25_049_039, 0) .saturating_add(Weight::from_parts(0, 3573)) - // Standard Error: 1_792 - .saturating_add(Weight::from_parts(107_787, 0).saturating_mul(p.into())) + // Standard Error: 2_149 + .saturating_add(Weight::from_parts(72_653, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(1)) } @@ -116,8 +116,8 @@ impl pallet_treasury::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `165` // Estimated: `1887` - // Minimum execution time: 7_677_000 picoseconds. - Weight::from_parts(7_922_000, 0) + // Minimum execution time: 14_970_000 picoseconds. + Weight::from_parts(15_582_000, 0) .saturating_add(Weight::from_parts(0, 1887)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) @@ -137,11 +137,11 @@ impl pallet_treasury::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `149 + p * (252 ±0)` // Estimated: `3593 + p * (5206 ±0)` - // Minimum execution time: 31_474_000 picoseconds. - Weight::from_parts(32_241_000, 0) + // Minimum execution time: 53_120_000 picoseconds. + Weight::from_parts(66_095_398, 0) .saturating_add(Weight::from_parts(0, 3593)) - // Standard Error: 222_050 - .saturating_add(Weight::from_parts(53_985_901, 0).saturating_mul(p.into())) + // Standard Error: 22_050 + .saturating_add(Weight::from_parts(60_736_041, 0).saturating_mul(p.into())) .saturating_add(T::DbWeight::get().reads(4)) .saturating_add(T::DbWeight::get().reads((3_u64).saturating_mul(p.into()))) .saturating_add(T::DbWeight::get().writes(4)) diff --git a/runtime/paseo/src/weights/pallet_utility.rs b/runtime/paseo/src/weights/pallet_utility.rs index 2426e338cc..ecb5eef39a 100644 --- a/runtime/paseo/src/weights/pallet_utility.rs +++ b/runtime/paseo/src/weights/pallet_utility.rs @@ -17,16 +17,16 @@ //! Autogenerated weights for `pallet_utility` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2024-08-28, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-09-16, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` //! HOSTNAME: `litentry-benchmark-server`, CPU: `Intel(R) Xeon(R) CPU E5-2686 v4 @ 2.30GHz` -//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("rococo-dev")`, DB CACHE: 20 +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("paseo-dev")`, DB CACHE: 20 // Executed Command: // ./litentry-collator // benchmark // pallet -// --chain=rococo-dev +// --chain=paseo-dev // --execution=wasm // --db-cache=20 // --wasm-execution=compiled @@ -36,7 +36,7 @@ // --steps=20 // --repeat=50 // --header=./LICENSE_HEADER -// --output=./runtime/rococo/src/weights/pallet_utility.rs +// --output=./runtime/paseo/src/weights/pallet_utility.rs #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(unused_parens)] @@ -54,18 +54,18 @@ impl pallet_utility::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_462_000 picoseconds. - Weight::from_parts(6_692_000, 0) + // Minimum execution time: 13_457_000 picoseconds. + Weight::from_parts(23_880_710, 0) .saturating_add(Weight::from_parts(0, 0)) - // Standard Error: 21_648 - .saturating_add(Weight::from_parts(6_706_710, 0).saturating_mul(c.into())) + // Standard Error: 3_382 + .saturating_add(Weight::from_parts(7_511_669, 0).saturating_mul(c.into())) } fn as_derivative() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 4_500_000 picoseconds. - Weight::from_parts(4_824_000, 0) + // Minimum execution time: 9_481_000 picoseconds. + Weight::from_parts(9_789_000, 0) .saturating_add(Weight::from_parts(0, 0)) } /// The range of component `c` is `[0, 1000]`. @@ -73,18 +73,18 @@ impl pallet_utility::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_600_000 picoseconds. - Weight::from_parts(7_067_000, 0) + // Minimum execution time: 13_210_000 picoseconds. + Weight::from_parts(29_499_585, 0) .saturating_add(Weight::from_parts(0, 0)) - // Standard Error: 21_698 - .saturating_add(Weight::from_parts(6_985_924, 0).saturating_mul(c.into())) + // Standard Error: 2_988 + .saturating_add(Weight::from_parts(7_920_940, 0).saturating_mul(c.into())) } fn dispatch_as() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 8_567_000 picoseconds. - Weight::from_parts(9_046_000, 0) + // Minimum execution time: 16_914_000 picoseconds. + Weight::from_parts(17_373_000, 0) .saturating_add(Weight::from_parts(0, 0)) } /// The range of component `c` is `[0, 1000]`. @@ -92,10 +92,10 @@ impl pallet_utility::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 6_552_000 picoseconds. - Weight::from_parts(6_747_000, 0) + // Minimum execution time: 13_422_000 picoseconds. + Weight::from_parts(24_241_884, 0) .saturating_add(Weight::from_parts(0, 0)) - // Standard Error: 22_937 - .saturating_add(Weight::from_parts(6_700_953, 0).saturating_mul(c.into())) + // Standard Error: 2_116 + .saturating_add(Weight::from_parts(7_489_440, 0).saturating_mul(c.into())) } } diff --git a/runtime/paseo/src/weights/pallet_vc_management.rs b/runtime/paseo/src/weights/pallet_vc_management.rs index 3c9323f0c2..aba5774998 100644 --- a/runtime/paseo/src/weights/pallet_vc_management.rs +++ b/runtime/paseo/src/weights/pallet_vc_management.rs @@ -17,16 +17,16 @@ //! Autogenerated weights for `pallet_vc_management` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2024-08-28, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-09-16, STEPS: `20`, REPEAT: `50`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` //! HOSTNAME: `litentry-benchmark-server`, CPU: `Intel(R) Xeon(R) CPU E5-2686 v4 @ 2.30GHz` -//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("rococo-dev")`, DB CACHE: 20 +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("paseo-dev")`, DB CACHE: 20 // Executed Command: // ./litentry-collator // benchmark // pallet -// --chain=rococo-dev +// --chain=paseo-dev // --execution=wasm // --db-cache=20 // --wasm-execution=compiled @@ -36,7 +36,7 @@ // --steps=20 // --repeat=50 // --header=./LICENSE_HEADER -// --output=./runtime/rococo/src/weights/pallet_vc_management.rs +// --output=./runtime/paseo/src/weights/pallet_vc_management.rs #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(unused_parens)] @@ -55,8 +55,8 @@ impl pallet_vc_management::WeightInfo for WeightInfo // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 8_151_000 picoseconds. - Weight::from_parts(8_591_000, 0) + // Minimum execution time: 15_743_000 picoseconds. + Weight::from_parts(16_368_000, 0) .saturating_add(Weight::from_parts(0, 0)) .saturating_add(T::DbWeight::get().writes(1)) } @@ -66,8 +66,8 @@ impl pallet_vc_management::WeightInfo for WeightInfo // Proof Size summary in bytes: // Measured: `113` // Estimated: `3513` - // Minimum execution time: 12_524_000 picoseconds. - Weight::from_parts(12_831_000, 0) + // Minimum execution time: 23_073_000 picoseconds. + Weight::from_parts(23_754_000, 0) .saturating_add(Weight::from_parts(0, 3513)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) @@ -78,8 +78,8 @@ impl pallet_vc_management::WeightInfo for WeightInfo // Proof Size summary in bytes: // Measured: `6` // Estimated: `1491` - // Minimum execution time: 9_407_000 picoseconds. - Weight::from_parts(9_800_000, 0) + // Minimum execution time: 17_033_000 picoseconds. + Weight::from_parts(17_442_000, 0) .saturating_add(Weight::from_parts(0, 1491)) .saturating_add(T::DbWeight::get().reads(1)) } @@ -89,8 +89,8 @@ impl pallet_vc_management::WeightInfo for WeightInfo // Proof Size summary in bytes: // Measured: `347` // Estimated: `3812` - // Minimum execution time: 12_659_000 picoseconds. - Weight::from_parts(13_134_000, 0) + // Minimum execution time: 23_719_000 picoseconds. + Weight::from_parts(24_315_000, 0) .saturating_add(Weight::from_parts(0, 3812)) .saturating_add(T::DbWeight::get().reads(1)) } @@ -100,8 +100,8 @@ impl pallet_vc_management::WeightInfo for WeightInfo // Proof Size summary in bytes: // Measured: `347` // Estimated: `3812` - // Minimum execution time: 12_419_000 picoseconds. - Weight::from_parts(12_933_000, 0) + // Minimum execution time: 23_801_000 picoseconds. + Weight::from_parts(24_361_000, 0) .saturating_add(Weight::from_parts(0, 3812)) .saturating_add(T::DbWeight::get().reads(1)) } @@ -111,8 +111,8 @@ impl pallet_vc_management::WeightInfo for WeightInfo // Proof Size summary in bytes: // Measured: `61` // Estimated: `1517` - // Minimum execution time: 10_226_000 picoseconds. - Weight::from_parts(10_824_000, 0) + // Minimum execution time: 19_444_000 picoseconds. + Weight::from_parts(19_934_000, 0) .saturating_add(Weight::from_parts(0, 1517)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) @@ -127,8 +127,8 @@ impl pallet_vc_management::WeightInfo for WeightInfo // Proof Size summary in bytes: // Measured: `61` // Estimated: `1517` - // Minimum execution time: 13_987_000 picoseconds. - Weight::from_parts(14_507_000, 0) + // Minimum execution time: 25_712_000 picoseconds. + Weight::from_parts(26_452_000, 0) .saturating_add(Weight::from_parts(0, 1517)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) @@ -141,8 +141,8 @@ impl pallet_vc_management::WeightInfo for WeightInfo // Proof Size summary in bytes: // Measured: `179` // Estimated: `6086` - // Minimum execution time: 14_696_000 picoseconds. - Weight::from_parts(15_262_000, 0) + // Minimum execution time: 26_911_000 picoseconds. + Weight::from_parts(27_426_000, 0) .saturating_add(Weight::from_parts(0, 6086)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(1)) @@ -155,8 +155,8 @@ impl pallet_vc_management::WeightInfo for WeightInfo // Proof Size summary in bytes: // Measured: `179` // Estimated: `6086` - // Minimum execution time: 14_553_000 picoseconds. - Weight::from_parts(15_289_000, 0) + // Minimum execution time: 26_612_000 picoseconds. + Weight::from_parts(27_407_000, 0) .saturating_add(Weight::from_parts(0, 6086)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(1)) @@ -169,8 +169,8 @@ impl pallet_vc_management::WeightInfo for WeightInfo // Proof Size summary in bytes: // Measured: `179` // Estimated: `6086` - // Minimum execution time: 15_129_000 picoseconds. - Weight::from_parts(15_648_000, 0) + // Minimum execution time: 27_075_000 picoseconds. + Weight::from_parts(27_804_000, 0) .saturating_add(Weight::from_parts(0, 6086)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(1))