absolutebi/serai
1
0
Fork 0
mirror of https://github.com/serai-dex/serai.git synced 2025-12-08 12:19:24 +00:00
Code Issues Packages Projects Releases Wiki Activity

Dex improvements (#422)

Browse Source 
* remove dex traits&balance types

* remove liq tokens pallet in favor of coins-pallet instance

* fix tests & benchmarks

* remove liquidity tokens trait

* fix CI

* fix pr comments

* Slight renamings

* Add burn_with_instruction as a negative to LiquidityTokens CallFilter

* Remove use of One, Zero, Saturating taits in dex pallet

---------

Co-authored-by: Luke Parker <lukeparker5132@gmail.com>
This commit is contained in:
akildemir
2023-11-12 14:37:31 +03:00
committed by GitHub
parent a43815f101
commit d015ee96a3
30 changed files with 1063 additions and 2162 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
substrate/dex/pallet/Cargo.toml
View File

@@ -26,13 +26,9 @@ frame-system = { git = "https://github.com/serai-dex/substrate", default-feature
frame-support = { git = "https://github.com/serai-dex/substrate", default-features = false }
frame-benchmarking = { git = "https://github.com/serai-dex/substrate", default-features = false, optional = true }
dex-primitives = { package = "serai-dex-primitives", path = "../primitives", default-features = false }
[dev-dependencies]
serai-primitives = { path = "../../primitives", default-features = false }
coins-pallet = { package = "serai-coins-pallet", path = "../../coins/pallet", default-features = false }
liquidity-tokens-pallet = { package = "serai-liquidity-tokens-pallet", path = "../../liquidity-tokens/pallet", default-features = false }
serai-primitives = { path = "../../primitives", default-features = false }
[features]
default = ["std"]
@@ -49,14 +45,11 @@ std = [
"serai-primitives/std",
"dex-primitives/std",
"frame-system/std",
"frame-support/std",
"frame-benchmarking?/std",
"coins-pallet/std",
"liquidity-tokens-pallet/std",
]
runtime-benchmarks = [
"sp-runtime/runtime-benchmarks",
@@ -64,8 +57,6 @@ runtime-benchmarks = [
"frame-system/runtime-benchmarks",
"frame-support/runtime-benchmarks",
"frame-benchmarking/runtime-benchmarks",
"dex-primitives/runtime-benchmarks",
]
try-runtime = [
"sp-runtime/try-runtime",

287
substrate/dex/pallet/src/benchmarking.rs
View File

@@ -24,247 +24,206 @@ 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_runtime::traits::StaticLookup;
use sp_std::{ops::Div, prelude::*};
use serai_primitives::{Amount, Balance};
use crate::Pallet as Dex;
use coins_pallet::Pallet as Coins;
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()
}
type LiquidityTokens<T> = coins_pallet::Pallet<T, coins_pallet::Instance1>;
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>,
{
fn create_coin<T: Config>(coin: &Coin) -> (T::AccountId, AccountIdLookupOf<T>) {
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()));
}
let caller_lookup = T::Lookup::unlookup(caller);
assert_ok!(Coins::<T>::mint(
caller,
Balance { coin: Coin::native(), amount: Amount(SubstrateAmount::max_value().div(1000u64)) }
));
assert_ok!(Coins::<T>::mint(
caller,
Balance { coin: *coin, amount: Amount(INITIAL_COIN_BALANCE) }
));
(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());
coin: &Coin,
) -> (PoolCoinId, T::AccountId, AccountIdLookupOf<T>) {
let (caller, caller_lookup) = create_coin::<T>(coin);
assert_ok!(Dex::<T>::create_pool(*coin));
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)
(*coin, 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;
let coin1 = Coin::native();
let coin2 = Coin::Bitcoin;
let (lp_token, caller, _) = create_coin_and_pool::<T>(&coin2);
let add_amount: u64 = 1000;
}: _(
SystemOrigin::Signed(caller.clone()),
coin1.clone(),
coin2.clone(),
add_amount.into(),
1000.into(),
0.into(),
0.into(),
caller.clone()
SystemOrigin::Signed(caller),
coin2,
1000u64,
add_amount,
0u64,
0u64,
caller
)
verify {
let pool_id = (coin1.clone(), coin2.clone());
let pool_id = Dex::<T>::get_pool_id(coin1, coin2).unwrap();
let lp_minted = Dex::<T>::calc_lp_amount_for_zero_supply(
&add_amount.into(),
&1000.into()
).unwrap().into();
add_amount,
1000u64,
).unwrap();
assert_eq!(
T::PoolCoins::balance(lp_token, &caller),
lp_minted.into()
LiquidityTokens::<T>::balance(caller, lp_token).0,
lp_minted
);
assert_eq!(
T::Currency::balance(&Dex::<T>::get_pool_account(&pool_id)),
add_amount.into()
Coins::<T>::balance(Dex::<T>::get_pool_account(pool_id), Coin::native()).0,
add_amount
);
assert_eq!(
T::Coins::balance(
T::BenchmarkHelper::coin_id(0),
&Dex::<T>::get_pool_account(&pool_id)
),
1000.into()
Coins::<T>::balance(
Dex::<T>::get_pool_account(pool_id),
Coin::Bitcoin,
).0,
1000
);
}
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 coin1 = Coin::native();
let coin2 = Coin::Monero;
let (lp_token, caller, _) = create_coin_and_pool::<T>(&coin2);
let add_amount: u64 = 100;
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();
add_amount,
1000u64
).unwrap();
let remove_lp_amount: u64 = 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(),
SystemOrigin::Signed(caller).into(),
coin2,
1000u64,
add_amount,
0u64,
0u64,
caller,
)?;
let total_supply =
<T::PoolCoins as LiquidityTokens<T::AccountId>>::total_issuance(lp_token.clone());
let total_supply = LiquidityTokens::<T>::supply(lp_token);
}: _(
SystemOrigin::Signed(caller.clone()),
coin1,
SystemOrigin::Signed(caller),
coin2,
remove_lp_amount.into(),
0.into(),
0.into(),
caller.clone()
remove_lp_amount,
0u64,
0u64,
caller
)
verify {
let new_total_supply =
<T::PoolCoins as LiquidityTokens<T::AccountId>>::total_issuance(lp_token.clone());
let new_total_supply = LiquidityTokens::<T>::supply(lp_token);
assert_eq!(
new_total_supply,
total_supply - remove_lp_amount.into()
total_supply - remove_lp_amount
);
}
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 native = Coin::native();
let coin1 = Coin::Bitcoin;
let coin2 = Coin::Ether;
let (_, caller, _) = create_coin_and_pool::<T>(&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(),
SystemOrigin::Signed(caller).into(),
coin1,
200u64,
// TODO: this call otherwise fails with `InsufficientLiquidityMinted` if we don't multiply
// with 3. Might be again related to their expectance on ed being > 1.
100 * 3,
0u64,
0u64,
caller,
)?;
let swap_amount = 100.into();
let swap_amount = 100u64;
// 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>::create_pool(coin2)?;
Dex::<T>::add_liquidity(
SystemOrigin::Signed(caller.clone()).into(),
native.clone(),
coin2.clone(),
(500 * ed).into(),
1000.into(),
0.into(),
0.into(),
caller.clone(),
SystemOrigin::Signed(caller).into(),
coin2,
1000u64,
500,
0u64,
0u64,
caller,
)?;
let path = vec![coin1.clone(), native.clone(), coin2.clone()];
let path = vec![coin1, native, coin2];
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())
let native_balance = Coins::<T>::balance(caller, native).0;
let coin1_balance = Coins::<T>::balance(caller, Coin::Bitcoin).0;
}: _(SystemOrigin::Signed(caller), path, swap_amount, 1u64, caller)
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());
let new_coin1_balance = Coins::<T>::balance(caller, Coin::Bitcoin).0;
assert_eq!(new_coin1_balance, coin1_balance - 100u64);
}
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 native = Coin::native();
let coin1 = Coin::Bitcoin;
let coin2 = Coin::Ether;
let (_, caller, _) = create_coin_and_pool::<T>(&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(),
SystemOrigin::Signed(caller).into(),
coin1,
500u64,
1000,
0u64,
0u64,
caller,
)?;
// 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>::create_pool(coin2)?;
Dex::<T>::add_liquidity(
SystemOrigin::Signed(caller.clone()).into(),
native.clone(),
coin2.clone(),
(500 * ed).into(),
1000.into(),
0.into(),
0.into(),
caller.clone(),
SystemOrigin::Signed(caller).into(),
coin2,
1000u64,
500,
0u64,
0u64,
caller,
)?;
let path = vec![coin1.clone(), native.clone(), coin2.clone()];
let path = vec![coin1, native, coin2];
let path: BoundedVec<_, T::MaxSwapPathLength> = BoundedVec::try_from(path).unwrap();
let coin2_balance = T::Coins::balance(T::BenchmarkHelper::coin_id(2), &caller);
let coin2_balance = Coins::<T>::balance(caller, Coin::Ether).0;
}: _(
SystemOrigin::Signed(caller.clone()),
SystemOrigin::Signed(caller),
path.clone(),
100.into(),
(1000 * ed).into(),
caller.clone()
100u64,
1000,
caller
)
verify {
let new_coin2_balance = T::Coins::balance(T::BenchmarkHelper::coin_id(2), &caller);
assert_eq!(new_coin2_balance, coin2_balance + 100.into());
let new_coin2_balance = Coins::<T>::balance(caller, Coin::Ether).0;
assert_eq!(new_coin2_balance, coin2_balance + 100u64);
}
impl_benchmark_test_suite!(Dex, crate::mock::new_test_ext(), crate::mock::Test);

