diff --git a/.github/ISSUE_TEMPLATE/release.md b/.github/ISSUE_TEMPLATE/release.md index 80d473588..4254103f9 100644 --- a/.github/ISSUE_TEMPLATE/release.md +++ b/.github/ISSUE_TEMPLATE/release.md @@ -34,6 +34,7 @@ These checks should be performed on the codebase prior to freezing our release c - [ ] Check that a draft release has been created on the [release page](https://github.com/Manta-Network/Manta/releases) and add relevant [release notes](#release-notes) - [ ] Check that build artifacts have been added to the draft-release - [ ] Promote the draft to a Pre-Release on github + - [ ] If there's any new extrinsic or pallet introduced, please add it to [runtime/calamari/src/diff_tx_fees.rs](../../runtime/calamari/src/diff_tx_fees.rs), then follow [tx-fees-data/README](../../runtime/calamari/tx-fees-data/README.md) to generate a new tx fees sheet. # Deploy to internal testnets ( fast runtime ) diff --git a/Cargo.lock b/Cargo.lock index e0159eba2..2621ca629 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1097,6 +1097,7 @@ name = "calamari-runtime" version = "4.3.1" dependencies = [ "calamari-vesting", + "csv", "cumulus-pallet-dmp-queue", "cumulus-pallet-parachain-system", "cumulus-pallet-session-benchmarking", @@ -1185,6 +1186,7 @@ dependencies = [ "sp-version", "substrate-fixed 0.5.9 (git+https://github.com/Manta-Network/substrate-fixed.git)", "substrate-wasm-builder", + "version-compare", "xcm", "xcm-builder", "xcm-executor", @@ -1791,6 +1793,27 @@ dependencies = [ "subtle", ] +[[package]] +name = "csv" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b015497079b9a9d69c02ad25de6c0a6edef051ea6360a327d0bd05802ef64ad" +dependencies = [ + "csv-core", + "itoa", + "ryu", + "serde", +] + +[[package]] +name = "csv-core" +version = "0.1.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2b2466559f260f48ad25fe6317b3c8dac77b5bdb5763ac7d9d6103530663bc90" +dependencies = [ + "memchr", +] + [[package]] name = "ctr" version = "0.8.0" @@ -5493,6 +5516,7 @@ dependencies = [ name = "manta-runtime" version = "4.3.1" dependencies = [ + "csv", "cumulus-pallet-dmp-queue", "cumulus-pallet-parachain-system", "cumulus-pallet-session-benchmarking", @@ -5573,6 +5597,7 @@ dependencies = [ "sp-transaction-pool", "sp-version", "substrate-wasm-builder", + "version-compare", "xcm", "xcm-builder", "xcm-executor", @@ -13725,6 +13750,12 @@ version = "0.2.15" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426" +[[package]] +name = "version-compare" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "579a42fc0b8e0c63b76519a339be31bed574929511fa53c1a3acae26eb258f29" + [[package]] name = "version_check" version = "0.9.4" diff --git a/runtime/calamari/Cargo.toml b/runtime/calamari/Cargo.toml index f1ab6eb13..ace8b9053 100644 --- a/runtime/calamari/Cargo.toml +++ b/runtime/calamari/Cargo.toml @@ -121,9 +121,11 @@ substrate-wasm-builder = { git = 'https://github.com/paritytech/substrate.git', [dev-dependencies] # Generic 3rd-party dependencies +csv = "1.2.1" lazy_static = "1.4.0" reqwest = { version = "0.11.6", features = ["blocking"] } serde_json = "1.0" +version-compare = "0.1.1" # Substrate 3rd-party dependencies cumulus-primitives-parachain-inherent = { git = "https://github.com/paritytech/cumulus.git", branch = "polkadot-v0.9.37" } diff --git a/runtime/calamari/src/diff_tx_fees.rs b/runtime/calamari/src/diff_tx_fees.rs new file mode 100644 index 000000000..73a02a05d --- /dev/null +++ b/runtime/calamari/src/diff_tx_fees.rs @@ -0,0 +1,3156 @@ +// Copyright 2020-2023 Manta Network. +// This file is part of Manta. +// +// Manta 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. +// +// Manta 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 Manta. If not, see . + +#![cfg(test)] + +use crate::{Runtime, TransactionPayment}; +use codec::{Decode, Encode}; +use frame_support::{ + dispatch::{DispatchInfo, GetDispatchInfo}, + traits::{GetCallMetadata, OriginTrait, StorePreimage}, +}; +use manta_primitives::assets::{AssetRegistryMetadata, TestingDefault}; +use manta_support::manta_pay::TransferPost; +use pallet_transaction_payment::Multiplier; +use runtime_common::MinimumMultiplier; +use sp_runtime::{ + traits::{Saturating, Zero}, + AccountId32, FixedPointNumber, MultiAddress, Perbill, Percent, +}; +use std::str::FromStr; +use xcm::prelude::*; + +const TX_FEE_FLUCTUATION: Percent = Percent::from_percent(10); +const ALICE: AccountId32 = AccountId32::new([1u8; 32]); +const BOB: AccountId32 = AccountId32::new([2u8; 32]); + +#[derive(Debug, serde::Serialize, serde::Deserialize)] +struct TxFeeDetail { + module: String, + extrinsic: String, + tx_fee_with_decimal: String, + tx_fee_without_decimal: String, + fee_multiplier: String, +} + +fn fee_multipliers() -> [Multiplier; 3] { + [ + MinimumMultiplier::get(), // 0.0002 + Multiplier::saturating_from_rational(1, 5u128), // 0.2 + Multiplier::saturating_from_rational(1, 1u128), // 1.0 + ] +} + +fn get_call_details(call: &crate::RuntimeCall) -> (DispatchInfo, u32) { + let dispatch_info = + <::RuntimeCall as GetDispatchInfo>::get_dispatch_info( + call, + ); + let call_len = call.using_encoded(|e| e.len()) as u32; + (dispatch_info, call_len) +} + +#[test] +fn diff_tx_fees() { + const CURRENT_PATH: &str = env!("CARGO_MANIFEST_DIR"); + let mut latest_version = String::new(); + for file in std::fs::read_dir(format!("{CURRENT_PATH}/tx-fees-data")).unwrap() { + let _version = file + .unwrap() + .path() + .file_name() + .unwrap() + .to_str() + .unwrap() + .split("-tx-fees.csv") + .collect::>()[0] + .to_string(); + if _version.contains("README.md") { + continue; + } + let _version = version_compare::Version::from(&_version).unwrap(); + let version = version_compare::Version::from(&latest_version).unwrap(); + if version < _version { + latest_version = _version.to_string(); + } + } + let version = version_compare::Version::from(&latest_version).unwrap(); + let csv_path = format!("{CURRENT_PATH}/tx-fees-data/{version}-tx-fees.csv"); + let mut rdr = csv::Reader::from_path(csv_path).unwrap(); + + let (calamari_runtime_calls, mut test_runner) = calculate_all_current_extrinsic_tx_fee(); + + let mut last_release_tx_fees = rdr.deserialize().map(|e| { + let record: TxFeeDetail = e.unwrap(); + record + }); + + // check whether there's new pallet introduced + test_runner.execute_with(|| { + let opaque_metadata = crate::Runtime::metadata(); + let pallets = match opaque_metadata.1 { + frame_support::metadata::RuntimeMetadata::V14(metadata) => metadata.pallets, + _ => unreachable!(), + }; + assert_eq!(pallets.len(), 39); + }); + + let fee_multipliers = fee_multipliers(); + for multiplier in fee_multipliers { + test_runner.execute_with(|| { + pallet_transaction_payment::NextFeeMultiplier::::set(multiplier); + }); + test_runner.execute_with(|| { + for (pallet_name, extrinsic_name, dispatch_info, call_len) in calamari_runtime_calls.iter() + { + match last_release_tx_fees.find(|e| e.extrinsic.eq(extrinsic_name) && e.fee_multiplier.eq(&multiplier.to_float().to_string())) { + Some(found) => { + let _tx_fee_with_decimal = TransactionPayment::compute_fee(*call_len, dispatch_info, 0); + let tx_fee_with_decimal = Multiplier::from_str(&_tx_fee_with_decimal.to_string()).unwrap(); + let last_tx_fee = Multiplier::from_str(&found.tx_fee_with_decimal).unwrap(); + let fluctuation = { + let diff_value = tx_fee_with_decimal.saturating_sub(last_tx_fee).div(last_tx_fee); + if diff_value < Multiplier::zero() { + Percent::from_float(diff_value.neg().to_float()) + } else { + Percent::from_float(diff_value.to_float()) + } + }; + let _multiplier = found.fee_multiplier; + assert!(fluctuation <= TX_FEE_FLUCTUATION, "The tx fee fluctuation for the extrinsic {extrinsic_name} is {fluctuation:?}, bigger than {TX_FEE_FLUCTUATION:?} with multiplier {_multiplier}."); + } + None => panic!("The extrinsic {pallet_name}.{extrinsic_name} is missing from current tx fees list, please add it to latest csv file."), + } + } + }); + } +} + +#[test] +#[ignore] +fn generate_all_current_extrinsics_tx_fee_to_csv() { + const VERSION: &str = env!("CARGO_PKG_VERSION"); + const CURRENT_PATH: &str = env!("CARGO_MANIFEST_DIR"); + let csv_path = format!("{CURRENT_PATH}/tx-fees-data/{VERSION}-tx-fees.csv"); + + let mut wtr = csv::Writer::from_path(csv_path).unwrap(); + let (calamari_runtime_calls, mut test_runner) = calculate_all_current_extrinsic_tx_fee(); + + let fee_multipliers = fee_multipliers(); + let decimal: Multiplier = Multiplier::from_u32(10).saturating_pow(12); + + let mut all_extrinsics_tx_fees = vec![]; + for multiplier in fee_multipliers { + // set the multiplier + test_runner.execute_with(|| { + pallet_transaction_payment::NextFeeMultiplier::::set(multiplier); + }); + test_runner.execute_with(|| { + for (pallet_name, extrinsic_name, dispatch_info, call_len) in + calamari_runtime_calls.clone() + { + let tx_fee_with_decimal = + TransactionPayment::compute_fee(call_len, &dispatch_info, 0); + let tx_fee_without_decimal = Multiplier::try_from(tx_fee_with_decimal) + .unwrap() + .div(decimal) + .to_float(); + let tx_fee = TxFeeDetail { + module: pallet_name.to_owned(), + extrinsic: extrinsic_name.to_owned(), + tx_fee_with_decimal: tx_fee_with_decimal.to_string(), + tx_fee_without_decimal: tx_fee_without_decimal.to_string(), + fee_multiplier: multiplier.to_float().to_string(), + }; + all_extrinsics_tx_fees.push(tx_fee); + } + }); + } + + for extrinsic in all_extrinsics_tx_fees { + wtr.serialize(extrinsic).unwrap(); + } + wtr.flush().unwrap(); +} + +fn calculate_all_current_extrinsic_tx_fee() -> ( + Vec<(&'static str, &'static str, DispatchInfo, u32)>, + sp_io::TestExternalities, +) { + let mut t: sp_io::TestExternalities = frame_system::GenesisConfig::default() + .build_storage::() + .unwrap() + .into(); + + let mut calamari_runtime_calls = vec![]; + // frame_system + { + assert_eq!( + crate::RuntimeCall::get_call_names("System").len(), + 8, + "Please update new extrinsic here." + ); + // remark, which length is 32 + let call = crate::RuntimeCall::System(frame_system::Call::remark { + remark: vec![1u8; 32], + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("frame_system", "remark-length=32", dispatch_info, call_len)); + + // remark, which length is 64 + let call = crate::RuntimeCall::System(frame_system::Call::remark { + remark: vec![1u8; 32], + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("frame_system", "remark-length=64", dispatch_info, call_len)); + + // set_heap_pages + let call = crate::RuntimeCall::System(frame_system::Call::set_heap_pages { pages: 64 }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("frame_system", "set_heap_pages", dispatch_info, call_len)); + + // set_code + let call = crate::RuntimeCall::System(frame_system::Call::set_code { + code: vec![1u8; 32], + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("frame_system", "set_code", dispatch_info, call_len)); + + // set_code_without_checks + let call = crate::RuntimeCall::System(frame_system::Call::set_code_without_checks { + code: vec![1u8; 32], + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "frame_system", + "set_code_without_checks", + dispatch_info, + call_len, + )); + + // set_storage + let call = crate::RuntimeCall::System(frame_system::Call::set_storage { + items: vec![(vec![1u8; 32], vec![2u8; 32])], + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("frame_system", "set_storage", dispatch_info, call_len)); + + // kill_storage + let call = crate::RuntimeCall::System(frame_system::Call::kill_storage { + keys: vec![vec![1u8; 32], vec![2u8; 32]], + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("frame_system", "kill_storage", dispatch_info, call_len)); + + // kill_prefix + let call = crate::RuntimeCall::System(frame_system::Call::kill_prefix { + prefix: vec![1u8; 32], + subkeys: 8, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("frame_system", "kill_prefix", dispatch_info, call_len)); + + // remark_with_event, which length is 32 + let call = crate::RuntimeCall::System(frame_system::Call::remark_with_event { + remark: vec![1u8; 32], + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "frame_system", + "remark_with_event-length=32", + dispatch_info, + call_len, + )); + + // remark_with_event, which length is 64 + let call = crate::RuntimeCall::System(frame_system::Call::remark_with_event { + remark: vec![1u8; 32], + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "frame_system", + "remark_with_event-length=64", + dispatch_info, + call_len, + )); + } + + // pallet_treasury + { + assert_eq!( + crate::RuntimeCall::get_call_names("Treasury").len(), + 5, + "Please update new extrinsic here." + ); + // propose_spend + let call = crate::RuntimeCall::Treasury(pallet_treasury::Call::propose_spend { + value: 8, + beneficiary: ALICE.into(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_treasury", "propose_spend", dispatch_info, call_len)); + + // reject_proposal + let call = + crate::RuntimeCall::Treasury(pallet_treasury::Call::reject_proposal { proposal_id: 8 }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_treasury", + "reject_proposal", + dispatch_info, + call_len, + )); + + // approve_proposal + let call = crate::RuntimeCall::Treasury(pallet_treasury::Call::approve_proposal { + proposal_id: 8, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_treasury", + "approve_proposal", + dispatch_info, + call_len, + )); + + // spend + let call = crate::RuntimeCall::Treasury(pallet_treasury::Call::spend { + amount: 8, + beneficiary: ALICE.into(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_treasury", "spend", dispatch_info, call_len)); + + // remove_approval + let call = + crate::RuntimeCall::Treasury(pallet_treasury::Call::remove_approval { proposal_id: 8 }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_treasury", + "remove_approval", + dispatch_info, + call_len, + )); + } + + // pallet_timestamp + { + assert_eq!( + crate::RuntimeCall::get_call_names("Timestamp").len(), + 1, + "Please update new extrinsic here." + ); + // set + let call = crate::RuntimeCall::Timestamp(pallet_timestamp::Call::set { + now: Default::default(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_timestamp", "set", dispatch_info, call_len)); + } + + // pallet_preimage + { + assert_eq!( + crate::RuntimeCall::get_call_names("Preimage").len(), + 4, + "Please update new extrinsic here." + ); + // note_preimage, preimage length is 32 + let call = crate::RuntimeCall::Preimage(pallet_preimage::Call::note_preimage { + bytes: vec![1u8; 32], + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_preimage", + "note_preimage-length=32", + dispatch_info, + call_len, + )); + + // note_preimage, preimage length is 64 + let call = crate::RuntimeCall::Preimage(pallet_preimage::Call::note_preimage { + bytes: vec![1u8; 64], + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_preimage", + "note_preimage-length=32", + dispatch_info, + call_len, + )); + + // unnote_preimage + let call = crate::RuntimeCall::Preimage(pallet_preimage::Call::unnote_preimage { + hash: Default::default(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_preimage", + "unnote_preimage", + dispatch_info, + call_len, + )); + + // request_preimage + let call = crate::RuntimeCall::Preimage(pallet_preimage::Call::request_preimage { + hash: Default::default(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_preimage", + "request_preimage", + dispatch_info, + call_len, + )); + + // unrequest_preimage + let call = crate::RuntimeCall::Preimage(pallet_preimage::Call::unrequest_preimage { + hash: Default::default(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_preimage", + "unrequest_preimage", + dispatch_info, + call_len, + )); + } + + // pallet_multisig + { + assert_eq!( + crate::RuntimeCall::get_call_names("Multisig").len(), + 4, + "Please update new extrinsic here." + ); + // as_multi_threshold_1 + let dummy_call = crate::RuntimeCall::Preimage(pallet_preimage::Call::unrequest_preimage { + hash: Default::default(), + }); + let call = crate::RuntimeCall::Multisig(pallet_multisig::Call::as_multi_threshold_1 { + other_signatories: vec![ALICE], + call: Box::new(dummy_call.clone()), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_multisig", + "as_multi_threshold_1", + dispatch_info, + call_len, + )); + + // as_multi + let call = crate::RuntimeCall::Multisig(pallet_multisig::Call::as_multi { + threshold: 2, + other_signatories: vec![ALICE], + maybe_timepoint: None, + call: Box::new(dummy_call), + max_weight: Default::default(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_multisig", "as_multi", dispatch_info, call_len)); + + // approve_as_multi + let call = crate::RuntimeCall::Multisig(pallet_multisig::Call::approve_as_multi { + threshold: 2, + other_signatories: vec![ALICE], + maybe_timepoint: None, + call_hash: [1u8; 32], + max_weight: Default::default(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_multisig", + "approve_as_multi", + dispatch_info, + call_len, + )); + + // cancel_as_multi + let call = crate::RuntimeCall::Multisig(pallet_multisig::Call::cancel_as_multi { + threshold: 2, + other_signatories: vec![ALICE], + timepoint: Default::default(), + call_hash: [1u8; 32], + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_multisig", + "cancel_as_multi", + dispatch_info, + call_len, + )); + } + + // pallet_membership + { + assert_eq!( + crate::RuntimeCall::get_call_names("CouncilMembership").len(), + 7, + "Please update new extrinsic here." + ); + // add_member + let call = crate::RuntimeCall::CouncilMembership(pallet_membership::Call::add_member { + who: ALICE.into(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_membership", "add_member", dispatch_info, call_len)); + + // remove_member + let call = crate::RuntimeCall::CouncilMembership(pallet_membership::Call::remove_member { + who: ALICE.into(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_membership", + "remove_member", + dispatch_info, + call_len, + )); + + // swap_member + let call = crate::RuntimeCall::CouncilMembership(pallet_membership::Call::swap_member { + remove: ALICE.into(), + add: BOB.into(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_membership", "swap_member", dispatch_info, call_len)); + + // reset_members + let call = crate::RuntimeCall::CouncilMembership(pallet_membership::Call::reset_members { + members: vec![ALICE, BOB], + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_membership", + "reset_members", + dispatch_info, + call_len, + )); + + // change_key + let call = crate::RuntimeCall::CouncilMembership(pallet_membership::Call::change_key { + new: ALICE.into(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_membership", "change_key", dispatch_info, call_len)); + + // set_prime + let call = crate::RuntimeCall::CouncilMembership(pallet_membership::Call::set_prime { + who: ALICE.into(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_membership", "set_prime", dispatch_info, call_len)); + + // clear_prime + let call = crate::RuntimeCall::CouncilMembership(pallet_membership::Call::clear_prime {}); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_membership", "clear_prime", dispatch_info, call_len)); + } + + // pallet_democracy + { + assert_eq!( + crate::RuntimeCall::get_call_names("Democracy").len(), + 18, + "Please update new extrinsic here." + ); + // propose + let dummy_call = crate::RuntimeCall::Democracy(pallet_democracy::Call::cancel_proposal { + prop_index: 2, + }); + let call = crate::RuntimeCall::Democracy(pallet_democracy::Call::propose { + proposal: crate::Preimage::bound(dummy_call.clone()).unwrap(), + value: 1, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_democracy", "propose", dispatch_info, call_len)); + + // second + let call = crate::RuntimeCall::Democracy(pallet_democracy::Call::second { proposal: 3 }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_democracy", "second", dispatch_info, call_len)); + + // vote + let call = crate::RuntimeCall::Democracy(pallet_democracy::Call::vote { + ref_index: 3, + vote: pallet_democracy::AccountVote::Standard { + vote: Default::default(), + balance: 2, + }, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_democracy", "vote", dispatch_info, call_len)); + + // emergency_cancel + let call = crate::RuntimeCall::Democracy(pallet_democracy::Call::emergency_cancel { + ref_index: 3, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_democracy", + "emergency_cancel", + dispatch_info, + call_len, + )); + + // external_propose + let call = crate::RuntimeCall::Democracy(pallet_democracy::Call::external_propose { + proposal: crate::Preimage::bound(dummy_call.clone()).unwrap(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_democracy", + "external_propose", + dispatch_info, + call_len, + )); + + // external_propose_majority + let call = + crate::RuntimeCall::Democracy(pallet_democracy::Call::external_propose_majority { + proposal: crate::Preimage::bound(dummy_call.clone()).unwrap(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_democracy", + "external_propose_majority", + dispatch_info, + call_len, + )); + + // external_propose_default + let call = + crate::RuntimeCall::Democracy(pallet_democracy::Call::external_propose_default { + proposal: crate::Preimage::bound(dummy_call).unwrap(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_democracy", + "external_propose_default", + dispatch_info, + call_len, + )); + + // fast_track + let call = crate::RuntimeCall::Democracy(pallet_democracy::Call::fast_track { + proposal_hash: Default::default(), + voting_period: 300, + delay: 30, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_democracy", "fast_track", dispatch_info, call_len)); + + // veto_external + let call = crate::RuntimeCall::Democracy(pallet_democracy::Call::veto_external { + proposal_hash: Default::default(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_democracy", "veto_external", dispatch_info, call_len)); + + // cancel_referendum + let call = crate::RuntimeCall::Democracy(pallet_democracy::Call::cancel_referendum { + ref_index: 3, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_democracy", + "cancel_referendum", + dispatch_info, + call_len, + )); + + // delegate + let call = crate::RuntimeCall::Democracy(pallet_democracy::Call::delegate { + to: ALICE.into(), + conviction: pallet_democracy::Conviction::Locked3x, + balance: 3, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_democracy", "delegate", dispatch_info, call_len)); + + // undelegate + let call = crate::RuntimeCall::Democracy(pallet_democracy::Call::undelegate {}); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_democracy", "undelegate", dispatch_info, call_len)); + + // clear_public_proposals + let call = crate::RuntimeCall::Democracy(pallet_democracy::Call::clear_public_proposals {}); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_democracy", + "clear_public_proposals", + dispatch_info, + call_len, + )); + + // unlock + let call = crate::RuntimeCall::Democracy(pallet_democracy::Call::unlock { + target: MultiAddress::Id(ALICE), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_democracy", "unlock", dispatch_info, call_len)); + + // remove_vote + let call = crate::RuntimeCall::Democracy(pallet_democracy::Call::remove_vote { index: 2 }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_democracy", "remove_vote", dispatch_info, call_len)); + + // remove_other_vote + let call = crate::RuntimeCall::Democracy(pallet_democracy::Call::remove_other_vote { + target: ALICE.into(), + index: 2, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_democracy", + "remove_other_vote", + dispatch_info, + call_len, + )); + + // blacklist + let call = crate::RuntimeCall::Democracy(pallet_democracy::Call::blacklist { + proposal_hash: Default::default(), + maybe_ref_index: Some(2), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_democracy", "blacklist", dispatch_info, call_len)); + + // cancel_proposal + let call = crate::RuntimeCall::Democracy(pallet_democracy::Call::cancel_proposal { + prop_index: 2, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_democracy", + "cancel_proposal", + dispatch_info, + call_len, + )); + } + + // pallet_collective + { + assert_eq!( + crate::RuntimeCall::get_call_names("TechnicalCommittee").len(), + 7, + "Please update new extrinsic here." + ); + // set_members + let call = crate::RuntimeCall::TechnicalCommittee(pallet_collective::Call::set_members { + new_members: vec![ALICE, BOB], + prime: Some(ALICE), + old_count: 6, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_collective", "set_members", dispatch_info, call_len)); + + // execute + let dummy_call = crate::RuntimeCall::Democracy(pallet_democracy::Call::cancel_proposal { + prop_index: 2, + }); + let call = crate::RuntimeCall::TechnicalCommittee(pallet_collective::Call::execute { + proposal: Box::new(dummy_call.clone()), + length_bound: 6, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_collective", "execute", dispatch_info, call_len)); + + // propose + let call = crate::RuntimeCall::TechnicalCommittee(pallet_collective::Call::propose { + threshold: 3, + proposal: Box::new(dummy_call), + length_bound: 6, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_collective", "propose", dispatch_info, call_len)); + + // vote + let call = crate::RuntimeCall::TechnicalCommittee(pallet_collective::Call::vote { + proposal: Default::default(), + index: 2, + approve: true, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_collective", "vote", dispatch_info, call_len)); + + // close + let call = crate::RuntimeCall::TechnicalCommittee(pallet_collective::Call::close { + proposal_hash: Default::default(), + index: 2, + proposal_weight_bound: Default::default(), + length_bound: 6, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_collective", "close", dispatch_info, call_len)); + + // disapprove_proposal + let call = + crate::RuntimeCall::TechnicalCommittee(pallet_collective::Call::disapprove_proposal { + proposal_hash: Default::default(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_collective", + "disapprove_proposal", + dispatch_info, + call_len, + )); + } + + // cumulus_pallet_xcmp_queue + { + assert_eq!( + crate::RuntimeCall::get_call_names("XcmpQueue").len(), + 9, + "Please update new extrinsic here." + ); + // service_overweight + let call = + crate::RuntimeCall::XcmpQueue(cumulus_pallet_xcmp_queue::Call::service_overweight { + index: 1, + weight_limit: 64, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "cumulus_pallet_xcmp_queue", + "service_overweight", + dispatch_info, + call_len, + )); + + // suspend_xcm_execution + let call = crate::RuntimeCall::XcmpQueue( + cumulus_pallet_xcmp_queue::Call::suspend_xcm_execution {}, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "cumulus_pallet_xcmp_queue", + "suspend_xcm_execution", + dispatch_info, + call_len, + )); + + // resume_xcm_execution + let call = + crate::RuntimeCall::XcmpQueue(cumulus_pallet_xcmp_queue::Call::resume_xcm_execution {}); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "cumulus_pallet_xcmp_queue", + "resume_xcm_execution", + dispatch_info, + call_len, + )); + + // update_suspend_threshold + let call = crate::RuntimeCall::XcmpQueue( + cumulus_pallet_xcmp_queue::Call::update_suspend_threshold { new: 2 }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "cumulus_pallet_xcmp_queue", + "update_suspend_threshold", + dispatch_info, + call_len, + )); + + // update_drop_threshold + let call = crate::RuntimeCall::XcmpQueue( + cumulus_pallet_xcmp_queue::Call::update_suspend_threshold { new: 2 }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "cumulus_pallet_xcmp_queue", + "update_drop_threshold", + dispatch_info, + call_len, + )); + + // update_resume_threshold + let call = crate::RuntimeCall::XcmpQueue( + cumulus_pallet_xcmp_queue::Call::update_resume_threshold { new: 2 }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "cumulus_pallet_xcmp_queue", + "update_resume_threshold", + dispatch_info, + call_len, + )); + + // update_threshold_weight + let call = crate::RuntimeCall::XcmpQueue( + cumulus_pallet_xcmp_queue::Call::update_threshold_weight { new: 64 }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "cumulus_pallet_xcmp_queue", + "update_threshold_weight", + dispatch_info, + call_len, + )); + + // update_weight_restrict_decay + let call = crate::RuntimeCall::XcmpQueue( + cumulus_pallet_xcmp_queue::Call::update_weight_restrict_decay { new: 64 }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "cumulus_pallet_xcmp_queue", + "update_weight_restrict_decay", + dispatch_info, + call_len, + )); + + // update_xcmp_max_individual_weight + let call = crate::RuntimeCall::XcmpQueue( + cumulus_pallet_xcmp_queue::Call::update_xcmp_max_individual_weight { new: 64 }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "cumulus_pallet_xcmp_queue", + "update_xcmp_max_individual_weight", + dispatch_info, + call_len, + )); + } + + // orml_xtokens + // cannot run this part out side of mock runtime. + t.execute_with(|| { + assert_eq!( + crate::RuntimeCall::get_call_names("XTokens").len(), + 6, + "Please update new extrinsic here." + ); + // transfer + let dest = VersionedMultiLocation::V1(Default::default()); + let call = crate::RuntimeCall::XTokens(orml_xtokens::Call::transfer { + currency_id: crate::xcm_config::CurrencyId::MantaCurrency(1), + amount: 10, + dest: Box::new(dest.clone()), + dest_weight_limit: WeightLimit::Unlimited, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("orml_xtokens", "transfer", dispatch_info, call_len)); + + // transfer_multiasset + let _asset = MultiAsset { + id: Concrete(MultiLocation { + parents: 1, + interior: X1(Parachain(1)), + }), + fun: Fungible(10000000000000), + }; + let asset = xcm::VersionedMultiAsset::V1(_asset.clone()); + let call = crate::RuntimeCall::XTokens(orml_xtokens::Call::transfer_multiasset { + asset: Box::new(asset.clone()), + dest: Box::new(dest.clone()), + dest_weight_limit: WeightLimit::Unlimited, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "orml_xtokens", + "transfer_multiasset", + dispatch_info, + call_len, + )); + + // transfer_with_fee + let call = crate::RuntimeCall::XTokens(orml_xtokens::Call::transfer_with_fee { + currency_id: crate::xcm_config::CurrencyId::MantaCurrency(1), + amount: 10, + fee: 20, + dest: Box::new(dest.clone()), + dest_weight_limit: WeightLimit::Unlimited, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("orml_xtokens", "transfer_with_fee", dispatch_info, call_len)); + + // transfer_multiasset_with_fee + let _fee_asset = MultiAsset { + id: Concrete(MultiLocation { + parents: 1, + interior: X1(Parachain(1)), + }), + fun: Fungible(5000000000000), + }; + let fee_asset = xcm::VersionedMultiAsset::V1(_fee_asset.clone()); + let call = crate::RuntimeCall::XTokens(orml_xtokens::Call::transfer_multiasset_with_fee { + asset: Box::new(asset), + fee: Box::new(fee_asset), + dest: Box::new(dest.clone()), + dest_weight_limit: WeightLimit::Unlimited, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "orml_xtokens", + "transfer_multiasset_with_fee", + dispatch_info, + call_len, + )); + + // transfer_multicurrencies + let call = crate::RuntimeCall::XTokens(orml_xtokens::Call::transfer_multicurrencies { + currencies: vec![ + (crate::xcm_config::CurrencyId::MantaCurrency(1), 10), + (crate::xcm_config::CurrencyId::MantaCurrency(2), 20), + ], + fee_item: 1, + dest: Box::new(dest.clone()), + dest_weight_limit: WeightLimit::Unlimited, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "orml_xtokens", + "transfer_multicurrencies", + dispatch_info, + call_len, + )); + + // transfer_multiassets + let assets = xcm::VersionedMultiAssets::V1(MultiAssets::from(vec![_asset, _fee_asset])); + let call = crate::RuntimeCall::XTokens(orml_xtokens::Call::transfer_multiassets { + assets: Box::new(assets), + fee_item: 1, + dest: Box::new(dest), + dest_weight_limit: WeightLimit::Unlimited, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "orml_xtokens", + "transfer_multiassets", + dispatch_info, + call_len, + )); + }); + + // calamari_vesting + { + assert_eq!( + crate::RuntimeCall::get_call_names("CalamariVesting").len(), + 3, + "Please update new extrinsic here." + ); + // vest + let call = crate::RuntimeCall::CalamariVesting(calamari_vesting::Call::vest {}); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("calamari_vesting", "vest", dispatch_info, call_len)); + } + + // manta_collator_selection + { + assert_eq!( + crate::RuntimeCall::get_call_names("CollatorSelection").len(), + 9, + "Please update new extrinsic here." + ); + // set_invulnerables + let call = crate::RuntimeCall::CollatorSelection( + manta_collator_selection::Call::set_invulnerables { new: vec![ALICE] }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "manta_collator_selection", + "set_invulnerables", + dispatch_info, + call_len, + )); + + // set_desired_candidates + let call = crate::RuntimeCall::CollatorSelection( + manta_collator_selection::Call::set_desired_candidates { max: 1 }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "manta_collator_selection", + "set_desired_candidates", + dispatch_info, + call_len, + )); + + // set_candidacy_bond + let call = crate::RuntimeCall::CollatorSelection( + manta_collator_selection::Call::set_candidacy_bond { bond: 1 }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "manta_collator_selection", + "set_candidacy_bond", + dispatch_info, + call_len, + )); + + // register_as_candidate + let call = crate::RuntimeCall::CollatorSelection( + manta_collator_selection::Call::register_as_candidate {}, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "manta_collator_selection", + "register_as_candidate", + dispatch_info, + call_len, + )); + + // register_candidate + let call = crate::RuntimeCall::CollatorSelection( + manta_collator_selection::Call::register_candidate { + new_candidate: ALICE, + }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "manta_collator_selection", + "register_candidate", + dispatch_info, + call_len, + )); + + // leave_intent + let call = + crate::RuntimeCall::CollatorSelection(manta_collator_selection::Call::leave_intent {}); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "manta_collator_selection", + "leave_intent", + dispatch_info, + call_len, + )); + + // remove_collator + let call = crate::RuntimeCall::CollatorSelection( + manta_collator_selection::Call::remove_collator { collator: ALICE }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "manta_collator_selection", + "remove_collator", + dispatch_info, + call_len, + )); + + // set_eviction_baseline + let call = crate::RuntimeCall::CollatorSelection( + manta_collator_selection::Call::set_eviction_baseline { + percentile: Default::default(), + }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "manta_collator_selection", + "set_eviction_baseline", + dispatch_info, + call_len, + )); + + // set_eviction_tolerance + let call = crate::RuntimeCall::CollatorSelection( + manta_collator_selection::Call::set_eviction_tolerance { + percentage: Default::default(), + }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "manta_collator_selection", + "set_eviction_tolerance", + dispatch_info, + call_len, + )); + } + + // pallet_asset_manager + { + assert_eq!( + crate::RuntimeCall::get_call_names("AssetManager").len(), + 8, + "Please update new extrinsic here." + ); + // register_asset + let call = crate::RuntimeCall::AssetManager(pallet_asset_manager::Call::register_asset { + location: Default::default(), + metadata: AssetRegistryMetadata::testing_default(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_asset_manager", + "register_asset", + dispatch_info, + call_len, + )); + + // update_asset_location + let call = + crate::RuntimeCall::AssetManager(pallet_asset_manager::Call::update_asset_location { + asset_id: 1, + location: Default::default(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_asset_manager", + "update_asset_location", + dispatch_info, + call_len, + )); + + // update_asset_metadata + let call = + crate::RuntimeCall::AssetManager(pallet_asset_manager::Call::update_asset_metadata { + asset_id: 1, + metadata: AssetRegistryMetadata::testing_default(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_asset_manager", + "update_asset_metadata", + dispatch_info, + call_len, + )); + + // set_units_per_second + let call = + crate::RuntimeCall::AssetManager(pallet_asset_manager::Call::set_units_per_second { + asset_id: 1, + units_per_second: 1, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_asset_manager", + "set_units_per_second", + dispatch_info, + call_len, + )); + + // mint_asset + let call = crate::RuntimeCall::AssetManager(pallet_asset_manager::Call::mint_asset { + asset_id: 1, + beneficiary: ALICE, + amount: 1, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_asset_manager", + "mint_asset", + dispatch_info, + call_len, + )); + + // set_min_xcm_fee + let call = crate::RuntimeCall::AssetManager(pallet_asset_manager::Call::set_min_xcm_fee { + reserve_chain: Default::default(), + min_xcm_fee: 1, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_asset_manager", + "set_min_xcm_fee", + dispatch_info, + call_len, + )); + + // update_outgoing_filtered_assets + let call = crate::RuntimeCall::AssetManager( + pallet_asset_manager::Call::update_outgoing_filtered_assets { + filtered_location: Default::default(), + should_add: true, + }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_asset_manager", + "update_outgoing_filtered_assets", + dispatch_info, + call_len, + )); + + // register_lp_asset + let call = + crate::RuntimeCall::AssetManager(pallet_asset_manager::Call::register_lp_asset { + asset_0: 1, + asset_1: 2, + metadata: AssetRegistryMetadata::testing_default(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_asset_manager", + "register_lp_asset", + dispatch_info, + call_len, + )); + } + + // pallet_assets + { + assert_eq!( + crate::RuntimeCall::get_call_names("Assets").len(), + 28, + "Please update new extrinsic here." + ); + // create + let call = crate::RuntimeCall::Assets(pallet_assets::Call::create { + id: 1, + admin: ALICE.into(), + min_balance: 1, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_assets", "create", dispatch_info, call_len)); + + // force_create + let call = crate::RuntimeCall::Assets(pallet_assets::Call::force_create { + id: 1, + owner: ALICE.into(), + is_sufficient: true, + min_balance: 1, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_assets", "force_create", dispatch_info, call_len)); + + // start_destroy + let call = crate::RuntimeCall::Assets(pallet_assets::Call::start_destroy { id: 1 }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_assets", "start_destroy", dispatch_info, call_len)); + + // destroy_accounts + let call = crate::RuntimeCall::Assets(pallet_assets::Call::destroy_accounts { id: 1 }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_assets", "destroy_accounts", dispatch_info, call_len)); + + // destroy_approvals + let call = crate::RuntimeCall::Assets(pallet_assets::Call::destroy_approvals { id: 1 }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_assets", + "destroy_approvals", + dispatch_info, + call_len, + )); + + // finish_destroy + let call = crate::RuntimeCall::Assets(pallet_assets::Call::finish_destroy { id: 1 }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_assets", "finish_destroy", dispatch_info, call_len)); + + // mint + let call = crate::RuntimeCall::Assets(pallet_assets::Call::mint { + id: 1, + beneficiary: ALICE.into(), + amount: 1, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_assets", "mint", dispatch_info, call_len)); + + // burn + let call = crate::RuntimeCall::Assets(pallet_assets::Call::burn { + id: 1, + who: ALICE.into(), + amount: 1, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_assets", "burn", dispatch_info, call_len)); + + // transfer + let call = crate::RuntimeCall::Assets(pallet_assets::Call::transfer { + id: 1, + target: ALICE.into(), + amount: 1, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_assets", "transfer", dispatch_info, call_len)); + + // transfer_keep_alive + let call = crate::RuntimeCall::Assets(pallet_assets::Call::transfer_keep_alive { + id: 1, + target: ALICE.into(), + amount: 1, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_assets", + "transfer_keep_alive", + dispatch_info, + call_len, + )); + + // force_transfer + let call = crate::RuntimeCall::Assets(pallet_assets::Call::force_transfer { + id: 1, + source: ALICE.into(), + dest: ALICE.into(), + amount: 1, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_assets", "force_transfer", dispatch_info, call_len)); + + // freeze + let call = crate::RuntimeCall::Assets(pallet_assets::Call::freeze { + id: 1, + who: ALICE.into(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_assets", "freeze", dispatch_info, call_len)); + + // thaw + let call = crate::RuntimeCall::Assets(pallet_assets::Call::thaw { + id: 1, + who: ALICE.into(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_assets", "thaw", dispatch_info, call_len)); + + // freeze_asset + let call = crate::RuntimeCall::Assets(pallet_assets::Call::freeze_asset { id: 1 }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_assets", "freeze_asset", dispatch_info, call_len)); + + // thaw_asset + let call = crate::RuntimeCall::Assets(pallet_assets::Call::thaw_asset { id: 1 }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_assets", "thaw_asset", dispatch_info, call_len)); + + // transfer_ownership + let call = crate::RuntimeCall::Assets(pallet_assets::Call::transfer_ownership { + id: 1, + owner: ALICE.into(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_assets", + "transfer_ownership", + dispatch_info, + call_len, + )); + + // set_team + let call = crate::RuntimeCall::Assets(pallet_assets::Call::set_team { + id: 1, + issuer: ALICE.into(), + admin: ALICE.into(), + freezer: ALICE.into(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_assets", "set_team", dispatch_info, call_len)); + + // set_metadata + let call = crate::RuntimeCall::Assets(pallet_assets::Call::set_metadata { + id: 1, + name: vec![1u8; 32], + symbol: vec![1u8; 32], + decimals: 12, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_assets", "set_metadata", dispatch_info, call_len)); + + // clear_metadata + let call = crate::RuntimeCall::Assets(pallet_assets::Call::clear_metadata { id: 1 }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_assets", "clear_metadata", dispatch_info, call_len)); + + // force_set_metadata + let call = crate::RuntimeCall::Assets(pallet_assets::Call::force_set_metadata { + id: 1, + name: vec![1u8; 32], + symbol: vec![1u8; 32], + decimals: 12, + is_frozen: true, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_assets", + "force_set_metadata", + dispatch_info, + call_len, + )); + + // force_clear_metadata + let call = crate::RuntimeCall::Assets(pallet_assets::Call::force_clear_metadata { id: 1 }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_assets", + "force_clear_metadata", + dispatch_info, + call_len, + )); + + // force_asset_status + let call = crate::RuntimeCall::Assets(pallet_assets::Call::force_asset_status { + id: 1, + owner: ALICE.into(), + issuer: ALICE.into(), + admin: ALICE.into(), + freezer: ALICE.into(), + min_balance: 1, + is_sufficient: true, + is_frozen: false, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_assets", + "force_asset_status", + dispatch_info, + call_len, + )); + + // approve_transfer + let call = crate::RuntimeCall::Assets(pallet_assets::Call::approve_transfer { + id: 1, + delegate: ALICE.into(), + amount: 1, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_assets", "approve_transfer", dispatch_info, call_len)); + + // cancel_approval + let call = crate::RuntimeCall::Assets(pallet_assets::Call::cancel_approval { + id: 1, + delegate: ALICE.into(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_assets", "cancel_approval", dispatch_info, call_len)); + + // force_cancel_approval + let call = crate::RuntimeCall::Assets(pallet_assets::Call::force_cancel_approval { + id: 1, + owner: ALICE.into(), + delegate: ALICE.into(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_assets", + "force_cancel_approval", + dispatch_info, + call_len, + )); + + // transfer_approved + let call = crate::RuntimeCall::Assets(pallet_assets::Call::transfer_approved { + id: 1, + owner: ALICE.into(), + destination: ALICE.into(), + amount: 1, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_assets", + "transfer_approved", + dispatch_info, + call_len, + )); + + // touch + let call = crate::RuntimeCall::Assets(pallet_assets::Call::touch { id: 1 }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_assets", "touch", dispatch_info, call_len)); + + // refund + let call = crate::RuntimeCall::Assets(pallet_assets::Call::refund { + id: 1, + allow_burn: true, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_assets", "refund", dispatch_info, call_len)); + } + + // pallet_author_inherent + { + assert_eq!( + crate::RuntimeCall::get_call_names("AuthorInherent").len(), + 1, + "Please update new extrinsic here." + ); + // kick_off_authorship_validation + let call = crate::RuntimeCall::AuthorInherent( + pallet_author_inherent::Call::kick_off_authorship_validation {}, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_author_inherent", + "kick_off_authorship_validation", + dispatch_info, + call_len, + )); + } + + // pallet_balances + { + assert_eq!( + crate::RuntimeCall::get_call_names("Balances").len(), + 6, + "Please update new extrinsic here." + ); + // transfer, 1 token + let call = crate::RuntimeCall::Balances(pallet_balances::Call::transfer { + dest: ALICE.into(), + value: 1, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_balances", "transfer-1", dispatch_info, call_len)); + + // transfer, 1M tokens + let call = crate::RuntimeCall::Balances(pallet_balances::Call::transfer { + dest: ALICE.into(), + value: 1_000_000, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_balances", + "transfer-1000_000", + dispatch_info, + call_len, + )); + + // set_balance + let call = crate::RuntimeCall::Balances(pallet_balances::Call::set_balance { + who: ALICE.into(), + new_free: 1, + new_reserved: 1, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_balances", "set_balance", dispatch_info, call_len)); + + // force_transfer + let call = crate::RuntimeCall::Balances(pallet_balances::Call::force_transfer { + source: ALICE.into(), + dest: ALICE.into(), + value: 1, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_balances", "force_transfer", dispatch_info, call_len)); + + // transfer_keep_alive, 1 token + let call = crate::RuntimeCall::Balances(pallet_balances::Call::transfer_keep_alive { + dest: ALICE.into(), + value: 1, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_balances", + "transfer_keep_alive-1", + dispatch_info, + call_len, + )); + + // transfer_keep_alive, 1M tokens + let call = crate::RuntimeCall::Balances(pallet_balances::Call::transfer_keep_alive { + dest: ALICE.into(), + value: 1_000_000, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_balances", + "transfer_keep_alive-1000_000", + dispatch_info, + call_len, + )); + + // transfer_all + let call = crate::RuntimeCall::Balances(pallet_balances::Call::transfer_all { + dest: ALICE.into(), + keep_alive: false, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_balances", "transfer_all", dispatch_info, call_len)); + + // force_unreserve + let call = crate::RuntimeCall::Balances(pallet_balances::Call::force_unreserve { + who: ALICE.into(), + amount: 1, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_balances", + "force_unreserve", + dispatch_info, + call_len, + )); + } + + // pallet_manta_pay + { + assert_eq!( + crate::RuntimeCall::get_call_names("MantaPay").len(), + 4, + "Please update new extrinsic here." + ); + + let to_private_proof = [0u8; 552]; + let private_transfer_proof = [0u8; 1290]; + let to_public_proof = [0u8; 1000]; + // to_private + let to_private_post = TransferPost::decode(&mut to_private_proof.as_slice()).unwrap(); + let call = crate::RuntimeCall::MantaPay(pallet_manta_pay::Call::to_private { + post: to_private_post, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_manta_pay", "to_private", dispatch_info, call_len)); + + // private_transfer + let private_transfer_post = + TransferPost::decode(&mut private_transfer_proof.as_slice()).unwrap(); + let call = crate::RuntimeCall::MantaPay(pallet_manta_pay::Call::private_transfer { + post: private_transfer_post, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_manta_pay", + "private_transfer", + dispatch_info, + call_len, + )); + + // to_public + let to_public_post = TransferPost::decode(&mut to_public_proof.as_slice()).unwrap(); + let call = crate::RuntimeCall::MantaPay(pallet_manta_pay::Call::to_public { + post: to_public_post, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_manta_pay", "to_public", dispatch_info, call_len)); + + // public_transfer + let call = crate::RuntimeCall::MantaPay(pallet_manta_pay::Call::public_transfer { + asset: Default::default(), + sink: ALICE, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_manta_pay", + "public_transfer", + dispatch_info, + call_len, + )); + } + + // pallet_manta_sbt + { + assert_eq!( + crate::RuntimeCall::get_call_names("MantaSbt").len(), + 13, + "Please update new extrinsic here." + ); + let to_private_proof = [0u8; 552]; + // to_private + let to_private_post = + Box::new(TransferPost::decode(&mut to_private_proof.as_slice()).unwrap()); + let call = crate::RuntimeCall::MantaSbt(pallet_manta_sbt::Call::to_private { + mint_id: None, + chain_id: None, + signature: None, + post: to_private_post, + metadata: Default::default(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_manta_sbt", "to_private", dispatch_info, call_len)); + + // force_to_private + let to_private_post = + Box::new(TransferPost::decode(&mut to_private_proof.as_slice()).unwrap()); + let call = crate::RuntimeCall::MantaSbt(pallet_manta_sbt::Call::force_to_private { + post: to_private_post.clone(), + mint_id: 1u32, + metadata: Default::default(), + minting_account: ALICE.clone(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_manta_sbt", + "force_to_private", + dispatch_info, + call_len, + )); + + // reserve_sbt + let call = crate::RuntimeCall::MantaSbt(pallet_manta_sbt::Call::reserve_sbt { + reservee: Default::default(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_manta_sbt", "reserve_sbt", dispatch_info, call_len)); + + // allowlist_evm_account + let call = crate::RuntimeCall::MantaSbt(pallet_manta_sbt::Call::allowlist_evm_account { + mint_id: 1, + evm_address: Default::default(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_manta_sbt", + "allowlist_evm_account", + dispatch_info, + call_len, + )); + + // set_next_sbt_id + let call = crate::RuntimeCall::MantaSbt(pallet_manta_sbt::Call::set_next_sbt_id { + asset_id: Some(1), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_manta_sbt", + "set_next_sbt_id", + dispatch_info, + call_len, + )); + + // remove_allowlist_evm_account + let call = + crate::RuntimeCall::MantaSbt(pallet_manta_sbt::Call::remove_allowlist_evm_account { + mint_id: 1, + evm_address: Default::default(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_manta_sbt", + "remove_allowlist_evm_account", + dispatch_info, + call_len, + )); + + // change_free_reserve_account + let call = + crate::RuntimeCall::MantaSbt(pallet_manta_sbt::Call::change_free_reserve_account { + account: Some(ALICE.clone()), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_manta_sbt", + "change_free_reserve_account", + dispatch_info, + call_len, + )); + + // force_mint_sbt_eth + let call = crate::RuntimeCall::MantaSbt(pallet_manta_sbt::Call::force_mint_sbt_eth { + post: to_private_post.clone(), + mint_id: 1u32, + address: Default::default(), + collection_id: Some(128), + item_id: Some(64), + metadata: Default::default(), + minting_account: ALICE.clone(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_manta_sbt", + "force_mint_sbt_eth", + dispatch_info, + call_len, + )); + + // change_force_account + let call = crate::RuntimeCall::MantaSbt(pallet_manta_sbt::Call::change_force_account { + account: Some(ALICE.clone()), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_manta_sbt", + "change_force_account", + dispatch_info, + call_len, + )); + + // mint_sbt_eth + let call = crate::RuntimeCall::MantaSbt(pallet_manta_sbt::Call::mint_sbt_eth { + post: to_private_post, + chain_id: 1, + eth_signature: [1u8; 65], + mint_id: 1, + collection_id: Some(1), + item_id: Some(1), + metadata: None, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_manta_sbt", "mint_sbt_eth", dispatch_info, call_len)); + + // change_allowlist_account + let call = crate::RuntimeCall::MantaSbt(pallet_manta_sbt::Call::change_allowlist_account { + account: Some(ALICE), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_manta_sbt", + "change_allowlist_account", + dispatch_info, + call_len, + )); + + // update_mint_info + let call = crate::RuntimeCall::MantaSbt(pallet_manta_sbt::Call::update_mint_info { + mint_id: 1, + start_time: Default::default(), + end_time: None, + mint_name: Default::default(), + public: true, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_manta_sbt", + "update_mint_info", + dispatch_info, + call_len, + )); + + // new_mint_info + let call = crate::RuntimeCall::MantaSbt(pallet_manta_sbt::Call::new_mint_info { + start_time: Default::default(), + end_time: None, + mint_name: Default::default(), + public: true, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_manta_sbt", "new_mint_info", dispatch_info, call_len)); + } + + // pallet_parachain_staking + { + assert_eq!( + crate::RuntimeCall::get_call_names("ParachainStaking").len(), + 26, + "Please update new extrinsic here." + ); + // set_staking_expectations + let call = crate::RuntimeCall::ParachainStaking( + pallet_parachain_staking::Call::set_staking_expectations { + expectations: pallet_parachain_staking::Range::from(1), + }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "set_staking_expectations", + dispatch_info, + call_len, + )); + + // set_inflation + let call = + crate::RuntimeCall::ParachainStaking(pallet_parachain_staking::Call::set_inflation { + schedule: pallet_parachain_staking::Range::from(Perbill::from_percent(20)), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "set_inflation", + dispatch_info, + call_len, + )); + + // set_parachain_bond_account + let call = crate::RuntimeCall::ParachainStaking( + pallet_parachain_staking::Call::set_parachain_bond_account { new: ALICE }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "set_parachain_bond_account", + dispatch_info, + call_len, + )); + + // set_parachain_bond_account + let call = crate::RuntimeCall::ParachainStaking( + pallet_parachain_staking::Call::set_parachain_bond_account { new: ALICE }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "set_parachain_bond_account", + dispatch_info, + call_len, + )); + + // set_parachain_bond_reserve_percent + let call = crate::RuntimeCall::ParachainStaking( + pallet_parachain_staking::Call::set_parachain_bond_reserve_percent { + new: Default::default(), + }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "set_parachain_bond_reserve_percent", + dispatch_info, + call_len, + )); + + // set_total_selected + let call = crate::RuntimeCall::ParachainStaking( + pallet_parachain_staking::Call::set_total_selected { new: 1 }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "set_total_selected", + dispatch_info, + call_len, + )); + + // set_collator_commission + let call = crate::RuntimeCall::ParachainStaking( + pallet_parachain_staking::Call::set_collator_commission { + new: Default::default(), + }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "set_collator_commission", + dispatch_info, + call_len, + )); + + // set_blocks_per_round + let call = crate::RuntimeCall::ParachainStaking( + pallet_parachain_staking::Call::set_blocks_per_round { new: 1 }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "set_blocks_per_round", + dispatch_info, + call_len, + )); + + // join_candidates + let call = + crate::RuntimeCall::ParachainStaking(pallet_parachain_staking::Call::join_candidates { + bond: 1, + candidate_count: 2, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "join_candidates", + dispatch_info, + call_len, + )); + + // schedule_leave_candidates + let call = crate::RuntimeCall::ParachainStaking( + pallet_parachain_staking::Call::schedule_leave_candidates { candidate_count: 2 }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "schedule_leave_candidates", + dispatch_info, + call_len, + )); + + // execute_leave_candidates + let call = crate::RuntimeCall::ParachainStaking( + pallet_parachain_staking::Call::execute_leave_candidates { + candidate: ALICE, + candidate_delegation_count: 2, + }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "execute_leave_candidates", + dispatch_info, + call_len, + )); + + // cancel_leave_candidates + let call = crate::RuntimeCall::ParachainStaking( + pallet_parachain_staking::Call::cancel_leave_candidates { candidate_count: 2 }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "cancel_leave_candidates", + dispatch_info, + call_len, + )); + + // go_offline + let call = + crate::RuntimeCall::ParachainStaking(pallet_parachain_staking::Call::go_offline {}); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "go_offline", + dispatch_info, + call_len, + )); + + // go_offline + let call = + crate::RuntimeCall::ParachainStaking(pallet_parachain_staking::Call::go_offline {}); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "go_offline", + dispatch_info, + call_len, + )); + + // candidate_bond_more + let call = crate::RuntimeCall::ParachainStaking( + pallet_parachain_staking::Call::candidate_bond_more { more: 1 }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "candidate_bond_more", + dispatch_info, + call_len, + )); + + // schedule_candidate_bond_less + let call = crate::RuntimeCall::ParachainStaking( + pallet_parachain_staking::Call::schedule_candidate_bond_less { less: 1 }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "schedule_candidate_bond_less", + dispatch_info, + call_len, + )); + + // execute_candidate_bond_less + let call = crate::RuntimeCall::ParachainStaking( + pallet_parachain_staking::Call::execute_candidate_bond_less { candidate: ALICE }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "execute_candidate_bond_less", + dispatch_info, + call_len, + )); + + // cancel_candidate_bond_less + let call = crate::RuntimeCall::ParachainStaking( + pallet_parachain_staking::Call::cancel_candidate_bond_less {}, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "cancel_candidate_bond_less", + dispatch_info, + call_len, + )); + + // delegate + let call = crate::RuntimeCall::ParachainStaking(pallet_parachain_staking::Call::delegate { + candidate: ALICE, + amount: 1, + candidate_delegation_count: 2, + delegation_count: 3, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "delegate_1_2_3", + dispatch_info, + call_len, + )); + + let call = crate::RuntimeCall::ParachainStaking(pallet_parachain_staking::Call::delegate { + candidate: ALICE, + amount: 1, + candidate_delegation_count: 25, + delegation_count: 3, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "delegate_1_25_3", + dispatch_info, + call_len, + )); + + let call = crate::RuntimeCall::ParachainStaking(pallet_parachain_staking::Call::delegate { + candidate: ALICE, + amount: 1, + candidate_delegation_count: 2, + delegation_count: 100, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "delegate_1_2_100", + dispatch_info, + call_len, + )); + + // schedule_leave_delegators + let call = crate::RuntimeCall::ParachainStaking( + pallet_parachain_staking::Call::schedule_leave_delegators {}, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "schedule_leave_delegators", + dispatch_info, + call_len, + )); + + // execute_leave_delegators + let call = crate::RuntimeCall::ParachainStaking( + pallet_parachain_staking::Call::execute_leave_delegators { + delegator: ALICE, + delegation_count: 3, + }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "execute_leave_delegators", + dispatch_info, + call_len, + )); + + // cancel_leave_delegators + let call = crate::RuntimeCall::ParachainStaking( + pallet_parachain_staking::Call::cancel_leave_delegators {}, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "cancel_leave_delegators", + dispatch_info, + call_len, + )); + + // schedule_revoke_delegation + let call = crate::RuntimeCall::ParachainStaking( + pallet_parachain_staking::Call::schedule_revoke_delegation { collator: ALICE }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "schedule_revoke_delegation", + dispatch_info, + call_len, + )); + + // delegator_bond_more + let call = crate::RuntimeCall::ParachainStaking( + pallet_parachain_staking::Call::delegator_bond_more { + candidate: ALICE, + more: 1, + }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "delegator_bond_more", + dispatch_info, + call_len, + )); + + // schedule_delegator_bond_less + let call = crate::RuntimeCall::ParachainStaking( + pallet_parachain_staking::Call::schedule_delegator_bond_less { + candidate: ALICE, + less: 1, + }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "schedule_delegator_bond_less", + dispatch_info, + call_len, + )); + + // execute_delegation_request + let call = crate::RuntimeCall::ParachainStaking( + pallet_parachain_staking::Call::execute_delegation_request { + delegator: ALICE, + candidate: ALICE, + }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "execute_delegation_request", + dispatch_info, + call_len, + )); + + // cancel_delegation_request + let call = crate::RuntimeCall::ParachainStaking( + pallet_parachain_staking::Call::cancel_delegation_request { candidate: ALICE }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "cancel_delegation_request", + dispatch_info, + call_len, + )); + } + + // pallet_scheduler + { + assert_eq!( + crate::RuntimeCall::get_call_names("Scheduler").len(), + 6, + "Please update new extrinsic here." + ); + // cancel + let call = + crate::RuntimeCall::Scheduler(pallet_scheduler::Call::cancel { when: 1, index: 1 }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_scheduler", "cancel", dispatch_info, call_len)); + + // schedule + let call = crate::RuntimeCall::Scheduler(pallet_scheduler::Call::schedule { + when: 1, + maybe_periodic: None, + priority: 1, + call: Box::new(call), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_scheduler", "schedule", dispatch_info, call_len)); + + // schedule_named + let call = crate::RuntimeCall::Scheduler(pallet_scheduler::Call::schedule_named { + id: [1u8; 32], + when: 1, + maybe_periodic: None, + priority: 1, + call: Box::new(call), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_scheduler", + "schedule_named", + dispatch_info, + call_len, + )); + + // cancel_named + let call = + crate::RuntimeCall::Scheduler(pallet_scheduler::Call::cancel_named { id: [1u8; 32] }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_scheduler", "cancel_named", dispatch_info, call_len)); + + // schedule_after + let call = crate::RuntimeCall::Scheduler(pallet_scheduler::Call::schedule_after { + after: 1, + maybe_periodic: None, + priority: 1, + call: Box::new(call), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_scheduler", + "schedule_after", + dispatch_info, + call_len, + )); + + // schedule_named_after + let call = crate::RuntimeCall::Scheduler(pallet_scheduler::Call::schedule_named_after { + id: [1u8; 32], + after: 1, + maybe_periodic: None, + priority: 1, + call: Box::new(call), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_scheduler", + "schedule_named_after", + dispatch_info, + call_len, + )); + } + + // pallet_session + { + assert_eq!( + crate::RuntimeCall::get_call_names("Session").len(), + 2, + "Please update new extrinsic here." + ); + // set_keys + let keys = crate::opaque::SessionKeys::from_seed_unchecked("//Alice"); + let call = crate::RuntimeCall::Session(pallet_session::Call::set_keys { + keys, + proof: vec![1u8; 32], + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_session", "set_keys", dispatch_info, call_len)); + + // purge_keys + let call = crate::RuntimeCall::Session(pallet_session::Call::purge_keys {}); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_session", "purge_keys", dispatch_info, call_len)); + } + + // pallet_tx_pause + { + assert_eq!( + crate::RuntimeCall::get_call_names("TransactionPause").len(), + 6, + "Please update new extrinsic here." + ); + // set_mint_chain_info + let call = crate::RuntimeCall::TransactionPause(pallet_tx_pause::Call::pause_transaction { + pallet_name: vec![1u8; 32], + function_name: vec![1u8; 32], + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_tx_pause", + "pause_transaction", + dispatch_info, + call_len, + )); + + // unpause_transaction + let call = + crate::RuntimeCall::TransactionPause(pallet_tx_pause::Call::unpause_transaction { + pallet_name: vec![1u8; 32], + function_name: vec![1u8; 32], + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_tx_pause", + "unpause_transaction", + dispatch_info, + call_len, + )); + + // pause_transactions + let call = + crate::RuntimeCall::TransactionPause(pallet_tx_pause::Call::pause_transactions { + pallet_and_funcs: vec![(vec![1u8; 32], vec![vec![1u8; 32]; 2])], + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_tx_pause", + "pause_transactions", + dispatch_info, + call_len, + )); + + // unpause_transactions + let call = + crate::RuntimeCall::TransactionPause(pallet_tx_pause::Call::unpause_transactions { + pallet_and_funcs: vec![(vec![1u8; 32], vec![vec![1u8; 32]; 2])], + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_tx_pause", + "unpause_transactions", + dispatch_info, + call_len, + )); + + // pause_pallets + let call = crate::RuntimeCall::TransactionPause(pallet_tx_pause::Call::pause_pallets { + pallet_names: vec![vec![1u8; 32], vec![2u8; 32]], + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_tx_pause", "pause_pallets", dispatch_info, call_len)); + + // unpause_pallets + let call = crate::RuntimeCall::TransactionPause(pallet_tx_pause::Call::unpause_pallets { + pallet_names: vec![vec![1u8; 32], vec![2u8; 32]], + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_tx_pause", + "unpause_pallets", + dispatch_info, + call_len, + )); + } + + // pallet_utility + { + assert_eq!( + crate::RuntimeCall::get_call_names("Utility").len(), + 6, + "Please update new extrinsic here." + ); + // batch, one call within + let call = crate::RuntimeCall::Utility(pallet_utility::Call::batch { calls: vec![] }); + let call = crate::RuntimeCall::Utility(pallet_utility::Call::batch { + calls: vec![call; 1], + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_utility", "batch-size=1", dispatch_info, call_len)); + + // batch, 32 call within + let call = crate::RuntimeCall::Utility(pallet_utility::Call::batch { calls: vec![] }); + let call = crate::RuntimeCall::Utility(pallet_utility::Call::batch { + calls: vec![call; 32], + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_utility", "batch-size=32", dispatch_info, call_len)); + + // as_derivative + let call = crate::RuntimeCall::Utility(pallet_utility::Call::as_derivative { + index: 1, + call: Box::new(call), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_utility", "as_derivative", dispatch_info, call_len)); + + // batch_all + let call = crate::RuntimeCall::Utility(pallet_utility::Call::batch_all { calls: vec![] }); + let call = crate::RuntimeCall::Utility(pallet_utility::Call::batch { + calls: vec![call; 1], + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_utility", + "batch_all-size=1", + dispatch_info, + call_len, + )); + + // batch_all + let call = crate::RuntimeCall::Utility(pallet_utility::Call::batch_all { calls: vec![] }); + let call = crate::RuntimeCall::Utility(pallet_utility::Call::batch { + calls: vec![call; 32], + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_utility", + "batch_all-size=32", + dispatch_info, + call_len, + )); + + // dispatch_as + let origin: crate::RuntimeOrigin = frame_system::RawOrigin::Signed(ALICE).into(); + let as_origin: ::PalletsOrigin = + origin.caller().clone(); + let call = crate::RuntimeCall::Utility(pallet_utility::Call::dispatch_as { + as_origin: Box::new(as_origin), + call: Box::new(call), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_utility", "dispatch_as", dispatch_info, call_len)); + + // force_batch + let call = crate::RuntimeCall::Utility(pallet_utility::Call::force_batch { calls: vec![] }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_utility", "force_batch", dispatch_info, call_len)); + } + + // pallet_randomness + { + assert_eq!( + crate::RuntimeCall::get_call_names("Randomness").len(), + 1, + "Please update new extrinsic here." + ); + // set_babe_randomness_results + let call = + crate::RuntimeCall::Randomness(pallet_randomness::Call::set_babe_randomness_results {}); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_randomness", + "set_babe_randomness_results", + dispatch_info, + call_len, + )); + } + + // pallet_name_service + { + assert_eq!( + crate::RuntimeCall::get_call_names("NameService").len(), + 5, + "Please update new extrinsic here." + ); + // register + let call = crate::RuntimeCall::NameService(pallet_name_service::Call::register { + username: "test".as_bytes().to_vec(), + registrant: ALICE.clone().into(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_name_service", "register", dispatch_info, call_len)); + + // accept_register + let call = crate::RuntimeCall::NameService(pallet_name_service::Call::accept_register { + username: "test".as_bytes().to_vec(), + registrant: ALICE.clone().into(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_name_service", + "accept_register", + dispatch_info, + call_len, + )); + + // set_primary_name + let call = crate::RuntimeCall::NameService(pallet_name_service::Call::set_primary_name { + username: "test".as_bytes().to_vec(), + registrant: ALICE.clone().into(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_name_service", + "set_primary_name", + dispatch_info, + call_len, + )); + + // cancel_pending_register + let call = + crate::RuntimeCall::NameService(pallet_name_service::Call::cancel_pending_register { + username: "test".as_bytes().to_vec(), + registrant: ALICE.clone().into(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_name_service", + "cancel_pending_register", + dispatch_info, + call_len, + )); + + // remove_register + let call = crate::RuntimeCall::NameService(pallet_name_service::Call::remove_register { + username: "test".as_bytes().to_vec(), + registrant: ALICE.clone().into(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_name_service", + "remove_register", + dispatch_info, + call_len, + )); + } + + // pallet_farming + { + assert_eq!( + crate::RuntimeCall::get_call_names("Farming").len(), + 14, + "Please update new extrinsic here." + ); + // create_farming_pool + let call = crate::RuntimeCall::Farming(pallet_farming::Call::create_farming_pool { + tokens_proportion: vec![ + (1, Perbill::from_percent(20)), + (2, Perbill::from_percent(40)), + ], + basic_rewards: vec![(1, 64), (2, 128)], + gauge_init: None, + min_deposit_to_start: 10, + after_block_to_start: 100, + withdraw_limit_time: 200, + claim_limit_time: 300, + withdraw_limit_count: 6, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_farming", + "create_farming_pool", + dispatch_info, + call_len, + )); + + // charge + let call = crate::RuntimeCall::Farming(pallet_farming::Call::charge { + pool_id: 1, + rewards: vec![(1, 64), (2, 128)], + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_farming", "charge", dispatch_info, call_len)); + + // deposit + let call = crate::RuntimeCall::Farming(pallet_farming::Call::deposit { + pool_id: 1, + add_value: 100, + gauge_info: Some((10, 64)), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_farming", "deposit", dispatch_info, call_len)); + + // withdraw + let call = crate::RuntimeCall::Farming(pallet_farming::Call::withdraw { + pool_id: 1, + remove_value: Some(100), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_farming", "withdraw", dispatch_info, call_len)); + + // claim + let call = crate::RuntimeCall::Farming(pallet_farming::Call::claim { pool_id: 1 }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_farming", "claim", dispatch_info, call_len)); + + // withdraw_claim + let call = crate::RuntimeCall::Farming(pallet_farming::Call::withdraw_claim { pool_id: 1 }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_farming", "withdraw_claim", dispatch_info, call_len)); + + // close_pool + let call = crate::RuntimeCall::Farming(pallet_farming::Call::close_pool { pool_id: 1 }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_farming", "close_pool", dispatch_info, call_len)); + + // set_retire_limit + let call = + crate::RuntimeCall::Farming(pallet_farming::Call::set_retire_limit { limit: 16 }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_farming", + "set_retire_limit", + dispatch_info, + call_len, + )); + + // retire_pool + let call = crate::RuntimeCall::Farming(pallet_farming::Call::retire_pool { pool_id: 1 }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_farming", "retire_pool", dispatch_info, call_len)); + + // reset_pool + let call = crate::RuntimeCall::Farming(pallet_farming::Call::reset_pool { + pool_id: 1, + basic_rewards: Some(vec![(1, 64), (2, 128)]), + min_deposit_to_start: Some(10), + after_block_to_start: Some(100), + withdraw_limit_time: Some(200), + claim_limit_time: Some(300), + withdraw_limit_count: Some(6), + gauge_init: None, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_farming", "reset_pool", dispatch_info, call_len)); + + // kill_pool + let call = crate::RuntimeCall::Farming(pallet_farming::Call::kill_pool { pool_id: 1 }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_farming", "kill_pool", dispatch_info, call_len)); + + // edit_pool + let call = crate::RuntimeCall::Farming(pallet_farming::Call::edit_pool { + pool_id: 1, + basic_rewards: Some(vec![(1, 64), (2, 128)]), + withdraw_limit_time: Some(200), + claim_limit_time: Some(300), + gauge_basic_rewards: Some(vec![(1, 64), (2, 128)]), + withdraw_limit_count: Some(6), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_farming", "edit_pool", dispatch_info, call_len)); + + // gauge_withdraw + let call = crate::RuntimeCall::Farming(pallet_farming::Call::gauge_withdraw { gid: 1 }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_farming", "gauge_withdraw", dispatch_info, call_len)); + + // force_gauge_claim + let call = crate::RuntimeCall::Farming(pallet_farming::Call::force_gauge_claim { gid: 1 }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_farming", + "force_gauge_claim", + dispatch_info, + call_len, + )); + } + + // pallet_lottery + { + assert_eq!( + crate::RuntimeCall::get_call_names("Lottery").len(), + 12, + "Please update new extrinsic here." + ); + t.execute_with(|| { + // deposit + let call = crate::RuntimeCall::Lottery(pallet_lottery::Call::deposit { amount: 10 }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_lottery", "deposit", dispatch_info, call_len)); + // request_withdraw + let call = + crate::RuntimeCall::Lottery(pallet_lottery::Call::request_withdraw { amount: 10 }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_lottery", + "request_withdraw", + dispatch_info, + call_len, + )); + + // claim_my_winnings + let call = crate::RuntimeCall::Lottery(pallet_lottery::Call::claim_my_winnings {}); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_lottery", + "claim_my_winnings", + dispatch_info, + call_len, + )); + // rebalance_stake + let call = crate::RuntimeCall::Lottery(pallet_lottery::Call::rebalance_stake {}); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_lottery", + "rebalance_stake", + dispatch_info, + call_len, + )); + + // start_lottery + let call = crate::RuntimeCall::Lottery(pallet_lottery::Call::start_lottery {}); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_lottery", + "start_lottery", + dispatch_info, + call_len, + )); + + // stop_lottery + let call = crate::RuntimeCall::Lottery(pallet_lottery::Call::stop_lottery {}); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_lottery", + "stop_lottery", + dispatch_info, + call_len, + )); + + // draw_lottery + let call = crate::RuntimeCall::Lottery(pallet_lottery::Call::draw_lottery {}); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_lottery", + "draw_lottery", + dispatch_info, + call_len, + )); + + // process_matured_withdrawals + let call = + crate::RuntimeCall::Lottery(pallet_lottery::Call::process_matured_withdrawals {}); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_lottery", + "process_matured_withdrawals", + dispatch_info, + call_len, + )); + + // liquidate_lottery + let call = crate::RuntimeCall::Lottery(pallet_lottery::Call::liquidate_lottery {}); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_lottery", + "liquidate_lottery", + dispatch_info, + call_len, + )); + + // set_min_deposit + let call = crate::RuntimeCall::Lottery(pallet_lottery::Call::set_min_deposit { + min_deposit: 10, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_lottery", + "set_min_deposit", + dispatch_info, + call_len, + )); + + // set_min_withdraw + let call = crate::RuntimeCall::Lottery(pallet_lottery::Call::set_min_withdraw { + min_withdraw: 10, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_lottery", + "set_min_withdraw", + dispatch_info, + call_len, + )); + + // set_gas_reserve + let call = crate::RuntimeCall::Lottery(pallet_lottery::Call::set_gas_reserve { + gas_reserve: 10, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_lottery", + "set_gas_reserve", + dispatch_info, + call_len, + )); + }); + } + + // zenlink_protocol + { + use zenlink_protocol::AssetId as ZenlinkAssetId; + assert_eq!( + crate::RuntimeCall::get_call_names("ZenlinkProtocol").len(), + 16, + "Please update new extrinsic here." + ); + // set_fee_receiver + let call = crate::RuntimeCall::ZenlinkProtocol(zenlink_protocol::Call::set_fee_receiver { + receiver: Some(ALICE.clone()), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "zenlink_protocol", + "set_fee_receiver", + dispatch_info, + call_len, + )); + + // set_fee_point + let call = crate::RuntimeCall::ZenlinkProtocol(zenlink_protocol::Call::set_fee_point { + fee_point: 8, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("zenlink_protocol", "set_fee_point", dispatch_info, call_len)); + + // transfer + let asset_id = ZenlinkAssetId { + chain_id: 2084, + asset_type: 0, + asset_index: 10, // native token + }; + let call = crate::RuntimeCall::ZenlinkProtocol(zenlink_protocol::Call::transfer { + asset_id, + recipient: ALICE.clone(), + amount: 10, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("zenlink_protocol", "transfer", dispatch_info, call_len)); + + // create_pair + let asset_1 = ZenlinkAssetId { + chain_id: 2084, + asset_type: 1, + asset_index: 45, // non native token + }; + let call = crate::RuntimeCall::ZenlinkProtocol(zenlink_protocol::Call::create_pair { + asset_0: asset_id, + asset_1, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("zenlink_protocol", "transfer", dispatch_info, call_len)); + + // add_liquidity + let call = crate::RuntimeCall::ZenlinkProtocol(zenlink_protocol::Call::add_liquidity { + asset_0: asset_id, + asset_1, + amount_0_desired: 2, + amount_1_desired: 4, + amount_0_min: 1, + amount_1_min: 3, + deadline: 20, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("zenlink_protocol", "add_liquidity", dispatch_info, call_len)); + + // remove_liquidity + let call = crate::RuntimeCall::ZenlinkProtocol(zenlink_protocol::Call::remove_liquidity { + asset_0: asset_id, + asset_1, + liquidity: 4, + amount_0_min: 1, + amount_1_min: 3, + recipient: ALICE.clone(), + deadline: 20, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "zenlink_protocol", + "remove_liquidity", + dispatch_info, + call_len, + )); + + // swap_exact_assets_for_assets + let asset_2 = ZenlinkAssetId { + chain_id: 2084, + asset_type: 8, + asset_index: 45, // non native token + }; + let call = crate::RuntimeCall::ZenlinkProtocol( + zenlink_protocol::Call::swap_exact_assets_for_assets { + amount_in: 1, + amount_out_min: 4, + path: vec![asset_id, asset_2, asset_1], + recipient: ALICE.clone(), + deadline: 20, + }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "zenlink_protocol", + "swap_exact_assets_for_assets", + dispatch_info, + call_len, + )); + + // swap_assets_for_exact_assets + let call = crate::RuntimeCall::ZenlinkProtocol( + zenlink_protocol::Call::swap_assets_for_exact_assets { + amount_out: 1, + amount_in_max: 4, + path: vec![asset_id, asset_2, asset_1], + recipient: ALICE.clone(), + deadline: 20, + }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "zenlink_protocol", + "swap_assets_for_exact_assets", + dispatch_info, + call_len, + )); + + // bootstrap_create + let call = crate::RuntimeCall::ZenlinkProtocol(zenlink_protocol::Call::bootstrap_create { + asset_0: asset_id, + asset_1, + target_supply_0: 1000, + target_supply_1: 5000, + capacity_supply_0: 1000000, + capacity_supply_1: 5000000, + end: 20, + rewards: vec![asset_2, asset_1], + limits: vec![(asset_1, 50000), (asset_2, 60000)], + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "zenlink_protocol", + "bootstrap_create", + dispatch_info, + call_len, + )); + + // bootstrap_contribute + let call = + crate::RuntimeCall::ZenlinkProtocol(zenlink_protocol::Call::bootstrap_contribute { + asset_0: asset_id, + asset_1, + amount_0_contribute: 100, + amount_1_contribute: 500, + deadline: 20, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "zenlink_protocol", + "bootstrap_contribute", + dispatch_info, + call_len, + )); + + // bootstrap_claim + let call = crate::RuntimeCall::ZenlinkProtocol(zenlink_protocol::Call::bootstrap_claim { + recipient: ALICE.clone(), + asset_0: asset_id, + asset_1, + deadline: 20, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "zenlink_protocol", + "bootstrap_claim", + dispatch_info, + call_len, + )); + + // bootstrap_end + let call = crate::RuntimeCall::ZenlinkProtocol(zenlink_protocol::Call::bootstrap_end { + asset_0: asset_id, + asset_1, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("zenlink_protocol", "bootstrap_end", dispatch_info, call_len)); + + // bootstrap_update + let call = crate::RuntimeCall::ZenlinkProtocol(zenlink_protocol::Call::bootstrap_update { + asset_0: asset_id, + asset_1, + target_supply_0: 1500, + target_supply_1: 7500, + capacity_supply_0: 10000000, + capacity_supply_1: 50000000, + end: 100, + rewards: vec![asset_2, asset_1], + limits: vec![(asset_1, 100000), (asset_2, 600000)], + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "zenlink_protocol", + "bootstrap_update", + dispatch_info, + call_len, + )); + + // bootstrap_refund + let call = crate::RuntimeCall::ZenlinkProtocol(zenlink_protocol::Call::bootstrap_refund { + asset_0: asset_id, + asset_1, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "zenlink_protocol", + "bootstrap_refund", + dispatch_info, + call_len, + )); + + // bootstrap_charge_reward + let call = + crate::RuntimeCall::ZenlinkProtocol(zenlink_protocol::Call::bootstrap_charge_reward { + asset_0: asset_id, + asset_1, + charge_rewards: vec![(asset_1, 1000), (asset_id, 6000)], + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "zenlink_protocol", + "bootstrap_charge_reward", + dispatch_info, + call_len, + )); + + // bootstrap_withdraw_reward + let call = crate::RuntimeCall::ZenlinkProtocol( + zenlink_protocol::Call::bootstrap_withdraw_reward { + asset_0: asset_id, + asset_1, + recipient: ALICE.clone(), + }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "zenlink_protocol", + "bootstrap_withdraw_reward", + dispatch_info, + call_len, + )); + } + + (calamari_runtime_calls, t) +} diff --git a/runtime/calamari/src/lib.rs b/runtime/calamari/src/lib.rs index 7f928a6d1..306a57688 100644 --- a/runtime/calamari/src/lib.rs +++ b/runtime/calamari/src/lib.rs @@ -81,6 +81,8 @@ use xcm::latest::prelude::*; pub mod assets_config; pub mod currency; +#[cfg(test)] +mod diff_tx_fees; pub mod fee; pub mod impls; pub mod migrations; diff --git a/runtime/calamari/tx-fees-data/4.3.1-tx-fees.csv b/runtime/calamari/tx-fees-data/4.3.1-tx-fees.csv new file mode 100644 index 000000000..6329ca69a --- /dev/null +++ b/runtime/calamari/tx-fees-data/4.3.1-tx-fees.csv @@ -0,0 +1,724 @@ +module,extrinsic,tx_fee_with_decimal,tx_fee_without_decimal,fee_multiplier +frame_system,remark-length=32,495240449935,0.495240449935,0.0002 +frame_system,remark-length=64,495240449935,0.495240449935,0.0002 +frame_system,set_heap_pages,495212245000,0.495212245,0.0002 +frame_system,set_code,995220000000,0.99522,0.0002 +frame_system,set_code_without_checks,995220000000,0.99522,0.0002 +frame_system,set_storage,495666027035,0.495666027035,0.0002 +frame_system,kill_storage,495765006870,0.49576500687,0.0002 +frame_system,kill_prefix,496176377275,0.496176377275,0.0002 +frame_system,remark_with_event-length=32,495233735248,0.495233735248,0.0002 +frame_system,remark_with_event-length=64,495233735248,0.495233735248,0.0002 +pallet_treasury,propose_spend,495487916000,0.495487916,0.0002 +pallet_treasury,reject_proposal,495202928000,0.495202928,0.0002 +pallet_treasury,approve_proposal,495075751422,0.495075751422,0.0002 +pallet_treasury,spend,495230227000,0.495230227,0.0002 +pallet_treasury,remove_approval,495035672000,0.495035672,0.0002 +pallet_timestamp,set,495033796000,0.495033796,0.0002 +pallet_preimage,note_preimage-length=32,495479572888,0.495479572888,0.0002 +pallet_preimage,note_preimage-length=32,495809666776,0.495809666776,0.0002 +pallet_preimage,unnote_preimage,495478276000,0.495478276,0.0002 +pallet_preimage,request_preimage,495364866000,0.495364866,0.0002 +pallet_preimage,unrequest_preimage,495463617000,0.495463617,0.0002 +pallet_multisig,as_multi_threshold_1,495958380145,0.495958380145,0.0002 +pallet_multisig,as_multi,495903129917,0.495903129917,0.0002 +pallet_multisig,approve_as_multi,495778609392,0.495778609392,0.0002 +pallet_multisig,cancel_as_multi,495803494734,0.495803494734,0.0002 +pallet_membership,add_member,495270000000,0.49527,0.0002 +pallet_membership,remove_member,495270000000,0.49527,0.0002 +pallet_membership,swap_member,495600000000,0.4956,0.0002 +pallet_membership,reset_members,495590000000,0.49559,0.0002 +pallet_membership,change_key,495270000000,0.49527,0.0002 +pallet_membership,set_prime,495270000000,0.49527,0.0002 +pallet_membership,clear_prime,494940000000,0.49494,0.0002 +pallet_democracy,propose,495378807000,0.495378807,0.0002 +pallet_democracy,second,495072175000,0.495072175,0.0002 +pallet_democracy,vote,495518922000,0.495518922,0.0002 +pallet_democracy,emergency_cancel,495204933000,0.495204933,0.0002 +pallet_democracy,external_propose,495108754000,0.495108754,0.0002 +pallet_democracy,external_propose_majority,495045578000,0.495045578,0.0002 +pallet_democracy,external_propose_default,495045609000,0.495045609,0.0002 +pallet_democracy,fast_track,495664291000,0.495664291,0.0002 +pallet_democracy,veto_external,495491413000,0.495491413,0.0002 +pallet_democracy,cancel_referendum,495015330000,0.49501533,0.0002 +pallet_democracy,delegate,508835694528,0.508835694528,0.0002 +pallet_democracy,undelegate,508062375029,0.508062375029,0.0002 +pallet_democracy,clear_public_proposals,494995765000,0.494995765,0.0002 +pallet_democracy,unlock,495641907257,0.495641907257,0.0002 +pallet_democracy,remove_vote,495213750628,0.495213750628,0.0002 +pallet_democracy,remove_other_vote,495544064329,0.495544064329,0.0002 +pallet_democracy,blacklist,496073915000,0.496073915,0.0002 +pallet_democracy,cancel_proposal,495349470000,0.49534947,0.0002 +pallet_collective,set_members,509586669428,0.509586669428,0.0002 +pallet_collective,execute,495428218332,0.495428218332,0.0002 +pallet_collective,propose,495492925091,0.495492925091,0.0002 +pallet_collective,vote,495422264923,0.495422264923,0.0002 +pallet_collective,close,495747440771,0.495747440771,0.0002 +pallet_collective,disapprove_proposal,495575555927,0.495575555927,0.0002 +cumulus_pallet_xcmp_queue,service_overweight,495051000064,0.495051000064,0.0002 +cumulus_pallet_xcmp_queue,suspend_xcm_execution,494990000000,0.49499,0.0002 +cumulus_pallet_xcmp_queue,resume_xcm_execution,494990000000,0.49499,0.0002 +cumulus_pallet_xcmp_queue,update_suspend_threshold,495062698000,0.495062698,0.0002 +cumulus_pallet_xcmp_queue,update_drop_threshold,495062698000,0.495062698,0.0002 +cumulus_pallet_xcmp_queue,update_resume_threshold,495062698000,0.495062698,0.0002 +cumulus_pallet_xcmp_queue,update_threshold_weight,495102571000,0.495102571,0.0002 +cumulus_pallet_xcmp_queue,update_weight_restrict_decay,495102571000,0.495102571,0.0002 +cumulus_pallet_xcmp_queue,update_xcmp_max_individual_weight,495102571000,0.495102571,0.0002 +orml_xtokens,transfer,495260000000,0.49526,0.0002 +orml_xtokens,transfer_multiasset,495070000000,0.49507,0.0002 +orml_xtokens,transfer_with_fee,495420000000,0.49542,0.0002 +orml_xtokens,transfer_multiasset_with_fee,495210000000,0.49521,0.0002 +orml_xtokens,transfer_multicurrencies,495640000000,0.49564,0.0002 +orml_xtokens,transfer_multiassets,495120000000,0.49512,0.0002 +calamari_vesting,vest,495361525000,0.495361525,0.0002 +manta_collator_selection,set_invulnerables,495334304899,0.495334304899,0.0002 +manta_collator_selection,set_desired_candidates,495046022000,0.495046022,0.0002 +manta_collator_selection,set_candidacy_bond,495164121000,0.495164121,0.0002 +manta_collator_selection,register_as_candidate,495180465557,0.495180465557,0.0002 +manta_collator_selection,register_candidate,495500278923,0.495500278923,0.0002 +manta_collator_selection,leave_intent,495061100506,0.495061100506,0.0002 +manta_collator_selection,remove_collator,495409672216,0.495409672216,0.0002 +manta_collator_selection,set_eviction_baseline,495013627000,0.495013627,0.0002 +manta_collator_selection,set_eviction_tolerance,495013646000,0.495013646,0.0002 +pallet_asset_manager,register_asset,495991247000,0.495991247,0.0002 +pallet_asset_manager,update_asset_location,495628914000,0.495628914,0.0002 +pallet_asset_manager,update_asset_metadata,495730585000,0.495730585,0.0002 +pallet_asset_manager,set_units_per_second,495101694000,0.495101694,0.0002 +pallet_asset_manager,mint_asset,495762481000,0.495762481,0.0002 +pallet_asset_manager,set_min_xcm_fee,495084526000,0.495084526,0.0002 +pallet_asset_manager,update_outgoing_filtered_assets,495082697000,0.495082697,0.0002 +pallet_asset_manager,register_lp_asset,496337434000,0.496337434,0.0002 +pallet_assets,create,495693857000,0.495693857,0.0002 +pallet_assets,force_create,495545176000,0.495545176,0.0002 +pallet_assets,start_destroy,495196886000,0.495196886,0.0002 +pallet_assets,destroy_accounts,761483940000,0.76148394,0.0002 +pallet_assets,destroy_approvals,628438832000,0.628438832,0.0002 +pallet_assets,finish_destroy,495223593000,0.495223593,0.0002 +pallet_assets,mint,495678299000,0.495678299,0.0002 +pallet_assets,burn,495698693000,0.495698693,0.0002 +pallet_assets,transfer,495950685000,0.495950685,0.0002 +pallet_assets,transfer_keep_alive,495940716000,0.495940716,0.0002 +pallet_assets,force_transfer,496280116000,0.496280116,0.0002 +pallet_assets,freeze,495557813000,0.495557813,0.0002 +pallet_assets,thaw,495557655000,0.495557655,0.0002 +pallet_assets,freeze_asset,495197047000,0.495197047,0.0002 +pallet_assets,thaw_asset,495196909000,0.495196909,0.0002 +pallet_assets,transfer_ownership,495554245000,0.495554245,0.0002 +pallet_assets,set_team,496185174000,0.496185174,0.0002 +pallet_assets,set_metadata,495895900673,0.495895900673,0.0002 +pallet_assets,clear_metadata,495224628000,0.495224628,0.0002 +pallet_assets,force_set_metadata,495912687948,0.495912687948,0.0002 +pallet_assets,force_clear_metadata,495225852000,0.495225852,0.0002 +pallet_assets,force_asset_status,496545916000,0.496545916,0.0002 +pallet_assets,approve_transfer,495668677000,0.495668677,0.0002 +pallet_assets,cancel_approval,495659625000,0.495659625,0.0002 +pallet_assets,force_cancel_approval,495991887000,0.495991887,0.0002 +pallet_assets,transfer_approved,496409733000,0.496409733,0.0002 +pallet_assets,touch,495338299000,0.495338299,0.0002 +pallet_assets,refund,495348299000,0.495348299,0.0002 +pallet_author_inherent,kick_off_authorship_validation,495108246000,0.495108246,0.0002 +pallet_balances,transfer-1,495405741000,0.495405741,0.0002 +pallet_balances,transfer-1000_000,495435741000,0.495435741,0.0002 +pallet_balances,set_balance,495394750000,0.49539475,0.0002 +pallet_balances,force_transfer,495859258000,0.495859258,0.0002 +pallet_balances,transfer_keep_alive-1,495392193000,0.495392193,0.0002 +pallet_balances,transfer_keep_alive-1000_000,495422193000,0.495422193,0.0002 +pallet_balances,transfer_all,495398326000,0.495398326,0.0002 +pallet_balances,force_unreserve,495527144000,0.495527144,0.0002 +pallet_manta_pay,to_private,536613228000,0.536613228,0.0002 +pallet_manta_pay,private_transfer,568647633000,0.568647633,0.0002 +pallet_manta_pay,to_public,550462672000,0.550462672,0.0002 +pallet_manta_pay,public_transfer,496134694000,0.496134694,0.0002 +pallet_manta_sbt,to_private,536358429000,0.536358429,0.0002 +pallet_manta_sbt,force_to_private,536480380000,0.53648038,0.0002 +pallet_manta_sbt,reserve_sbt,495356296000,0.495356296,0.0002 +pallet_manta_sbt,allowlist_evm_account,495487074000,0.495487074,0.0002 +pallet_manta_sbt,set_next_sbt_id,495175875000,0.495175875,0.0002 +pallet_manta_sbt,remove_allowlist_evm_account,495247103000,0.495247103,0.0002 +pallet_manta_sbt,change_free_reserve_account,495351869000,0.495351869,0.0002 +pallet_manta_sbt,force_mint_sbt_eth,537151589000,0.537151589,0.0002 +pallet_manta_sbt,change_force_account,495336677000,0.495336677,0.0002 +pallet_manta_sbt,mint_sbt_eth,537480349000,0.537480349,0.0002 +pallet_manta_sbt,change_allowlist_account,495336806000,0.495336806,0.0002 +pallet_manta_sbt,update_mint_info,495288824000,0.495288824,0.0002 +pallet_manta_sbt,new_mint_info,495345635000,0.495345635,0.0002 +pallet_parachain_staking,set_staking_expectations,495516263000,0.495516263,0.0002 +pallet_parachain_staking,set_inflation,495201917000,0.495201917,0.0002 +pallet_parachain_staking,set_parachain_bond_account,495356426000,0.495356426,0.0002 +pallet_parachain_staking,set_parachain_bond_account,495356426000,0.495356426,0.0002 +pallet_parachain_staking,set_parachain_bond_reserve_percent,495045170000,0.49504517,0.0002 +pallet_parachain_staking,set_total_selected,495046803000,0.495046803,0.0002 +pallet_parachain_staking,set_collator_commission,495044299000,0.495044299,0.0002 +pallet_parachain_staking,set_blocks_per_round,495121280000,0.49512128,0.0002 +pallet_parachain_staking,join_candidates,495854816070,0.49585481607,0.0002 +pallet_parachain_staking,schedule_leave_candidates,495187966896,0.495187966896,0.0002 +pallet_parachain_staking,execute_leave_candidates,496613154810,0.49661315481,0.0002 +pallet_parachain_staking,cancel_leave_candidates,495186047648,0.495186047648,0.0002 +pallet_parachain_staking,go_offline,495172191000,0.495172191,0.0002 +pallet_parachain_staking,go_offline,495172191000,0.495172191,0.0002 +pallet_parachain_staking,candidate_bond_more,495575927000,0.495575927,0.0002 +pallet_parachain_staking,schedule_candidate_bond_less,495203809000,0.495203809,0.0002 +pallet_parachain_staking,execute_candidate_bond_less,495898191000,0.495898191,0.0002 +pallet_parachain_staking,cancel_candidate_bond_less,495041302000,0.495041302,0.0002 +pallet_parachain_staking,delegate_1_2_3,496195721012,0.496195721012,0.0002 +pallet_parachain_staking,delegate_1_25_3,496202879141,0.496202879141,0.0002 +pallet_parachain_staking,delegate_1_2_100,496222622680,0.49622262268,0.0002 +pallet_parachain_staking,schedule_leave_delegators,495171385000,0.495171385,0.0002 +pallet_parachain_staking,execute_leave_delegators,496706744010,0.49670674401,0.0002 +pallet_parachain_staking,cancel_leave_delegators,495173158000,0.495173158,0.0002 +pallet_parachain_staking,schedule_revoke_delegation,495491462000,0.495491462,0.0002 +pallet_parachain_staking,delegator_bond_more,496194764000,0.496194764,0.0002 +pallet_parachain_staking,schedule_delegator_bond_less,495501613000,0.495501613,0.0002 +pallet_parachain_staking,execute_delegation_request,496615107000,0.496615107,0.0002 +pallet_parachain_staking,cancel_delegation_request,495497847000,0.495497847,0.0002 +pallet_scheduler,cancel,495290357970,0.49529035797,0.0002 +pallet_scheduler,schedule,495240778188,0.495240778188,0.0002 +pallet_scheduler,schedule_named,495771384390,0.49577138439,0.0002 +pallet_scheduler,cancel_named,495559893605,0.495559893605,0.0002 +pallet_scheduler,schedule_after,495480778188,0.495480778188,0.0002 +pallet_scheduler,schedule_named_after,496011384390,0.49601138439,0.0002 +pallet_session,set_keys,496713297000,0.496713297,0.0002 +pallet_session,purge_keys,495340258000,0.495340258,0.0002 +pallet_tx_pause,pause_transaction,495694814000,0.495694814,0.0002 +pallet_tx_pause,unpause_transaction,495696195000,0.495696195,0.0002 +pallet_tx_pause,pause_transactions,496189628000,0.496189628,0.0002 +pallet_tx_pause,unpause_transactions,496192390000,0.49619239,0.0002 +pallet_tx_pause,pause_pallets,502800700000,0.5028007,0.0002 +pallet_tx_pause,unpause_pallets,502800700000,0.5028007,0.0002 +pallet_utility,batch-size=1,495004963474,0.495004963474,0.0002 +pallet_utility,batch-size=32,497176946048,0.497176946048,0.0002 +pallet_utility,as_derivative,497348996048,0.497348996048,0.0002 +pallet_utility,batch_all-size=1,495010589730,0.49501058973,0.0002 +pallet_utility,batch_all-size=32,497356986240,0.49735698624,0.0002 +pallet_utility,dispatch_as,497732404240,0.49773240424,0.0002 +pallet_utility,force_batch,494930521082,0.494930521082,0.0002 +pallet_randomness,set_babe_randomness_results,495279651000,0.495279651,0.0002 +pallet_name_service,register,495586720000,0.49558672,0.0002 +pallet_name_service,accept_register,495512297000,0.495512297,0.0002 +pallet_name_service,set_primary_name,495437925000,0.495437925,0.0002 +pallet_name_service,cancel_pending_register,495409540000,0.49540954,0.0002 +pallet_name_service,remove_register,495437940000,0.49543794,0.0002 +pallet_farming,create_farming_pool,496514763000,0.496514763,0.0002 +pallet_farming,charge,496393225000,0.496393225,0.0002 +pallet_farming,deposit,496107597000,0.496107597,0.0002 +pallet_farming,withdraw,495510143000,0.495510143,0.0002 +pallet_farming,claim,495366283000,0.495366283,0.0002 +pallet_farming,withdraw_claim,495366283000,0.495366283,0.0002 +pallet_farming,close_pool,495050001000,0.495050001,0.0002 +pallet_farming,set_retire_limit,494930001000,0.494930001,0.0002 +pallet_farming,retire_pool,495050001000,0.495050001,0.0002 +pallet_farming,reset_pool,496060001000,0.496060001,0.0002 +pallet_farming,kill_pool,495050001000,0.495050001,0.0002 +pallet_farming,edit_pool,496490001000,0.496490001,0.0002 +pallet_farming,gauge_withdraw,495394881000,0.495394881,0.0002 +pallet_farming,force_gauge_claim,495050001000,0.495050001,0.0002 +pallet_lottery,deposit,497149654002,0.497149654002,0.0002 +pallet_lottery,request_withdraw,496515492952,0.496515492952,0.0002 +pallet_lottery,claim_my_winnings,495470863826,0.495470863826,0.0002 +pallet_lottery,rebalance_stake,494890000000,0.49489,0.0002 +pallet_lottery,start_lottery,495357425000,0.495357425,0.0002 +pallet_lottery,stop_lottery,495183149000,0.495183149,0.0002 +pallet_lottery,draw_lottery,495269402000,0.495269402,0.0002 +pallet_lottery,process_matured_withdrawals,494978516000,0.494978516,0.0002 +pallet_lottery,liquidate_lottery,494890000000,0.49489,0.0002 +pallet_lottery,set_min_deposit,495183711000,0.495183711,0.0002 +pallet_lottery,set_min_withdraw,495154620000,0.49515462,0.0002 +pallet_lottery,set_gas_reserve,495164326000,0.495164326,0.0002 +zenlink_protocol,set_fee_receiver,495353045000,0.495353045,0.0002 +zenlink_protocol,set_fee_point,495032540000,0.49503254,0.0002 +zenlink_protocol,transfer,495351000000,0.495351,0.0002 +zenlink_protocol,transfer,495457130000,0.49545713,0.0002 +zenlink_protocol,add_liquidity,498984648000,0.498984648,0.0002 +zenlink_protocol,remove_liquidity,497561416000,0.497561416,0.0002 +zenlink_protocol,swap_exact_assets_for_assets,496568961000,0.496568961,0.0002 +zenlink_protocol,swap_assets_for_exact_assets,496569156000,0.496569156,0.0002 +zenlink_protocol,bootstrap_create,496490660000,0.49649066,0.0002 +zenlink_protocol,bootstrap_contribute,496065317000,0.496065317,0.0002 +zenlink_protocol,bootstrap_claim,498336141000,0.498336141,0.0002 +zenlink_protocol,bootstrap_end,499158518000,0.499158518,0.0002 +zenlink_protocol,bootstrap_update,496532326000,0.496532326,0.0002 +zenlink_protocol,bootstrap_refund,495995596000,0.495995596,0.0002 +zenlink_protocol,bootstrap_charge_reward,495840000000,0.49584,0.0002 +zenlink_protocol,bootstrap_withdraw_reward,495570000000,0.49557,0.0002 +frame_system,remark-length=32,515669935000,0.515669935,0.2 +frame_system,remark-length=64,515669935000,0.515669935,0.2 +frame_system,set_heap_pages,737215000000,0.737215,0.2 +frame_system,set_code,500495220000000,500.49521999999996,0.2 +frame_system,set_code_without_checks,500495220000000,500.49521999999996,0.2 +frame_system,set_storage,601587035000,0.601587035,0.2 +frame_system,kill_storage,700566870000,0.70056687,0.2 +frame_system,kill_prefix,1411637275000,1.411637275,0.2 +frame_system,remark_with_event-length=32,508955248000,0.508955248,0.2 +frame_system,remark_with_event-length=64,508955248000,0.508955248,0.2 +pallet_treasury,propose_spend,753146000000,0.753146,0.2 +pallet_treasury,reject_proposal,797828000000,0.797828,0.2 +pallet_treasury,approve_proposal,670651422000,0.670651422,0.2 +pallet_treasury,spend,495457000000,0.495457,0.2 +pallet_treasury,remove_approval,630572000000,0.630572,0.2 +pallet_timestamp,set,628696000000,0.628696,0.2 +pallet_preimage,note_preimage-length=32,754792888000,0.754792888,0.2 +pallet_preimage,note_preimage-length=32,755216776000,0.755216776,0.2 +pallet_preimage,unnote_preimage,763486000000,0.763486,0.2 +pallet_preimage,request_preimage,650076000000,0.650076,0.2 +pallet_preimage,unrequest_preimage,748827000000,0.748827,0.2 +pallet_multisig,as_multi_threshold_1,893940145000,0.893940145,0.2 +pallet_multisig,as_multi,788739917000,0.788739917,0.2 +pallet_multisig,approve_as_multi,684199392000,0.684199392,0.2 +pallet_multisig,cancel_as_multi,659134734000,0.659134734,0.2 +pallet_membership,add_member,545220000000,0.54522,0.2 +pallet_membership,remove_member,545220000000,0.54522,0.2 +pallet_membership,swap_member,545550000000,0.54555,0.2 +pallet_membership,reset_members,545540000000,0.54554,0.2 +pallet_membership,change_key,545220000000,0.54522,0.2 +pallet_membership,set_prime,545220000000,0.54522,0.2 +pallet_membership,clear_prime,544890000000,0.54489,0.2 +pallet_democracy,propose,923757000000,0.923757,0.2 +pallet_democracy,second,667075000000,0.667075,0.2 +pallet_democracy,vote,934002000000,0.934002,0.2 +pallet_democracy,emergency_cancel,769863000000,0.769863,0.2 +pallet_democracy,external_propose,663694000000,0.663694,0.2 +pallet_democracy,external_propose_majority,600518000000,0.600518,0.2 +pallet_democracy,external_propose_default,600549000000,0.600549,0.2 +pallet_democracy,fast_track,869581000000,0.869581,0.2 +pallet_democracy,veto_external,776623000000,0.776623,0.2 +pallet_democracy,cancel_referendum,610230000000,0.61023,0.2 +pallet_democracy,delegate,13941084528000,13.941084528,0.2 +pallet_democracy,undelegate,13667265029000,13.667265029,0.2 +pallet_democracy,clear_public_proposals,600655000000,0.600655,0.2 +pallet_democracy,unlock,917127257000,0.917127257,0.2 +pallet_democracy,remove_vote,778680628000,0.778680628,0.2 +pallet_democracy,remove_other_vote,779324329000,0.779324329,0.2 +pallet_democracy,blacklist,1309175000000,1.309175,0.2 +pallet_democracy,cancel_proposal,944370000000,0.94437,0.2 +pallet_collective,set_members,14172579428000,14.172579428,0.2 +pallet_collective,execute,993148332000,0.993148332,0.2 +pallet_collective,propose,1047865091000,1.047865091,0.2 +pallet_collective,vote,687494923000,0.687494923,0.2 +pallet_collective,close,992690771000,0.992690771,0.2 +pallet_collective,disapprove_proposal,860765927000,0.860765927,0.2 +cumulus_pallet_xcmp_queue,service_overweight,496050064000,0.496050064,0.2 +cumulus_pallet_xcmp_queue,suspend_xcm_execution,594890000000,0.59489,0.2 +cumulus_pallet_xcmp_queue,resume_xcm_execution,594890000000,0.59489,0.2 +cumulus_pallet_xcmp_queue,update_suspend_threshold,627628000000,0.627628,0.2 +cumulus_pallet_xcmp_queue,update_drop_threshold,627628000000,0.627628,0.2 +cumulus_pallet_xcmp_queue,update_resume_threshold,627628000000,0.627628,0.2 +cumulus_pallet_xcmp_queue,update_threshold_weight,627541000000,0.627541,0.2 +cumulus_pallet_xcmp_queue,update_weight_restrict_decay,627541000000,0.627541,0.2 +cumulus_pallet_xcmp_queue,update_xcmp_max_individual_weight,627541000000,0.627541,0.2 +orml_xtokens,transfer,495260000000,0.49526,0.2 +orml_xtokens,transfer_multiasset,495070000000,0.49507,0.2 +orml_xtokens,transfer_with_fee,495420000000,0.49542,0.2 +orml_xtokens,transfer_multiasset_with_fee,495210000000,0.49521,0.2 +orml_xtokens,transfer_multicurrencies,495640000000,0.49564,0.2 +orml_xtokens,transfer_multiassets,495120000000,0.49512,0.2 +calamari_vesting,vest,966415000000,0.966415,0.2 +manta_collator_selection,set_invulnerables,609524899000,0.609524899,0.2 +manta_collator_selection,set_desired_candidates,610952000000,0.610952,0.2 +manta_collator_selection,set_candidacy_bond,609171000000,0.609171,0.2 +manta_collator_selection,register_as_candidate,785355557000,0.785355557,0.2 +manta_collator_selection,register_candidate,785488923000,0.785488923,0.2 +manta_collator_selection,leave_intent,665990506000,0.665990506,0.2 +manta_collator_selection,remove_collator,694882216000,0.694882216,0.2 +manta_collator_selection,set_eviction_baseline,608527000000,0.608527,0.2 +manta_collator_selection,set_eviction_tolerance,608546000000,0.608546,0.2 +pallet_asset_manager,register_asset,1256477000000,1.256477,0.2 +pallet_asset_manager,update_asset_location,1193844000000,1.193844,0.2 +pallet_asset_manager,update_asset_metadata,865945000000,0.865945,0.2 +pallet_asset_manager,set_units_per_second,686604000000,0.686604,0.2 +pallet_asset_manager,mint_asset,877861000000,0.877861,0.2 +pallet_asset_manager,set_min_xcm_fee,649456000000,0.649456,0.2 +pallet_asset_manager,update_outgoing_filtered_assets,647627000000,0.647627,0.2 +pallet_asset_manager,register_lp_asset,1312954000000,1.312954,0.2 +pallet_assets,create,649397000000,0.649397,0.2 +pallet_assets,force_create,640576000000,0.640576,0.2 +pallet_assets,start_destroy,641936000000,0.641936,0.2 +pallet_assets,destroy_accounts,266928990000000,266.92899,0.2 +pallet_assets,destroy_approvals,133883882000000,133.883882,0.2 +pallet_assets,finish_destroy,668643000000,0.668643,0.2 +pallet_assets,mint,783689000000,0.783689,0.2 +pallet_assets,burn,804083000000,0.804083,0.2 +pallet_assets,transfer,1056075000000,1.056075,0.2 +pallet_assets,transfer_keep_alive,1046106000000,1.046106,0.2 +pallet_assets,force_transfer,1055836000000,1.055836,0.2 +pallet_assets,freeze,673193000000,0.673193,0.2 +pallet_assets,thaw,673035000000,0.673035,0.2 +pallet_assets,freeze_asset,642097000000,0.642097,0.2 +pallet_assets,thaw_asset,641959000000,0.641959,0.2 +pallet_assets,transfer_ownership,669625000000,0.669625,0.2 +pallet_assets,set_team,641214000000,0.641214,0.2 +pallet_assets,set_metadata,671620673000,0.671620673,0.2 +pallet_assets,clear_metadata,669678000000,0.669678,0.2 +pallet_assets,force_set_metadata,678417948000,0.678417948,0.2 +pallet_assets,force_clear_metadata,670902000000,0.670902,0.2 +pallet_assets,force_asset_status,642316000000,0.642316,0.2 +pallet_assets,approve_transfer,774067000000,0.774067,0.2 +pallet_assets,cancel_approval,775005000000,0.775005,0.2 +pallet_assets,force_cancel_approval,777597000000,0.777597,0.2 +pallet_assets,transfer_approved,1185453000000,1.185453,0.2 +pallet_assets,touch,783349000000,0.783349,0.2 +pallet_assets,refund,783359000000,0.783359,0.2 +pallet_author_inherent,kick_off_authorship_validation,713136000000,0.713136,0.2 +pallet_balances,transfer-1,670971000000,0.670971,0.2 +pallet_balances,transfer-1000_000,671001000000,0.671001,0.2 +pallet_balances,set_balance,649990000000,0.64999,0.2 +pallet_balances,force_transfer,794818000000,0.794818,0.2 +pallet_balances,transfer_keep_alive-1,657423000000,0.657423,0.2 +pallet_balances,transfer_keep_alive-1000_000,657453000000,0.657453,0.2 +pallet_balances,transfer_all,663556000000,0.663556,0.2 +pallet_balances,force_unreserve,642524000000,0.642524,0.2 +pallet_manta_pay,to_private,40869468000000,40.869468,0.2 +pallet_manta_pay,private_transfer,72903873000000,72.90387299999999,0.2 +pallet_manta_pay,to_public,54718912000000,54.718912,0.2 +pallet_manta_pay,public_transfer,940384000000,0.940384,0.2 +pallet_manta_sbt,to_private,40574709000000,40.574709,0.2 +pallet_manta_sbt,force_to_private,40366990000000,40.36699,0.2 +pallet_manta_sbt,reserve_sbt,951196000000,0.951196,0.2 +pallet_manta_sbt,allowlist_evm_account,852204000000,0.852204,0.2 +pallet_manta_sbt,set_next_sbt_id,610935000000,0.610935,0.2 +pallet_manta_sbt,remove_allowlist_evm_account,612233000000,0.612233,0.2 +pallet_manta_sbt,change_free_reserve_account,627089000000,0.627089,0.2 +pallet_manta_sbt,force_mint_sbt_eth,40498739000000,40.49873900000001,0.2 +pallet_manta_sbt,change_force_account,611897000000,0.611897,0.2 +pallet_manta_sbt,mint_sbt_eth,40617709000000,40.617709,0.2 +pallet_manta_sbt,change_allowlist_account,612026000000,0.612026,0.2 +pallet_manta_sbt,update_mint_info,743864000000,0.743864,0.2 +pallet_manta_sbt,new_mint_info,840635000000,0.840635,0.2 +pallet_parachain_staking,set_staking_expectations,641633000000,0.641633,0.2 +pallet_parachain_staking,set_inflation,686927000000,0.686927,0.2 +pallet_parachain_staking,set_parachain_bond_account,641636000000,0.641636,0.2 +pallet_parachain_staking,set_parachain_bond_account,641636000000,0.641636,0.2 +pallet_parachain_staking,set_parachain_bond_reserve_percent,640070000000,0.64007,0.2 +pallet_parachain_staking,set_total_selected,641703000000,0.641703,0.2 +pallet_parachain_staking,set_collator_commission,639199000000,0.639199,0.2 +pallet_parachain_staking,set_blocks_per_round,716180000000,0.71618,0.2 +pallet_parachain_staking,join_candidates,1439726070000,1.43972607,0.2 +pallet_parachain_staking,schedule_leave_candidates,782866896000,0.782866896,0.2 +pallet_parachain_staking,execute_leave_candidates,1888374810000,1.88837481,0.2 +pallet_parachain_staking,cancel_leave_candidates,780947648000,0.780947648,0.2 +pallet_parachain_staking,go_offline,777081000000,0.777081,0.2 +pallet_parachain_staking,go_offline,777081000000,0.777081,0.2 +pallet_parachain_staking,candidate_bond_more,1170827000000,1.170827,0.2 +pallet_parachain_staking,schedule_candidate_bond_less,648859000000,0.648859,0.2 +pallet_parachain_staking,execute_candidate_bond_less,1183401000000,1.183401,0.2 +pallet_parachain_staking,cancel_candidate_bond_less,646192000000,0.646192,0.2 +pallet_parachain_staking,delegate_1_2_3,1450961012000,1.450961012,0.2 +pallet_parachain_staking,delegate_1_25_3,1458119141000,1.458119141,0.2 +pallet_parachain_staking,delegate_1_2_100,1467872680000,1.46787268,0.2 +pallet_parachain_staking,schedule_leave_delegators,776275000000,0.776275,0.2 +pallet_parachain_staking,execute_leave_delegators,1981964010000,1.98196401,0.2 +pallet_parachain_staking,cancel_leave_delegators,778048000000,0.778048,0.2 +pallet_parachain_staking,schedule_revoke_delegation,776672000000,0.776672,0.2 +pallet_parachain_staking,delegator_bond_more,1469984000000,1.469984,0.2 +pallet_parachain_staking,schedule_delegator_bond_less,776833000000,0.776833,0.2 +pallet_parachain_staking,execute_delegation_request,1580637000000,1.580637,0.2 +pallet_parachain_staking,cancel_delegation_request,783057000000,0.783057,0.2 +pallet_scheduler,cancel,815327970000,0.81532797,0.2 +pallet_scheduler,schedule,685828188000,0.685828188,0.2 +pallet_scheduler,schedule_named,816834390000,0.81683439,0.2 +pallet_scheduler,cancel_named,845103605000,0.845103605,0.2 +pallet_scheduler,schedule_after,686068188000,0.686068188,0.2 +pallet_scheduler,schedule_named_after,817074390000,0.81707439,0.2 +pallet_session,set_keys,1029477000000,1.029477,0.2 +pallet_session,purge_keys,945148000000,0.945148,0.2 +pallet_tx_pause,pause_transaction,640364000000,0.640364,0.2 +pallet_tx_pause,unpause_transaction,641745000000,0.641745,0.2 +pallet_tx_pause,pause_transactions,785528000000,0.785528,0.2 +pallet_tx_pause,unpause_transactions,788290000000,0.78829,0.2 +pallet_tx_pause,pause_pallets,7736260000000,7.73626,0.2 +pallet_tx_pause,unpause_pallets,7736260000000,7.73626,0.2 +pallet_utility,batch-size=1,569893474000,0.569893474,0.2 +pallet_utility,batch-size=32,1812806048000,1.812806048,0.2 +pallet_utility,as_derivative,1944896048000,1.944896048,0.2 +pallet_utility,batch_all-size=1,575519730000,0.57551973,0.2 +pallet_utility,batch_all-size=32,1992846240000,1.99284624,0.2 +pallet_utility,dispatch_as,2008624240000,2.00862424,0.2 +pallet_utility,force_batch,525421082000,0.525421082,0.2 +pallet_randomness,set_babe_randomness_results,884541000000,0.884541,0.2 +pallet_name_service,register,821980000000,0.82198,0.2 +pallet_name_service,accept_register,747557000000,0.747557,0.2 +pallet_name_service,set_primary_name,673185000000,0.673185,0.2 +pallet_name_service,cancel_pending_register,644800000000,0.6448,0.2 +pallet_name_service,remove_register,673200000000,0.6732,0.2 +pallet_farming,create_farming_pool,970803000000,0.970803,0.2 +pallet_farming,charge,1188925000000,1.188925,0.2 +pallet_farming,deposit,1322877000000,1.322877,0.2 +pallet_farming,withdraw,785363000000,0.785363,0.2 +pallet_farming,claim,811333000000,0.811333,0.2 +pallet_farming,withdraw_claim,811333000000,0.811333,0.2 +pallet_farming,close_pool,495051000000,0.495051,0.2 +pallet_farming,set_retire_limit,494931000000,0.494931,0.2 +pallet_farming,retire_pool,495051000000,0.495051,0.2 +pallet_farming,reset_pool,496061000000,0.496061,0.2 +pallet_farming,kill_pool,495051000000,0.495051,0.2 +pallet_farming,edit_pool,496491000000,0.496491,0.2 +pallet_farming,gauge_withdraw,839931000000,0.839931,0.2 +pallet_farming,force_gauge_claim,495051000000,0.495051,0.2 +pallet_lottery,deposit,2594704002000,2.594704002,0.2 +pallet_lottery,request_withdraw,1960542952000,1.960542952,0.2 +pallet_lottery,claim_my_winnings,1075753826000,1.075753826,0.2 +pallet_lottery,rebalance_stake,494890000000,0.49489,0.2 +pallet_lottery,start_lottery,962315000000,0.962315,0.2 +pallet_lottery,stop_lottery,788039000000,0.788039,0.2 +pallet_lottery,draw_lottery,874292000000,0.874292,0.2 +pallet_lottery,process_matured_withdrawals,583406000000,0.583406,0.2 +pallet_lottery,liquidate_lottery,494890000000,0.49489,0.2 +pallet_lottery,set_min_deposit,628761000000,0.628761,0.2 +pallet_lottery,set_min_withdraw,599670000000,0.59967,0.2 +pallet_lottery,set_gas_reserve,609376000000,0.609376,0.2 +zenlink_protocol,set_fee_receiver,628265000000,0.628265,0.2 +zenlink_protocol,set_fee_point,627440000000,0.62744,0.2 +zenlink_protocol,transfer,496350000000,0.49635,0.2 +zenlink_protocol,transfer,802280000000,0.80228,0.2 +zenlink_protocol,add_liquidity,4279848000000,4.279848,0.2 +zenlink_protocol,remove_liquidity,2546926000000,2.546926,0.2 +zenlink_protocol,swap_exact_assets_for_assets,1424601000000,1.424601,0.2 +zenlink_protocol,swap_assets_for_exact_assets,1424796000000,1.424796,0.2 +zenlink_protocol,bootstrap_create,846800000000,0.8468,0.2 +zenlink_protocol,bootstrap_contribute,1360517000000,1.360517,0.2 +zenlink_protocol,bootstrap_claim,3351621000000,3.351621,0.2 +zenlink_protocol,bootstrap_end,4503668000000,4.503668,0.2 +zenlink_protocol,bootstrap_update,878476000000,0.878476,0.2 +zenlink_protocol,bootstrap_refund,1340746000000,1.340746,0.2 +zenlink_protocol,bootstrap_charge_reward,595740000000,0.59574,0.2 +zenlink_protocol,bootstrap_withdraw_reward,595470000000,0.59547,0.2 +frame_system,remark-length=32,597469675000,0.597469675,1 +frame_system,remark-length=64,597469675000,0.597469675,1 +frame_system,set_heap_pages,1706195000000,1.706195,1 +frame_system,set_code,2500495220000000,2500.49522,1 +frame_system,set_code_without_checks,2500495220000000,2500.49522,1 +frame_system,set_storage,1025695175000,1.025695175,1 +frame_system,kill_storage,1520594350000,1.52059435,1 +frame_system,kill_prefix,5077146375000,5.077146375000001,1 +frame_system,remark_with_event-length=32,563896240000,0.56389624,1 +frame_system,remark_with_event-length=64,563896240000,0.56389624,1 +pallet_treasury,propose_spend,1784810000000,1.78481,1 +pallet_treasury,reject_proposal,2009540000000,2.00954,1 +pallet_treasury,approve_proposal,1373657110000,1.37365711,1 +pallet_treasury,spend,496365000000,0.496365,1 +pallet_treasury,remove_approval,1173260000000,1.17326,1 +pallet_timestamp,set,1163880000000,1.16388,1 +pallet_preimage,note_preimage-length=32,1793084440000,1.79308444,1 +pallet_preimage,note_preimage-length=32,1793883880000,1.79388388,1 +pallet_preimage,unnote_preimage,1836590000000,1.83659,1 +pallet_preimage,request_preimage,1269540000000,1.26954,1 +pallet_preimage,unrequest_preimage,1763295000000,1.763295,1 +pallet_multisig,as_multi_threshold_1,2487460725000,2.487460725,1 +pallet_multisig,as_multi,1961259585000,1.961259585,1 +pallet_multisig,approve_as_multi,1438636960000,1.43863696,1 +pallet_multisig,cancel_as_multi,1313113670000,1.31311367,1 +pallet_membership,add_member,745220000000,0.74522,1 +pallet_membership,remove_member,745220000000,0.74522,1 +pallet_membership,swap_member,745550000000,0.74555,1 +pallet_membership,reset_members,745540000000,0.74554,1 +pallet_membership,change_key,745220000000,0.74522,1 +pallet_membership,set_prime,745220000000,0.74522,1 +pallet_membership,clear_prime,744890000000,0.74489,1 +pallet_democracy,propose,2638985000000,2.638985,1 +pallet_democracy,second,1355775000000,1.355775,1 +pallet_democracy,vote,2689690000000,2.68969,1 +pallet_democracy,emergency_cancel,1869595000000,1.869595,1 +pallet_democracy,external_propose,1338710000000,1.33871,1 +pallet_democracy,external_propose_majority,1022830000000,1.02283,1 +pallet_democracy,external_propose_default,1022985000000,1.022985,1 +pallet_democracy,fast_track,2366745000000,2.366745,1 +pallet_democracy,veto_external,1902275000000,1.902275,1 +pallet_democracy,cancel_referendum,1071550000000,1.07155,1 +pallet_democracy,delegate,67723862640000,67.72386264,1 +pallet_democracy,undelegate,66356765145000,66.356765145,1 +pallet_democracy,clear_public_proposals,1023715000000,1.023715,1 +pallet_democracy,unlock,2604756285000,2.604756285,1 +pallet_democracy,remove_vote,1913683140000,1.91368314,1 +pallet_democracy,remove_other_vote,1915581645000,1.915581645,1 +pallet_democracy,blacklist,4564835000000,4.564835,1 +pallet_democracy,cancel_proposal,2742250000000,2.74225,1 +pallet_collective,set_members,68879257140000,68.87925713999999,1 +pallet_collective,execute,2986021660000,2.98602166,1 +pallet_collective,propose,3259565455000,3.259565455,1 +pallet_collective,vote,1456554615000,1.456554615,1 +pallet_collective,close,2982453855000,2.982453855,1 +pallet_collective,disapprove_proposal,2322989635000,2.322989635,1 +cumulus_pallet_xcmp_queue,service_overweight,500050320000,0.50005032,1 +cumulus_pallet_xcmp_queue,suspend_xcm_execution,994890000000,0.99489,1 +cumulus_pallet_xcmp_queue,resume_xcm_execution,994890000000,0.99489,1 +cumulus_pallet_xcmp_queue,update_suspend_threshold,1158420000000,1.15842,1 +cumulus_pallet_xcmp_queue,update_drop_threshold,1158420000000,1.15842,1 +cumulus_pallet_xcmp_queue,update_resume_threshold,1158420000000,1.15842,1 +cumulus_pallet_xcmp_queue,update_threshold_weight,1157825000000,1.157825,1 +cumulus_pallet_xcmp_queue,update_weight_restrict_decay,1157825000000,1.157825,1 +cumulus_pallet_xcmp_queue,update_xcmp_max_individual_weight,1157825000000,1.157825,1 +orml_xtokens,transfer,495260000000,0.49526,1 +orml_xtokens,transfer_multiasset,495070000000,0.49507,1 +orml_xtokens,transfer_with_fee,495420000000,0.49542,1 +orml_xtokens,transfer_multiasset_with_fee,495210000000,0.49521,1 +orml_xtokens,transfer_multicurrencies,495640000000,0.49564,1 +orml_xtokens,transfer_multiassets,495120000000,0.49512,1 +calamari_vesting,vest,2852515000000,2.852515,1 +manta_collator_selection,set_invulnerables,1066744495000,1.066744495,1 +manta_collator_selection,set_desired_candidates,1075040000000,1.07504,1 +manta_collator_selection,set_candidacy_bond,1065655000000,1.065655,1 +manta_collator_selection,register_as_candidate,1947217785000,1.947217785,1 +manta_collator_selection,register_candidate,1946604615000,1.946604615,1 +manta_collator_selection,leave_intent,1350392530000,1.35039253,1 +manta_collator_selection,remove_collator,1493571080000,1.49357108,1 +manta_collator_selection,set_eviction_baseline,1063035000000,1.063035,1 +manta_collator_selection,set_eviction_tolerance,1063130000000,1.06313,1 +pallet_asset_manager,register_asset,4301465000000,4.301465,1 +pallet_asset_manager,update_asset_location,3989500000000,3.9895,1 +pallet_asset_manager,update_asset_metadata,2348285000000,2.348285,1 +pallet_asset_manager,set_units_per_second,1453380000000,1.45338,1 +pallet_asset_manager,mint_asset,2407785000000,2.407785,1 +pallet_asset_manager,set_min_xcm_fee,1267560000000,1.26756,1 +pallet_asset_manager,update_outgoing_filtered_assets,1258415000000,1.258415,1 +pallet_asset_manager,register_lp_asset,4582690000000,4.58269,1 +pallet_assets,create,1264825000000,1.264825,1 +pallet_assets,force_create,1221280000000,1.22128,1 +pallet_assets,start_destroy,1229480000000,1.22948,1 +pallet_assets,destroy_accounts,1332664750000000,1332.66475,1 +pallet_assets,destroy_approvals,667439210000000,667.43921,1 +pallet_assets,finish_destroy,1363015000000,1.363015,1 +pallet_assets,mint,1936885000000,1.936885,1 +pallet_assets,burn,2038855000000,2.038855,1 +pallet_assets,transfer,3298815000000,3.298815,1 +pallet_assets,transfer_keep_alive,3248970000000,3.24897,1 +pallet_assets,force_transfer,3296300000000,3.2963,1 +pallet_assets,freeze,1384445000000,1.384445,1 +pallet_assets,thaw,1383655000000,1.383655,1 +pallet_assets,freeze_asset,1230285000000,1.230285,1 +pallet_assets,thaw_asset,1229595000000,1.229595,1 +pallet_assets,transfer_ownership,1366605000000,1.366605,1 +pallet_assets,set_team,1221910000000,1.22191,1 +pallet_assets,set_metadata,1375223365000,1.375223365,1 +pallet_assets,clear_metadata,1368190000000,1.36819,1 +pallet_assets,force_set_metadata,1409169740000,1.40916974,1 +pallet_assets,force_clear_metadata,1374310000000,1.37431,1 +pallet_assets,force_asset_status,1225980000000,1.22598,1 +pallet_assets,approve_transfer,1888775000000,1.888775,1 +pallet_assets,cancel_approval,1893505000000,1.893505,1 +pallet_assets,force_cancel_approval,1905145000000,1.905145,1 +pallet_assets,transfer_approved,3944385000000,3.944385,1 +pallet_assets,touch,1936545000000,1.936545,1 +pallet_assets,refund,1936555000000,1.936555,1 +pallet_author_inherent,kick_off_authorship_validation,1586120000000,1.58612,1 +pallet_balances,transfer-1,1373935000000,1.373935,1 +pallet_balances,transfer-1000_000,1373965000000,1.373965,1 +pallet_balances,set_balance,1268990000000,1.26899,1 +pallet_balances,force_transfer,1991850000000,1.99185,1 +pallet_balances,transfer_keep_alive-1,1306195000000,1.306195,1 +pallet_balances,transfer_keep_alive-1000_000,1306225000000,1.306225,1 +pallet_balances,transfer_all,1336860000000,1.33686,1 +pallet_balances,force_unreserve,1231100000000,1.2311,1 +pallet_manta_pay,to_private,202362380000000,202.36238000000003,1 +pallet_manta_pay,private_transfer,362534405000000,362.534405,1 +pallet_manta_pay,to_public,271609600000000,271.6096,1 +pallet_manta_pay,public_transfer,2719160000000,2.71916,1 +pallet_manta_sbt,to_private,200888425000000,200.88842499999998,1 +pallet_manta_sbt,force_to_private,199848510000000,199.84851,1 +pallet_manta_sbt,reserve_sbt,2776380000000,2.77638,1 +pallet_manta_sbt,allowlist_evm_account,2280500000000,2.2805,1 +pallet_manta_sbt,set_next_sbt_id,1074435000000,1.074435,1 +pallet_manta_sbt,remove_allowlist_evm_account,1080645000000,1.080645,1 +pallet_manta_sbt,change_free_reserve_account,1154565000000,1.154565,1 +pallet_manta_sbt,force_mint_sbt_eth,200505095000000,200.505095,1 +pallet_manta_sbt,change_force_account,1078605000000,1.078605,1 +pallet_manta_sbt,mint_sbt_eth,201099105000000,201.099105,1 +pallet_manta_sbt,change_allowlist_account,1079250000000,1.07925,1 +pallet_manta_sbt,update_mint_info,1739160000000,1.73916,1 +pallet_manta_sbt,new_mint_info,2223175000000,2.223175,1 +pallet_parachain_staking,set_staking_expectations,1226685000000,1.226685,1 +pallet_parachain_staking,set_inflation,1454595000000,1.454595,1 +pallet_parachain_staking,set_parachain_bond_account,1227340000000,1.22734,1 +pallet_parachain_staking,set_parachain_bond_account,1227340000000,1.22734,1 +pallet_parachain_staking,set_parachain_bond_reserve_percent,1220750000000,1.22075,1 +pallet_parachain_staking,set_total_selected,1228915000000,1.228915,1 +pallet_parachain_staking,set_collator_commission,1216395000000,1.216395,1 +pallet_parachain_staking,set_blocks_per_round,1601300000000,1.6013,1 +pallet_parachain_staking,join_candidates,5218990350000,5.21899035,1 +pallet_parachain_staking,schedule_leave_candidates,1934734480000,1.93473448,1 +pallet_parachain_staking,execute_leave_candidates,7460994050000,7.46099405,1 +pallet_parachain_staking,cancel_leave_candidates,1925138240000,1.92513824,1 +pallet_parachain_staking,go_offline,1905845000000,1.905845,1 +pallet_parachain_staking,go_offline,1905845000000,1.905845,1 +pallet_parachain_staking,candidate_bond_more,3874535000000,3.874535,1 +pallet_parachain_staking,schedule_candidate_bond_less,1264095000000,1.264095,1 +pallet_parachain_staking,execute_candidate_bond_less,3936165000000,3.936165,1 +pallet_parachain_staking,cancel_candidate_bond_less,1251400000000,1.2514,1 +pallet_parachain_staking,delegate_1_2_3,5273845060000,5.27384506,1 +pallet_parachain_staking,delegate_1_25_3,5309635705000,5.309635705,1 +pallet_parachain_staking,delegate_1_2_100,5358363400000,5.3583634,1 +pallet_parachain_staking,schedule_leave_delegators,1901815000000,1.901815,1 +pallet_parachain_staking,execute_leave_delegators,7928940050000,7.92894005,1 +pallet_parachain_staking,cancel_leave_delegators,1910680000000,1.91068,1 +pallet_parachain_staking,schedule_revoke_delegation,1902520000000,1.90252,1 +pallet_parachain_staking,delegator_bond_more,5369040000000,5.36904,1 +pallet_parachain_staking,schedule_delegator_bond_less,1903285000000,1.903285,1 +pallet_parachain_staking,execute_delegation_request,5921065000000,5.921065,1 +pallet_parachain_staking,cancel_delegation_request,1934445000000,1.934445,1 +pallet_scheduler,cancel,2096759850000,2.09675985,1 +pallet_scheduler,schedule,1448940940000,1.44894094,1 +pallet_scheduler,schedule_named,2102371950000,2.10237195,1 +pallet_scheduler,cancel_named,2244678025000,2.244678025,1 +pallet_scheduler,schedule_after,1449180940000,1.44918094,1 +pallet_scheduler,schedule_named_after,2102611950000,2.10261195,1 +pallet_session,set_keys,3162665000000,3.162665,1 +pallet_session,purge_keys,2746180000000,2.74618,1 +pallet_tx_pause,pause_transaction,1219620000000,1.21962,1 +pallet_tx_pause,unpause_transaction,1226525000000,1.226525,1 +pallet_tx_pause,pause_transactions,1944040000000,1.94404,1 +pallet_tx_pause,unpause_transactions,1957850000000,1.95785,1 +pallet_tx_pause,pause_pallets,36699060000000,36.69906,1 +pallet_tx_pause,unpause_pallets,36699060000000,36.69906,1 +pallet_utility,batch-size=1,869747370000,0.86974737,1 +pallet_utility,batch-size=32,7080590240000,7.08059024,1 +pallet_utility,as_derivative,7740880240000,7.74088024,1 +pallet_utility,batch_all-size=1,897878650000,0.89787865,1 +pallet_utility,batch_all-size=32,7980791200000,7.9807912,1 +pallet_utility,dispatch_as,8058241200000,8.0582412,1 +pallet_utility,force_batch,647505410000,0.64750541,1 +pallet_randomness,set_babe_randomness_results,2443145000000,2.443145,1 +pallet_name_service,register,2128860000000,2.12886,1 +pallet_name_service,accept_register,1756745000000,1.756745,1 +pallet_name_service,set_primary_name,1384885000000,1.384885,1 +pallet_name_service,cancel_pending_register,1242960000000,1.24296,1 +pallet_name_service,remove_register,1384960000000,1.38496,1 +pallet_farming,create_farming_pool,2869855000000,2.869855,1 +pallet_farming,charge,3961825000000,3.961825,1 +pallet_farming,deposit,4633265000000,4.633265,1 +pallet_farming,withdraw,1945935000000,1.945935,1 +pallet_farming,claim,2076465000000,2.076465,1 +pallet_farming,withdraw_claim,2076465000000,2.076465,1 +pallet_farming,close_pool,495055000000,0.495055,1 +pallet_farming,set_retire_limit,494935000000,0.494935,1 +pallet_farming,retire_pool,495055000000,0.495055,1 +pallet_farming,reset_pool,496065000000,0.496065,1 +pallet_farming,kill_pool,495055000000,0.495055,1 +pallet_farming,edit_pool,496495000000,0.496495,1 +pallet_farming,gauge_withdraw,2219455000000,2.219455,1 +pallet_farming,force_gauge_claim,495055000000,0.495055,1 +pallet_lottery,deposit,10993320010000,10.99332001,1 +pallet_lottery,request_withdraw,7822514760000,7.82251476,1 +pallet_lottery,claim_my_winnings,3399209130000,3.39920913,1 +pallet_lottery,rebalance_stake,494890000000,0.49489,1 +pallet_lottery,start_lottery,2832015000000,2.832015,1 +pallet_lottery,stop_lottery,1960635000000,1.960635,1 +pallet_lottery,draw_lottery,2391900000000,2.3919,1 +pallet_lottery,process_matured_withdrawals,937470000000,0.93747,1 +pallet_lottery,liquidate_lottery,494890000000,0.49489,1 +pallet_lottery,set_min_deposit,1163605000000,1.163605,1 +pallet_lottery,set_min_withdraw,1018150000000,1.01815,1 +pallet_lottery,set_gas_reserve,1066680000000,1.06668,1 +zenlink_protocol,set_fee_receiver,1160445000000,1.160445,1 +zenlink_protocol,set_fee_point,1157600000000,1.1576,1 +zenlink_protocol,transfer,500350000000,0.50035,1 +zenlink_protocol,transfer,2030800000000,2.0308,1 +zenlink_protocol,add_liquidity,19418440000000,19.41844,1 +zenlink_protocol,remove_liquidity,10752590000000,10.75259,1 +zenlink_protocol,swap_exact_assets_for_assets,5140445000000,5.140445,1 +zenlink_protocol,swap_assets_for_exact_assets,5141420000000,5.14142,1 +zenlink_protocol,bootstrap_create,2249440000000,2.24944,1 +zenlink_protocol,bootstrap_contribute,4821785000000,4.821785,1 +zenlink_protocol,bootstrap_claim,14776185000000,14.776185,1 +zenlink_protocol,bootstrap_end,20537740000000,20.53774,1 +zenlink_protocol,bootstrap_update,2407780000000,2.40778,1 +zenlink_protocol,bootstrap_refund,4723130000000,4.72313,1 +zenlink_protocol,bootstrap_charge_reward,995740000000,0.99574,1 +zenlink_protocol,bootstrap_withdraw_reward,995470000000,0.99547,1 diff --git a/runtime/calamari/tx-fees-data/README.md b/runtime/calamari/tx-fees-data/README.md new file mode 100644 index 000000000..50115519a --- /dev/null +++ b/runtime/calamari/tx-fees-data/README.md @@ -0,0 +1,19 @@ +# Transaction Fees History for Calamari Runtime + +- The code about estimating all tx fees locates at [`diff_gas_fees.rs`](../src/diff_gas_fees.rs). +- All tx fees history locates at [`tx-fees-data`](.). +- If any extrinsic fluctuates over **10**, the test case `diff_gas_fees::diff_gas_fees` will fail. + +## Generate the latest tx fees sheet + +Run the command. +```sh +cargo t generate_all_current_extrinsics_tx_fee_to_csv +``` +> Before you run this test case, please disable this line of code: `#[ignore]`. + +It will generate a csv file located at `tx-fees-data/{crate-version}-tx-fees.csv`. + +## When to add new extrinsics to diff_gas_fees + +If there's new pallet or new extrinsic introduced, please add them to [`diff_gas_fees.rs`](../src/diff_gas_fees.rs). diff --git a/runtime/manta/Cargo.toml b/runtime/manta/Cargo.toml index b65f3579c..38a4ae10f 100644 --- a/runtime/manta/Cargo.toml +++ b/runtime/manta/Cargo.toml @@ -109,9 +109,11 @@ runtime-common = { path = '../common', default-features = false } session-key-primitives = { path = '../../primitives/session-keys', default-features = false } [dev-dependencies] +csv = "1.2.1" polkadot-core-primitives = { git = 'https://github.com/paritytech/polkadot.git', branch = "release-v0.9.37" } polkadot-runtime-parachains = { git = 'https://github.com/paritytech/polkadot.git', branch = "release-v0.9.37" } runtime-common = { path = '../common', features = ["test-helpers"] } +version-compare = "0.1.1" xcm-simulator = { git = 'https://github.com/paritytech/polkadot.git', branch = "release-v0.9.37" } [package.metadata.docs.rs] diff --git a/runtime/manta/src/diff_tx_fees.rs b/runtime/manta/src/diff_tx_fees.rs new file mode 100644 index 000000000..9f0312458 --- /dev/null +++ b/runtime/manta/src/diff_tx_fees.rs @@ -0,0 +1,3143 @@ +// Copyright 2020-2023 Manta Network. +// This file is part of Manta. +// +// Manta 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. +// +// Manta 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 Manta. If not, see . + +#![cfg(test)] + +use crate::{Runtime, TransactionPayment}; +use codec::{Decode, Encode}; +use frame_support::{ + dispatch::{DispatchInfo, GetDispatchInfo}, + traits::{GetCallMetadata, OriginTrait, StorePreimage}, +}; +use manta_primitives::assets::{AssetRegistryMetadata, TestingDefault}; +use manta_support::manta_pay::TransferPost; +use pallet_transaction_payment::Multiplier; +use runtime_common::MinimumMultiplier; +use sp_runtime::{ + traits::{Saturating, Zero}, + AccountId32, FixedPointNumber, MultiAddress, Perbill, Percent, +}; +use std::str::FromStr; +use xcm::prelude::*; + +const TX_FEE_FLUCTUATION: Percent = Percent::from_percent(10); +const ALICE: AccountId32 = AccountId32::new([1u8; 32]); +const BOB: AccountId32 = AccountId32::new([2u8; 32]); + +#[derive(Debug, serde::Serialize, serde::Deserialize)] +struct TxFeeDetail { + module: String, + extrinsic: String, + tx_fee_with_decimal: String, + tx_fee_without_decimal: String, + fee_multiplier: String, +} + +fn fee_multipliers() -> [Multiplier; 3] { + [ + MinimumMultiplier::get(), // 0.0002 + Multiplier::saturating_from_rational(1, 5u128), // 0.2 + Multiplier::saturating_from_rational(1, 1u128), // 1.0 + ] +} + +fn get_call_details(call: &crate::RuntimeCall) -> (DispatchInfo, u32) { + let dispatch_info = + <::RuntimeCall as GetDispatchInfo>::get_dispatch_info( + call, + ); + let call_len = call.using_encoded(|e| e.len()) as u32; + (dispatch_info, call_len) +} + +#[test] +fn diff_tx_fees() { + const CURRENT_PATH: &str = env!("CARGO_MANIFEST_DIR"); + let mut latest_version = String::new(); + for file in std::fs::read_dir(format!("{CURRENT_PATH}/tx-fees-data")).unwrap() { + let _version = file + .unwrap() + .path() + .file_name() + .unwrap() + .to_str() + .unwrap() + .split("-tx-fees.csv") + .collect::>()[0] + .to_string(); + if _version.contains("README.md") { + continue; + } + let _version = version_compare::Version::from(&_version).unwrap(); + let version = version_compare::Version::from(&latest_version).unwrap(); + if version < _version { + latest_version = _version.to_string(); + } + } + let version = version_compare::Version::from(&latest_version).unwrap(); + let csv_path = format!("{CURRENT_PATH}/tx-fees-data/{version}-tx-fees.csv"); + let mut rdr = csv::Reader::from_path(csv_path).unwrap(); + + let (calamari_runtime_calls, mut test_runner) = calculate_all_current_extrinsic_tx_fee(); + + let mut last_release_tx_fees = rdr.deserialize().map(|e| { + let record: TxFeeDetail = e.unwrap(); + record + }); + + // check whether there's new pallet introduced + test_runner.execute_with(|| { + let opaque_metadata = crate::Runtime::metadata(); + let pallets = match opaque_metadata.1 { + frame_support::metadata::RuntimeMetadata::V14(metadata) => metadata.pallets, + _ => unreachable!(), + }; + assert_eq!(pallets.len(), 39); + }); + + let fee_multipliers = fee_multipliers(); + for multiplier in fee_multipliers { + test_runner.execute_with(|| { + pallet_transaction_payment::NextFeeMultiplier::::set(multiplier); + }); + test_runner.execute_with(|| { + for (pallet_name, extrinsic_name, dispatch_info, call_len) in calamari_runtime_calls.iter() + { + match last_release_tx_fees.find(|e| e.extrinsic.eq(extrinsic_name) && e.fee_multiplier.eq(&multiplier.to_float().to_string())) { + Some(found) => { + let _tx_fee_with_decimal = TransactionPayment::compute_fee(*call_len, dispatch_info, 0); + let tx_fee_with_decimal = Multiplier::from_str(&_tx_fee_with_decimal.to_string()).unwrap(); + let last_tx_fee = Multiplier::from_str(&found.tx_fee_with_decimal).unwrap(); + let fluctuation = { + let diff_value = tx_fee_with_decimal.saturating_sub(last_tx_fee).div(last_tx_fee); + if diff_value < Multiplier::zero() { + Percent::from_float(diff_value.neg().to_float()) + } else { + Percent::from_float(diff_value.to_float()) + } + }; + let _multiplier = found.fee_multiplier; + assert!(fluctuation <= TX_FEE_FLUCTUATION, "The tx fee fluctuation for the extrinsic {extrinsic_name} is {fluctuation:?}, bigger than {TX_FEE_FLUCTUATION:?} with multiplier {_multiplier}."); + } + None => panic!("The extrinsic {pallet_name}.{extrinsic_name} is missing from current tx fees list, please add it to latest csv file."), + } + } + }); + } +} + +#[test] +#[ignore] +fn generate_all_current_extrinsics_tx_fee_to_csv() { + const VERSION: &str = env!("CARGO_PKG_VERSION"); + const CURRENT_PATH: &str = env!("CARGO_MANIFEST_DIR"); + let csv_path = format!("{CURRENT_PATH}/tx-fees-data/{VERSION}-tx-fees.csv"); + + let mut wtr = csv::Writer::from_path(csv_path).unwrap(); + let (calamari_runtime_calls, mut test_runner) = calculate_all_current_extrinsic_tx_fee(); + + let fee_multipliers = fee_multipliers(); + let decimal: Multiplier = Multiplier::from_u32(10).saturating_pow(18); + + let mut all_extrinsics_tx_fees = vec![]; + for multiplier in fee_multipliers { + // set the multiplier + test_runner.execute_with(|| { + pallet_transaction_payment::NextFeeMultiplier::::set(multiplier); + }); + test_runner.execute_with(|| { + for (pallet_name, extrinsic_name, dispatch_info, call_len) in + calamari_runtime_calls.clone() + { + let tx_fee_with_decimal = + TransactionPayment::compute_fee(call_len, &dispatch_info, 0); + let tx_fee_without_decimal = Multiplier::try_from(tx_fee_with_decimal) + .unwrap() + .div(decimal) + .to_float(); + let tx_fee = TxFeeDetail { + module: pallet_name.to_owned(), + extrinsic: extrinsic_name.to_owned(), + tx_fee_with_decimal: tx_fee_with_decimal.to_string(), + tx_fee_without_decimal: tx_fee_without_decimal.to_string(), + fee_multiplier: multiplier.to_float().to_string(), + }; + all_extrinsics_tx_fees.push(tx_fee); + } + }); + } + + for extrinsic in all_extrinsics_tx_fees { + wtr.serialize(extrinsic).unwrap(); + } + wtr.flush().unwrap(); +} + +fn calculate_all_current_extrinsic_tx_fee() -> ( + Vec<(&'static str, &'static str, DispatchInfo, u32)>, + sp_io::TestExternalities, +) { + let mut t: sp_io::TestExternalities = frame_system::GenesisConfig::default() + .build_storage::() + .unwrap() + .into(); + + let mut calamari_runtime_calls = vec![]; + // frame_system + { + assert_eq!( + crate::RuntimeCall::get_call_names("System").len(), + 8, + "Please update new extrinsic here." + ); + // remark, which length is 32 + let call = crate::RuntimeCall::System(frame_system::Call::remark { + remark: vec![1u8; 32], + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("frame_system", "remark-length=32", dispatch_info, call_len)); + + // remark, which length is 64 + let call = crate::RuntimeCall::System(frame_system::Call::remark { + remark: vec![1u8; 32], + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("frame_system", "remark-length=64", dispatch_info, call_len)); + + // set_heap_pages + let call = crate::RuntimeCall::System(frame_system::Call::set_heap_pages { pages: 64 }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("frame_system", "set_heap_pages", dispatch_info, call_len)); + + // set_code + let call = crate::RuntimeCall::System(frame_system::Call::set_code { + code: vec![1u8; 32], + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("frame_system", "set_code", dispatch_info, call_len)); + + // set_code_without_checks + let call = crate::RuntimeCall::System(frame_system::Call::set_code_without_checks { + code: vec![1u8; 32], + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "frame_system", + "set_code_without_checks", + dispatch_info, + call_len, + )); + + // set_storage + let call = crate::RuntimeCall::System(frame_system::Call::set_storage { + items: vec![(vec![1u8; 32], vec![2u8; 32])], + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("frame_system", "set_storage", dispatch_info, call_len)); + + // kill_storage + let call = crate::RuntimeCall::System(frame_system::Call::kill_storage { + keys: vec![vec![1u8; 32], vec![2u8; 32]], + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("frame_system", "kill_storage", dispatch_info, call_len)); + + // kill_prefix + let call = crate::RuntimeCall::System(frame_system::Call::kill_prefix { + prefix: vec![1u8; 32], + subkeys: 8, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("frame_system", "kill_prefix", dispatch_info, call_len)); + + // remark_with_event, which length is 32 + let call = crate::RuntimeCall::System(frame_system::Call::remark_with_event { + remark: vec![1u8; 32], + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "frame_system", + "remark_with_event-length=32", + dispatch_info, + call_len, + )); + + // remark_with_event, which length is 64 + let call = crate::RuntimeCall::System(frame_system::Call::remark_with_event { + remark: vec![1u8; 32], + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "frame_system", + "remark_with_event-length=64", + dispatch_info, + call_len, + )); + } + + // pallet_treasury + { + assert_eq!( + crate::RuntimeCall::get_call_names("Treasury").len(), + 5, + "Please update new extrinsic here." + ); + // propose_spend + let call = crate::RuntimeCall::Treasury(pallet_treasury::Call::propose_spend { + value: 8, + beneficiary: ALICE.into(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_treasury", "propose_spend", dispatch_info, call_len)); + + // reject_proposal + let call = + crate::RuntimeCall::Treasury(pallet_treasury::Call::reject_proposal { proposal_id: 8 }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_treasury", + "reject_proposal", + dispatch_info, + call_len, + )); + + // approve_proposal + let call = crate::RuntimeCall::Treasury(pallet_treasury::Call::approve_proposal { + proposal_id: 8, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_treasury", + "approve_proposal", + dispatch_info, + call_len, + )); + + // spend + let call = crate::RuntimeCall::Treasury(pallet_treasury::Call::spend { + amount: 8, + beneficiary: ALICE.into(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_treasury", "spend", dispatch_info, call_len)); + + // remove_approval + let call = + crate::RuntimeCall::Treasury(pallet_treasury::Call::remove_approval { proposal_id: 8 }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_treasury", + "remove_approval", + dispatch_info, + call_len, + )); + } + + // pallet_timestamp + { + assert_eq!( + crate::RuntimeCall::get_call_names("Timestamp").len(), + 1, + "Please update new extrinsic here." + ); + // set + let call = crate::RuntimeCall::Timestamp(pallet_timestamp::Call::set { + now: Default::default(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_timestamp", "set", dispatch_info, call_len)); + } + + // pallet_preimage + { + assert_eq!( + crate::RuntimeCall::get_call_names("Preimage").len(), + 4, + "Please update new extrinsic here." + ); + // note_preimage, preimage length is 32 + let call = crate::RuntimeCall::Preimage(pallet_preimage::Call::note_preimage { + bytes: vec![1u8; 32], + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_preimage", + "note_preimage-length=32", + dispatch_info, + call_len, + )); + + // note_preimage, preimage length is 64 + let call = crate::RuntimeCall::Preimage(pallet_preimage::Call::note_preimage { + bytes: vec![1u8; 64], + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_preimage", + "note_preimage-length=32", + dispatch_info, + call_len, + )); + + // unnote_preimage + let call = crate::RuntimeCall::Preimage(pallet_preimage::Call::unnote_preimage { + hash: Default::default(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_preimage", + "unnote_preimage", + dispatch_info, + call_len, + )); + + // request_preimage + let call = crate::RuntimeCall::Preimage(pallet_preimage::Call::request_preimage { + hash: Default::default(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_preimage", + "request_preimage", + dispatch_info, + call_len, + )); + + // unrequest_preimage + let call = crate::RuntimeCall::Preimage(pallet_preimage::Call::unrequest_preimage { + hash: Default::default(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_preimage", + "unrequest_preimage", + dispatch_info, + call_len, + )); + } + + // pallet_multisig + { + assert_eq!( + crate::RuntimeCall::get_call_names("Multisig").len(), + 4, + "Please update new extrinsic here." + ); + // as_multi_threshold_1 + let dummy_call = crate::RuntimeCall::Preimage(pallet_preimage::Call::unrequest_preimage { + hash: Default::default(), + }); + let call = crate::RuntimeCall::Multisig(pallet_multisig::Call::as_multi_threshold_1 { + other_signatories: vec![ALICE], + call: Box::new(dummy_call.clone()), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_multisig", + "as_multi_threshold_1", + dispatch_info, + call_len, + )); + + // as_multi + let call = crate::RuntimeCall::Multisig(pallet_multisig::Call::as_multi { + threshold: 2, + other_signatories: vec![ALICE], + maybe_timepoint: None, + call: Box::new(dummy_call), + max_weight: Default::default(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_multisig", "as_multi", dispatch_info, call_len)); + + // approve_as_multi + let call = crate::RuntimeCall::Multisig(pallet_multisig::Call::approve_as_multi { + threshold: 2, + other_signatories: vec![ALICE], + maybe_timepoint: None, + call_hash: [1u8; 32], + max_weight: Default::default(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_multisig", + "approve_as_multi", + dispatch_info, + call_len, + )); + + // cancel_as_multi + let call = crate::RuntimeCall::Multisig(pallet_multisig::Call::cancel_as_multi { + threshold: 2, + other_signatories: vec![ALICE], + timepoint: Default::default(), + call_hash: [1u8; 32], + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_multisig", + "cancel_as_multi", + dispatch_info, + call_len, + )); + } + + // pallet_membership + { + assert_eq!( + crate::RuntimeCall::get_call_names("CouncilMembership").len(), + 7, + "Please update new extrinsic here." + ); + // add_member + let call = crate::RuntimeCall::CouncilMembership(pallet_membership::Call::add_member { + who: ALICE.into(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_membership", "add_member", dispatch_info, call_len)); + + // remove_member + let call = crate::RuntimeCall::CouncilMembership(pallet_membership::Call::remove_member { + who: ALICE.into(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_membership", + "remove_member", + dispatch_info, + call_len, + )); + + // swap_member + let call = crate::RuntimeCall::CouncilMembership(pallet_membership::Call::swap_member { + remove: ALICE.into(), + add: BOB.into(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_membership", "swap_member", dispatch_info, call_len)); + + // reset_members + let call = crate::RuntimeCall::CouncilMembership(pallet_membership::Call::reset_members { + members: vec![ALICE, BOB], + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_membership", + "reset_members", + dispatch_info, + call_len, + )); + + // change_key + let call = crate::RuntimeCall::CouncilMembership(pallet_membership::Call::change_key { + new: ALICE.into(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_membership", "change_key", dispatch_info, call_len)); + + // set_prime + let call = crate::RuntimeCall::CouncilMembership(pallet_membership::Call::set_prime { + who: ALICE.into(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_membership", "set_prime", dispatch_info, call_len)); + + // clear_prime + let call = crate::RuntimeCall::CouncilMembership(pallet_membership::Call::clear_prime {}); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_membership", "clear_prime", dispatch_info, call_len)); + } + + // pallet_democracy + { + assert_eq!( + crate::RuntimeCall::get_call_names("Democracy").len(), + 18, + "Please update new extrinsic here." + ); + // propose + let dummy_call = crate::RuntimeCall::Democracy(pallet_democracy::Call::cancel_proposal { + prop_index: 2, + }); + let call = crate::RuntimeCall::Democracy(pallet_democracy::Call::propose { + proposal: crate::Preimage::bound(dummy_call.clone()).unwrap(), + value: 1, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_democracy", "propose", dispatch_info, call_len)); + + // second + let call = crate::RuntimeCall::Democracy(pallet_democracy::Call::second { proposal: 3 }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_democracy", "second", dispatch_info, call_len)); + + // vote + let call = crate::RuntimeCall::Democracy(pallet_democracy::Call::vote { + ref_index: 3, + vote: pallet_democracy::AccountVote::Standard { + vote: Default::default(), + balance: 2, + }, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_democracy", "vote", dispatch_info, call_len)); + + // emergency_cancel + let call = crate::RuntimeCall::Democracy(pallet_democracy::Call::emergency_cancel { + ref_index: 3, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_democracy", + "emergency_cancel", + dispatch_info, + call_len, + )); + + // external_propose + let call = crate::RuntimeCall::Democracy(pallet_democracy::Call::external_propose { + proposal: crate::Preimage::bound(dummy_call.clone()).unwrap(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_democracy", + "external_propose", + dispatch_info, + call_len, + )); + + // external_propose_majority + let call = + crate::RuntimeCall::Democracy(pallet_democracy::Call::external_propose_majority { + proposal: crate::Preimage::bound(dummy_call.clone()).unwrap(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_democracy", + "external_propose_majority", + dispatch_info, + call_len, + )); + + // external_propose_default + let call = + crate::RuntimeCall::Democracy(pallet_democracy::Call::external_propose_default { + proposal: crate::Preimage::bound(dummy_call).unwrap(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_democracy", + "external_propose_default", + dispatch_info, + call_len, + )); + + // fast_track + let call = crate::RuntimeCall::Democracy(pallet_democracy::Call::fast_track { + proposal_hash: Default::default(), + voting_period: 300, + delay: 30, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_democracy", "fast_track", dispatch_info, call_len)); + + // veto_external + let call = crate::RuntimeCall::Democracy(pallet_democracy::Call::veto_external { + proposal_hash: Default::default(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_democracy", "veto_external", dispatch_info, call_len)); + + // cancel_referendum + let call = crate::RuntimeCall::Democracy(pallet_democracy::Call::cancel_referendum { + ref_index: 3, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_democracy", + "cancel_referendum", + dispatch_info, + call_len, + )); + + // delegate + let call = crate::RuntimeCall::Democracy(pallet_democracy::Call::delegate { + to: ALICE.into(), + conviction: pallet_democracy::Conviction::Locked3x, + balance: 3, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_democracy", "delegate", dispatch_info, call_len)); + + // undelegate + let call = crate::RuntimeCall::Democracy(pallet_democracy::Call::undelegate {}); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_democracy", "undelegate", dispatch_info, call_len)); + + // clear_public_proposals + let call = crate::RuntimeCall::Democracy(pallet_democracy::Call::clear_public_proposals {}); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_democracy", + "clear_public_proposals", + dispatch_info, + call_len, + )); + + // unlock + let call = crate::RuntimeCall::Democracy(pallet_democracy::Call::unlock { + target: MultiAddress::Id(ALICE), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_democracy", "unlock", dispatch_info, call_len)); + + // remove_vote + let call = crate::RuntimeCall::Democracy(pallet_democracy::Call::remove_vote { index: 2 }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_democracy", "remove_vote", dispatch_info, call_len)); + + // remove_other_vote + let call = crate::RuntimeCall::Democracy(pallet_democracy::Call::remove_other_vote { + target: ALICE.into(), + index: 2, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_democracy", + "remove_other_vote", + dispatch_info, + call_len, + )); + + // blacklist + let call = crate::RuntimeCall::Democracy(pallet_democracy::Call::blacklist { + proposal_hash: Default::default(), + maybe_ref_index: Some(2), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_democracy", "blacklist", dispatch_info, call_len)); + + // cancel_proposal + let call = crate::RuntimeCall::Democracy(pallet_democracy::Call::cancel_proposal { + prop_index: 2, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_democracy", + "cancel_proposal", + dispatch_info, + call_len, + )); + } + + // pallet_collective + { + assert_eq!( + crate::RuntimeCall::get_call_names("TechnicalCommittee").len(), + 7, + "Please update new extrinsic here." + ); + // set_members + let call = crate::RuntimeCall::TechnicalCommittee(pallet_collective::Call::set_members { + new_members: vec![ALICE, BOB], + prime: Some(ALICE), + old_count: 6, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_collective", "set_members", dispatch_info, call_len)); + + // execute + let dummy_call = crate::RuntimeCall::Democracy(pallet_democracy::Call::cancel_proposal { + prop_index: 2, + }); + let call = crate::RuntimeCall::TechnicalCommittee(pallet_collective::Call::execute { + proposal: Box::new(dummy_call.clone()), + length_bound: 6, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_collective", "execute", dispatch_info, call_len)); + + // propose + let call = crate::RuntimeCall::TechnicalCommittee(pallet_collective::Call::propose { + threshold: 3, + proposal: Box::new(dummy_call), + length_bound: 6, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_collective", "propose", dispatch_info, call_len)); + + // vote + let call = crate::RuntimeCall::TechnicalCommittee(pallet_collective::Call::vote { + proposal: Default::default(), + index: 2, + approve: true, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_collective", "vote", dispatch_info, call_len)); + + // close + let call = crate::RuntimeCall::TechnicalCommittee(pallet_collective::Call::close { + proposal_hash: Default::default(), + index: 2, + proposal_weight_bound: Default::default(), + length_bound: 6, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_collective", "close", dispatch_info, call_len)); + + // disapprove_proposal + let call = + crate::RuntimeCall::TechnicalCommittee(pallet_collective::Call::disapprove_proposal { + proposal_hash: Default::default(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_collective", + "disapprove_proposal", + dispatch_info, + call_len, + )); + } + + // cumulus_pallet_xcmp_queue + { + assert_eq!( + crate::RuntimeCall::get_call_names("XcmpQueue").len(), + 9, + "Please update new extrinsic here." + ); + // service_overweight + let call = + crate::RuntimeCall::XcmpQueue(cumulus_pallet_xcmp_queue::Call::service_overweight { + index: 1, + weight_limit: 64, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "cumulus_pallet_xcmp_queue", + "service_overweight", + dispatch_info, + call_len, + )); + + // suspend_xcm_execution + let call = crate::RuntimeCall::XcmpQueue( + cumulus_pallet_xcmp_queue::Call::suspend_xcm_execution {}, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "cumulus_pallet_xcmp_queue", + "suspend_xcm_execution", + dispatch_info, + call_len, + )); + + // resume_xcm_execution + let call = + crate::RuntimeCall::XcmpQueue(cumulus_pallet_xcmp_queue::Call::resume_xcm_execution {}); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "cumulus_pallet_xcmp_queue", + "resume_xcm_execution", + dispatch_info, + call_len, + )); + + // update_suspend_threshold + let call = crate::RuntimeCall::XcmpQueue( + cumulus_pallet_xcmp_queue::Call::update_suspend_threshold { new: 2 }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "cumulus_pallet_xcmp_queue", + "update_suspend_threshold", + dispatch_info, + call_len, + )); + + // update_drop_threshold + let call = crate::RuntimeCall::XcmpQueue( + cumulus_pallet_xcmp_queue::Call::update_suspend_threshold { new: 2 }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "cumulus_pallet_xcmp_queue", + "update_drop_threshold", + dispatch_info, + call_len, + )); + + // update_resume_threshold + let call = crate::RuntimeCall::XcmpQueue( + cumulus_pallet_xcmp_queue::Call::update_resume_threshold { new: 2 }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "cumulus_pallet_xcmp_queue", + "update_resume_threshold", + dispatch_info, + call_len, + )); + + // update_threshold_weight + let call = crate::RuntimeCall::XcmpQueue( + cumulus_pallet_xcmp_queue::Call::update_threshold_weight { new: 64 }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "cumulus_pallet_xcmp_queue", + "update_threshold_weight", + dispatch_info, + call_len, + )); + + // update_weight_restrict_decay + let call = crate::RuntimeCall::XcmpQueue( + cumulus_pallet_xcmp_queue::Call::update_weight_restrict_decay { new: 64 }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "cumulus_pallet_xcmp_queue", + "update_weight_restrict_decay", + dispatch_info, + call_len, + )); + + // update_xcmp_max_individual_weight + let call = crate::RuntimeCall::XcmpQueue( + cumulus_pallet_xcmp_queue::Call::update_xcmp_max_individual_weight { new: 64 }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "cumulus_pallet_xcmp_queue", + "update_xcmp_max_individual_weight", + dispatch_info, + call_len, + )); + } + + // orml_xtokens + // cannot run this part out side of mock runtime. + t.execute_with(|| { + assert_eq!( + crate::RuntimeCall::get_call_names("XTokens").len(), + 6, + "Please update new extrinsic here." + ); + // transfer + let dest = VersionedMultiLocation::V1(Default::default()); + let call = crate::RuntimeCall::XTokens(orml_xtokens::Call::transfer { + currency_id: crate::xcm_config::CurrencyId::MantaCurrency(1), + amount: 10, + dest: Box::new(dest.clone()), + dest_weight_limit: WeightLimit::Unlimited, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("orml_xtokens", "transfer", dispatch_info, call_len)); + + // transfer_multiasset + let _asset = MultiAsset { + id: Concrete(MultiLocation { + parents: 1, + interior: X1(Parachain(1)), + }), + fun: Fungible(10000000000000), + }; + let asset = xcm::VersionedMultiAsset::V1(_asset.clone()); + let call = crate::RuntimeCall::XTokens(orml_xtokens::Call::transfer_multiasset { + asset: Box::new(asset.clone()), + dest: Box::new(dest.clone()), + dest_weight_limit: WeightLimit::Unlimited, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "orml_xtokens", + "transfer_multiasset", + dispatch_info, + call_len, + )); + + // transfer_with_fee + let call = crate::RuntimeCall::XTokens(orml_xtokens::Call::transfer_with_fee { + currency_id: crate::xcm_config::CurrencyId::MantaCurrency(1), + amount: 10, + fee: 20, + dest: Box::new(dest.clone()), + dest_weight_limit: WeightLimit::Unlimited, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("orml_xtokens", "transfer_with_fee", dispatch_info, call_len)); + + // transfer_multiasset_with_fee + let _fee_asset = MultiAsset { + id: Concrete(MultiLocation { + parents: 1, + interior: X1(Parachain(1)), + }), + fun: Fungible(5000000000000), + }; + let fee_asset = xcm::VersionedMultiAsset::V1(_fee_asset.clone()); + let call = crate::RuntimeCall::XTokens(orml_xtokens::Call::transfer_multiasset_with_fee { + asset: Box::new(asset), + fee: Box::new(fee_asset), + dest: Box::new(dest.clone()), + dest_weight_limit: WeightLimit::Unlimited, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "orml_xtokens", + "transfer_multiasset_with_fee", + dispatch_info, + call_len, + )); + + // transfer_multicurrencies + let call = crate::RuntimeCall::XTokens(orml_xtokens::Call::transfer_multicurrencies { + currencies: vec![ + (crate::xcm_config::CurrencyId::MantaCurrency(1), 10), + (crate::xcm_config::CurrencyId::MantaCurrency(2), 20), + ], + fee_item: 1, + dest: Box::new(dest.clone()), + dest_weight_limit: WeightLimit::Unlimited, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "orml_xtokens", + "transfer_multicurrencies", + dispatch_info, + call_len, + )); + + // transfer_multiassets + let assets = xcm::VersionedMultiAssets::V1(MultiAssets::from(vec![_asset, _fee_asset])); + let call = crate::RuntimeCall::XTokens(orml_xtokens::Call::transfer_multiassets { + assets: Box::new(assets), + fee_item: 1, + dest: Box::new(dest), + dest_weight_limit: WeightLimit::Unlimited, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "orml_xtokens", + "transfer_multiassets", + dispatch_info, + call_len, + )); + }); + + // manta_collator_selection + { + assert_eq!( + crate::RuntimeCall::get_call_names("CollatorSelection").len(), + 9, + "Please update new extrinsic here." + ); + // set_invulnerables + let call = crate::RuntimeCall::CollatorSelection( + manta_collator_selection::Call::set_invulnerables { new: vec![ALICE] }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "manta_collator_selection", + "set_invulnerables", + dispatch_info, + call_len, + )); + + // set_desired_candidates + let call = crate::RuntimeCall::CollatorSelection( + manta_collator_selection::Call::set_desired_candidates { max: 1 }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "manta_collator_selection", + "set_desired_candidates", + dispatch_info, + call_len, + )); + + // set_candidacy_bond + let call = crate::RuntimeCall::CollatorSelection( + manta_collator_selection::Call::set_candidacy_bond { bond: 1 }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "manta_collator_selection", + "set_candidacy_bond", + dispatch_info, + call_len, + )); + + // register_as_candidate + let call = crate::RuntimeCall::CollatorSelection( + manta_collator_selection::Call::register_as_candidate {}, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "manta_collator_selection", + "register_as_candidate", + dispatch_info, + call_len, + )); + + // register_candidate + let call = crate::RuntimeCall::CollatorSelection( + manta_collator_selection::Call::register_candidate { + new_candidate: ALICE, + }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "manta_collator_selection", + "register_candidate", + dispatch_info, + call_len, + )); + + // leave_intent + let call = + crate::RuntimeCall::CollatorSelection(manta_collator_selection::Call::leave_intent {}); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "manta_collator_selection", + "leave_intent", + dispatch_info, + call_len, + )); + + // remove_collator + let call = crate::RuntimeCall::CollatorSelection( + manta_collator_selection::Call::remove_collator { collator: ALICE }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "manta_collator_selection", + "remove_collator", + dispatch_info, + call_len, + )); + + // set_eviction_baseline + let call = crate::RuntimeCall::CollatorSelection( + manta_collator_selection::Call::set_eviction_baseline { + percentile: Default::default(), + }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "manta_collator_selection", + "set_eviction_baseline", + dispatch_info, + call_len, + )); + + // set_eviction_tolerance + let call = crate::RuntimeCall::CollatorSelection( + manta_collator_selection::Call::set_eviction_tolerance { + percentage: Default::default(), + }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "manta_collator_selection", + "set_eviction_tolerance", + dispatch_info, + call_len, + )); + } + + // pallet_asset_manager + { + assert_eq!( + crate::RuntimeCall::get_call_names("AssetManager").len(), + 8, + "Please update new extrinsic here." + ); + // register_asset + let call = crate::RuntimeCall::AssetManager(pallet_asset_manager::Call::register_asset { + location: Default::default(), + metadata: AssetRegistryMetadata::testing_default(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_asset_manager", + "register_asset", + dispatch_info, + call_len, + )); + + // update_asset_location + let call = + crate::RuntimeCall::AssetManager(pallet_asset_manager::Call::update_asset_location { + asset_id: 1, + location: Default::default(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_asset_manager", + "update_asset_location", + dispatch_info, + call_len, + )); + + // update_asset_metadata + let call = + crate::RuntimeCall::AssetManager(pallet_asset_manager::Call::update_asset_metadata { + asset_id: 1, + metadata: AssetRegistryMetadata::testing_default(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_asset_manager", + "update_asset_metadata", + dispatch_info, + call_len, + )); + + // set_units_per_second + let call = + crate::RuntimeCall::AssetManager(pallet_asset_manager::Call::set_units_per_second { + asset_id: 1, + units_per_second: 1, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_asset_manager", + "set_units_per_second", + dispatch_info, + call_len, + )); + + // mint_asset + let call = crate::RuntimeCall::AssetManager(pallet_asset_manager::Call::mint_asset { + asset_id: 1, + beneficiary: ALICE, + amount: 1, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_asset_manager", + "mint_asset", + dispatch_info, + call_len, + )); + + // set_min_xcm_fee + let call = crate::RuntimeCall::AssetManager(pallet_asset_manager::Call::set_min_xcm_fee { + reserve_chain: Default::default(), + min_xcm_fee: 1, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_asset_manager", + "set_min_xcm_fee", + dispatch_info, + call_len, + )); + + // update_outgoing_filtered_assets + let call = crate::RuntimeCall::AssetManager( + pallet_asset_manager::Call::update_outgoing_filtered_assets { + filtered_location: Default::default(), + should_add: true, + }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_asset_manager", + "update_outgoing_filtered_assets", + dispatch_info, + call_len, + )); + + // register_lp_asset + let call = + crate::RuntimeCall::AssetManager(pallet_asset_manager::Call::register_lp_asset { + asset_0: 1, + asset_1: 2, + metadata: AssetRegistryMetadata::testing_default(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_asset_manager", + "register_lp_asset", + dispatch_info, + call_len, + )); + } + + // pallet_assets + { + assert_eq!( + crate::RuntimeCall::get_call_names("Assets").len(), + 28, + "Please update new extrinsic here." + ); + // create + let call = crate::RuntimeCall::Assets(pallet_assets::Call::create { + id: 1, + admin: ALICE.into(), + min_balance: 1, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_assets", "create", dispatch_info, call_len)); + + // force_create + let call = crate::RuntimeCall::Assets(pallet_assets::Call::force_create { + id: 1, + owner: ALICE.into(), + is_sufficient: true, + min_balance: 1, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_assets", "force_create", dispatch_info, call_len)); + + // start_destroy + let call = crate::RuntimeCall::Assets(pallet_assets::Call::start_destroy { id: 1 }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_assets", "start_destroy", dispatch_info, call_len)); + + // destroy_accounts + let call = crate::RuntimeCall::Assets(pallet_assets::Call::destroy_accounts { id: 1 }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_assets", "destroy_accounts", dispatch_info, call_len)); + + // destroy_approvals + let call = crate::RuntimeCall::Assets(pallet_assets::Call::destroy_approvals { id: 1 }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_assets", + "destroy_approvals", + dispatch_info, + call_len, + )); + + // finish_destroy + let call = crate::RuntimeCall::Assets(pallet_assets::Call::finish_destroy { id: 1 }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_assets", "finish_destroy", dispatch_info, call_len)); + + // mint + let call = crate::RuntimeCall::Assets(pallet_assets::Call::mint { + id: 1, + beneficiary: ALICE.into(), + amount: 1, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_assets", "mint", dispatch_info, call_len)); + + // burn + let call = crate::RuntimeCall::Assets(pallet_assets::Call::burn { + id: 1, + who: ALICE.into(), + amount: 1, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_assets", "burn", dispatch_info, call_len)); + + // transfer + let call = crate::RuntimeCall::Assets(pallet_assets::Call::transfer { + id: 1, + target: ALICE.into(), + amount: 1, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_assets", "transfer", dispatch_info, call_len)); + + // transfer_keep_alive + let call = crate::RuntimeCall::Assets(pallet_assets::Call::transfer_keep_alive { + id: 1, + target: ALICE.into(), + amount: 1, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_assets", + "transfer_keep_alive", + dispatch_info, + call_len, + )); + + // force_transfer + let call = crate::RuntimeCall::Assets(pallet_assets::Call::force_transfer { + id: 1, + source: ALICE.into(), + dest: ALICE.into(), + amount: 1, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_assets", "force_transfer", dispatch_info, call_len)); + + // freeze + let call = crate::RuntimeCall::Assets(pallet_assets::Call::freeze { + id: 1, + who: ALICE.into(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_assets", "freeze", dispatch_info, call_len)); + + // thaw + let call = crate::RuntimeCall::Assets(pallet_assets::Call::thaw { + id: 1, + who: ALICE.into(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_assets", "thaw", dispatch_info, call_len)); + + // freeze_asset + let call = crate::RuntimeCall::Assets(pallet_assets::Call::freeze_asset { id: 1 }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_assets", "freeze_asset", dispatch_info, call_len)); + + // thaw_asset + let call = crate::RuntimeCall::Assets(pallet_assets::Call::thaw_asset { id: 1 }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_assets", "thaw_asset", dispatch_info, call_len)); + + // transfer_ownership + let call = crate::RuntimeCall::Assets(pallet_assets::Call::transfer_ownership { + id: 1, + owner: ALICE.into(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_assets", + "transfer_ownership", + dispatch_info, + call_len, + )); + + // set_team + let call = crate::RuntimeCall::Assets(pallet_assets::Call::set_team { + id: 1, + issuer: ALICE.into(), + admin: ALICE.into(), + freezer: ALICE.into(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_assets", "set_team", dispatch_info, call_len)); + + // set_metadata + let call = crate::RuntimeCall::Assets(pallet_assets::Call::set_metadata { + id: 1, + name: vec![1u8; 32], + symbol: vec![1u8; 32], + decimals: 12, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_assets", "set_metadata", dispatch_info, call_len)); + + // clear_metadata + let call = crate::RuntimeCall::Assets(pallet_assets::Call::clear_metadata { id: 1 }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_assets", "clear_metadata", dispatch_info, call_len)); + + // force_set_metadata + let call = crate::RuntimeCall::Assets(pallet_assets::Call::force_set_metadata { + id: 1, + name: vec![1u8; 32], + symbol: vec![1u8; 32], + decimals: 12, + is_frozen: true, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_assets", + "force_set_metadata", + dispatch_info, + call_len, + )); + + // force_clear_metadata + let call = crate::RuntimeCall::Assets(pallet_assets::Call::force_clear_metadata { id: 1 }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_assets", + "force_clear_metadata", + dispatch_info, + call_len, + )); + + // force_asset_status + let call = crate::RuntimeCall::Assets(pallet_assets::Call::force_asset_status { + id: 1, + owner: ALICE.into(), + issuer: ALICE.into(), + admin: ALICE.into(), + freezer: ALICE.into(), + min_balance: 1, + is_sufficient: true, + is_frozen: false, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_assets", + "force_asset_status", + dispatch_info, + call_len, + )); + + // approve_transfer + let call = crate::RuntimeCall::Assets(pallet_assets::Call::approve_transfer { + id: 1, + delegate: ALICE.into(), + amount: 1, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_assets", "approve_transfer", dispatch_info, call_len)); + + // cancel_approval + let call = crate::RuntimeCall::Assets(pallet_assets::Call::cancel_approval { + id: 1, + delegate: ALICE.into(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_assets", "cancel_approval", dispatch_info, call_len)); + + // force_cancel_approval + let call = crate::RuntimeCall::Assets(pallet_assets::Call::force_cancel_approval { + id: 1, + owner: ALICE.into(), + delegate: ALICE.into(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_assets", + "force_cancel_approval", + dispatch_info, + call_len, + )); + + // transfer_approved + let call = crate::RuntimeCall::Assets(pallet_assets::Call::transfer_approved { + id: 1, + owner: ALICE.into(), + destination: ALICE.into(), + amount: 1, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_assets", + "transfer_approved", + dispatch_info, + call_len, + )); + + // touch + let call = crate::RuntimeCall::Assets(pallet_assets::Call::touch { id: 1 }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_assets", "touch", dispatch_info, call_len)); + + // refund + let call = crate::RuntimeCall::Assets(pallet_assets::Call::refund { + id: 1, + allow_burn: true, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_assets", "refund", dispatch_info, call_len)); + } + + // pallet_author_inherent + { + assert_eq!( + crate::RuntimeCall::get_call_names("AuthorInherent").len(), + 1, + "Please update new extrinsic here." + ); + // kick_off_authorship_validation + let call = crate::RuntimeCall::AuthorInherent( + pallet_author_inherent::Call::kick_off_authorship_validation {}, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_author_inherent", + "kick_off_authorship_validation", + dispatch_info, + call_len, + )); + } + + // pallet_balances + { + assert_eq!( + crate::RuntimeCall::get_call_names("Balances").len(), + 6, + "Please update new extrinsic here." + ); + // transfer, 1 token + let call = crate::RuntimeCall::Balances(pallet_balances::Call::transfer { + dest: ALICE.into(), + value: 1, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_balances", "transfer-1", dispatch_info, call_len)); + + // transfer, 1M tokens + let call = crate::RuntimeCall::Balances(pallet_balances::Call::transfer { + dest: ALICE.into(), + value: 1_000_000, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_balances", + "transfer-1000_000", + dispatch_info, + call_len, + )); + + // set_balance + let call = crate::RuntimeCall::Balances(pallet_balances::Call::set_balance { + who: ALICE.into(), + new_free: 1, + new_reserved: 1, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_balances", "set_balance", dispatch_info, call_len)); + + // force_transfer + let call = crate::RuntimeCall::Balances(pallet_balances::Call::force_transfer { + source: ALICE.into(), + dest: ALICE.into(), + value: 1, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_balances", "force_transfer", dispatch_info, call_len)); + + // transfer_keep_alive, 1 token + let call = crate::RuntimeCall::Balances(pallet_balances::Call::transfer_keep_alive { + dest: ALICE.into(), + value: 1, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_balances", + "transfer_keep_alive-1", + dispatch_info, + call_len, + )); + + // transfer_keep_alive, 1M tokens + let call = crate::RuntimeCall::Balances(pallet_balances::Call::transfer_keep_alive { + dest: ALICE.into(), + value: 1_000_000, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_balances", + "transfer_keep_alive-1000_000", + dispatch_info, + call_len, + )); + + // transfer_all + let call = crate::RuntimeCall::Balances(pallet_balances::Call::transfer_all { + dest: ALICE.into(), + keep_alive: false, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_balances", "transfer_all", dispatch_info, call_len)); + + // force_unreserve + let call = crate::RuntimeCall::Balances(pallet_balances::Call::force_unreserve { + who: ALICE.into(), + amount: 1, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_balances", + "force_unreserve", + dispatch_info, + call_len, + )); + } + + // pallet_manta_pay + { + assert_eq!( + crate::RuntimeCall::get_call_names("MantaPay").len(), + 4, + "Please update new extrinsic here." + ); + + let to_private_proof = [0u8; 552]; + let private_transfer_proof = [0u8; 1290]; + let to_public_proof = [0u8; 1000]; + // to_private + let to_private_post = TransferPost::decode(&mut to_private_proof.as_slice()).unwrap(); + let call = crate::RuntimeCall::MantaPay(pallet_manta_pay::Call::to_private { + post: to_private_post, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_manta_pay", "to_private", dispatch_info, call_len)); + + // private_transfer + let private_transfer_post = + TransferPost::decode(&mut private_transfer_proof.as_slice()).unwrap(); + let call = crate::RuntimeCall::MantaPay(pallet_manta_pay::Call::private_transfer { + post: private_transfer_post, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_manta_pay", + "private_transfer", + dispatch_info, + call_len, + )); + + // to_public + let to_public_post = TransferPost::decode(&mut to_public_proof.as_slice()).unwrap(); + let call = crate::RuntimeCall::MantaPay(pallet_manta_pay::Call::to_public { + post: to_public_post, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_manta_pay", "to_public", dispatch_info, call_len)); + + // public_transfer + let call = crate::RuntimeCall::MantaPay(pallet_manta_pay::Call::public_transfer { + asset: Default::default(), + sink: ALICE, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_manta_pay", + "public_transfer", + dispatch_info, + call_len, + )); + } + + // pallet_manta_sbt + { + assert_eq!( + crate::RuntimeCall::get_call_names("MantaSbt").len(), + 13, + "Please update new extrinsic here." + ); + let to_private_proof = [0u8; 552]; + // to_private + let to_private_post = + Box::new(TransferPost::decode(&mut to_private_proof.as_slice()).unwrap()); + let call = crate::RuntimeCall::MantaSbt(pallet_manta_sbt::Call::to_private { + mint_id: None, + chain_id: None, + signature: None, + post: to_private_post, + metadata: Default::default(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_manta_sbt", "to_private", dispatch_info, call_len)); + + // force_to_private + let to_private_post = + Box::new(TransferPost::decode(&mut to_private_proof.as_slice()).unwrap()); + let call = crate::RuntimeCall::MantaSbt(pallet_manta_sbt::Call::force_to_private { + post: to_private_post.clone(), + mint_id: 1u32, + metadata: Default::default(), + minting_account: ALICE.clone(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_manta_sbt", + "force_to_private", + dispatch_info, + call_len, + )); + + // reserve_sbt + let call = crate::RuntimeCall::MantaSbt(pallet_manta_sbt::Call::reserve_sbt { + reservee: Default::default(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_manta_sbt", "reserve_sbt", dispatch_info, call_len)); + + // allowlist_evm_account + let call = crate::RuntimeCall::MantaSbt(pallet_manta_sbt::Call::allowlist_evm_account { + mint_id: 1, + evm_address: Default::default(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_manta_sbt", + "allowlist_evm_account", + dispatch_info, + call_len, + )); + + // set_next_sbt_id + let call = crate::RuntimeCall::MantaSbt(pallet_manta_sbt::Call::set_next_sbt_id { + asset_id: Some(1), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_manta_sbt", + "set_next_sbt_id", + dispatch_info, + call_len, + )); + + // remove_allowlist_evm_account + let call = + crate::RuntimeCall::MantaSbt(pallet_manta_sbt::Call::remove_allowlist_evm_account { + mint_id: 1, + evm_address: Default::default(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_manta_sbt", + "remove_allowlist_evm_account", + dispatch_info, + call_len, + )); + + // change_free_reserve_account + let call = + crate::RuntimeCall::MantaSbt(pallet_manta_sbt::Call::change_free_reserve_account { + account: Some(ALICE.clone()), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_manta_sbt", + "change_free_reserve_account", + dispatch_info, + call_len, + )); + + // force_mint_sbt_eth + let call = crate::RuntimeCall::MantaSbt(pallet_manta_sbt::Call::force_mint_sbt_eth { + post: to_private_post.clone(), + mint_id: 1u32, + address: Default::default(), + collection_id: Some(128), + item_id: Some(64), + metadata: Default::default(), + minting_account: ALICE.clone(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_manta_sbt", + "force_mint_sbt_eth", + dispatch_info, + call_len, + )); + + // change_force_account + let call = crate::RuntimeCall::MantaSbt(pallet_manta_sbt::Call::change_force_account { + account: Some(ALICE.clone()), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_manta_sbt", + "change_force_account", + dispatch_info, + call_len, + )); + + // mint_sbt_eth + let call = crate::RuntimeCall::MantaSbt(pallet_manta_sbt::Call::mint_sbt_eth { + post: to_private_post, + chain_id: 1, + eth_signature: [1u8; 65], + mint_id: 1, + collection_id: Some(1), + item_id: Some(1), + metadata: None, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_manta_sbt", "mint_sbt_eth", dispatch_info, call_len)); + + // change_allowlist_account + let call = crate::RuntimeCall::MantaSbt(pallet_manta_sbt::Call::change_allowlist_account { + account: Some(ALICE), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_manta_sbt", + "change_allowlist_account", + dispatch_info, + call_len, + )); + + // update_mint_info + let call = crate::RuntimeCall::MantaSbt(pallet_manta_sbt::Call::update_mint_info { + mint_id: 1, + start_time: Default::default(), + end_time: None, + mint_name: Default::default(), + public: true, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_manta_sbt", + "update_mint_info", + dispatch_info, + call_len, + )); + + // new_mint_info + let call = crate::RuntimeCall::MantaSbt(pallet_manta_sbt::Call::new_mint_info { + start_time: Default::default(), + end_time: None, + mint_name: Default::default(), + public: true, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_manta_sbt", "new_mint_info", dispatch_info, call_len)); + } + + // pallet_parachain_staking + { + assert_eq!( + crate::RuntimeCall::get_call_names("ParachainStaking").len(), + 26, + "Please update new extrinsic here." + ); + // set_staking_expectations + let call = crate::RuntimeCall::ParachainStaking( + pallet_parachain_staking::Call::set_staking_expectations { + expectations: pallet_parachain_staking::Range::from(1), + }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "set_staking_expectations", + dispatch_info, + call_len, + )); + + // set_inflation + let call = + crate::RuntimeCall::ParachainStaking(pallet_parachain_staking::Call::set_inflation { + schedule: pallet_parachain_staking::Range::from(Perbill::from_percent(20)), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "set_inflation", + dispatch_info, + call_len, + )); + + // set_parachain_bond_account + let call = crate::RuntimeCall::ParachainStaking( + pallet_parachain_staking::Call::set_parachain_bond_account { new: ALICE }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "set_parachain_bond_account", + dispatch_info, + call_len, + )); + + // set_parachain_bond_account + let call = crate::RuntimeCall::ParachainStaking( + pallet_parachain_staking::Call::set_parachain_bond_account { new: ALICE }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "set_parachain_bond_account", + dispatch_info, + call_len, + )); + + // set_parachain_bond_reserve_percent + let call = crate::RuntimeCall::ParachainStaking( + pallet_parachain_staking::Call::set_parachain_bond_reserve_percent { + new: Default::default(), + }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "set_parachain_bond_reserve_percent", + dispatch_info, + call_len, + )); + + // set_total_selected + let call = crate::RuntimeCall::ParachainStaking( + pallet_parachain_staking::Call::set_total_selected { new: 1 }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "set_total_selected", + dispatch_info, + call_len, + )); + + // set_collator_commission + let call = crate::RuntimeCall::ParachainStaking( + pallet_parachain_staking::Call::set_collator_commission { + new: Default::default(), + }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "set_collator_commission", + dispatch_info, + call_len, + )); + + // set_blocks_per_round + let call = crate::RuntimeCall::ParachainStaking( + pallet_parachain_staking::Call::set_blocks_per_round { new: 1 }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "set_blocks_per_round", + dispatch_info, + call_len, + )); + + // join_candidates + let call = + crate::RuntimeCall::ParachainStaking(pallet_parachain_staking::Call::join_candidates { + bond: 1, + candidate_count: 2, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "join_candidates", + dispatch_info, + call_len, + )); + + // schedule_leave_candidates + let call = crate::RuntimeCall::ParachainStaking( + pallet_parachain_staking::Call::schedule_leave_candidates { candidate_count: 2 }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "schedule_leave_candidates", + dispatch_info, + call_len, + )); + + // execute_leave_candidates + let call = crate::RuntimeCall::ParachainStaking( + pallet_parachain_staking::Call::execute_leave_candidates { + candidate: ALICE, + candidate_delegation_count: 2, + }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "execute_leave_candidates", + dispatch_info, + call_len, + )); + + // cancel_leave_candidates + let call = crate::RuntimeCall::ParachainStaking( + pallet_parachain_staking::Call::cancel_leave_candidates { candidate_count: 2 }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "cancel_leave_candidates", + dispatch_info, + call_len, + )); + + // go_offline + let call = + crate::RuntimeCall::ParachainStaking(pallet_parachain_staking::Call::go_offline {}); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "go_offline", + dispatch_info, + call_len, + )); + + // go_offline + let call = + crate::RuntimeCall::ParachainStaking(pallet_parachain_staking::Call::go_offline {}); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "go_offline", + dispatch_info, + call_len, + )); + + // candidate_bond_more + let call = crate::RuntimeCall::ParachainStaking( + pallet_parachain_staking::Call::candidate_bond_more { more: 1 }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "candidate_bond_more", + dispatch_info, + call_len, + )); + + // schedule_candidate_bond_less + let call = crate::RuntimeCall::ParachainStaking( + pallet_parachain_staking::Call::schedule_candidate_bond_less { less: 1 }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "schedule_candidate_bond_less", + dispatch_info, + call_len, + )); + + // execute_candidate_bond_less + let call = crate::RuntimeCall::ParachainStaking( + pallet_parachain_staking::Call::execute_candidate_bond_less { candidate: ALICE }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "execute_candidate_bond_less", + dispatch_info, + call_len, + )); + + // cancel_candidate_bond_less + let call = crate::RuntimeCall::ParachainStaking( + pallet_parachain_staking::Call::cancel_candidate_bond_less {}, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "cancel_candidate_bond_less", + dispatch_info, + call_len, + )); + + // delegate + let call = crate::RuntimeCall::ParachainStaking(pallet_parachain_staking::Call::delegate { + candidate: ALICE, + amount: 1, + candidate_delegation_count: 2, + delegation_count: 3, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "delegate_1_2_3", + dispatch_info, + call_len, + )); + + let call = crate::RuntimeCall::ParachainStaking(pallet_parachain_staking::Call::delegate { + candidate: ALICE, + amount: 1, + candidate_delegation_count: 25, + delegation_count: 3, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "delegate_1_25_3", + dispatch_info, + call_len, + )); + + let call = crate::RuntimeCall::ParachainStaking(pallet_parachain_staking::Call::delegate { + candidate: ALICE, + amount: 1, + candidate_delegation_count: 2, + delegation_count: 100, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "delegate_1_2_100", + dispatch_info, + call_len, + )); + + // schedule_leave_delegators + let call = crate::RuntimeCall::ParachainStaking( + pallet_parachain_staking::Call::schedule_leave_delegators {}, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "schedule_leave_delegators", + dispatch_info, + call_len, + )); + + // execute_leave_delegators + let call = crate::RuntimeCall::ParachainStaking( + pallet_parachain_staking::Call::execute_leave_delegators { + delegator: ALICE, + delegation_count: 3, + }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "execute_leave_delegators", + dispatch_info, + call_len, + )); + + // cancel_leave_delegators + let call = crate::RuntimeCall::ParachainStaking( + pallet_parachain_staking::Call::cancel_leave_delegators {}, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "cancel_leave_delegators", + dispatch_info, + call_len, + )); + + // schedule_revoke_delegation + let call = crate::RuntimeCall::ParachainStaking( + pallet_parachain_staking::Call::schedule_revoke_delegation { collator: ALICE }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "schedule_revoke_delegation", + dispatch_info, + call_len, + )); + + // delegator_bond_more + let call = crate::RuntimeCall::ParachainStaking( + pallet_parachain_staking::Call::delegator_bond_more { + candidate: ALICE, + more: 1, + }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "delegator_bond_more", + dispatch_info, + call_len, + )); + + // schedule_delegator_bond_less + let call = crate::RuntimeCall::ParachainStaking( + pallet_parachain_staking::Call::schedule_delegator_bond_less { + candidate: ALICE, + less: 1, + }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "schedule_delegator_bond_less", + dispatch_info, + call_len, + )); + + // execute_delegation_request + let call = crate::RuntimeCall::ParachainStaking( + pallet_parachain_staking::Call::execute_delegation_request { + delegator: ALICE, + candidate: ALICE, + }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "execute_delegation_request", + dispatch_info, + call_len, + )); + + // cancel_delegation_request + let call = crate::RuntimeCall::ParachainStaking( + pallet_parachain_staking::Call::cancel_delegation_request { candidate: ALICE }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_parachain_staking", + "cancel_delegation_request", + dispatch_info, + call_len, + )); + } + + // pallet_scheduler + { + assert_eq!( + crate::RuntimeCall::get_call_names("Scheduler").len(), + 6, + "Please update new extrinsic here." + ); + // cancel + let call = + crate::RuntimeCall::Scheduler(pallet_scheduler::Call::cancel { when: 1, index: 1 }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_scheduler", "cancel", dispatch_info, call_len)); + + // schedule + let call = crate::RuntimeCall::Scheduler(pallet_scheduler::Call::schedule { + when: 1, + maybe_periodic: None, + priority: 1, + call: Box::new(call), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_scheduler", "schedule", dispatch_info, call_len)); + + // schedule_named + let call = crate::RuntimeCall::Scheduler(pallet_scheduler::Call::schedule_named { + id: [1u8; 32], + when: 1, + maybe_periodic: None, + priority: 1, + call: Box::new(call), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_scheduler", + "schedule_named", + dispatch_info, + call_len, + )); + + // cancel_named + let call = + crate::RuntimeCall::Scheduler(pallet_scheduler::Call::cancel_named { id: [1u8; 32] }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_scheduler", "cancel_named", dispatch_info, call_len)); + + // schedule_after + let call = crate::RuntimeCall::Scheduler(pallet_scheduler::Call::schedule_after { + after: 1, + maybe_periodic: None, + priority: 1, + call: Box::new(call), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_scheduler", + "schedule_after", + dispatch_info, + call_len, + )); + + // schedule_named_after + let call = crate::RuntimeCall::Scheduler(pallet_scheduler::Call::schedule_named_after { + id: [1u8; 32], + after: 1, + maybe_periodic: None, + priority: 1, + call: Box::new(call), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_scheduler", + "schedule_named_after", + dispatch_info, + call_len, + )); + } + + // pallet_session + { + assert_eq!( + crate::RuntimeCall::get_call_names("Session").len(), + 2, + "Please update new extrinsic here." + ); + // set_keys + let keys = crate::opaque::SessionKeys::from_seed_unchecked("//Alice"); + let call = crate::RuntimeCall::Session(pallet_session::Call::set_keys { + keys, + proof: vec![1u8; 32], + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_session", "set_keys", dispatch_info, call_len)); + + // purge_keys + let call = crate::RuntimeCall::Session(pallet_session::Call::purge_keys {}); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_session", "purge_keys", dispatch_info, call_len)); + } + + // pallet_tx_pause + { + assert_eq!( + crate::RuntimeCall::get_call_names("TransactionPause").len(), + 6, + "Please update new extrinsic here." + ); + // set_mint_chain_info + let call = crate::RuntimeCall::TransactionPause(pallet_tx_pause::Call::pause_transaction { + pallet_name: vec![1u8; 32], + function_name: vec![1u8; 32], + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_tx_pause", + "pause_transaction", + dispatch_info, + call_len, + )); + + // unpause_transaction + let call = + crate::RuntimeCall::TransactionPause(pallet_tx_pause::Call::unpause_transaction { + pallet_name: vec![1u8; 32], + function_name: vec![1u8; 32], + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_tx_pause", + "unpause_transaction", + dispatch_info, + call_len, + )); + + // pause_transactions + let call = + crate::RuntimeCall::TransactionPause(pallet_tx_pause::Call::pause_transactions { + pallet_and_funcs: vec![(vec![1u8; 32], vec![vec![1u8; 32]; 2])], + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_tx_pause", + "pause_transactions", + dispatch_info, + call_len, + )); + + // unpause_transactions + let call = + crate::RuntimeCall::TransactionPause(pallet_tx_pause::Call::unpause_transactions { + pallet_and_funcs: vec![(vec![1u8; 32], vec![vec![1u8; 32]; 2])], + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_tx_pause", + "unpause_transactions", + dispatch_info, + call_len, + )); + + // pause_pallets + let call = crate::RuntimeCall::TransactionPause(pallet_tx_pause::Call::pause_pallets { + pallet_names: vec![vec![1u8; 32], vec![2u8; 32]], + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_tx_pause", "pause_pallets", dispatch_info, call_len)); + + // unpause_pallets + let call = crate::RuntimeCall::TransactionPause(pallet_tx_pause::Call::unpause_pallets { + pallet_names: vec![vec![1u8; 32], vec![2u8; 32]], + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_tx_pause", + "unpause_pallets", + dispatch_info, + call_len, + )); + } + + // pallet_utility + { + assert_eq!( + crate::RuntimeCall::get_call_names("Utility").len(), + 6, + "Please update new extrinsic here." + ); + // batch, one call within + let call = crate::RuntimeCall::Utility(pallet_utility::Call::batch { calls: vec![] }); + let call = crate::RuntimeCall::Utility(pallet_utility::Call::batch { + calls: vec![call; 1], + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_utility", "batch-size=1", dispatch_info, call_len)); + + // batch, 32 call within + let call = crate::RuntimeCall::Utility(pallet_utility::Call::batch { calls: vec![] }); + let call = crate::RuntimeCall::Utility(pallet_utility::Call::batch { + calls: vec![call; 32], + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_utility", "batch-size=32", dispatch_info, call_len)); + + // as_derivative + let call = crate::RuntimeCall::Utility(pallet_utility::Call::as_derivative { + index: 1, + call: Box::new(call), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_utility", "as_derivative", dispatch_info, call_len)); + + // batch_all + let call = crate::RuntimeCall::Utility(pallet_utility::Call::batch_all { calls: vec![] }); + let call = crate::RuntimeCall::Utility(pallet_utility::Call::batch { + calls: vec![call; 1], + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_utility", + "batch_all-size=1", + dispatch_info, + call_len, + )); + + // batch_all + let call = crate::RuntimeCall::Utility(pallet_utility::Call::batch_all { calls: vec![] }); + let call = crate::RuntimeCall::Utility(pallet_utility::Call::batch { + calls: vec![call; 32], + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_utility", + "batch_all-size=32", + dispatch_info, + call_len, + )); + + // dispatch_as + let origin: crate::RuntimeOrigin = frame_system::RawOrigin::Signed(ALICE).into(); + let as_origin: ::PalletsOrigin = + origin.caller().clone(); + let call = crate::RuntimeCall::Utility(pallet_utility::Call::dispatch_as { + as_origin: Box::new(as_origin), + call: Box::new(call), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_utility", "dispatch_as", dispatch_info, call_len)); + + // force_batch + let call = crate::RuntimeCall::Utility(pallet_utility::Call::force_batch { calls: vec![] }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_utility", "force_batch", dispatch_info, call_len)); + } + + // pallet_randomness + { + assert_eq!( + crate::RuntimeCall::get_call_names("Randomness").len(), + 1, + "Please update new extrinsic here." + ); + // set_babe_randomness_results + let call = + crate::RuntimeCall::Randomness(pallet_randomness::Call::set_babe_randomness_results {}); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_randomness", + "set_babe_randomness_results", + dispatch_info, + call_len, + )); + } + + // pallet_name_service + { + assert_eq!( + crate::RuntimeCall::get_call_names("NameService").len(), + 5, + "Please update new extrinsic here." + ); + // register + let call = crate::RuntimeCall::NameService(pallet_name_service::Call::register { + username: "test".as_bytes().to_vec(), + registrant: ALICE.clone().into(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_name_service", "register", dispatch_info, call_len)); + + // accept_register + let call = crate::RuntimeCall::NameService(pallet_name_service::Call::accept_register { + username: "test".as_bytes().to_vec(), + registrant: ALICE.clone().into(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_name_service", + "accept_register", + dispatch_info, + call_len, + )); + + // set_primary_name + let call = crate::RuntimeCall::NameService(pallet_name_service::Call::set_primary_name { + username: "test".as_bytes().to_vec(), + registrant: ALICE.clone().into(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_name_service", + "set_primary_name", + dispatch_info, + call_len, + )); + + // cancel_pending_register + let call = + crate::RuntimeCall::NameService(pallet_name_service::Call::cancel_pending_register { + username: "test".as_bytes().to_vec(), + registrant: ALICE.clone().into(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_name_service", + "cancel_pending_register", + dispatch_info, + call_len, + )); + + // remove_register + let call = crate::RuntimeCall::NameService(pallet_name_service::Call::remove_register { + username: "test".as_bytes().to_vec(), + registrant: ALICE.clone().into(), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_name_service", + "remove_register", + dispatch_info, + call_len, + )); + } + + // pallet_farming + { + assert_eq!( + crate::RuntimeCall::get_call_names("Farming").len(), + 14, + "Please update new extrinsic here." + ); + // create_farming_pool + let call = crate::RuntimeCall::Farming(pallet_farming::Call::create_farming_pool { + tokens_proportion: vec![ + (1, Perbill::from_percent(20)), + (2, Perbill::from_percent(40)), + ], + basic_rewards: vec![(1, 64), (2, 128)], + gauge_init: None, + min_deposit_to_start: 10, + after_block_to_start: 100, + withdraw_limit_time: 200, + claim_limit_time: 300, + withdraw_limit_count: 6, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_farming", + "create_farming_pool", + dispatch_info, + call_len, + )); + + // charge + let call = crate::RuntimeCall::Farming(pallet_farming::Call::charge { + pool_id: 1, + rewards: vec![(1, 64), (2, 128)], + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_farming", "charge", dispatch_info, call_len)); + + // deposit + let call = crate::RuntimeCall::Farming(pallet_farming::Call::deposit { + pool_id: 1, + add_value: 100, + gauge_info: Some((10, 64)), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_farming", "deposit", dispatch_info, call_len)); + + // withdraw + let call = crate::RuntimeCall::Farming(pallet_farming::Call::withdraw { + pool_id: 1, + remove_value: Some(100), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_farming", "withdraw", dispatch_info, call_len)); + + // claim + let call = crate::RuntimeCall::Farming(pallet_farming::Call::claim { pool_id: 1 }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_farming", "claim", dispatch_info, call_len)); + + // withdraw_claim + let call = crate::RuntimeCall::Farming(pallet_farming::Call::withdraw_claim { pool_id: 1 }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_farming", "withdraw_claim", dispatch_info, call_len)); + + // close_pool + let call = crate::RuntimeCall::Farming(pallet_farming::Call::close_pool { pool_id: 1 }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_farming", "close_pool", dispatch_info, call_len)); + + // set_retire_limit + let call = + crate::RuntimeCall::Farming(pallet_farming::Call::set_retire_limit { limit: 16 }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_farming", + "set_retire_limit", + dispatch_info, + call_len, + )); + + // retire_pool + let call = crate::RuntimeCall::Farming(pallet_farming::Call::retire_pool { pool_id: 1 }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_farming", "retire_pool", dispatch_info, call_len)); + + // reset_pool + let call = crate::RuntimeCall::Farming(pallet_farming::Call::reset_pool { + pool_id: 1, + basic_rewards: Some(vec![(1, 64), (2, 128)]), + min_deposit_to_start: Some(10), + after_block_to_start: Some(100), + withdraw_limit_time: Some(200), + claim_limit_time: Some(300), + withdraw_limit_count: Some(6), + gauge_init: None, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_farming", "reset_pool", dispatch_info, call_len)); + + // kill_pool + let call = crate::RuntimeCall::Farming(pallet_farming::Call::kill_pool { pool_id: 1 }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_farming", "kill_pool", dispatch_info, call_len)); + + // edit_pool + let call = crate::RuntimeCall::Farming(pallet_farming::Call::edit_pool { + pool_id: 1, + basic_rewards: Some(vec![(1, 64), (2, 128)]), + withdraw_limit_time: Some(200), + claim_limit_time: Some(300), + gauge_basic_rewards: Some(vec![(1, 64), (2, 128)]), + withdraw_limit_count: Some(6), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_farming", "edit_pool", dispatch_info, call_len)); + + // gauge_withdraw + let call = crate::RuntimeCall::Farming(pallet_farming::Call::gauge_withdraw { gid: 1 }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_farming", "gauge_withdraw", dispatch_info, call_len)); + + // force_gauge_claim + let call = crate::RuntimeCall::Farming(pallet_farming::Call::force_gauge_claim { gid: 1 }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_farming", + "force_gauge_claim", + dispatch_info, + call_len, + )); + } + + // pallet_lottery + { + assert_eq!( + crate::RuntimeCall::get_call_names("Lottery").len(), + 12, + "Please update new extrinsic here." + ); + t.execute_with(|| { + // deposit + let call = crate::RuntimeCall::Lottery(pallet_lottery::Call::deposit { amount: 10 }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("pallet_lottery", "deposit", dispatch_info, call_len)); + // request_withdraw + let call = + crate::RuntimeCall::Lottery(pallet_lottery::Call::request_withdraw { amount: 10 }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_lottery", + "request_withdraw", + dispatch_info, + call_len, + )); + + // claim_my_winnings + let call = crate::RuntimeCall::Lottery(pallet_lottery::Call::claim_my_winnings {}); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_lottery", + "claim_my_winnings", + dispatch_info, + call_len, + )); + // rebalance_stake + let call = crate::RuntimeCall::Lottery(pallet_lottery::Call::rebalance_stake {}); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_lottery", + "rebalance_stake", + dispatch_info, + call_len, + )); + + // start_lottery + let call = crate::RuntimeCall::Lottery(pallet_lottery::Call::start_lottery {}); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_lottery", + "start_lottery", + dispatch_info, + call_len, + )); + + // stop_lottery + let call = crate::RuntimeCall::Lottery(pallet_lottery::Call::stop_lottery {}); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_lottery", + "stop_lottery", + dispatch_info, + call_len, + )); + + // draw_lottery + let call = crate::RuntimeCall::Lottery(pallet_lottery::Call::draw_lottery {}); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_lottery", + "draw_lottery", + dispatch_info, + call_len, + )); + + // process_matured_withdrawals + let call = + crate::RuntimeCall::Lottery(pallet_lottery::Call::process_matured_withdrawals {}); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_lottery", + "process_matured_withdrawals", + dispatch_info, + call_len, + )); + + // liquidate_lottery + let call = crate::RuntimeCall::Lottery(pallet_lottery::Call::liquidate_lottery {}); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_lottery", + "liquidate_lottery", + dispatch_info, + call_len, + )); + + // set_min_deposit + let call = crate::RuntimeCall::Lottery(pallet_lottery::Call::set_min_deposit { + min_deposit: 10, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_lottery", + "set_min_deposit", + dispatch_info, + call_len, + )); + + // set_min_withdraw + let call = crate::RuntimeCall::Lottery(pallet_lottery::Call::set_min_withdraw { + min_withdraw: 10, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_lottery", + "set_min_withdraw", + dispatch_info, + call_len, + )); + + // set_gas_reserve + let call = crate::RuntimeCall::Lottery(pallet_lottery::Call::set_gas_reserve { + gas_reserve: 10, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "pallet_lottery", + "set_gas_reserve", + dispatch_info, + call_len, + )); + }); + } + + // zenlink_protocol + { + use zenlink_protocol::AssetId as ZenlinkAssetId; + assert_eq!( + crate::RuntimeCall::get_call_names("ZenlinkProtocol").len(), + 16, + "Please update new extrinsic here." + ); + // set_fee_receiver + let call = crate::RuntimeCall::ZenlinkProtocol(zenlink_protocol::Call::set_fee_receiver { + receiver: Some(ALICE.clone()), + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "zenlink_protocol", + "set_fee_receiver", + dispatch_info, + call_len, + )); + + // set_fee_point + let call = crate::RuntimeCall::ZenlinkProtocol(zenlink_protocol::Call::set_fee_point { + fee_point: 8, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("zenlink_protocol", "set_fee_point", dispatch_info, call_len)); + + // transfer + let asset_id = ZenlinkAssetId { + chain_id: 2084, + asset_type: 0, + asset_index: 10, // native token + }; + let call = crate::RuntimeCall::ZenlinkProtocol(zenlink_protocol::Call::transfer { + asset_id, + recipient: ALICE.clone(), + amount: 10, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("zenlink_protocol", "transfer", dispatch_info, call_len)); + + // create_pair + let asset_1 = ZenlinkAssetId { + chain_id: 2084, + asset_type: 1, + asset_index: 45, // non native token + }; + let call = crate::RuntimeCall::ZenlinkProtocol(zenlink_protocol::Call::create_pair { + asset_0: asset_id, + asset_1, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("zenlink_protocol", "transfer", dispatch_info, call_len)); + + // add_liquidity + let call = crate::RuntimeCall::ZenlinkProtocol(zenlink_protocol::Call::add_liquidity { + asset_0: asset_id, + asset_1, + amount_0_desired: 2, + amount_1_desired: 4, + amount_0_min: 1, + amount_1_min: 3, + deadline: 20, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("zenlink_protocol", "add_liquidity", dispatch_info, call_len)); + + // remove_liquidity + let call = crate::RuntimeCall::ZenlinkProtocol(zenlink_protocol::Call::remove_liquidity { + asset_0: asset_id, + asset_1, + liquidity: 4, + amount_0_min: 1, + amount_1_min: 3, + recipient: ALICE.clone(), + deadline: 20, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "zenlink_protocol", + "remove_liquidity", + dispatch_info, + call_len, + )); + + // swap_exact_assets_for_assets + let asset_2 = ZenlinkAssetId { + chain_id: 2084, + asset_type: 8, + asset_index: 45, // non native token + }; + let call = crate::RuntimeCall::ZenlinkProtocol( + zenlink_protocol::Call::swap_exact_assets_for_assets { + amount_in: 1, + amount_out_min: 4, + path: vec![asset_id, asset_2, asset_1], + recipient: ALICE.clone(), + deadline: 20, + }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "zenlink_protocol", + "swap_exact_assets_for_assets", + dispatch_info, + call_len, + )); + + // swap_assets_for_exact_assets + let call = crate::RuntimeCall::ZenlinkProtocol( + zenlink_protocol::Call::swap_assets_for_exact_assets { + amount_out: 1, + amount_in_max: 4, + path: vec![asset_id, asset_2, asset_1], + recipient: ALICE.clone(), + deadline: 20, + }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "zenlink_protocol", + "swap_assets_for_exact_assets", + dispatch_info, + call_len, + )); + + // bootstrap_create + let call = crate::RuntimeCall::ZenlinkProtocol(zenlink_protocol::Call::bootstrap_create { + asset_0: asset_id, + asset_1, + target_supply_0: 1000, + target_supply_1: 5000, + capacity_supply_0: 1000000, + capacity_supply_1: 5000000, + end: 20, + rewards: vec![asset_2, asset_1], + limits: vec![(asset_1, 50000), (asset_2, 60000)], + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "zenlink_protocol", + "bootstrap_create", + dispatch_info, + call_len, + )); + + // bootstrap_contribute + let call = + crate::RuntimeCall::ZenlinkProtocol(zenlink_protocol::Call::bootstrap_contribute { + asset_0: asset_id, + asset_1, + amount_0_contribute: 100, + amount_1_contribute: 500, + deadline: 20, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "zenlink_protocol", + "bootstrap_contribute", + dispatch_info, + call_len, + )); + + // bootstrap_claim + let call = crate::RuntimeCall::ZenlinkProtocol(zenlink_protocol::Call::bootstrap_claim { + recipient: ALICE.clone(), + asset_0: asset_id, + asset_1, + deadline: 20, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "zenlink_protocol", + "bootstrap_claim", + dispatch_info, + call_len, + )); + + // bootstrap_end + let call = crate::RuntimeCall::ZenlinkProtocol(zenlink_protocol::Call::bootstrap_end { + asset_0: asset_id, + asset_1, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(("zenlink_protocol", "bootstrap_end", dispatch_info, call_len)); + + // bootstrap_update + let call = crate::RuntimeCall::ZenlinkProtocol(zenlink_protocol::Call::bootstrap_update { + asset_0: asset_id, + asset_1, + target_supply_0: 1500, + target_supply_1: 7500, + capacity_supply_0: 10000000, + capacity_supply_1: 50000000, + end: 100, + rewards: vec![asset_2, asset_1], + limits: vec![(asset_1, 100000), (asset_2, 600000)], + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "zenlink_protocol", + "bootstrap_update", + dispatch_info, + call_len, + )); + + // bootstrap_refund + let call = crate::RuntimeCall::ZenlinkProtocol(zenlink_protocol::Call::bootstrap_refund { + asset_0: asset_id, + asset_1, + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "zenlink_protocol", + "bootstrap_refund", + dispatch_info, + call_len, + )); + + // bootstrap_charge_reward + let call = + crate::RuntimeCall::ZenlinkProtocol(zenlink_protocol::Call::bootstrap_charge_reward { + asset_0: asset_id, + asset_1, + charge_rewards: vec![(asset_1, 1000), (asset_id, 6000)], + }); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "zenlink_protocol", + "bootstrap_charge_reward", + dispatch_info, + call_len, + )); + + // bootstrap_withdraw_reward + let call = crate::RuntimeCall::ZenlinkProtocol( + zenlink_protocol::Call::bootstrap_withdraw_reward { + asset_0: asset_id, + asset_1, + recipient: ALICE.clone(), + }, + ); + let (dispatch_info, call_len) = get_call_details(&call); + calamari_runtime_calls.push(( + "zenlink_protocol", + "bootstrap_withdraw_reward", + dispatch_info, + call_len, + )); + } + + (calamari_runtime_calls, t) +} diff --git a/runtime/manta/src/lib.rs b/runtime/manta/src/lib.rs index e2f650129..c8d491277 100644 --- a/runtime/manta/src/lib.rs +++ b/runtime/manta/src/lib.rs @@ -85,6 +85,8 @@ pub use sp_runtime::BuildStorage; pub mod assets_config; pub mod currency; +#[cfg(test)] +mod diff_tx_fees; pub mod fee; pub mod impls; pub mod migrations; diff --git a/runtime/manta/tx-fees-data/4.3.1-tx-fees.csv b/runtime/manta/tx-fees-data/4.3.1-tx-fees.csv new file mode 100644 index 000000000..d6d756078 --- /dev/null +++ b/runtime/manta/tx-fees-data/4.3.1-tx-fees.csv @@ -0,0 +1,721 @@ +module,extrinsic,tx_fee_with_decimal,tx_fee_without_decimal,fee_multiplier +frame_system,remark-length=32,5298830572860000,0.00529883057286,0.0002 +frame_system,remark-length=64,5298830572860000,0.00529883057286,0.0002 +frame_system,set_heap_pages,5051141460000000,0.00505114146,0.0002 +frame_system,set_code,10298700000000000,0.0102987,0.0002 +frame_system,set_code_without_checks,10298700000000000,0.0102987,0.0002 +frame_system,set_storage,5639768311780000,0.00563976831178,0.0002 +frame_system,kill_storage,5640752394480000,0.00564075239448,0.0002 +frame_system,kill_prefix,5347866901860000,0.00534786690186,0.0002 +frame_system,remark_with_event-length=32,5299125157360000,0.00529912515736,0.0002 +frame_system,remark_with_event-length=64,5299125157360000,0.00529912515736,0.0002 +pallet_treasury,propose_spend,5311276620000000,0.00531127662,0.0002 +pallet_treasury,reject_proposal,4981698420000000,0.00498169842,0.0002 +pallet_treasury,approve_proposal,4980450907360000,0.00498045090736,0.0002 +pallet_treasury,spend,5308702160000000,0.00530870216,0.0002 +pallet_treasury,remove_approval,4980050160000000,0.00498005016,0.0002 +pallet_timestamp,set,4980035850000000,0.00498003585,0.0002 +pallet_preimage,note_preimage-length=32,5301296427280000,0.00530129642728,0.0002 +pallet_preimage,note_preimage-length=32,5631297364560000,0.00563129736456,0.0002 +pallet_preimage,unnote_preimage,5291382510000000,0.00529138251,0.0002 +pallet_preimage,request_preimage,5290247100000000,0.0052902471,0.0002 +pallet_preimage,unrequest_preimage,5291241490000000,0.00529124149,0.0002 +pallet_multisig,as_multi_threshold_1,5642687391770000,0.00564268739177,0.0002 +pallet_multisig,as_multi,5691638551760000,0.00569163855176,0.0002 +pallet_multisig,approve_as_multi,5670582089910000,0.00567058208991,0.0002 +pallet_multisig,cancel_as_multi,5720320808640000,0.00572032080864,0.0002 +pallet_membership,add_member,5299200000000000,0.0052992,0.0002 +pallet_membership,remove_member,5299200000000000,0.0052992,0.0002 +pallet_membership,swap_member,5629200000000000,0.0056292,0.0002 +pallet_membership,reset_members,5619200000000000,0.0056192,0.0002 +pallet_membership,change_key,5299200000000000,0.0052992,0.0002 +pallet_membership,set_prime,5299200000000000,0.0052992,0.0002 +pallet_membership,clear_prime,4969200000000000,0.0049692,0.0002 +pallet_democracy,propose,5032995490000000,0.00503299549,0.0002 +pallet_democracy,second,4980429690000000,0.00498042969,0.0002 +pallet_democracy,vote,5163085350000000,0.00516308535,0.0002 +pallet_democracy,emergency_cancel,5011444130000000,0.00501144413,0.0002 +pallet_democracy,external_propose,5020387100000000,0.0050203871,0.0002 +pallet_democracy,external_propose_majority,5019756720000000,0.00501975672,0.0002 +pallet_democracy,external_propose_default,5019752840000000,0.00501975284,0.0002 +pallet_democracy,fast_track,5372440150000000,0.00537244015,0.0002 +pallet_democracy,veto_external,5291500590000000,0.00529150059,0.0002 +pallet_democracy,cancel_referendum,4979852690000000,0.00497985269,0.0002 +pallet_democracy,delegate,5603062813470000,0.00560306281347,0.0002 +pallet_democracy,undelegate,5100351366490000,0.00510035136649,0.0002 +pallet_democracy,clear_public_proposals,4969756230000000,0.00496975623,0.0002 +pallet_democracy,unlock,5302924337590000,0.00530292433759,0.0002 +pallet_democracy,remove_vote,5011535981420000,0.00501153598142,0.0002 +pallet_democracy,remove_other_vote,5341539914110000,0.00534153991411,0.0002 +pallet_democracy,blacklist,5346852900000000,0.0053468529,0.0002 +pallet_democracy,cancel_proposal,4983209950000000,0.00498320995,0.0002 +pallet_collective,set_members,6125589740880000,0.00612558974088,0.0002 +pallet_collective,execute,5013692878910000,0.00501369287891,0.0002 +pallet_collective,propose,5024233103700000,0.0050242331037,0.0002 +pallet_collective,vote,5310644751780000,0.00531064475178,0.0002 +pallet_collective,close,5333665390400000,0.0053336653904,0.0002 +pallet_collective,disapprove_proposal,5292362275140000,0.00529236227514,0.0002 +cumulus_pallet_xcmp_queue,service_overweight,5128710000640000,0.00512871000064,0.0002 +cumulus_pallet_xcmp_queue,suspend_xcm_execution,4969700000000000,0.0049697,0.0002 +cumulus_pallet_xcmp_queue,resume_xcm_execution,4969700000000000,0.0049697,0.0002 +cumulus_pallet_xcmp_queue,update_suspend_threshold,5010028100000000,0.0050100281,0.0002 +cumulus_pallet_xcmp_queue,update_drop_threshold,5010028100000000,0.0050100281,0.0002 +cumulus_pallet_xcmp_queue,update_resume_threshold,5010028100000000,0.0050100281,0.0002 +cumulus_pallet_xcmp_queue,update_threshold_weight,5050027260000000,0.00505002726,0.0002 +cumulus_pallet_xcmp_queue,update_weight_restrict_decay,5050027260000000,0.00505002726,0.0002 +cumulus_pallet_xcmp_queue,update_xcmp_max_individual_weight,5050027260000000,0.00505002726,0.0002 +orml_xtokens,transfer,5338700000000000,0.0053387,0.0002 +orml_xtokens,transfer_multiasset,5148700000000000,0.0051487,0.0002 +orml_xtokens,transfer_with_fee,5498700000000000,0.0054987,0.0002 +orml_xtokens,transfer_multiasset_with_fee,5288700000000000,0.0052887,0.0002 +orml_xtokens,transfer_multicurrencies,5718700000000000,0.0057187,0.0002 +orml_xtokens,transfer_multiassets,5198700000000000,0.0051987,0.0002 +manta_collator_selection,set_invulnerables,5299848067980000,0.00529984806798,0.0002 +manta_collator_selection,set_desired_candidates,5009882270000000,0.00500988227,0.0002 +manta_collator_selection,set_candidacy_bond,5129857460000000,0.00512985746,0.0002 +manta_collator_selection,register_as_candidate,4971618918340000,0.00497161891834,0.0002 +manta_collator_selection,register_candidate,5291620903510000,0.00529162090351,0.0002 +manta_collator_selection,leave_intent,4970431577860000,0.00497043157786,0.0002 +manta_collator_selection,remove_collator,5290704365720000,0.00529070436572,0.0002 +manta_collator_selection,set_eviction_baseline,4979850280000000,0.00497985028,0.0002 +manta_collator_selection,set_eviction_tolerance,4979848820000000,0.00497984882,0.0002 +pallet_asset_manager,register_asset,5316306990000000,0.00531630699,0.0002 +pallet_asset_manager,update_asset_location,5015656650000000,0.00501565665,0.0002 +pallet_asset_manager,update_asset_metadata,5442385420000000,0.00544238542,0.0002 +pallet_asset_manager,set_units_per_second,4990541700000000,0.0049905417,0.0002 +pallet_asset_manager,mint_asset,5462491600000000,0.0054624916,0.0002 +pallet_asset_manager,set_min_xcm_fee,5010184700000000,0.0050101847,0.0002 +pallet_asset_manager,update_outgoing_filtered_assets,5010180010000000,0.00501018001,0.0002 +pallet_asset_manager,register_lp_asset,5606862120000000,0.00560686212,0.0002 +pallet_assets,create,5620165170000000,0.00562016517,0.0002 +pallet_assets,force_create,5480155780000000,0.00548015578,0.0002 +pallet_assets,start_destroy,5130165640000000,0.00513016564,0.0002 +pallet_assets,destroy_accounts,7789942740000000,0.00778994274,0.0002 +pallet_assets,destroy_approvals,6460649080000000,0.00646064908,0.0002 +pallet_assets,finish_destroy,5130603750000000,0.00513060375,0.0002 +pallet_assets,mint,5471567870000000,0.00547156787,0.0002 +pallet_assets,burn,5471639510000000,0.00547163951,0.0002 +pallet_assets,transfer,5474286510000000,0.00547428651,0.0002 +pallet_assets,transfer_keep_alive,5474205220000000,0.00547420522,0.0002 +pallet_assets,force_transfer,5804287650000000,0.00580428765,0.0002 +pallet_assets,freeze,5460457860000000,0.00546045786,0.0002 +pallet_assets,thaw,5460477080000000,0.00546047708,0.0002 +pallet_assets,freeze_asset,5130168740000000,0.00513016874,0.0002 +pallet_assets,thaw_asset,5130166230000000,0.00513016623,0.0002 +pallet_assets,transfer_ownership,5460437680000000,0.00546043768,0.0002 +pallet_assets,set_team,6120164660000000,0.00612016466,0.0002 +pallet_assets,set_metadata,5800456368310000,0.00580045636831,0.0002 +pallet_assets,clear_metadata,5130461700000000,0.0051304617,0.0002 +pallet_assets,force_set_metadata,5810462369050000,0.00581046236905,0.0002 +pallet_assets,force_clear_metadata,5130460480000000,0.00513046048,0.0002 +pallet_assets,force_asset_status,6480158970000000,0.00648015897,0.0002 +pallet_assets,approve_transfer,5471485470000000,0.00547148547,0.0002 +pallet_assets,cancel_approval,5461511900000000,0.0054615119,0.0002 +pallet_assets,force_cancel_approval,5791518790000000,0.00579151879,0.0002 +pallet_assets,transfer_approved,5805591880000000,0.00580559188,0.0002 +pallet_assets,touch,5131567870000000,0.00513156787,0.0002 +pallet_assets,refund,5141567870000000,0.00514156787,0.0002 +pallet_author_inherent,kick_off_authorship_validation,4970880300000000,0.0049708803,0.0002 +pallet_balances,transfer-1,5310446670000000,0.00531044667,0.0002 +pallet_balances,transfer-1000_000,5340446670000000,0.00534044667,0.0002 +pallet_balances,set_balance,5320247880000000,0.00532024788,0.0002 +pallet_balances,force_transfer,5641680230000000,0.00564168023,0.0002 +pallet_balances,transfer_keep_alive-1,5310312570000000,0.00531031257,0.0002 +pallet_balances,transfer_keep_alive-1000_000,5340312570000000,0.00534031257,0.0002 +pallet_balances,transfer_all,5310349270000000,0.00531034927,0.0002 +pallet_balances,force_unreserve,5460168470000000,0.00546016847,0.0002 +pallet_manta_pay,to_private,6722688280000000,0.00672268828,0.0002 +pallet_manta_pay,private_transfer,7040982200000000,0.0070409822,0.0002 +pallet_manta_pay,to_public,6858627160000000,0.00685862716,0.0002 +pallet_manta_pay,public_transfer,5773112270000000,0.00577311227,0.0002 +pallet_manta_sbt,to_private,6759176550000000,0.00675917655,0.0002 +pallet_manta_sbt,force_to_private,7087417100000000,0.0070874171,0.0002 +pallet_manta_sbt,reserve_sbt,4983262060000000,0.00498326206,0.0002 +pallet_manta_sbt,allowlist_evm_account,5212282760000000,0.00521228276,0.0002 +pallet_manta_sbt,set_next_sbt_id,5139864870000000,0.00513986487,0.0002 +pallet_manta_sbt,remove_allowlist_evm_account,5209883220000000,0.00520988322,0.0002 +pallet_manta_sbt,change_free_reserve_account,5300061790000000,0.00530006179,0.0002 +pallet_manta_sbt,force_mint_sbt_eth,7628723620000000,0.00762872362,0.0002 +pallet_manta_sbt,change_force_account,5299870120000000,0.00529987012,0.0002 +pallet_manta_sbt,mint_sbt_eth,7839580440000000,0.00783958044,0.0002 +pallet_manta_sbt,change_allowlist_account,5299867290000000,0.00529986729,0.0002 +pallet_manta_sbt,update_mint_info,5121193990000000,0.00512119399,0.0002 +pallet_manta_sbt,new_mint_info,5082154520000000,0.00508215452,0.0002 +pallet_parachain_staking,set_staking_expectations,5450171760000000,0.00545017176,0.0002 +pallet_parachain_staking,set_inflation,5090592120000000,0.00509059212,0.0002 +pallet_parachain_staking,set_parachain_bond_account,5290175500000000,0.0052901755,0.0002 +pallet_parachain_staking,set_parachain_bond_account,5290175500000000,0.0052901755,0.0002 +pallet_parachain_staking,set_parachain_bond_reserve_percent,4980161600000000,0.0049801616,0.0002 +pallet_parachain_staking,set_total_selected,4980176040000000,0.00498017604,0.0002 +pallet_parachain_staking,set_collator_commission,4980327840000000,0.00498032784,0.0002 +pallet_parachain_staking,set_blocks_per_round,4980930960000000,0.00498093096,0.0002 +pallet_parachain_staking,join_candidates,4998139763540000,0.00499813976354,0.0002 +pallet_parachain_staking,schedule_leave_candidates,4981593902010000,0.00498159390201,0.0002 +pallet_parachain_staking,execute_leave_candidates,5312616212160000,0.00531261621216,0.0002 +pallet_parachain_staking,cancel_leave_candidates,4981557774340000,0.00498155777434,0.0002 +pallet_parachain_staking,go_offline,4971503740000000,0.00497150374,0.0002 +pallet_parachain_staking,go_offline,4971503740000000,0.00497150374,0.0002 +pallet_parachain_staking,candidate_bond_more,4985493190000000,0.00498549319,0.0002 +pallet_parachain_staking,schedule_candidate_bond_less,5130230020000000,0.00513023002,0.0002 +pallet_parachain_staking,execute_candidate_bond_less,5295584510000000,0.00529558451,0.0002 +pallet_parachain_staking,cancel_candidate_bond_less,4970213570000000,0.00497021357,0.0002 +pallet_parachain_staking,delegate_1_2_3,5328270435980000,0.00532827043598,0.0002 +pallet_parachain_staking,delegate_1_25_3,5328344643410000,0.00532834464341,0.0002 +pallet_parachain_staking,delegate_1_2_100,5338430120290000,0.00533843012029,0.0002 +pallet_parachain_staking,schedule_leave_delegators,4971539170000000,0.00497153917,0.0002 +pallet_parachain_staking,execute_leave_delegators,5313574418140000,0.00531357441814,0.0002 +pallet_parachain_staking,cancel_leave_delegators,4971567550000000,0.00497156755,0.0002 +pallet_parachain_staking,schedule_revoke_delegation,5291528220000000,0.00529152822,0.0002 +pallet_parachain_staking,delegator_bond_more,5308433500000000,0.0053084335,0.0002 +pallet_parachain_staking,schedule_delegator_bond_less,5301548340000000,0.00530154834,0.0002 +pallet_parachain_staking,execute_delegation_request,5619564930000000,0.00561956493,0.0002 +pallet_parachain_staking,cancel_delegation_request,5291593080000000,0.00529159308,0.0002 +pallet_scheduler,cancel,5051923674850000,0.00505192367485,0.0002 +pallet_scheduler,schedule,5130611020810000,0.00513061102081,0.0002 +pallet_scheduler,schedule_named,5531920983690000,0.00553192098369,0.0002 +pallet_scheduler,cancel_named,5292205462920000,0.00529220546292,0.0002 +pallet_scheduler,schedule_after,5370611020810000,0.00537061102081,0.0002 +pallet_scheduler,schedule_named_after,5771920983690000,0.00577192098369,0.0002 +pallet_session,set_keys,5942733340000000,0.00594273334,0.0002 +pallet_session,purge_keys,4972178010000000,0.00497217801,0.0002 +pallet_tx_pause,pause_transaction,5630151710000000,0.00563015171,0.0002 +pallet_tx_pause,unpause_transaction,5630169220000000,0.00563016922,0.0002 +pallet_tx_pause,pause_transactions,5981603420000000,0.00598160342,0.0002 +pallet_tx_pause,unpause_transactions,5981638440000000,0.00598163844,0.0002 +pallet_tx_pause,pause_pallets,5711285500000000,0.0057112855,0.0002 +pallet_tx_pause,unpause_pallets,5711285500000000,0.0057112855,0.0002 +pallet_utility,batch-size=1,5009440951330000,0.00500944095133,0.0002 +pallet_utility,batch-size=32,5951726944180000,0.00595172694418,0.0002 +pallet_utility,as_derivative,5993051454180000,0.00599305145418,0.0002 +pallet_utility,batch_all-size=1,5009428389120000,0.00500942838912,0.0002 +pallet_utility,batch_all-size=32,5951324953460000,0.00595132495346,0.0002 +pallet_utility,dispatch_as,6311484683460000,0.00631148468346,0.0002 +pallet_utility,force_batch,4979056949780000,0.00497905694978,0.0002 +pallet_randomness,set_babe_randomness_results,4972597140000000,0.00497259714,0.0002 +pallet_name_service,register,5341971690000000,0.00534197169,0.0002 +pallet_name_service,accept_register,5341220970000000,0.00534122097,0.0002 +pallet_name_service,set_primary_name,5340466210000000,0.00534046621,0.0002 +pallet_name_service,cancel_pending_register,5340193150000000,0.00534019315,0.0002 +pallet_name_service,remove_register,5340475440000000,0.00534047544,0.0002 +pallet_farming,create_farming_pool,6123454400000000,0.0061234544,0.0002 +pallet_farming,charge,5785586410000000,0.00578558641,0.0002 +pallet_farming,deposit,5366958530000000,0.00536695853,0.0002 +pallet_farming,withdraw,5301598800000000,0.0053015988,0.0002 +pallet_farming,claim,5131842270000000,0.00513184227,0.0002 +pallet_farming,withdraw_claim,5131842270000000,0.00513184227,0.0002 +pallet_farming,close_pool,5128700010000000,0.00512870001,0.0002 +pallet_farming,set_retire_limit,5008700010000000,0.00500870001,0.0002 +pallet_farming,retire_pool,5128700010000000,0.00512870001,0.0002 +pallet_farming,reset_pool,6138700010000000,0.00613870001,0.0002 +pallet_farming,kill_pool,5128700010000000,0.00512870001,0.0002 +pallet_farming,edit_pool,6568700010000000,0.00656870001,0.0002 +pallet_farming,gauge_withdraw,5132138870000000,0.00513213887,0.0002 +pallet_farming,force_gauge_claim,5128700010000000,0.00512870001,0.0002 +pallet_lottery,deposit,5148930542980000,0.00514893054298,0.0002 +pallet_lottery,request_withdraw,5143139419240000,0.00514313941924,0.0002 +pallet_lottery,claim_my_winnings,4974507401170000,0.00497450740117,0.0002 +pallet_lottery,rebalance_stake,4968700000000000,0.0049687,0.0002 +pallet_lottery,start_lottery,4972914630000000,0.00497291463,0.0002 +pallet_lottery,stop_lottery,4971513650000000,0.00497151365,0.0002 +pallet_lottery,draw_lottery,4972494500000000,0.0049724945,0.0002 +pallet_lottery,process_matured_withdrawals,4969853700000000,0.0049698537,0.0002 +pallet_lottery,liquidate_lottery,4968700000000000,0.0049687,0.0002 +pallet_lottery,set_min_deposit,5130129350000000,0.00513012935,0.0002 +pallet_lottery,set_min_withdraw,5129795400000000,0.0051297954,0.0002 +pallet_lottery,set_gas_reserve,5129764770000000,0.00512976477,0.0002 +zenlink_protocol,set_fee_receiver,5300031420000000,0.00530003142,0.0002 +zenlink_protocol,set_fee_point,4980026040000000,0.00498002604,0.0002 +zenlink_protocol,transfer,5428710000000000,0.00542871,0.0002 +zenlink_protocol,transfer,5231781750000000,0.00523178175,0.0002 +zenlink_protocol,add_liquidity,5316435970000000,0.00531643597,0.0002 +zenlink_protocol,remove_liquidity,5609203290000000,0.00560920329,0.0002 +zenlink_protocol,swap_exact_assets_for_assets,5727973630000000,0.00572797363,0.0002 +zenlink_protocol,swap_assets_for_exact_assets,5728027170000000,0.00572802717,0.0002 +zenlink_protocol,bootstrap_create,6222204460000000,0.00622220446,0.0002 +zenlink_protocol,bootstrap_contribute,5287379380000000,0.00528737938,0.0002 +zenlink_protocol,bootstrap_claim,5587207160000000,0.00558720716,0.0002 +zenlink_protocol,bootstrap_end,5268850700000000,0.0052688507,0.0002 +zenlink_protocol,bootstrap_update,6232515640000000,0.00623251564,0.0002 +zenlink_protocol,bootstrap_refund,5237096110000000,0.00523709611,0.0002 +zenlink_protocol,bootstrap_charge_reward,5819700000000000,0.0058197,0.0002 +zenlink_protocol,bootstrap_withdraw_reward,5549700000000000,0.0055497,0.0002 +frame_system,remark-length=32,5429272860000000,0.00542927286,0.2 +frame_system,remark-length=64,5429272860000000,0.00542927286,0.2 +frame_system,set_heap_pages,7490160000000000,0.00749016,0.2 +frame_system,set_code,5005298700000000000,5.0052987,0.2 +frame_system,set_code_without_checks,5005298700000000000,5.0052987,0.2 +frame_system,set_storage,6707011780000000,0.00670701178,0.2 +frame_system,kill_storage,7691094480000000,0.00769109448,0.2 +frame_system,kill_prefix,14505601860000000,0.01450560186,0.2 +frame_system,remark_with_event-length=32,5723857360000000,0.00572385736,0.2 +frame_system,remark_with_event-length=64,5723857360000000,0.00572385736,0.2 +pallet_treasury,propose_spend,7885320000000000,0.00788532,0.2 +pallet_treasury,reject_proposal,7977120000000000,0.00797712,0.2 +pallet_treasury,approve_proposal,6729607360000000,0.00672960736,0.2 +pallet_treasury,spend,5310860000000000,0.00531086,0.2 +pallet_treasury,remove_approval,6328860000000000,0.00632886,0.2 +pallet_timestamp,set,6314550000000000,0.00631455,0.2 +pallet_preimage,note_preimage-length=32,7895127280000000,0.00789512728,0.2 +pallet_preimage,note_preimage-length=32,8226064560000000,0.00822606456,0.2 +pallet_preimage,unnote_preimage,7971210000000000,0.00797121,0.2 +pallet_preimage,request_preimage,6835800000000000,0.0068358,0.2 +pallet_preimage,unrequest_preimage,7830190000000000,0.00783019,0.2 +pallet_multisig,as_multi_threshold_1,9626091770000000,0.00962609177,0.2 +pallet_multisig,as_multi,8627251760000000,0.00862725176,0.2 +pallet_multisig,approve_as_multi,7550789910000000,0.00755078991,0.2 +pallet_multisig,cancel_as_multi,7339508640000000,0.00733950864,0.2 +pallet_membership,add_member,5798700000000000,0.0057987,0.2 +pallet_membership,remove_member,5798700000000000,0.0057987,0.2 +pallet_membership,swap_member,6128700000000000,0.0061287,0.2 +pallet_membership,reset_members,6118700000000000,0.0061187,0.2 +pallet_membership,change_key,5798700000000000,0.0057987,0.2 +pallet_membership,set_prime,5798700000000000,0.0057987,0.2 +pallet_membership,clear_prime,5468700000000000,0.0054687,0.2 +pallet_democracy,propose,9324190000000000,0.00932419,0.2 +pallet_democracy,second,6708390000000000,0.00670839,0.2 +pallet_democracy,vote,9544050000000000,0.00954405,0.2 +pallet_democracy,emergency_cancel,7752830000000000,0.00775283,0.2 +pallet_democracy,external_propose,6705800000000000,0.0067058,0.2 +pallet_democracy,external_propose_majority,6075420000000000,0.00607542,0.2 +pallet_democracy,external_propose_default,6071540000000000,0.00607154,0.2 +pallet_democracy,fast_track,9108850000000000,0.00910885,0.2 +pallet_democracy,veto_external,8089290000000000,0.00808929,0.2 +pallet_democracy,cancel_referendum,6131390000000000,0.00613139,0.2 +pallet_democracy,delegate,139831513470000000,0.13983151347,0.2 +pallet_democracy,undelegate,136620066490000000,0.13662006649,0.2 +pallet_democracy,clear_public_proposals,6024930000000000,0.00602493,0.2 +pallet_democracy,unlock,9523037590000000,0.00952303759,0.2 +pallet_democracy,remove_vote,7844681420000000,0.00784468142,0.2 +pallet_democracy,remove_other_vote,8178614110000000,0.00817861411,0.2 +pallet_democracy,blacklist,13491600000000000,0.0134916,0.2 +pallet_democracy,cancel_proposal,9488650000000000,0.00948865,0.2 +pallet_collective,set_members,142878440880000000,0.14287844088,0.2 +pallet_collective,execute,10001578910000000,0.01000157891,0.2 +pallet_collective,propose,10551803700000000,0.0105518037,0.2 +pallet_collective,vote,7253451780000000,0.00725345178,0.2 +pallet_collective,close,10294090400000000,0.0102940904,0.2 +pallet_collective,disapprove_proposal,8950975140000000,0.00895097514,0.2 +cumulus_pallet_xcmp_queue,service_overweight,5138700640000000,0.00513870064,0.2 +cumulus_pallet_xcmp_queue,suspend_xcm_execution,5968700000000000,0.0059687,0.2 +cumulus_pallet_xcmp_queue,resume_xcm_execution,5968700000000000,0.0059687,0.2 +cumulus_pallet_xcmp_queue,update_suspend_threshold,6336800000000000,0.0063368,0.2 +cumulus_pallet_xcmp_queue,update_drop_threshold,6336800000000000,0.0063368,0.2 +cumulus_pallet_xcmp_queue,update_resume_threshold,6336800000000000,0.0063368,0.2 +cumulus_pallet_xcmp_queue,update_threshold_weight,6375960000000000,0.00637596,0.2 +cumulus_pallet_xcmp_queue,update_weight_restrict_decay,6375960000000000,0.00637596,0.2 +cumulus_pallet_xcmp_queue,update_xcmp_max_individual_weight,6375960000000000,0.00637596,0.2 +orml_xtokens,transfer,5338700000000000,0.0053387,0.2 +orml_xtokens,transfer_multiasset,5148700000000000,0.0051487,0.2 +orml_xtokens,transfer_with_fee,5498700000000000,0.0054987,0.2 +orml_xtokens,transfer_multiasset_with_fee,5288700000000000,0.0052887,0.2 +orml_xtokens,transfer_multicurrencies,5718700000000000,0.0057187,0.2 +orml_xtokens,transfer_multiassets,5198700000000000,0.0051987,0.2 +manta_collator_selection,set_invulnerables,6446767980000000,0.00644676798,0.2 +manta_collator_selection,set_desired_candidates,6190970000000000,0.00619097,0.2 +manta_collator_selection,set_candidacy_bond,6286160000000000,0.00628616,0.2 +manta_collator_selection,register_as_candidate,7887618340000000,0.00788761834,0.2 +manta_collator_selection,register_candidate,8209603510000000,0.00820960351,0.2 +manta_collator_selection,leave_intent,6700277860000000,0.00670027786,0.2 +manta_collator_selection,remove_collator,7293065720000000,0.00729306572,0.2 +manta_collator_selection,set_eviction_baseline,6128980000000000,0.00612898,0.2 +manta_collator_selection,set_eviction_tolerance,6127520000000000,0.00612752,0.2 +pallet_asset_manager,register_asset,12915690000000000,0.01291569,0.2 +pallet_asset_manager,update_asset_location,11965350000000000,0.01196535,0.2 +pallet_asset_manager,update_asset_metadata,9124120000000000,0.00912412,0.2 +pallet_asset_manager,set_units_per_second,6830400000000000,0.0068304,0.2 +pallet_asset_manager,mint_asset,9250300000000000,0.0092503,0.2 +pallet_asset_manager,set_min_xcm_fee,6493400000000000,0.0064934,0.2 +pallet_asset_manager,update_outgoing_filtered_assets,6488710000000000,0.00648871,0.2 +pallet_asset_manager,register_lp_asset,13760820000000000,0.01376082,0.2 +pallet_assets,create,7083870000000000,0.00708387,0.2 +pallet_assets,force_create,6934480000000000,0.00693448,0.2 +pallet_assets,start_destroy,6594340000000000,0.00659434,0.2 +pallet_assets,destroy_accounts,2666371440000000000,2.66637144,0.2 +pallet_assets,destroy_approvals,1337077780000000000,1.33707778,0.2 +pallet_assets,finish_destroy,7032450000000000,0.00703245,0.2 +pallet_assets,mint,8336570000000000,0.00833657,0.2 +pallet_assets,burn,8408210000000000,0.00840821,0.2 +pallet_assets,transfer,11055210000000000,0.01105521,0.2 +pallet_assets,transfer_keep_alive,10973920000000000,0.01097392,0.2 +pallet_assets,force_transfer,11386350000000000,0.01138635,0.2 +pallet_assets,freeze,7216560000000000,0.00721656,0.2 +pallet_assets,thaw,7235780000000000,0.00723578,0.2 +pallet_assets,freeze_asset,6597440000000000,0.00659744,0.2 +pallet_assets,thaw_asset,6594930000000000,0.00659493,0.2 +pallet_assets,transfer_ownership,7196380000000000,0.00719638,0.2 +pallet_assets,set_team,7583360000000000,0.00758336,0.2 +pallet_assets,set_metadata,7555068310000000,0.00755506831,0.2 +pallet_assets,clear_metadata,6890400000000000,0.0068904,0.2 +pallet_assets,force_set_metadata,7571069050000000,0.00757106905,0.2 +pallet_assets,force_clear_metadata,6889180000000000,0.00688918,0.2 +pallet_assets,force_asset_status,7937670000000000,0.00793767,0.2 +pallet_assets,approve_transfer,8254170000000000,0.00825417,0.2 +pallet_assets,cancel_approval,8270600000000000,0.0082706,0.2 +pallet_assets,force_cancel_approval,8607490000000000,0.00860749,0.2 +pallet_assets,transfer_approved,12690580000000000,0.01269058,0.2 +pallet_assets,touch,7996570000000000,0.00799657,0.2 +pallet_assets,refund,8006570000000000,0.00800657,0.2 +pallet_author_inherent,kick_off_authorship_validation,7149000000000000,0.007149,0.2 +pallet_balances,transfer-1,7055370000000000,0.00705537,0.2 +pallet_balances,transfer-1000_000,7085370000000000,0.00708537,0.2 +pallet_balances,set_balance,6866580000000000,0.00686658,0.2 +pallet_balances,force_transfer,8618930000000000,0.00861893,0.2 +pallet_balances,transfer_keep_alive-1,6921270000000000,0.00692127,0.2 +pallet_balances,transfer_keep_alive-1000_000,6951270000000000,0.00695127,0.2 +pallet_balances,transfer_all,6957970000000000,0.00695797,0.2 +pallet_balances,force_unreserve,6927170000000000,0.00692717,0.2 +pallet_manta_pay,to_private,410306980000000000,0.41030698,0.2 +pallet_manta_pay,private_transfer,728600900000000000,0.7286009,0.2 +pallet_manta_pay,to_public,546245860000000000,0.54624586,0.2 +pallet_manta_pay,public_transfer,10180970000000000,0.01018097,0.2 +pallet_manta_sbt,to_private,406835250000000000,0.40683525,0.2 +pallet_manta_sbt,force_to_private,405405800000000000,0.4054058,0.2 +pallet_manta_sbt,reserve_sbt,9540760000000000,0.00954076,0.2 +pallet_manta_sbt,allowlist_evm_account,8791460000000000,0.00879146,0.2 +pallet_manta_sbt,set_next_sbt_id,6303570000000000,0.00630357,0.2 +pallet_manta_sbt,remove_allowlist_evm_account,6391920000000000,0.00639192,0.2 +pallet_manta_sbt,change_free_reserve_account,6660490000000000,0.00666049,0.2 +pallet_manta_sbt,force_mint_sbt_eth,407252320000000000,0.40725232,0.2 +pallet_manta_sbt,change_force_account,6468820000000000,0.00646882,0.2 +pallet_manta_sbt,mint_sbt_eth,408319140000000000,0.40831914,0.2 +pallet_manta_sbt,change_allowlist_account,6465990000000000,0.00646599,0.2 +pallet_manta_sbt,update_mint_info,7612690000000000,0.00761269,0.2 +pallet_manta_sbt,new_mint_info,8533220000000000,0.00853322,0.2 +pallet_parachain_staking,set_staking_expectations,6920460000000000,0.00692046,0.2 +pallet_parachain_staking,set_inflation,6980820000000000,0.00698082,0.2 +pallet_parachain_staking,set_parachain_bond_account,6764200000000000,0.0067642,0.2 +pallet_parachain_staking,set_parachain_bond_account,6764200000000000,0.0067642,0.2 +pallet_parachain_staking,set_parachain_bond_reserve_percent,6440300000000000,0.0064403,0.2 +pallet_parachain_staking,set_total_selected,6454740000000000,0.00645474,0.2 +pallet_parachain_staking,set_collator_commission,6606540000000000,0.00660654,0.2 +pallet_parachain_staking,set_blocks_per_round,7209660000000000,0.00720966,0.2 +pallet_parachain_staking,join_candidates,14428463540000000,0.01442846354,0.2 +pallet_parachain_staking,schedule_leave_candidates,7872602010000000,0.00787260201,0.2 +pallet_parachain_staking,execute_leave_candidates,19214912160000000,0.01921491216,0.2 +pallet_parachain_staking,cancel_leave_candidates,7836474340000000,0.00783647434,0.2 +pallet_parachain_staking,go_offline,7772440000000000,0.00777244,0.2 +pallet_parachain_staking,go_offline,7772440000000000,0.00777244,0.2 +pallet_parachain_staking,candidate_bond_more,11771890000000000,0.01177189,0.2 +pallet_parachain_staking,schedule_candidate_bond_less,6658720000000000,0.00665872,0.2 +pallet_parachain_staking,execute_candidate_bond_less,12173210000000000,0.01217321,0.2 +pallet_parachain_staking,cancel_candidate_bond_less,6482270000000000,0.00648227,0.2 +pallet_parachain_staking,delegate_1_2_3,14889135980000000,0.01488913598,0.2 +pallet_parachain_staking,delegate_1_25_3,14963343410000000,0.01496334341,0.2 +pallet_parachain_staking,delegate_1_2_100,15058820290000000,0.01505882029,0.2 +pallet_parachain_staking,schedule_leave_delegators,7807870000000000,0.00780787,0.2 +pallet_parachain_staking,execute_leave_delegators,20173118140000000,0.02017311814,0.2 +pallet_parachain_staking,cancel_leave_delegators,7836250000000000,0.00783625,0.2 +pallet_parachain_staking,schedule_revoke_delegation,8116920000000000,0.00811692,0.2 +pallet_parachain_staking,delegator_bond_more,15032200000000000,0.0150322,0.2 +pallet_parachain_staking,schedule_delegator_bond_less,8147040000000000,0.00814704,0.2 +pallet_parachain_staking,execute_delegation_request,16473630000000000,0.01647363,0.2 +pallet_parachain_staking,cancel_delegation_request,8181780000000000,0.00818178,0.2 +pallet_scheduler,cancel,8272374850000000,0.00827237485,0.2 +pallet_scheduler,schedule,7039720810000000,0.00703972081,0.2 +pallet_scheduler,schedule_named,8749683690000000,0.00874968369,0.2 +pallet_scheduler,cancel_named,8794162920000000,0.00879416292,0.2 +pallet_scheduler,schedule_after,7279720810000000,0.00727972081,0.2 +pallet_scheduler,schedule_named_after,8989683690000000,0.00898968369,0.2 +pallet_session,set_keys,9972040000000000,0.00997204,0.2 +pallet_session,purge_keys,8446710000000000,0.00844671,0.2 +pallet_tx_pause,pause_transaction,7080410000000000,0.00708041,0.2 +pallet_tx_pause,unpause_transaction,7097920000000000,0.00709792,0.2 +pallet_tx_pause,pause_transactions,8882120000000000,0.00888212,0.2 +pallet_tx_pause,unpause_transactions,8917140000000000,0.00891714,0.2 +pallet_tx_pause,pause_pallets,78224200000000000,0.0782242,0.2 +pallet_tx_pause,unpause_pallets,78224200000000000,0.0782242,0.2 +pallet_utility,batch-size=1,5749651330000000,0.00574965133,0.2 +pallet_utility,batch-size=32,18965644180000000,0.01896564418,0.2 +pallet_utility,as_derivative,20330154180000000,0.02033015418,0.2 +pallet_utility,batch_all-size=1,5737089120000000,0.00573708912,0.2 +pallet_utility,batch_all-size=32,18563653460000000,0.01856365346,0.2 +pallet_utility,dispatch_as,19083383460000000,0.01908338346,0.2 +pallet_utility,force_batch,5335649780000000,0.00533564978,0.2 +pallet_randomness,set_babe_randomness_results,8865840000000000,0.00886584,0.2 +pallet_name_service,register,8610390000000000,0.00861039,0.2 +pallet_name_service,accept_register,7859670000000000,0.00785967,0.2 +pallet_name_service,set_primary_name,7104910000000000,0.00710491,0.2 +pallet_name_service,cancel_pending_register,6831850000000000,0.00683185,0.2 +pallet_name_service,remove_register,7114140000000000,0.00711414,0.2 +pallet_farming,create_farming_pool,10873100000000000,0.0108731,0.2 +pallet_farming,charge,12665110000000000,0.01266511,0.2 +pallet_farming,deposit,13617230000000000,0.01361723,0.2 +pallet_farming,withdraw,8197500000000000,0.0081975,0.2 +pallet_farming,claim,8270970000000000,0.00827097,0.2 +pallet_farming,withdraw_claim,8270970000000000,0.00827097,0.2 +pallet_farming,close_pool,5128710000000000,0.00512871,0.2 +pallet_farming,set_retire_limit,5008710000000000,0.00500871,0.2 +pallet_farming,retire_pool,5128710000000000,0.00512871,0.2 +pallet_farming,reset_pool,6138710000000000,0.00613871,0.2 +pallet_farming,kill_pool,5128710000000000,0.00512871,0.2 +pallet_farming,edit_pool,6568710000000000,0.00656871,0.2 +pallet_farming,gauge_withdraw,8567570000000000,0.00856757,0.2 +pallet_farming,force_gauge_claim,5128710000000000,0.00512871,0.2 +pallet_lottery,deposit,25359242980000000,0.02535924298,0.2 +pallet_lottery,request_withdraw,19568119240000000,0.01956811924,0.2 +pallet_lottery,claim_my_winnings,10776101170000000,0.01077610117,0.2 +pallet_lottery,rebalance_stake,4968700000000000,0.0049687,0.2 +pallet_lottery,start_lottery,9183330000000000,0.00918333,0.2 +pallet_lottery,stop_lottery,7782350000000000,0.00778235,0.2 +pallet_lottery,draw_lottery,8763200000000000,0.0087632,0.2 +pallet_lottery,process_matured_withdrawals,6122400000000000,0.0061224,0.2 +pallet_lottery,liquidate_lottery,4968700000000000,0.0049687,0.2 +pallet_lottery,set_min_deposit,6558050000000000,0.00655805,0.2 +pallet_lottery,set_min_withdraw,6224100000000000,0.0062241,0.2 +pallet_lottery,set_gas_reserve,6193470000000000,0.00619347,0.2 +zenlink_protocol,set_fee_receiver,6630120000000000,0.00663012,0.2 +zenlink_protocol,set_fee_point,6304740000000000,0.00630474,0.2 +zenlink_protocol,transfer,5438700000000000,0.0054387,0.2 +zenlink_protocol,transfer,8310450000000000,0.00831045,0.2 +zenlink_protocol,add_liquidity,43014670000000000,0.04301467,0.2 +zenlink_protocol,remove_liquidity,26091990000000000,0.02609199,0.2 +zenlink_protocol,swap_exact_assets_for_assets,14992330000000000,0.01499233,0.2 +zenlink_protocol,swap_assets_for_exact_assets,15045870000000000,0.01504587,0.2 +zenlink_protocol,bootstrap_create,9723160000000000,0.00972316,0.2 +zenlink_protocol,bootstrap_contribute,13958080000000000,0.01395808,0.2 +zenlink_protocol,bootstrap_claim,34065860000000000,0.03406586,0.2 +zenlink_protocol,bootstrap_end,45379400000000000,0.0453794,0.2 +zenlink_protocol,bootstrap_update,10044340000000000,0.01004434,0.2 +zenlink_protocol,bootstrap_refund,13624810000000000,0.01362481,0.2 +zenlink_protocol,bootstrap_charge_reward,6818700000000000,0.0068187,0.2 +zenlink_protocol,bootstrap_withdraw_reward,6548700000000000,0.0065487,0.2 +frame_system,remark-length=32,5951564300000000,0.0059515643,1 +frame_system,remark-length=64,5951564300000000,0.0059515643,1 +frame_system,set_heap_pages,17256000000000000,0.017256,1 +frame_system,set_code,25005298700000000000,25.0052987,1 +frame_system,set_code_without_checks,25005298700000000000,25.0052987,1 +frame_system,set_storage,10980258900000000,0.0109802589,1 +frame_system,kill_storage,15900672400000000,0.0159006724,1 +frame_system,kill_prefix,51173209300000000,0.0511732093,1 +frame_system,remark_with_event-length=32,7424486800000000,0.0074244868,1 +frame_system,remark_with_event-length=64,7424486800000000,0.0074244868,1 +pallet_treasury,propose_spend,18191800000000000,0.0181918,1 +pallet_treasury,reject_proposal,19970800000000000,0.0199708,1 +pallet_treasury,approve_proposal,13733236800000000,0.0137332368,1 +pallet_treasury,spend,5319500000000000,0.0053195,1 +pallet_treasury,remove_approval,11729500000000000,0.0117295,1 +pallet_timestamp,set,11657950000000000,0.01165795,1 +pallet_preimage,note_preimage-length=32,18280836400000000,0.0182808364,1 +pallet_preimage,note_preimage-length=32,18615522800000000,0.0186155228,1 +pallet_preimage,unnote_preimage,18701250000000000,0.01870125,1 +pallet_preimage,request_preimage,13024200000000000,0.0130242,1 +pallet_preimage,unrequest_preimage,17996150000000000,0.01799615,1 +pallet_multisig,as_multi_threshold_1,25575658850000000,0.02557565885,1 +pallet_multisig,as_multi,20381458800000000,0.0203814588,1 +pallet_multisig,approve_as_multi,15079149550000000,0.01507914955,1 +pallet_multisig,cancel_as_multi,13822743200000000,0.0138227432,1 +pallet_membership,add_member,7798700000000000,0.0077987,1 +pallet_membership,remove_member,7798700000000000,0.0077987,1 +pallet_membership,swap_member,8128700000000000,0.0081287,1 +pallet_membership,reset_members,8118700000000000,0.0081187,1 +pallet_membership,change_key,7798700000000000,0.0077987,1 +pallet_membership,set_prime,7798700000000000,0.0077987,1 +pallet_membership,clear_prime,7468700000000000,0.0074687,1 +pallet_democracy,propose,26506150000000000,0.02650615,1 +pallet_democracy,second,13627150000000000,0.01362715,1 +pallet_democracy,vote,27085450000000000,0.02708545,1 +pallet_democracy,emergency_cancel,18729350000000000,0.01872935,1 +pallet_democracy,external_propose,13454200000000000,0.0134542,1 +pallet_democracy,external_propose_majority,10302300000000000,0.0103023,1 +pallet_democracy,external_propose_default,10282900000000000,0.0102829,1 +pallet_democracy,fast_track,24069450000000000,0.02406945,1 +pallet_democracy,veto_external,19291650000000000,0.01929165,1 +pallet_democracy,cancel_referendum,10742150000000000,0.01074215,1 +pallet_democracy,delegate,677282767350000000,0.67728276735,1 +pallet_democracy,undelegate,663225532450000000,0.66322553245,1 +pallet_democracy,clear_public_proposals,10249850000000000,0.01024985,1 +pallet_democracy,unlock,26420387950000000,0.02642038795,1 +pallet_democracy,remove_vote,19188607100000000,0.0191886071,1 +pallet_democracy,remove_other_vote,19538270550000000,0.01953827055,1 +pallet_democracy,blacklist,46103200000000000,0.0461032,1 +pallet_democracy,cancel_proposal,27528450000000000,0.02752845,1 +pallet_collective,set_members,690437404400000000,0.6904374044,1 +pallet_collective,execute,29973094550000000,0.02997309455,1 +pallet_collective,propose,32684218500000000,0.0326842185,1 +pallet_collective,vote,15032458900000000,0.0150324589,1 +pallet_collective,close,30155652000000000,0.030155652,1 +pallet_collective,disapprove_proposal,23600075700000000,0.0236000757,1 +cumulus_pallet_xcmp_queue,service_overweight,5178703200000000,0.0051787032,1 +cumulus_pallet_xcmp_queue,suspend_xcm_execution,9968700000000000,0.0099687,1 +cumulus_pallet_xcmp_queue,resume_xcm_execution,9968700000000000,0.0099687,1 +cumulus_pallet_xcmp_queue,update_suspend_threshold,11649200000000000,0.0116492,1 +cumulus_pallet_xcmp_queue,update_drop_threshold,11649200000000000,0.0116492,1 +cumulus_pallet_xcmp_queue,update_resume_threshold,11649200000000000,0.0116492,1 +cumulus_pallet_xcmp_queue,update_threshold_weight,11685000000000000,0.011685,1 +cumulus_pallet_xcmp_queue,update_weight_restrict_decay,11685000000000000,0.011685,1 +cumulus_pallet_xcmp_queue,update_xcmp_max_individual_weight,11685000000000000,0.011685,1 +orml_xtokens,transfer,5338700000000000,0.0053387,1 +orml_xtokens,transfer_multiasset,5148700000000000,0.0051487,1 +orml_xtokens,transfer_with_fee,5498700000000000,0.0054987,1 +orml_xtokens,transfer_multiasset_with_fee,5288700000000000,0.0052887,1 +orml_xtokens,transfer_multicurrencies,5718700000000000,0.0057187,1 +orml_xtokens,transfer_multiassets,5198700000000000,0.0051987,1 +manta_collator_selection,set_invulnerables,11039039900000000,0.0110390399,1 +manta_collator_selection,set_desired_candidates,10920050000000000,0.01092005,1 +manta_collator_selection,set_candidacy_bond,10916000000000000,0.010916,1 +manta_collator_selection,register_as_candidate,19563291700000000,0.0195632917,1 +manta_collator_selection,register_candidate,19893217550000000,0.01989321755,1 +manta_collator_selection,leave_intent,13626589300000000,0.0136265893,1 +manta_collator_selection,remove_collator,15310528600000000,0.0153105286,1 +manta_collator_selection,set_eviction_baseline,10730100000000000,0.0107301,1 +manta_collator_selection,set_eviction_tolerance,10722800000000000,0.0107228,1 +pallet_asset_manager,register_asset,43343650000000000,0.04334365,1 +pallet_asset_manager,update_asset_location,39791950000000000,0.03979195,1 +pallet_asset_manager,update_asset_metadata,23865800000000000,0.0238658,1 +pallet_asset_manager,set_units_per_second,14197200000000000,0.0141972,1 +pallet_asset_manager,mint_asset,24416700000000000,0.0244167,1 +pallet_asset_manager,set_min_xcm_fee,12432200000000000,0.0124322,1 +pallet_asset_manager,update_outgoing_filtered_assets,12408750000000000,0.01240875,1 +pallet_asset_manager,register_lp_asset,46409300000000000,0.0464093,1 +pallet_assets,create,12944550000000000,0.01294455,1 +pallet_assets,force_create,12757600000000000,0.0127576,1 +pallet_assets,start_destroy,12456900000000000,0.0124569,1 +pallet_assets,destroy_accounts,13311342400000000000,13.3113424,1 +pallet_assets,destroy_approvals,6664874100000000000,6.6648741,1 +pallet_assets,finish_destroy,14647450000000000,0.01464745,1 +pallet_assets,mint,19808050000000000,0.01980805,1 +pallet_assets,burn,20166250000000000,0.02016625,1 +pallet_assets,transfer,33401250000000000,0.03340125,1 +pallet_assets,transfer_keep_alive,32994800000000000,0.0329948,1 +pallet_assets,force_transfer,33736950000000000,0.03373695,1 +pallet_assets,freeze,14248000000000000,0.014248,1 +pallet_assets,thaw,14344100000000000,0.0143441,1 +pallet_assets,freeze_asset,12472400000000000,0.0124724,1 +pallet_assets,thaw_asset,12459850000000000,0.01245985,1 +pallet_assets,transfer_ownership,14147100000000000,0.0141471,1 +pallet_assets,set_team,13442000000000000,0.013442,1 +pallet_assets,set_metadata,14580541550000000,0.01458054155,1 +pallet_assets,clear_metadata,13937200000000000,0.0139372,1 +pallet_assets,force_set_metadata,14620545250000000,0.01462054525,1 +pallet_assets,force_clear_metadata,13931100000000000,0.0139311,1 +pallet_assets,force_asset_status,13773550000000000,0.01377355,1 +pallet_assets,approve_transfer,19396050000000000,0.01939605,1 +pallet_assets,cancel_approval,19518200000000000,0.0195182,1 +pallet_assets,force_cancel_approval,19882650000000000,0.01988265,1 +pallet_assets,transfer_approved,40258100000000000,0.0402581,1 +pallet_assets,touch,19468050000000000,0.01946805,1 +pallet_assets,refund,19478050000000000,0.01947805,1 +pallet_author_inherent,kick_off_authorship_validation,15870200000000000,0.0158702,1 +pallet_balances,transfer-1,14042050000000000,0.01404205,1 +pallet_balances,transfer-1000_000,14072050000000000,0.01407205,1 +pallet_balances,set_balance,13058100000000000,0.0130581,1 +pallet_balances,force_transfer,20539850000000000,0.02053985,1 +pallet_balances,transfer_keep_alive-1,13371550000000000,0.01337155,1 +pallet_balances,transfer_keep_alive-1000_000,13401550000000000,0.01340155,1 +pallet_balances,transfer_all,13555050000000000,0.01355505,1 +pallet_balances,force_unreserve,12801050000000000,0.01280105,1 +pallet_manta_pay,to_private,2026260100000000000,2.0262601,1 +pallet_manta_pay,private_transfer,3617729700000000000,3.6177297,1 +pallet_manta_pay,to_public,2705954500000000000,2.7059545,1 +pallet_manta_pay,public_transfer,27830050000000000,0.02783005,1 +pallet_manta_sbt,to_private,2008741450000000000,2.00874145,1 +pallet_manta_sbt,force_to_private,2000274200000000000,2.0002742,1 +pallet_manta_sbt,reserve_sbt,27789000000000000,0.027789,1 +pallet_manta_sbt,allowlist_evm_account,23122500000000000,0.0231225,1 +pallet_manta_sbt,set_next_sbt_id,10963050000000000,0.01096305,1 +pallet_manta_sbt,remove_allowlist_evm_account,11124800000000000,0.0111248,1 +pallet_manta_sbt,change_free_reserve_account,12107650000000000,0.01210765,1 +pallet_manta_sbt,force_mint_sbt_eth,2007346800000000000,2.0073468,1 +pallet_manta_sbt,change_force_account,11149300000000000,0.0111493,1 +pallet_manta_sbt,mint_sbt_eth,2011840900000000000,2.0118409,1 +pallet_manta_sbt,change_allowlist_account,11135150000000000,0.01113515,1 +pallet_manta_sbt,update_mint_info,17588650000000000,0.01758865,1 +pallet_manta_sbt,new_mint_info,22351300000000000,0.0223513,1 +pallet_parachain_staking,set_staking_expectations,12807500000000000,0.0128075,1 +pallet_parachain_staking,set_inflation,14549300000000000,0.0145493,1 +pallet_parachain_staking,set_parachain_bond_account,12666200000000000,0.0126662,1 +pallet_parachain_staking,set_parachain_bond_account,12666200000000000,0.0126662,1 +pallet_parachain_staking,set_parachain_bond_reserve_percent,12286700000000000,0.0122867,1 +pallet_parachain_staking,set_total_selected,12358900000000000,0.0123589,1 +pallet_parachain_staking,set_collator_commission,13117900000000000,0.0131179,1 +pallet_parachain_staking,set_blocks_per_round,16133500000000000,0.0161335,1 +pallet_parachain_staking,join_candidates,52187517700000000,0.0521875177,1 +pallet_parachain_staking,schedule_leave_candidates,19448210050000000,0.01944821005,1 +pallet_parachain_staking,execute_leave_candidates,74879760800000000,0.0748797608,1 +pallet_parachain_staking,cancel_leave_candidates,19267571700000000,0.0192675717,1 +pallet_parachain_staking,go_offline,18987400000000000,0.0189874,1 +pallet_parachain_staking,go_offline,18987400000000000,0.0189874,1 +pallet_parachain_staking,candidate_bond_more,38944650000000000,0.03894465,1 +pallet_parachain_staking,schedule_candidate_bond_less,12778800000000000,0.0127788,1 +pallet_parachain_staking,execute_candidate_bond_less,39711250000000000,0.03971125,1 +pallet_parachain_staking,cancel_candidate_bond_less,12536550000000000,0.01253655,1 +pallet_parachain_staking,delegate_1_2_3,53170879900000000,0.0531708799,1 +pallet_parachain_staking,delegate_1_25_3,53541917050000000,0.05354191705,1 +pallet_parachain_staking,delegate_1_2_100,53979301450000000,0.05397930145,1 +pallet_parachain_staking,schedule_leave_delegators,19164550000000000,0.01916455,1 +pallet_parachain_staking,execute_leave_delegators,79670790700000000,0.0796707907,1 +pallet_parachain_staking,cancel_leave_delegators,19306450000000000,0.01930645,1 +pallet_parachain_staking,schedule_revoke_delegation,19429800000000000,0.0194298,1 +pallet_parachain_staking,delegator_bond_more,53966200000000000,0.0539662,1 +pallet_parachain_staking,schedule_delegator_bond_less,19540400000000000,0.0195404,1 +pallet_parachain_staking,execute_delegation_request,59933350000000000,0.05993335,1 +pallet_parachain_staking,cancel_delegation_request,19754100000000000,0.0197541,1 +pallet_scheduler,cancel,21167074250000000,0.02116707425,1 +pallet_scheduler,schedule,14683804050000000,0.01468380405,1 +pallet_scheduler,schedule_named,21633618450000000,0.02163361845,1 +pallet_scheduler,cancel_named,22816014600000000,0.0228160146,1 +pallet_scheduler,schedule_after,14923804050000000,0.01492380405,1 +pallet_scheduler,schedule_named_after,21873618450000000,0.02187361845,1 +pallet_session,set_keys,26105400000000000,0.0261054,1 +pallet_session,purge_keys,22358750000000000,0.02235875,1 +pallet_tx_pause,pause_transaction,12887250000000000,0.01288725,1 +pallet_tx_pause,unpause_transaction,12974800000000000,0.0129748,1 +pallet_tx_pause,pause_transactions,20495800000000000,0.0204958,1 +pallet_tx_pause,unpause_transactions,20670900000000000,0.0206709,1 +pallet_tx_pause,pause_pallets,368566200000000000,0.3685662,1 +pallet_tx_pause,unpause_pallets,368566200000000000,0.3685662,1 +pallet_utility,batch-size=1,8713456650000000,0.00871345665,1 +pallet_utility,batch-size=32,71073420900000000,0.0710734209,1 +pallet_utility,as_derivative,77735970900000000,0.0777359709,1 +pallet_utility,batch_all-size=1,8650645600000000,0.0086506456,1 +pallet_utility,batch_all-size=32,69063467300000000,0.0690634673,1 +pallet_utility,dispatch_as,70222117300000000,0.0702221173,1 +pallet_utility,force_batch,6763448900000000,0.0067634489,1 +pallet_randomness,set_babe_randomness_results,24454400000000000,0.0244544,1 +pallet_name_service,register,21697150000000000,0.02169715,1 +pallet_name_service,accept_register,17943550000000000,0.01794355,1 +pallet_name_service,set_primary_name,14169750000000000,0.01416975,1 +pallet_name_service,cancel_pending_register,12804450000000000,0.01280445,1 +pallet_name_service,remove_register,14215900000000000,0.0142159,1 +pallet_farming,create_farming_pool,29890700000000000,0.0298907,1 +pallet_farming,charge,40210750000000000,0.04021075,1 +pallet_farming,deposit,46651350000000000,0.04665135,1 +pallet_farming,withdraw,19792700000000000,0.0197927,1 +pallet_farming,claim,20840050000000000,0.02084005,1 +pallet_farming,withdraw_claim,20840050000000000,0.02084005,1 +pallet_farming,close_pool,5128750000000000,0.00512875,1 +pallet_farming,set_retire_limit,5008750000000000,0.00500875,1 +pallet_farming,retire_pool,5128750000000000,0.00512875,1 +pallet_farming,reset_pool,6138750000000000,0.00613875,1 +pallet_farming,kill_pool,5128750000000000,0.00512875,1 +pallet_farming,edit_pool,6568750000000000,0.00656875,1 +pallet_farming,gauge_withdraw,22323050000000000,0.02232305,1 +pallet_farming,force_gauge_claim,5128750000000000,0.00512875,1 +pallet_lottery,deposit,106281414900000000,0.1062814149,1 +pallet_lottery,request_withdraw,77325796200000000,0.0773257962,1 +pallet_lottery,claim_my_winnings,34005705850000000,0.03400570585,1 +pallet_lottery,rebalance_stake,4968700000000000,0.0049687,1 +pallet_lottery,start_lottery,26041850000000000,0.02604185,1 +pallet_lottery,stop_lottery,19036950000000000,0.01903695,1 +pallet_lottery,draw_lottery,23941200000000000,0.0239412,1 +pallet_lottery,process_matured_withdrawals,10737200000000000,0.0107372,1 +pallet_lottery,liquidate_lottery,4968700000000000,0.0049687,1 +pallet_lottery,set_min_deposit,12275450000000000,0.01227545,1 +pallet_lottery,set_min_withdraw,10605700000000000,0.0106057,1 +pallet_lottery,set_gas_reserve,10452550000000000,0.01045255,1 +zenlink_protocol,set_fee_receiver,11955800000000000,0.0119558,1 +zenlink_protocol,set_fee_point,11608900000000000,0.0116089,1 +zenlink_protocol,transfer,5478700000000000,0.0054787,1 +zenlink_protocol,transfer,20637450000000000,0.02063745,1 +zenlink_protocol,add_liquidity,193958550000000000,0.19395855,1 +zenlink_protocol,remove_liquidity,108105150000000000,0.10810515,1 +zenlink_protocol,swap_exact_assets_for_assets,52086850000000000,0.05208685,1 +zenlink_protocol,swap_assets_for_exact_assets,52354550000000000,0.05235455,1 +zenlink_protocol,bootstrap_create,23741000000000000,0.023741,1 +zenlink_protocol,bootstrap_contribute,48675600000000000,0.0486756,1 +zenlink_protocol,bootstrap_claim,148094500000000000,0.1480945,1 +zenlink_protocol,bootstrap_end,205982200000000000,0.2059822,1 +zenlink_protocol,bootstrap_update,25306900000000000,0.0253069,1 +zenlink_protocol,bootstrap_refund,47209250000000000,0.04720925,1 +zenlink_protocol,bootstrap_charge_reward,10818700000000000,0.0108187,1 +zenlink_protocol,bootstrap_withdraw_reward,10548700000000000,0.0105487,1 diff --git a/runtime/manta/tx-fees-data/README.md b/runtime/manta/tx-fees-data/README.md new file mode 100644 index 000000000..50115519a --- /dev/null +++ b/runtime/manta/tx-fees-data/README.md @@ -0,0 +1,19 @@ +# Transaction Fees History for Calamari Runtime + +- The code about estimating all tx fees locates at [`diff_gas_fees.rs`](../src/diff_gas_fees.rs). +- All tx fees history locates at [`tx-fees-data`](.). +- If any extrinsic fluctuates over **10**, the test case `diff_gas_fees::diff_gas_fees` will fail. + +## Generate the latest tx fees sheet + +Run the command. +```sh +cargo t generate_all_current_extrinsics_tx_fee_to_csv +``` +> Before you run this test case, please disable this line of code: `#[ignore]`. + +It will generate a csv file located at `tx-fees-data/{crate-version}-tx-fees.csv`. + +## When to add new extrinsics to diff_gas_fees + +If there's new pallet or new extrinsic introduced, please add them to [`diff_gas_fees.rs`](../src/diff_gas_fees.rs).