Remove now-consolidated primitives crates

substrate/dex/src/benchmarking.rs

@@ -0,0 +1,230 @@
+// 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::BoundedVec};
+use frame_system::RawOrigin as SystemOrigin;
+
+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 LiquidityTokens<T> = coins_pallet::Pallet<T, coins_pallet::Instance1>;
+
+fn create_coin<T: Config>(coin: &ExternalCoin) -> (T::AccountId, AccountIdLookupOf<T>) {
+  let caller: T::AccountId = whitelisted_caller();
+  let caller_lookup = T::Lookup::unlookup(caller);
+  assert_ok!(Coins::<T>::mint(
+    caller,
+    Balance { coin: Coin::native(), amount: Amount(SubstrateAmount::MAX.div(1000u64)) }
+  ));
+  assert_ok!(Coins::<T>::mint(
+    caller,
+    Balance { coin: (*coin).into(), amount: Amount(INITIAL_COIN_BALANCE) }
+  ));
+  (caller, caller_lookup)
+}
+
+fn create_coin_and_pool<T: Config>(
+  coin: &ExternalCoin,
+) -> (ExternalCoin, T::AccountId, AccountIdLookupOf<T>) {
+  let (caller, caller_lookup) = create_coin::<T>(coin);
+  assert_ok!(Dex::<T>::create_pool(*coin));
+
+  (*coin, caller, caller_lookup)
+}
+
+benchmarks! {
+  add_liquidity {
+    let coin1 = Coin::native();
+    let coin2 = ExternalCoin::Bitcoin;
+    let (lp_token, caller, _) = create_coin_and_pool::<T>(&coin2);
+    let add_amount: u64 = 1000;
+  }: _(
+    SystemOrigin::Signed(caller),
+    coin2,
+    1000u64,
+    add_amount,
+    0u64,
+    0u64,
+    caller
+  )
+  verify {
+    let pool_id = Dex::<T>::get_pool_id(coin1, coin2.into()).unwrap();
+    let lp_minted = Dex::<T>::calc_lp_amount_for_zero_supply(
+      add_amount,
+      1000u64,
+    ).unwrap();
+    assert_eq!(
+      LiquidityTokens::<T>::balance(caller, lp_token.into()).0,
+      lp_minted
+    );
+    assert_eq!(
+      Coins::<T>::balance(Dex::<T>::get_pool_account(pool_id), Coin::native()).0,
+      add_amount
+    );
+    assert_eq!(
+      Coins::<T>::balance(
+        Dex::<T>::get_pool_account(pool_id),
+        ExternalCoin::Bitcoin.into(),
+      ).0,
+      1000
+    );
+  }
+
+  remove_liquidity {
+    let coin1 = Coin::native();
+    let coin2 = ExternalCoin::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,
+      1000u64
+    ).unwrap();
+    let remove_lp_amount: u64 = lp_minted.checked_div(10).unwrap();
+
+    Dex::<T>::add_liquidity(
+      SystemOrigin::Signed(caller).into(),
+      coin2,
+      1000u64,
+      add_amount,
+      0u64,
+      0u64,
+      caller,
+    )?;
+    let total_supply = LiquidityTokens::<T>::supply(Coin::from(lp_token));
+  }: _(
+    SystemOrigin::Signed(caller),
+    coin2,
+    remove_lp_amount,
+    0u64,
+    0u64,
+    caller
+  )
+  verify {
+    let new_total_supply =  LiquidityTokens::<T>::supply(Coin::from(lp_token));
+    assert_eq!(
+      new_total_supply,
+      total_supply - remove_lp_amount
+    );
+  }
+
+  swap_exact_tokens_for_tokens {
+    let native = Coin::native();
+    let coin1 = ExternalCoin::Bitcoin;
+    let coin2 = ExternalCoin::Ether;
+    let (_, caller, _) = create_coin_and_pool::<T>(&coin1);
+    let (_, _) = create_coin::<T>(&coin2);
+
+    Dex::<T>::add_liquidity(
+      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 = 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)?;
+    Dex::<T>::add_liquidity(
+      SystemOrigin::Signed(caller).into(),
+      coin2,
+      1000u64,
+      500,
+      0u64,
+      0u64,
+      caller,
+    )?;
+
+    let path = vec![Coin::from(coin1), native, Coin::from(coin2)];
+    let path = BoundedVec::<_, T::MaxSwapPathLength>::try_from(path).unwrap();
+    let native_balance = Coins::<T>::balance(caller, native).0;
+    let coin1_balance = Coins::<T>::balance(caller, ExternalCoin::Bitcoin.into()).0;
+  }: _(SystemOrigin::Signed(caller), path, swap_amount, 1u64, caller)
+  verify {
+    let ed_bump = 2u64;
+    let new_coin1_balance = Coins::<T>::balance(caller, ExternalCoin::Bitcoin.into()).0;
+    assert_eq!(new_coin1_balance, coin1_balance - 100u64);
+  }
+
+  swap_tokens_for_exact_tokens {
+    let native = Coin::native();
+    let coin1 = ExternalCoin::Bitcoin;
+    let coin2 = ExternalCoin::Ether;
+    let (_, caller, _) = create_coin_and_pool::<T>(&coin1);
+    let (_, _) = create_coin::<T>(&coin2);
+
+    Dex::<T>::add_liquidity(
+      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)?;
+    Dex::<T>::add_liquidity(
+      SystemOrigin::Signed(caller).into(),
+      coin2,
+      1000u64,
+      500,
+      0u64,
+      0u64,
+      caller,
+    )?;
+    let path = vec![Coin::from(coin1), native, Coin::from(coin2)];
+
+    let path: BoundedVec<_, T::MaxSwapPathLength> = BoundedVec::try_from(path).unwrap();
+    let coin2_balance = Coins::<T>::balance(caller, ExternalCoin::Ether.into()).0;
+  }: _(
+    SystemOrigin::Signed(caller),
+    path.clone(),
+    100u64,
+    1000,
+    caller
+  )
+  verify {
+    let new_coin2_balance = Coins::<T>::balance(caller, ExternalCoin::Ether.into()).0;
+    assert_eq!(new_coin2_balance, coin2_balance + 100u64);
+  }
+
+  impl_benchmark_test_suite!(Dex, crate::mock::new_test_ext(), crate::mock::Test);
+}