813
substrate/dex/pallet/src/lib.rs
View File

File diff suppressed because it is too large Load Diff

44
substrate/dex/pallet/src/mock.rs
View File

@@ -37,7 +37,6 @@ use sp_runtime::{
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>;
@@ -46,7 +45,7 @@ construct_runtime!(
{
System: frame_system,
CoinsPallet: coins,
LiquidityTokens: liquidity_tokens,
LiquidityTokens: coins::<Instance1>::{Pallet, Call, Storage, Event<T>},
Dex: dex,
}
);
@@ -81,54 +80,18 @@ impl coins::Config for Test {
type RuntimeEvent = RuntimeEvent;
}
impl liquidity_tokens::Config for Test {
impl coins::Config<coins::Instance1> 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 {
@@ -145,6 +108,7 @@ pub(crate) fn new_test_ext() -> sp_io::TestExternalities {
.into_iter()
.map(|a| (a, Balance { coin: Coin::Serai, amount: Amount(1 << 60) }))
.collect(),
_ignore: Default::default(),
}
.assimilate_storage(&mut t)
.unwrap();

881
substrate/dex/pallet/src/tests.rs
View File

File diff suppressed because it is too large Load Diff

64
substrate/dex/pallet/src/types.rs Normal file
View File

@@ -0,0 +1,64 @@
// 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.
use super::*;
use codec::{Decode, Encode, MaxEncodedLen};
use scale_info::TypeInfo;
/// Stores the lp_token coin id a particular pool has been assigned.
#[derive(Decode, Encode, Default, PartialEq, Eq, MaxEncodedLen, TypeInfo)]
pub struct PoolInfo<PoolCoinId> {
/// Liquidity pool coin
pub lp_token: PoolCoinId,
}
/// Trait for providing methods to swap between the various coin classes.
pub trait Swap<AccountId, Balance, MultiCoinId> {
/// Swap exactly `amount_in` of coin `path[0]` for coin `path[1]`.
/// If an `amount_out_min` is specified, it will return an error if it is unable to acquire
/// the amount desired.
///
/// Withdraws the `path[0]` coin from `sender`, deposits the `path[1]` coin to `send_to`,
///
/// If successful, returns the amount of `path[1]` acquired for the `amount_in`.
fn swap_exact_tokens_for_tokens(
sender: AccountId,
path: Vec<MultiCoinId>,
amount_in: Balance,
amount_out_min: Option<Balance>,
send_to: AccountId,
) -> Result<Balance, DispatchError>;
/// Take the `path[0]` coin and swap some amount for `amount_out` of the `path[1]`. If an
/// `amount_in_max` is specified, it will return an error if acquiring `amount_out` would be
/// too costly.
///
/// Withdraws `path[0]` coin from `sender`, deposits `path[1]` coin to `send_to`,
///
/// If successful returns the amount of the `path[0]` taken to provide `path[1]`.
fn swap_tokens_for_exact_tokens(
sender: AccountId,
path: Vec<MultiCoinId>,
amount_out: Balance,
amount_in_max: Option<Balance>,
send_to: AccountId,
) -> Result<Balance, DispatchError>;
}

42
substrate/dex/pallet/src/weights.rs
View File

@@ -18,7 +18,7 @@
// 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
//! Autogenerated weights for Dex Pallet.
//!
//! 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: `[]`
@@ -36,10 +36,10 @@
// --wasm-execution=compiled
// --heap-pages=4096
// --json-file=/builds/parity/mirrors/substrate/.git/.artifacts/bench.json
// --pallet=pallet_coin_conversion
// --pallet=serai_dex_pallet
// --chain=dev
// --header=./HEADER-APACHE2
// --output=./frame/coin-conversion/src/weights.rs
// --output=./substrate/dex/pallet/src/weights.rs
// --template=./.maintain/frame-weight-template.hbs
#![cfg_attr(rustfmt, rustfmt_skip)]
@@ -50,7 +50,7 @@
use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}};
use core::marker::PhantomData;
/// Weight functions needed for pallet_coin_conversion.
/// Weight functions needed for Dex Pallet.
pub trait WeightInfo {
fn create_pool() -> Weight;
fn add_liquidity() -> Weight;
@@ -59,19 +59,19 @@ pub trait WeightInfo {
fn swap_tokens_for_exact_tokens() -> Weight;
}
/// Weights for pallet_coin_conversion using the Substrate node and recommended hardware.
/// Weights for Dex Pallet 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: `DexPallet::Pools` (r:1 w:1)
/// Proof: `DexPallet::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: `DexPallet::NextPoolCoinId` (r:1 w:1)
/// Proof: `DexPallet::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)
@@ -85,8 +85,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
.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: `DexPallet::Pools` (r:1 w:0)
/// Proof: `DexPallet::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)
@@ -106,8 +106,8 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
.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: `DexPallet::Pools` (r:1 w:0)
/// Proof: `DexPallet::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)
@@ -161,16 +161,16 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
// 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: `DexPallet::Pools` (r:1 w:1)
/// Proof: `DexPallet::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: `DexPallet::NextPoolCoinId` (r:1 w:1)
/// Proof: `DexPallet::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)
@@ -184,8 +184,8 @@ impl WeightInfo for () {
.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: `DexPallet::Pools` (r:1 w:0)
/// Proof: `DexPallet::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)
@@ -205,8 +205,8 @@ impl WeightInfo for () {
.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: `DexPallet::Pools` (r:1 w:0)
/// Proof: `DexPallet::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)