diff --git a/pallets/issuance/src/benchmarking.rs b/pallets/issuance/src/benchmarking.rs index 8d36c294a..271213b5d 100644 --- a/pallets/issuance/src/benchmarking.rs +++ b/pallets/issuance/src/benchmarking.rs @@ -68,7 +68,6 @@ benchmarks! { } execute_tge { - let x in 3..100; assert!(!IsTGEFinalized::::get()); @@ -103,5 +102,19 @@ benchmarks! { } + set_issuance_config { + let new_linear_issuance_amount: BalanceOf = 10_000_000_000u128.try_into().ok().expect("balance"); + + assert_ok!(Issuance::::finalize_tge(RawOrigin::Root.into())); + assert_ok!(Issuance::::init_issuance_config(RawOrigin::Root.into())); + + assert!(IssuanceConfigStore::::get().unwrap().linear_issuance_amount != new_linear_issuance_amount); + + }: _(RawOrigin::Root, Some(new_linear_issuance_amount), None, None, None, None) + verify { + assert_eq!(IssuanceConfigStore::::get().unwrap().linear_issuance_amount, new_linear_issuance_amount); + } + + impl_benchmark_test_suite!(Issuance, crate::mock::new_test_ext_without_issuance_config(), crate::mock::Test) } diff --git a/pallets/issuance/src/lib.rs b/pallets/issuance/src/lib.rs index bf7c8dc92..7abc1eb85 100644 --- a/pallets/issuance/src/lib.rs +++ b/pallets/issuance/src/lib.rs @@ -52,36 +52,9 @@ pub struct TgeInfo { pub amount: Balance, } -/// Weight functions needed for pallet_xyk. -pub trait WeightInfo { - fn init_issuance_config() -> Weight; - fn finalize_tge() -> Weight; - fn execute_tge(x: u32) -> Weight; -} - -// For backwards compatibility and tests -impl WeightInfo for () { - // Storage: Vesting Vesting (r:1 w:1) - // Storage: Balances Locks (r:1 w:1) - fn init_issuance_config() -> Weight { - Weight::from_parts(50_642_000, 0) - } - // Storage: Vesting Vesting (r:1 w:1) - // Storage: Balances Locks (r:1 w:1) - fn finalize_tge() -> Weight { - Weight::from_parts(50_830_000, 0) - } - // Storage: Vesting Vesting (r:1 w:1) - // Storage: Balances Locks (r:1 w:1) - // Storage: System Account (r:1 w:1) - fn execute_tge(l: u32) -> Weight { - Weight::from_parts(52_151_000, 0) - // Standard Error: 1_000 - .saturating_add((Weight::from_parts(130_000, 0)).saturating_mul(l as u64)) - } -} - +pub mod weights; pub use pallet::*; +pub use weights::WeightInfo; type BalanceOf = <::Tokens as MultiTokenCurrency<::AccountId>>::Balance; @@ -203,6 +176,8 @@ pub mod pallet { MathError, /// unknown pool UnknownPool, + /// The issuance config has not been initialized + InvalidSplitAmounts, } // XYK extrinsics. @@ -300,6 +275,54 @@ pub mod pallet { Ok(().into()) } + + #[pallet::call_index(3)] + #[pallet::weight(T::WeightInfo::set_issuance_config())] + pub fn set_issuance_config( + origin: OriginFor, + linear_issuance_amount: Option>, + linear_issuance_blocks: Option, + liquidity_mining_split: Option, + staking_split: Option, + sequencers_split: Option, + ) -> DispatchResultWithPostInfo { + ensure_root(origin)?; + + let config = IssuanceConfigStore::::try_mutate(|config| { + let cfg = config.as_mut().ok_or(Error::::IssuanceConfigNotInitialized)?; + + if let Some(linear_issuance_amount) = linear_issuance_amount { + cfg.linear_issuance_amount = linear_issuance_amount; + } + + if let Some(linear_issuance_blocks) = linear_issuance_blocks { + cfg.linear_issuance_blocks = linear_issuance_blocks; + } + + if let Some(liquidity_mining_split) = liquidity_mining_split { + cfg.liquidity_mining_split = liquidity_mining_split; + } + + if let Some(staking_split) = staking_split { + cfg.staking_split = staking_split; + } + + if let Some(sequencers_split) = sequencers_split { + cfg.sequencers_split = sequencers_split; + } + + Ok::>, Error>(cfg.clone()) + })?; + + let total_splits = + config.liquidity_mining_split + config.staking_split + config.sequencers_split; + + ensure!(total_splits.is_one(), Error::::InvalidSplitAmounts); + + Pallet::::deposit_event(Event::IssuanceConfigSet(config)); + + Ok(().into()) + } } #[pallet::event] @@ -317,6 +340,8 @@ pub mod pallet { TGEInstanceFailed(TgeInfo>), /// A TGE instance has succeeded TGEInstanceSucceeded(TgeInfo>), + /// Issuance configuration updated + IssuanceConfigSet(IssuanceInfo>), } } @@ -411,10 +436,12 @@ impl Pallet { } pub fn calculate_and_store_round_issuance(current_round: u32) -> DispatchResult { - let _ = IssuanceConfigStore::::get().ok_or(Error::::IssuanceConfigNotInitialized)?; + let config = + IssuanceConfigStore::::get().ok_or(Error::::IssuanceConfigNotInitialized)?; // Get everything from config and ignore the storage config data - let to_be_issued: BalanceOf = T::LinearIssuanceAmount::get(); - let linear_issuance_sessions: u32 = T::LinearIssuanceBlocks::get() + let to_be_issued: BalanceOf = config.linear_issuance_amount; + let linear_issuance_sessions: u32 = config + .linear_issuance_blocks .checked_div(T::BlocksPerRound::get()) .ok_or(Error::::MathError)?; let linear_issuance_per_session = to_be_issued @@ -423,10 +450,9 @@ impl Pallet { let current_round_issuance: BalanceOf = linear_issuance_per_session; - let liquidity_mining_issuance = T::LiquidityMiningSplit::get() * current_round_issuance; - - let staking_issuance = T::StakingSplit::get() * current_round_issuance; - let sequencers_issuance = T::SequencersSplit::get() * current_round_issuance; + let liquidity_mining_issuance = config.liquidity_mining_split * current_round_issuance; + let staking_issuance = config.staking_split * current_round_issuance; + let sequencers_issuance = config.sequencers_split * current_round_issuance; T::LiquidityMiningApi::distribute_rewards(liquidity_mining_issuance); diff --git a/pallets/issuance/src/tests.rs b/pallets/issuance/src/tests.rs index c2657263e..f2dca7450 100644 --- a/pallets/issuance/src/tests.rs +++ b/pallets/issuance/src/tests.rs @@ -3,7 +3,7 @@ use mock::{ new_test_ext, new_test_ext_without_issuance_config, roll_to_while_minting, BlocksPerRound, Issuance, RuntimeOrigin, StakeCurrency, System, Test, Tokens, Vesting, MGA_TOKEN_ID, }; -use sp_runtime::SaturatedConversion; +use sp_runtime::{traits::BadOrigin, SaturatedConversion}; use frame_support::{assert_noop, assert_ok}; @@ -354,3 +354,93 @@ fn issuance_after_linear_period_never_execeeds_linear() { assert_eq!(3902430240, Tokens::total_issuance(0u32)); }); } + +#[test] +fn update_issuance_config_only_as_root() { + new_test_ext_without_issuance_config().execute_with(|| { + const USER_ID: u64 = 0; + + assert_ok!(Issuance::finalize_tge(RuntimeOrigin::root())); + assert_ok!(Issuance::init_issuance_config(RuntimeOrigin::root())); + + assert_noop!( + Issuance::set_issuance_config( + RuntimeOrigin::signed(USER_ID), + None, + None, + None, + None, + None + ), + sp_runtime::traits::BadOrigin + ); + }); +} + +#[test] +fn set_issuance_modifies_the_config() { + new_test_ext_without_issuance_config().execute_with(|| { + const USER_ID: u64 = 0; + + assert_ok!(Issuance::finalize_tge(RuntimeOrigin::root())); + assert_ok!(Issuance::init_issuance_config(RuntimeOrigin::root())); + + let initial_config = IssuanceConfigStore::::get().unwrap(); + + let linear_issuance_amount = 5_000_000_000u128; + let linear_issuance_blocks = 33_222u32; + let liquidity_mining_split = Perbill::from_percent(10); + let staking_split = Perbill::from_percent(20); + let sequencers_split = Perbill::from_percent(70); + + assert!(initial_config.linear_issuance_amount != linear_issuance_amount); + assert!(initial_config.linear_issuance_blocks != linear_issuance_blocks); + assert!(initial_config.liquidity_mining_split != liquidity_mining_split); + assert!(initial_config.staking_split != staking_split); + assert!(initial_config.sequencers_split != sequencers_split); + + assert_ok!(Issuance::set_issuance_config( + RuntimeOrigin::root(), + Some(linear_issuance_amount), + Some(linear_issuance_blocks), + Some(liquidity_mining_split), + Some(staking_split), + Some(sequencers_split) + )); + + let cfg = IssuanceConfigStore::::get().unwrap(); + assert_eq!(cfg.linear_issuance_amount, linear_issuance_amount); + assert_eq!(cfg.linear_issuance_blocks, linear_issuance_blocks); + assert_eq!(cfg.liquidity_mining_split, liquidity_mining_split); + assert_eq!(cfg.staking_split, staking_split); + assert_eq!(cfg.sequencers_split, sequencers_split); + }); +} + +#[test] +fn test_fail_on_wrong_splits_amounts() { + new_test_ext_without_issuance_config().execute_with(|| { + const USER_ID: u64 = 0; + + assert_ok!(Issuance::finalize_tge(RuntimeOrigin::root())); + assert_ok!(Issuance::init_issuance_config(RuntimeOrigin::root())); + + let initial_config = IssuanceConfigStore::::get().unwrap(); + + let liquidity_mining_split = Perbill::from_percent(10); + let staking_split = Perbill::from_percent(20); + let sequencers_split = Perbill::from_percent(30); + + assert_noop!( + Issuance::set_issuance_config( + RuntimeOrigin::root(), + None, + None, + Some(liquidity_mining_split), + Some(staking_split), + Some(sequencers_split) + ), + Error::::InvalidSplitAmounts + ); + }); +} diff --git a/pallets/issuance/src/weights.rs b/pallets/issuance/src/weights.rs new file mode 100644 index 000000000..da1a6ed01 --- /dev/null +++ b/pallets/issuance/src/weights.rs @@ -0,0 +1,158 @@ +// This file is part of Mangata. + +// Copyright (C) 2020-2022 Mangata Foundation. +// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0 + +// This program 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. + +// This program 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 this program. If not, see . + +//! Autogenerated weights for pallet_issuance +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0 +//! DATE: 2025-01-15, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! EXECUTION: , WASM-EXECUTION: Compiled, CHAIN: Some("rollup-local"), DB CACHE: 1024 + +// Executed Command: +// target/release/rollup-node +// benchmark +// pallet +// -l=info,runtime::collective=warn,xyk=warn +// --chain +// rollup-local +// --wasm-execution +// compiled +// --pallet +// * +// --extrinsic +// * +// --steps +// 50 +// --repeat +// 20 +// --template +// ./templates/module-weight-template.hbs +// --output +// ./benchmarks/ + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] +#![allow(clippy::unnecessary_cast)] + +use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}}; +use sp_std::marker::PhantomData; + +/// Weight functions needed for pallet_issuance. +pub trait WeightInfo { + fn init_issuance_config() -> Weight; + fn finalize_tge() -> Weight; + fn execute_tge(x: u32, ) -> Weight; + fn set_issuance_config() -> Weight; +} + +/// Weights for pallet_issuance using the Mangata node and recommended hardware. +pub struct ModuleWeight(PhantomData); +impl WeightInfo for ModuleWeight { + // Storage: `Issuance::IssuanceConfigStore` (r:1 w:1) + // Proof: `Issuance::IssuanceConfigStore` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `Issuance::IsTGEFinalized` (r:1 w:0) + // Proof: `Issuance::IsTGEFinalized` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `Tokens::TotalIssuance` (r:1 w:0) + // Proof: `Tokens::TotalIssuance` (`max_values`: None, `max_size`: Some(28), added: 2503, mode: `MaxEncodedLen`) + fn init_issuance_config() -> Weight { + (Weight::from_parts(17_750_000, 0)) + .saturating_add(T::DbWeight::get().reads(3 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } + // Storage: `Issuance::IsTGEFinalized` (r:1 w:1) + // Proof: `Issuance::IsTGEFinalized` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + fn finalize_tge() -> Weight { + (Weight::from_parts(9_809_000, 0)) + .saturating_add(T::DbWeight::get().reads(1 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } + // Storage: `Issuance::IsTGEFinalized` (r:1 w:0) + // Proof: `Issuance::IsTGEFinalized` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `Tokens::Accounts` (r:100 w:100) + // Proof: `Tokens::Accounts` (`max_values`: None, `max_size`: Some(96), added: 2571, mode: `MaxEncodedLen`) + // Storage: `Tokens::TotalIssuance` (r:1 w:1) + // Proof: `Tokens::TotalIssuance` (`max_values`: None, `max_size`: Some(28), added: 2503, mode: `MaxEncodedLen`) + // Storage: `System::Account` (r:100 w:100) + // Proof: `System::Account` (`max_values`: None, `max_size`: Some(52), added: 2527, mode: `MaxEncodedLen`) + // Storage: `Issuance::TGETotal` (r:1 w:1) + // Proof: `Issuance::TGETotal` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + fn execute_tge(x: u32, ) -> Weight { + (Weight::from_parts(26_290_460, 0)) + // Standard Error: 10_945 + .saturating_add((Weight::from_parts(22_350_615, 0)).saturating_mul(x as u64)) + .saturating_add(T::DbWeight::get().reads(3 as u64)) + .saturating_add(T::DbWeight::get().reads((2 as u64).saturating_mul(x as u64))) + .saturating_add(T::DbWeight::get().writes(2 as u64)) + .saturating_add(T::DbWeight::get().writes((2 as u64).saturating_mul(x as u64))) + } + // Storage: `Issuance::IssuanceConfigStore` (r:1 w:1) + // Proof: `Issuance::IssuanceConfigStore` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + fn set_issuance_config() -> Weight { + (Weight::from_parts(11_770_000, 0)) + .saturating_add(T::DbWeight::get().reads(1 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } +} + +// For backwards compatibility and tests +impl WeightInfo for () { + // Storage: `Issuance::IssuanceConfigStore` (r:1 w:1) + // Proof: `Issuance::IssuanceConfigStore` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `Issuance::IsTGEFinalized` (r:1 w:0) + // Proof: `Issuance::IsTGEFinalized` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `Tokens::TotalIssuance` (r:1 w:0) + // Proof: `Tokens::TotalIssuance` (`max_values`: None, `max_size`: Some(28), added: 2503, mode: `MaxEncodedLen`) + fn init_issuance_config() -> Weight { + (Weight::from_parts(17_750_000, 0)) + .saturating_add(RocksDbWeight::get().reads(3 as u64)) + .saturating_add(RocksDbWeight::get().writes(1 as u64)) + } + // Storage: `Issuance::IsTGEFinalized` (r:1 w:1) + // Proof: `Issuance::IsTGEFinalized` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + fn finalize_tge() -> Weight { + (Weight::from_parts(9_809_000, 0)) + .saturating_add(RocksDbWeight::get().reads(1 as u64)) + .saturating_add(RocksDbWeight::get().writes(1 as u64)) + } + // Storage: `Issuance::IsTGEFinalized` (r:1 w:0) + // Proof: `Issuance::IsTGEFinalized` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `Tokens::Accounts` (r:100 w:100) + // Proof: `Tokens::Accounts` (`max_values`: None, `max_size`: Some(96), added: 2571, mode: `MaxEncodedLen`) + // Storage: `Tokens::TotalIssuance` (r:1 w:1) + // Proof: `Tokens::TotalIssuance` (`max_values`: None, `max_size`: Some(28), added: 2503, mode: `MaxEncodedLen`) + // Storage: `System::Account` (r:100 w:100) + // Proof: `System::Account` (`max_values`: None, `max_size`: Some(52), added: 2527, mode: `MaxEncodedLen`) + // Storage: `Issuance::TGETotal` (r:1 w:1) + // Proof: `Issuance::TGETotal` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + fn execute_tge(x: u32, ) -> Weight { + (Weight::from_parts(26_290_460, 0)) + // Standard Error: 10_945 + .saturating_add((Weight::from_parts(22_350_615, 0)).saturating_mul(x as u64)) + .saturating_add(RocksDbWeight::get().reads(3 as u64)) + .saturating_add(RocksDbWeight::get().reads((2 as u64).saturating_mul(x as u64))) + .saturating_add(RocksDbWeight::get().writes(2 as u64)) + .saturating_add(RocksDbWeight::get().writes((2 as u64).saturating_mul(x as u64))) + } + // Storage: `Issuance::IssuanceConfigStore` (r:1 w:1) + // Proof: `Issuance::IssuanceConfigStore` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + fn set_issuance_config() -> Weight { + (Weight::from_parts(11_770_000, 0)) + .saturating_add(RocksDbWeight::get().reads(1 as u64)) + .saturating_add(RocksDbWeight::get().writes(1 as u64)) + } +} diff --git a/rollup/runtime/src/weights/pallet_issuance.rs b/rollup/runtime/src/weights/pallet_issuance.rs index df83321e1..72721f2e1 100644 --- a/rollup/runtime/src/weights/pallet_issuance.rs +++ b/rollup/runtime/src/weights/pallet_issuance.rs @@ -19,7 +19,7 @@ //! Autogenerated weights for pallet_issuance //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0 -//! DATE: 2024-11-29, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2025-01-15, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` //! EXECUTION: , WASM-EXECUTION: Compiled, CHAIN: Some("rollup-local"), DB CACHE: 1024 // Executed Command: @@ -57,6 +57,7 @@ pub trait WeightInfo { fn init_issuance_config() -> Weight; fn finalize_tge() -> Weight; fn execute_tge(x: u32, ) -> Weight; + fn set_issuance_config() -> Weight; } /// Weights for pallet_issuance using the Mangata node and recommended hardware. @@ -69,39 +70,42 @@ impl pallet_issuance::WeightInfo for ModuleWeight { // Storage: `Tokens::TotalIssuance` (r:1 w:0) // Proof: `Tokens::TotalIssuance` (`max_values`: None, `max_size`: Some(28), added: 2503, mode: `MaxEncodedLen`) fn init_issuance_config() -> Weight { - (Weight::from_parts(17_810_000, 0)) + (Weight::from_parts(17_750_000, 0)) .saturating_add(T::DbWeight::get().reads(3 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: `Issuance::IsTGEFinalized` (r:1 w:1) // Proof: `Issuance::IsTGEFinalized` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) fn finalize_tge() -> Weight { - (Weight::from_parts(9_720_000, 0)) + (Weight::from_parts(9_809_000, 0)) .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } // Storage: `Issuance::IsTGEFinalized` (r:1 w:0) // Proof: `Issuance::IsTGEFinalized` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) - // Storage: `Vesting::Vesting` (r:100 w:100) - // Proof: `Vesting::Vesting` (`max_values`: None, `max_size`: Some(1857), added: 4332, mode: `MaxEncodedLen`) // Storage: `Tokens::Accounts` (r:100 w:100) // Proof: `Tokens::Accounts` (`max_values`: None, `max_size`: Some(96), added: 2571, mode: `MaxEncodedLen`) // Storage: `Tokens::TotalIssuance` (r:1 w:1) // Proof: `Tokens::TotalIssuance` (`max_values`: None, `max_size`: Some(28), added: 2503, mode: `MaxEncodedLen`) // Storage: `System::Account` (r:100 w:100) // Proof: `System::Account` (`max_values`: None, `max_size`: Some(52), added: 2527, mode: `MaxEncodedLen`) - // Storage: `Tokens::Locks` (r:100 w:100) - // Proof: `Tokens::Locks` (`max_values`: None, `max_size`: Some(1249), added: 3724, mode: `MaxEncodedLen`) // Storage: `Issuance::TGETotal` (r:1 w:1) // Proof: `Issuance::TGETotal` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) fn execute_tge(x: u32, ) -> Weight { - (Weight::from_parts(41_367_508, 0)) - // Standard Error: 30_952 - .saturating_add((Weight::from_parts(55_608_672, 0)).saturating_mul(x as u64)) + (Weight::from_parts(26_290_460, 0)) + // Standard Error: 10_945 + .saturating_add((Weight::from_parts(22_350_615, 0)).saturating_mul(x as u64)) .saturating_add(T::DbWeight::get().reads(3 as u64)) - .saturating_add(T::DbWeight::get().reads((4 as u64).saturating_mul(x as u64))) + .saturating_add(T::DbWeight::get().reads((2 as u64).saturating_mul(x as u64))) .saturating_add(T::DbWeight::get().writes(2 as u64)) - .saturating_add(T::DbWeight::get().writes((4 as u64).saturating_mul(x as u64))) + .saturating_add(T::DbWeight::get().writes((2 as u64).saturating_mul(x as u64))) + } + // Storage: `Issuance::IssuanceConfigStore` (r:1 w:1) + // Proof: `Issuance::IssuanceConfigStore` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + fn set_issuance_config() -> Weight { + (Weight::from_parts(11_770_000, 0)) + .saturating_add(T::DbWeight::get().reads(1 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) } } @@ -114,38 +118,41 @@ impl WeightInfo for () { // Storage: `Tokens::TotalIssuance` (r:1 w:0) // Proof: `Tokens::TotalIssuance` (`max_values`: None, `max_size`: Some(28), added: 2503, mode: `MaxEncodedLen`) fn init_issuance_config() -> Weight { - (Weight::from_parts(17_810_000, 0)) + (Weight::from_parts(17_750_000, 0)) .saturating_add(RocksDbWeight::get().reads(3 as u64)) .saturating_add(RocksDbWeight::get().writes(1 as u64)) } // Storage: `Issuance::IsTGEFinalized` (r:1 w:1) // Proof: `Issuance::IsTGEFinalized` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) fn finalize_tge() -> Weight { - (Weight::from_parts(9_720_000, 0)) + (Weight::from_parts(9_809_000, 0)) .saturating_add(RocksDbWeight::get().reads(1 as u64)) .saturating_add(RocksDbWeight::get().writes(1 as u64)) } // Storage: `Issuance::IsTGEFinalized` (r:1 w:0) // Proof: `Issuance::IsTGEFinalized` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) - // Storage: `Vesting::Vesting` (r:100 w:100) - // Proof: `Vesting::Vesting` (`max_values`: None, `max_size`: Some(1857), added: 4332, mode: `MaxEncodedLen`) // Storage: `Tokens::Accounts` (r:100 w:100) // Proof: `Tokens::Accounts` (`max_values`: None, `max_size`: Some(96), added: 2571, mode: `MaxEncodedLen`) // Storage: `Tokens::TotalIssuance` (r:1 w:1) // Proof: `Tokens::TotalIssuance` (`max_values`: None, `max_size`: Some(28), added: 2503, mode: `MaxEncodedLen`) // Storage: `System::Account` (r:100 w:100) // Proof: `System::Account` (`max_values`: None, `max_size`: Some(52), added: 2527, mode: `MaxEncodedLen`) - // Storage: `Tokens::Locks` (r:100 w:100) - // Proof: `Tokens::Locks` (`max_values`: None, `max_size`: Some(1249), added: 3724, mode: `MaxEncodedLen`) // Storage: `Issuance::TGETotal` (r:1 w:1) // Proof: `Issuance::TGETotal` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) fn execute_tge(x: u32, ) -> Weight { - (Weight::from_parts(41_367_508, 0)) - // Standard Error: 30_952 - .saturating_add((Weight::from_parts(55_608_672, 0)).saturating_mul(x as u64)) + (Weight::from_parts(26_290_460, 0)) + // Standard Error: 10_945 + .saturating_add((Weight::from_parts(22_350_615, 0)).saturating_mul(x as u64)) .saturating_add(RocksDbWeight::get().reads(3 as u64)) - .saturating_add(RocksDbWeight::get().reads((4 as u64).saturating_mul(x as u64))) + .saturating_add(RocksDbWeight::get().reads((2 as u64).saturating_mul(x as u64))) .saturating_add(RocksDbWeight::get().writes(2 as u64)) - .saturating_add(RocksDbWeight::get().writes((4 as u64).saturating_mul(x as u64))) + .saturating_add(RocksDbWeight::get().writes((2 as u64).saturating_mul(x as u64))) + } + // Storage: `Issuance::IssuanceConfigStore` (r:1 w:1) + // Proof: `Issuance::IssuanceConfigStore` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + fn set_issuance_config() -> Weight { + (Weight::from_parts(11_770_000, 0)) + .saturating_add(RocksDbWeight::get().reads(1 as u64)) + .saturating_add(RocksDbWeight::get().writes(1 as u64)) } }