mirror of
https://github.com/serai-dex/serai.git
synced 2025-12-08 12:19:24 +00:00
Add Dex pallet (#407)
* Move pallet-asset-conversion * update licensing * initial integration * Integrate Currency & Assets types * integrate liquidity tokens * fmt * integrate dex pallet tests * fmt * compilation error fixes * integrate dex benchmarks * fmt * cargo clippy * replace all occurrences of "asset" with "coin" * add the actual add liq/swap logic to in-instructions * add client side & tests * fix deny * Lint and changes - Renames InInstruction::AddLiquidity to InInstruction::SwapAndAddLiquidity - Makes create_pool an internal function - Makes dex-pallet exclusively create pools against a native coin - Removes various fees - Adds new crates to GH workflow * Fix rebase artifacts * Correct other rebase artifact * Correct CI specification for liquidity-tokens * Correct primitives' test to the standardized pallet account scheme --------- Co-authored-by: Luke Parker <lukeparker5132@gmail.com>
This commit is contained in:
akildemir
GitHub
271
substrate/dex/pallet/src/benchmarking.rs
Normal file
271
substrate/dex/pallet/src/benchmarking.rs
Normal file
@@ -0,0 +1,271 @@
|
||||
// This file was originally:
|
||||
|
||||
// Copyright (C) Parity Technologies (UK) Ltd.
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
// It has been forked into a crate distributed under the AGPL 3.0.
|
||||
// Please check the current distribution for up-to-date copyright and licensing information.
|
||||
|
||||
//! Dex pallet benchmarking.
|
||||
|
||||
use super::*;
|
||||
use frame_benchmarking::{benchmarks, whitelisted_caller};
|
||||
use frame_support::{assert_ok, storage::bounded_vec::BoundedVec};
|
||||
use frame_system::RawOrigin as SystemOrigin;
|
||||
use sp_runtime::traits::{Bounded, StaticLookup};
|
||||
use sp_std::{ops::Div, prelude::*};
|
||||
|
||||
use crate::Pallet as Dex;
|
||||
|
||||
const INITIAL_COIN_BALANCE: u64 = 1_000_000_000;
|
||||
type AccountIdLookupOf<T> = <<T as frame_system::Config>::Lookup as StaticLookup>::Source;
|
||||
type BalanceOf<T> =
|
||||
<<T as Config>::Currency as Currency<<T as frame_system::Config>::AccountId>>::Balance;
|
||||
|
||||
fn get_lp_token_id<T: Config>() -> T::PoolCoinId
|
||||
where
|
||||
T::PoolCoinId: Into<u32>,
|
||||
{
|
||||
let next_id: u32 = Dex::<T>::get_next_pool_coin_id().into();
|
||||
(next_id - 1).into()
|
||||
}
|
||||
|
||||
fn create_coin<T: Config>(coin: &T::MultiCoinId) -> (T::AccountId, AccountIdLookupOf<T>)
|
||||
where
|
||||
T::CoinBalance: From<u64>,
|
||||
T::Currency: Currency<T::AccountId>,
|
||||
T::Coins: Coins<T::AccountId>,
|
||||
{
|
||||
let caller: T::AccountId = whitelisted_caller();
|
||||
let caller_lookup = T::Lookup::unlookup(caller.clone());
|
||||
if let MultiCoinIdConversionResult::Converted(coin_id) =
|
||||
T::MultiCoinIdConverter::try_convert(coin)
|
||||
{
|
||||
assert_ok!(T::Currency::mint(&caller, BalanceOf::<T>::max_value().div(1000u32.into())));
|
||||
assert_ok!(T::Coins::mint(coin_id, &caller, INITIAL_COIN_BALANCE.into()));
|
||||
}
|
||||
(caller, caller_lookup)
|
||||
}
|
||||
|
||||
fn create_coin_and_pool<T: Config>(
|
||||
coin1: &T::MultiCoinId,
|
||||
coin2: &T::MultiCoinId,
|
||||
) -> (T::PoolCoinId, T::AccountId, AccountIdLookupOf<T>)
|
||||
where
|
||||
T::CoinBalance: From<u64>,
|
||||
T::Currency: Currency<T::AccountId>,
|
||||
T::Coins: Coins<T::AccountId>,
|
||||
T::PoolCoinId: Into<u32>,
|
||||
{
|
||||
assert_eq!(coin1, &T::MultiCoinIdConverter::get_native());
|
||||
|
||||
let (caller, caller_lookup) = create_coin::<T>(coin2);
|
||||
|
||||
assert_ok!(Dex::<T>::create_pool(coin2.clone()));
|
||||
let lp_token = get_lp_token_id::<T>();
|
||||
|
||||
(lp_token, caller, caller_lookup)
|
||||
}
|
||||
|
||||
benchmarks! {
|
||||
where_clause {
|
||||
where
|
||||
T::CoinBalance: From<u64> + Into<u64>,
|
||||
T::Currency: Currency<T::AccountId>,
|
||||
T::Balance: From<u64> + Into<u64>,
|
||||
T::Coins: Coins<T::AccountId>,
|
||||
T::PoolCoinId: Into<u32>,
|
||||
}
|
||||
|
||||
add_liquidity {
|
||||
let coin1 = T::MultiCoinIdConverter::get_native();
|
||||
let coin2: T::MultiCoinId = T::BenchmarkHelper::coin_id(0).into();
|
||||
let (lp_token, caller, _) = create_coin_and_pool::<T>(&coin1, &coin2);
|
||||
let ed: u64 = T::Currency::minimum_balance().into();
|
||||
let add_amount = 1000 + ed;
|
||||
}: _(
|
||||
SystemOrigin::Signed(caller.clone()),
|
||||
coin1.clone(),
|
||||
coin2.clone(),
|
||||
add_amount.into(),
|
||||
1000.into(),
|
||||
0.into(),
|
||||
0.into(),
|
||||
caller.clone()
|
||||
)
|
||||
verify {
|
||||
let pool_id = (coin1.clone(), coin2.clone());
|
||||
let lp_minted = Dex::<T>::calc_lp_amount_for_zero_supply(
|
||||
&add_amount.into(),
|
||||
&1000.into()
|
||||
).unwrap().into();
|
||||
assert_eq!(
|
||||
T::PoolCoins::balance(lp_token, &caller),
|
||||
lp_minted.into()
|
||||
);
|
||||
assert_eq!(
|
||||
T::Currency::balance(&Dex::<T>::get_pool_account(&pool_id)),
|
||||
add_amount.into()
|
||||
);
|
||||
assert_eq!(
|
||||
T::Coins::balance(
|
||||
T::BenchmarkHelper::coin_id(0),
|
||||
&Dex::<T>::get_pool_account(&pool_id)
|
||||
),
|
||||
1000.into()
|
||||
);
|
||||
}
|
||||
|
||||
remove_liquidity {
|
||||
let coin1 = T::MultiCoinIdConverter::get_native();
|
||||
let coin2: T::MultiCoinId = T::BenchmarkHelper::coin_id(0).into();
|
||||
let (lp_token, caller, _) = create_coin_and_pool::<T>(&coin1, &coin2);
|
||||
let ed: u64 = T::Currency::minimum_balance().into();
|
||||
let add_amount = 100 * ed;
|
||||
let lp_minted = Dex::<T>::calc_lp_amount_for_zero_supply(
|
||||
&add_amount.into(),
|
||||
&1000.into()
|
||||
).unwrap().into();
|
||||
let remove_lp_amount = lp_minted.checked_div(10).unwrap();
|
||||
|
||||
Dex::<T>::add_liquidity(
|
||||
SystemOrigin::Signed(caller.clone()).into(),
|
||||
coin1.clone(),
|
||||
coin2.clone(),
|
||||
add_amount.into(),
|
||||
1000.into(),
|
||||
0.into(),
|
||||
0.into(),
|
||||
caller.clone(),
|
||||
)?;
|
||||
let total_supply =
|
||||
<T::PoolCoins as LiquidityTokens<T::AccountId>>::total_issuance(lp_token.clone());
|
||||
}: _(
|
||||
SystemOrigin::Signed(caller.clone()),
|
||||
coin1,
|
||||
coin2,
|
||||
remove_lp_amount.into(),
|
||||
0.into(),
|
||||
0.into(),
|
||||
caller.clone()
|
||||
)
|
||||
verify {
|
||||
let new_total_supply =
|
||||
<T::PoolCoins as LiquidityTokens<T::AccountId>>::total_issuance(lp_token.clone());
|
||||
assert_eq!(
|
||||
new_total_supply,
|
||||
total_supply - remove_lp_amount.into()
|
||||
);
|
||||
}
|
||||
|
||||
swap_exact_tokens_for_tokens {
|
||||
let native = T::MultiCoinIdConverter::get_native();
|
||||
let coin1: T::MultiCoinId = T::BenchmarkHelper::coin_id(1).into();
|
||||
let coin2: T::MultiCoinId = T::BenchmarkHelper::coin_id(2).into();
|
||||
let (_, caller, _) = create_coin_and_pool::<T>(&native, &coin1);
|
||||
let (_, _) = create_coin::<T>(&coin2);
|
||||
let ed: u64 = T::Currency::minimum_balance().into();
|
||||
let ed_bump = 2u64;
|
||||
|
||||
Dex::<T>::add_liquidity(
|
||||
SystemOrigin::Signed(caller.clone()).into(),
|
||||
native.clone(),
|
||||
coin1.clone(),
|
||||
// TODO: this call otherwise fails with `InsufficientLiquidityMinted`.
|
||||
// might be again related to their expectance on ed being > 1.
|
||||
(100 * (ed + ed_bump)).into(),
|
||||
200.into(),
|
||||
0.into(),
|
||||
0.into(),
|
||||
caller.clone(),
|
||||
)?;
|
||||
|
||||
let swap_amount = 100.into();
|
||||
|
||||
// since we only allow the native-coin pools, then the worst case scenario would be to swap
|
||||
// coin1-native-coin2
|
||||
Dex::<T>::create_pool(coin2.clone())?;
|
||||
Dex::<T>::add_liquidity(
|
||||
SystemOrigin::Signed(caller.clone()).into(),
|
||||
native.clone(),
|
||||
coin2.clone(),
|
||||
(500 * ed).into(),
|
||||
1000.into(),
|
||||
0.into(),
|
||||
0.into(),
|
||||
caller.clone(),
|
||||
)?;
|
||||
|
||||
let path = vec![coin1.clone(), native.clone(), coin2.clone()];
|
||||
let path = BoundedVec::<_, T::MaxSwapPathLength>::try_from(path).unwrap();
|
||||
let native_balance = T::Currency::balance(&caller);
|
||||
let coin1_balance = T::Coins::balance(T::BenchmarkHelper::coin_id(1), &caller);
|
||||
}: _(SystemOrigin::Signed(caller.clone()), path, swap_amount, 1.into(), caller.clone())
|
||||
verify {
|
||||
let ed_bump = 2u64;
|
||||
let new_coin1_balance = T::Coins::balance(T::BenchmarkHelper::coin_id(1), &caller);
|
||||
assert_eq!(new_coin1_balance, coin1_balance - 100.into());
|
||||
}
|
||||
|
||||
swap_tokens_for_exact_tokens {
|
||||
let native = T::MultiCoinIdConverter::get_native();
|
||||
let coin1: T::MultiCoinId = T::BenchmarkHelper::coin_id(1).into();
|
||||
let coin2: T::MultiCoinId = T::BenchmarkHelper::coin_id(2).into();
|
||||
let (_, caller, _) = create_coin_and_pool::<T>(&native, &coin1);
|
||||
let (_, _) = create_coin::<T>(&coin2);
|
||||
let ed: u64 = T::Currency::minimum_balance().into();
|
||||
|
||||
Dex::<T>::add_liquidity(
|
||||
SystemOrigin::Signed(caller.clone()).into(),
|
||||
native.clone(),
|
||||
coin1.clone(),
|
||||
(1000 * ed).into(),
|
||||
500.into(),
|
||||
0.into(),
|
||||
0.into(),
|
||||
caller.clone(),
|
||||
)?;
|
||||
|
||||
// since we only allow the native-coin pools, then the worst case scenario would be to swap
|
||||
// coin1-native-coin2
|
||||
Dex::<T>::create_pool(coin2.clone())?;
|
||||
Dex::<T>::add_liquidity(
|
||||
SystemOrigin::Signed(caller.clone()).into(),
|
||||
native.clone(),
|
||||
coin2.clone(),
|
||||
(500 * ed).into(),
|
||||
1000.into(),
|
||||
0.into(),
|
||||
0.into(),
|
||||
caller.clone(),
|
||||
)?;
|
||||
let path = vec![coin1.clone(), native.clone(), coin2.clone()];
|
||||
|
||||
let path: BoundedVec<_, T::MaxSwapPathLength> = BoundedVec::try_from(path).unwrap();
|
||||
let coin2_balance = T::Coins::balance(T::BenchmarkHelper::coin_id(2), &caller);
|
||||
}: _(
|
||||
SystemOrigin::Signed(caller.clone()),
|
||||
path.clone(),
|
||||
100.into(),
|
||||
(1000 * ed).into(),
|
||||
caller.clone()
|
||||
)
|
||||
verify {
|
||||
let new_coin2_balance = T::Coins::balance(T::BenchmarkHelper::coin_id(2), &caller);
|
||||
assert_eq!(new_coin2_balance, coin2_balance + 100.into());
|
||||
}
|
||||
|
||||
impl_benchmark_test_suite!(Dex, crate::mock::new_test_ext(), crate::mock::Test);
|
||||
}
|
||||
1217
substrate/dex/pallet/src/lib.rs
Normal file
1217
substrate/dex/pallet/src/lib.rs
Normal file
File diff suppressed because it is too large
Load Diff
155
substrate/dex/pallet/src/mock.rs
Normal file
155
substrate/dex/pallet/src/mock.rs
Normal file
@@ -0,0 +1,155 @@
|
||||
// This file was originally:
|
||||
|
||||
// Copyright (C) Parity Technologies (UK) Ltd.
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
// It has been forked into a crate distributed under the AGPL 3.0.
|
||||
// Please check the current distribution for up-to-date copyright and licensing information.
|
||||
|
||||
//! Test environment for Dex pallet.
|
||||
|
||||
use super::*;
|
||||
use crate as dex;
|
||||
|
||||
use frame_support::{
|
||||
construct_runtime,
|
||||
traits::{ConstU32, ConstU64},
|
||||
};
|
||||
|
||||
use sp_core::{H256, sr25519::Public};
|
||||
use sp_runtime::{
|
||||
traits::{BlakeTwo256, IdentityLookup},
|
||||
BuildStorage,
|
||||
};
|
||||
|
||||
use serai_primitives::{Coin, Balance, Amount, system_address};
|
||||
|
||||
pub use coins_pallet as coins;
|
||||
pub use liquidity_tokens_pallet as liquidity_tokens;
|
||||
|
||||
type Block = frame_system::mocking::MockBlock<Test>;
|
||||
|
||||
construct_runtime!(
|
||||
pub enum Test
|
||||
{
|
||||
System: frame_system,
|
||||
CoinsPallet: coins,
|
||||
LiquidityTokens: liquidity_tokens,
|
||||
Dex: dex,
|
||||
}
|
||||
);
|
||||
|
||||
impl frame_system::Config for Test {
|
||||
type BaseCallFilter = frame_support::traits::Everything;
|
||||
type BlockWeights = ();
|
||||
type BlockLength = ();
|
||||
type RuntimeOrigin = RuntimeOrigin;
|
||||
type RuntimeCall = RuntimeCall;
|
||||
type Nonce = u64;
|
||||
type Hash = H256;
|
||||
type Hashing = BlakeTwo256;
|
||||
type AccountId = Public;
|
||||
type Lookup = IdentityLookup<Self::AccountId>;
|
||||
type Block = Block;
|
||||
type RuntimeEvent = RuntimeEvent;
|
||||
type BlockHashCount = ConstU64<250>;
|
||||
type DbWeight = ();
|
||||
type Version = ();
|
||||
type PalletInfo = PalletInfo;
|
||||
type AccountData = ();
|
||||
type OnNewAccount = ();
|
||||
type OnKilledAccount = ();
|
||||
type SystemWeightInfo = ();
|
||||
type SS58Prefix = ();
|
||||
type OnSetCode = ();
|
||||
type MaxConsumers = ConstU32<16>;
|
||||
}
|
||||
|
||||
impl coins::Config for Test {
|
||||
type RuntimeEvent = RuntimeEvent;
|
||||
}
|
||||
|
||||
impl liquidity_tokens::Config for Test {
|
||||
type RuntimeEvent = RuntimeEvent;
|
||||
}
|
||||
|
||||
pub struct CoinConverter;
|
||||
impl MultiCoinIdConverter<Coin, Coin> for CoinConverter {
|
||||
/// Returns the MultiCoinId representing the native currency of the chain.
|
||||
fn get_native() -> Coin {
|
||||
Coin::Serai
|
||||
}
|
||||
|
||||
/// Returns true if the given MultiCoinId is the native currency.
|
||||
fn is_native(coin: &Coin) -> bool {
|
||||
coin.is_native()
|
||||
}
|
||||
|
||||
/// If it's not native, returns the CoinId for the given MultiCoinId.
|
||||
fn try_convert(coin: &Coin) -> MultiCoinIdConversionResult<Coin, Coin> {
|
||||
if coin.is_native() {
|
||||
MultiCoinIdConversionResult::Native
|
||||
} else {
|
||||
MultiCoinIdConversionResult::Converted(*coin)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Config for Test {
|
||||
type RuntimeEvent = RuntimeEvent;
|
||||
type Currency = CoinsPallet;
|
||||
type CoinBalance = u64;
|
||||
type CoinId = Coin;
|
||||
type PoolCoinId = u32;
|
||||
type Coins = CoinsPallet;
|
||||
type PoolCoins = LiquidityTokens;
|
||||
type WeightInfo = ();
|
||||
type LPFee = ConstU32<3>; // means 0.3%
|
||||
type MaxSwapPathLength = ConstU32<4>;
|
||||
// 100 is good enough when the main currency has 12 decimals.
|
||||
type MintMinLiquidity = ConstU64<100>;
|
||||
|
||||
type Balance = u64;
|
||||
type HigherPrecisionBalance = u128;
|
||||
|
||||
type MultiCoinId = Coin;
|
||||
type MultiCoinIdConverter = CoinConverter;
|
||||
|
||||
#[cfg(feature = "runtime-benchmarks")]
|
||||
type BenchmarkHelper = ();
|
||||
}
|
||||
|
||||
pub(crate) fn new_test_ext() -> sp_io::TestExternalities {
|
||||
let mut t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
|
||||
|
||||
let accounts: Vec<Public> = vec![
|
||||
system_address(b"account1").into(),
|
||||
system_address(b"account2").into(),
|
||||
system_address(b"account3").into(),
|
||||
system_address(b"account4").into(),
|
||||
];
|
||||
coins::GenesisConfig::<Test> {
|
||||
accounts: accounts
|
||||
.into_iter()
|
||||
.map(|a| (a, Balance { coin: Coin::Serai, amount: Amount(1 << 60) }))
|
||||
.collect(),
|
||||
}
|
||||
.assimilate_storage(&mut t)
|
||||
.unwrap();
|
||||
|
||||
let mut ext = sp_io::TestExternalities::new(t);
|
||||
ext.execute_with(|| System::set_block_number(1));
|
||||
ext
|
||||
}
|
||||
1411
substrate/dex/pallet/src/tests.rs
Normal file
1411
substrate/dex/pallet/src/tests.rs
Normal file
File diff suppressed because it is too large
Load Diff
259
substrate/dex/pallet/src/weights.rs
Normal file
259
substrate/dex/pallet/src/weights.rs
Normal file
@@ -0,0 +1,259 @@
|
||||
// This file was originally:
|
||||
|
||||
// Copyright (C) Parity Technologies (UK) Ltd.
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
// It has been forked into a crate distributed under the AGPL 3.0.
|
||||
// Please check the current distribution for up-to-date copyright and licensing information.
|
||||
|
||||
//! Autogenerated weights for pallet_coin_conversion
|
||||
//!
|
||||
//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
|
||||
//! DATE: 2023-07-18, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
|
||||
//! WORST CASE MAP SIZE: `1000000`
|
||||
//! HOSTNAME: `runner-gghbxkbs-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
|
||||
//! EXECUTION: ``, WASM-EXECUTION: `Compiled`, CHAIN: `Some("dev")`, DB CACHE: `1024`
|
||||
|
||||
// Executed Command:
|
||||
// target/production/substrate
|
||||
// benchmark
|
||||
// pallet
|
||||
// --steps=50
|
||||
// --repeat=20
|
||||
// --extrinsic=*
|
||||
// --wasm-execution=compiled
|
||||
// --heap-pages=4096
|
||||
// --json-file=/builds/parity/mirrors/substrate/.git/.artifacts/bench.json
|
||||
// --pallet=pallet_coin_conversion
|
||||
// --chain=dev
|
||||
// --header=./HEADER-APACHE2
|
||||
// --output=./frame/coin-conversion/src/weights.rs
|
||||
// --template=./.maintain/frame-weight-template.hbs
|
||||
|
||||
#![cfg_attr(rustfmt, rustfmt_skip)]
|
||||
#![allow(unused_parens)]
|
||||
#![allow(unused_imports)]
|
||||
#![allow(missing_docs)]
|
||||
|
||||
use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
|
||||
use core::marker::PhantomData;
|
||||
|
||||
/// Weight functions needed for pallet_coin_conversion.
|
||||
pub trait WeightInfo {
|
||||
fn create_pool() -> Weight;
|
||||
fn add_liquidity() -> Weight;
|
||||
fn remove_liquidity() -> Weight;
|
||||
fn swap_exact_tokens_for_tokens() -> Weight;
|
||||
fn swap_tokens_for_exact_tokens() -> Weight;
|
||||
}
|
||||
|
||||
/// Weights for pallet_coin_conversion using the Substrate node and recommended hardware.
|
||||
pub struct SubstrateWeight<T>(PhantomData<T>);
|
||||
impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
|
||||
/// Storage: `CoinConversion::Pools` (r:1 w:1)
|
||||
/// Proof: `CoinConversion::Pools` (`max_values`: None, `max_size`: Some(30), added: 2505, mode: `MaxEncodedLen`)
|
||||
/// Storage: `System::Account` (r:2 w:2)
|
||||
/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
|
||||
/// Storage: `Coins::Account` (r:1 w:1)
|
||||
/// Proof: `Coins::Account` (`max_values`: None, `max_size`: Some(134), added: 2609, mode: `MaxEncodedLen`)
|
||||
/// Storage: `Coins::Coin` (r:1 w:1)
|
||||
/// Proof: `Coins::Coin` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
|
||||
/// Storage: `CoinConversion::NextPoolCoinId` (r:1 w:1)
|
||||
/// Proof: `CoinConversion::NextPoolCoinId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
|
||||
/// Storage: `PoolCoins::Coin` (r:1 w:1)
|
||||
/// Proof: `PoolCoins::Coin` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
|
||||
/// Storage: `PoolCoins::Account` (r:1 w:1)
|
||||
/// Proof: `PoolCoins::Account` (`max_values`: None, `max_size`: Some(134), added: 2609, mode: `MaxEncodedLen`)
|
||||
fn create_pool() -> Weight {
|
||||
// Proof Size summary in bytes:
|
||||
// Measured: `729`
|
||||
// Estimated: `6196`
|
||||
// Minimum execution time: 131_688_000 picoseconds.
|
||||
Weight::from_parts(134_092_000, 6196)
|
||||
.saturating_add(T::DbWeight::get().reads(8_u64))
|
||||
.saturating_add(T::DbWeight::get().writes(8_u64))
|
||||
}
|
||||
/// Storage: `CoinConversion::Pools` (r:1 w:0)
|
||||
/// Proof: `CoinConversion::Pools` (`max_values`: None, `max_size`: Some(30), added: 2505, mode: `MaxEncodedLen`)
|
||||
/// Storage: `System::Account` (r:1 w:1)
|
||||
/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
|
||||
/// Storage: `Coins::Coin` (r:1 w:1)
|
||||
/// Proof: `Coins::Coin` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
|
||||
/// Storage: `Coins::Account` (r:2 w:2)
|
||||
/// Proof: `Coins::Account` (`max_values`: None, `max_size`: Some(134), added: 2609, mode: `MaxEncodedLen`)
|
||||
/// Storage: `PoolCoins::Coin` (r:1 w:1)
|
||||
/// Proof: `PoolCoins::Coin` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
|
||||
/// Storage: `PoolCoins::Account` (r:2 w:2)
|
||||
/// Proof: `PoolCoins::Account` (`max_values`: None, `max_size`: Some(134), added: 2609, mode: `MaxEncodedLen`)
|
||||
fn add_liquidity() -> Weight {
|
||||
// Proof Size summary in bytes:
|
||||
// Measured: `1382`
|
||||
// Estimated: `6208`
|
||||
// Minimum execution time: 157_310_000 picoseconds.
|
||||
Weight::from_parts(161_547_000, 6208)
|
||||
.saturating_add(T::DbWeight::get().reads(8_u64))
|
||||
.saturating_add(T::DbWeight::get().writes(7_u64))
|
||||
}
|
||||
/// Storage: `CoinConversion::Pools` (r:1 w:0)
|
||||
/// Proof: `CoinConversion::Pools` (`max_values`: None, `max_size`: Some(30), added: 2505, mode: `MaxEncodedLen`)
|
||||
/// Storage: `System::Account` (r:1 w:1)
|
||||
/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
|
||||
/// Storage: `Coins::Coin` (r:1 w:1)
|
||||
/// Proof: `Coins::Coin` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
|
||||
/// Storage: `Coins::Account` (r:2 w:2)
|
||||
/// Proof: `Coins::Account` (`max_values`: None, `max_size`: Some(134), added: 2609, mode: `MaxEncodedLen`)
|
||||
/// Storage: `PoolCoins::Coin` (r:1 w:1)
|
||||
/// Proof: `PoolCoins::Coin` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
|
||||
/// Storage: `PoolCoins::Account` (r:1 w:1)
|
||||
/// Proof: `PoolCoins::Account` (`max_values`: None, `max_size`: Some(134), added: 2609, mode: `MaxEncodedLen`)
|
||||
fn remove_liquidity() -> Weight {
|
||||
// Proof Size summary in bytes:
|
||||
// Measured: `1371`
|
||||
// Estimated: `6208`
|
||||
// Minimum execution time: 142_769_000 picoseconds.
|
||||
Weight::from_parts(145_139_000, 6208)
|
||||
.saturating_add(T::DbWeight::get().reads(7_u64))
|
||||
.saturating_add(T::DbWeight::get().writes(6_u64))
|
||||
}
|
||||
/// Storage: `System::Account` (r:1 w:1)
|
||||
/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
|
||||
/// Storage: `Coins::Coin` (r:3 w:3)
|
||||
/// Proof: `Coins::Coin` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
|
||||
/// Storage: `Coins::Account` (r:6 w:6)
|
||||
/// Proof: `Coins::Account` (`max_values`: None, `max_size`: Some(134), added: 2609, mode: `MaxEncodedLen`)
|
||||
fn swap_exact_tokens_for_tokens() -> Weight {
|
||||
// Proof Size summary in bytes:
|
||||
// Measured: `1738`
|
||||
// Estimated: `16644`
|
||||
// Minimum execution time: 213_186_000 picoseconds.
|
||||
Weight::from_parts(217_471_000, 16644)
|
||||
.saturating_add(T::DbWeight::get().reads(10_u64))
|
||||
.saturating_add(T::DbWeight::get().writes(10_u64))
|
||||
}
|
||||
/// Storage: `Coins::Coin` (r:3 w:3)
|
||||
/// Proof: `Coins::Coin` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
|
||||
/// Storage: `Coins::Account` (r:6 w:6)
|
||||
/// Proof: `Coins::Account` (`max_values`: None, `max_size`: Some(134), added: 2609, mode: `MaxEncodedLen`)
|
||||
/// Storage: `System::Account` (r:1 w:1)
|
||||
/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
|
||||
fn swap_tokens_for_exact_tokens() -> Weight {
|
||||
// Proof Size summary in bytes:
|
||||
// Measured: `1738`
|
||||
// Estimated: `16644`
|
||||
// Minimum execution time: 213_793_000 picoseconds.
|
||||
Weight::from_parts(218_584_000, 16644)
|
||||
.saturating_add(T::DbWeight::get().reads(10_u64))
|
||||
.saturating_add(T::DbWeight::get().writes(10_u64))
|
||||
}
|
||||
}
|
||||
|
||||
// For backwards compatibility and tests.
|
||||
impl WeightInfo for () {
|
||||
/// Storage: `CoinConversion::Pools` (r:1 w:1)
|
||||
/// Proof: `CoinConversion::Pools` (`max_values`: None, `max_size`: Some(30), added: 2505, mode: `MaxEncodedLen`)
|
||||
/// Storage: `System::Account` (r:2 w:2)
|
||||
/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
|
||||
/// Storage: `Coins::Account` (r:1 w:1)
|
||||
/// Proof: `Coins::Account` (`max_values`: None, `max_size`: Some(134), added: 2609, mode: `MaxEncodedLen`)
|
||||
/// Storage: `Coins::Coin` (r:1 w:1)
|
||||
/// Proof: `Coins::Coin` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
|
||||
/// Storage: `CoinConversion::NextPoolCoinId` (r:1 w:1)
|
||||
/// Proof: `CoinConversion::NextPoolCoinId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
|
||||
/// Storage: `PoolCoins::Coin` (r:1 w:1)
|
||||
/// Proof: `PoolCoins::Coin` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
|
||||
/// Storage: `PoolCoins::Account` (r:1 w:1)
|
||||
/// Proof: `PoolCoins::Account` (`max_values`: None, `max_size`: Some(134), added: 2609, mode: `MaxEncodedLen`)
|
||||
fn create_pool() -> Weight {
|
||||
// Proof Size summary in bytes:
|
||||
// Measured: `729`
|
||||
// Estimated: `6196`
|
||||
// Minimum execution time: 131_688_000 picoseconds.
|
||||
Weight::from_parts(134_092_000, 6196)
|
||||
.saturating_add(RocksDbWeight::get().reads(8_u64))
|
||||
.saturating_add(RocksDbWeight::get().writes(8_u64))
|
||||
}
|
||||
/// Storage: `CoinConversion::Pools` (r:1 w:0)
|
||||
/// Proof: `CoinConversion::Pools` (`max_values`: None, `max_size`: Some(30), added: 2505, mode: `MaxEncodedLen`)
|
||||
/// Storage: `System::Account` (r:1 w:1)
|
||||
/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
|
||||
/// Storage: `Coins::Coin` (r:1 w:1)
|
||||
/// Proof: `Coins::Coin` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
|
||||
/// Storage: `Coins::Account` (r:2 w:2)
|
||||
/// Proof: `Coins::Account` (`max_values`: None, `max_size`: Some(134), added: 2609, mode: `MaxEncodedLen`)
|
||||
/// Storage: `PoolCoins::Coin` (r:1 w:1)
|
||||
/// Proof: `PoolCoins::Coin` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
|
||||
/// Storage: `PoolCoins::Account` (r:2 w:2)
|
||||
/// Proof: `PoolCoins::Account` (`max_values`: None, `max_size`: Some(134), added: 2609, mode: `MaxEncodedLen`)
|
||||
fn add_liquidity() -> Weight {
|
||||
// Proof Size summary in bytes:
|
||||
// Measured: `1382`
|
||||
// Estimated: `6208`
|
||||
// Minimum execution time: 157_310_000 picoseconds.
|
||||
Weight::from_parts(161_547_000, 6208)
|
||||
.saturating_add(RocksDbWeight::get().reads(8_u64))
|
||||
.saturating_add(RocksDbWeight::get().writes(7_u64))
|
||||
}
|
||||
/// Storage: `CoinConversion::Pools` (r:1 w:0)
|
||||
/// Proof: `CoinConversion::Pools` (`max_values`: None, `max_size`: Some(30), added: 2505, mode: `MaxEncodedLen`)
|
||||
/// Storage: `System::Account` (r:1 w:1)
|
||||
/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
|
||||
/// Storage: `Coins::Coin` (r:1 w:1)
|
||||
/// Proof: `Coins::Coin` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
|
||||
/// Storage: `Coins::Account` (r:2 w:2)
|
||||
/// Proof: `Coins::Account` (`max_values`: None, `max_size`: Some(134), added: 2609, mode: `MaxEncodedLen`)
|
||||
/// Storage: `PoolCoins::Coin` (r:1 w:1)
|
||||
/// Proof: `PoolCoins::Coin` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
|
||||
/// Storage: `PoolCoins::Account` (r:1 w:1)
|
||||
/// Proof: `PoolCoins::Account` (`max_values`: None, `max_size`: Some(134), added: 2609, mode: `MaxEncodedLen`)
|
||||
fn remove_liquidity() -> Weight {
|
||||
// Proof Size summary in bytes:
|
||||
// Measured: `1371`
|
||||
// Estimated: `6208`
|
||||
// Minimum execution time: 142_769_000 picoseconds.
|
||||
Weight::from_parts(145_139_000, 6208)
|
||||
.saturating_add(RocksDbWeight::get().reads(7_u64))
|
||||
.saturating_add(RocksDbWeight::get().writes(6_u64))
|
||||
}
|
||||
/// Storage: `System::Account` (r:1 w:1)
|
||||
/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
|
||||
/// Storage: `Coins::Coin` (r:3 w:3)
|
||||
/// Proof: `Coins::Coin` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
|
||||
/// Storage: `Coins::Account` (r:6 w:6)
|
||||
/// Proof: `Coins::Account` (`max_values`: None, `max_size`: Some(134), added: 2609, mode: `MaxEncodedLen`)
|
||||
fn swap_exact_tokens_for_tokens() -> Weight {
|
||||
// Proof Size summary in bytes:
|
||||
// Measured: `1738`
|
||||
// Estimated: `16644`
|
||||
// Minimum execution time: 213_186_000 picoseconds.
|
||||
Weight::from_parts(217_471_000, 16644)
|
||||
.saturating_add(RocksDbWeight::get().reads(10_u64))
|
||||
.saturating_add(RocksDbWeight::get().writes(10_u64))
|
||||
}
|
||||
/// Storage: `Coins::Coin` (r:3 w:3)
|
||||
/// Proof: `Coins::Coin` (`max_values`: None, `max_size`: Some(210), added: 2685, mode: `MaxEncodedLen`)
|
||||
/// Storage: `Coins::Account` (r:6 w:6)
|
||||
/// Proof: `Coins::Account` (`max_values`: None, `max_size`: Some(134), added: 2609, mode: `MaxEncodedLen`)
|
||||
/// Storage: `System::Account` (r:1 w:1)
|
||||
/// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`)
|
||||
fn swap_tokens_for_exact_tokens() -> Weight {
|
||||
// Proof Size summary in bytes:
|
||||
// Measured: `1738`
|
||||
// Estimated: `16644`
|
||||
// Minimum execution time: 213_793_000 picoseconds.
|
||||
Weight::from_parts(218_584_000, 16644)
|
||||
.saturating_add(RocksDbWeight::get().reads(10_u64))
|
||||
.saturating_add(RocksDbWeight::get().writes(10_u64))
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user