substrate/dex/src/mock.rs

@@ -0,0 +1,126 @@
+// 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::{ConstU16, 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;
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+pub const MEDIAN_PRICE_WINDOW_LENGTH: u16 = 10;
+
+construct_runtime!(
+  pub enum Test
+  {
+    System: frame_system,
+    CoinsPallet: coins,
+    LiquidityTokens: coins::<Instance1>::{Pallet, Call, Storage, Event<T>},
+    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;
+  type AllowMint = ();
+}
+
+impl coins::Config<coins::Instance1> for Test {
+  type RuntimeEvent = RuntimeEvent;
+  type AllowMint = ();
+}
+
+impl Config for Test {
+  type RuntimeEvent = RuntimeEvent;
+
+  type WeightInfo = ();
+  type LPFee = ConstU32<3>; // means 0.3%
+  type MaxSwapPathLength = ConstU32<4>;
+
+  type MedianPriceWindowLength = ConstU16<{ MEDIAN_PRICE_WINDOW_LENGTH }>;
+
+  // 100 is good enough when the main currency has 12 decimals.
+  type MintMinLiquidity = ConstU64<100>;
+}
+
+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(),
+    _ignore: Default::default(),
+  }
+  .assimilate_storage(&mut t)
+  .unwrap();
+
+  let mut ext = sp_io::TestExternalities::new(t);
+  ext.execute_with(|| System::set_block_number(1));
+  ext
+}

substrate/dex/src/types.rs

@@ -0,0 +1,54 @@
+// 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::*;
+
+/// 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>;
+}

substrate/dex/src/weights.rs

@@ -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 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: `[]`
+//! 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=serai_dex_pallet
+// --chain=dev
+// --header=./HEADER-APACHE2
+// --output=./substrate/dex/pallet/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 Dex Pallet.
+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 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: `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: `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)
+	/// 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: `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)
+	/// 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: `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)
+	/// 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: `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: `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)
+	/// 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: `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)
+	/// 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: `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)
+	/// 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))
+	}
+}