Asset Conversion pallet (#12984)

* Add pallet dex

* Fmt

* Add RPC endpoint

* Fix RPC

* Fix the build

* Some more fixes

* Add a method to topup pallet's account

* Add support for multi-currency into Uniques

* Fix the build

* Add [transactional] + setup() + fix balances

* Improve tests

* Fix price quotation

* Code clean up

* Validate swaps

* Fmt

* Update README

* add test

* mint LP assets in a different instance

* remove transactional as now the default

AssetsLocal renamed to Assets

* merge master

* Revert "Merge master"

* fix tests post merge.

* attempt to set create origin

* Internally allocate lp asset id.

* Simplify

* Bump to be in line

* additional bumps to make compile

* fix compile

* less bounds

* use fungible crates

* multiasset enum

* only allow native currency pairs

* added slippage tests

* transfer into separate method

(Also fee not set in 2 places now.)

Added test where lp and user are different users.

* Add benchmarks + weights

* Typos

* Clean up

* More tests,

split error into two because it wasn't clear which parameter.

renamed liquidity to lp_tokens_minted or lp_tokens_burned in events.

* tighten up naming

* Default, zero, square root traits not needed

Also let's not force people to be compact

* add keep-alive param

* add insufficient liquidity test

* Fix quote() to support u64

* Avoid recording balances twice

* cargo fmt

* Didn't mean to change error type

* temp

* Less

* Rework get_amount_in/get_amount_out

* Convert other places

* Rework the last piece

* Typo

* Fix benchmarks

* use hash trait

* Extract a native asset check into the runtime setting

* Don't set the metadata

* Remove spec file

* Enable multi-assets swaps by default

* Refactor conversion into u128

* Add path param to swap_token_for_exact_tokens

* Fix typo + a bit of refactoring

* Implement path param for swap_exact_tokens_for_tokens()

* Deref

* Minor fixes

* Add test with sensible scale values

* Use .windows()

* Fix benchmarks

* update docs

* Fix everything :)

* Chore

* Revert

* Chore

* prev way of creating sub accounts lead to collisions

* Update frame/dex/src/lib.rs

Co-authored-by: Jegor Sidorenko <5252494+jsidorenko@users.noreply.github.com>

* Update frame/dex/src/lib.rs

Co-authored-by: Jegor Sidorenko <5252494+jsidorenko@users.noreply.github.com>

* Chore

* Fmt fix on Uniques

* add call_index

bring code up to date with latest master

* revert readme changes

* add cr

* revert uniques changes

* reducing noise

* no need for deadline (#12990)

(there's generic transaction deadline functionality already)

* fix kitchen sink (#12991)

* fix kitchen sink

* Only the dex can mint lp_tokens

* add BenchmarkHelper for second instance (#12998)

* update mock to latest master

* less indirections (#13012)

* remove dex PR's custom RPC (#13050)

* As we have state_call we don't need a custom RPC

* fix docs

* no longer a need to upgrade rpc version (#13053)

* add CallbackHadle

* quote bugfix (#13191)

quote was giving same price in both directions as we were inverting needlessly.

* merging in dex specific changes due to pay by dex

* update lock file

* merging in kitchen sink changes

* Add get_reserves() api method

* Partial updating of the benchmarks

* Fix tests

* clippy

* Temp fix weights

* Fix benchmarks

* Add pool setup fee

* Money upfront

* Address some comments

* Use u128 in mock

* Fix benchmarks

* Change error message

* Update comments

* Change error names

* Implement PartialOrd for NativeOrAssetId

* add note

* Update errors

* More tests for assets sorting

* ".git/.scripts/commands/bench/bench.sh" pallet dev pallet_dex

* Change the way we generate pool accounts

* Improve the liquidity removal method

* Extract MintMinLiquidity to config, rework all tests

* Add comments

* Validate provided amount

* Rename to asset-conversion

* Validate ED

* Improve handling the ED related errors

* typos

* Try to fix benchmarks

* Another try

* Another day, another try

* Fix benchmarks

* Expose fee related params

* Validate token's minimal amount the same way as ED

* fix typo

* Use longer path for swaps in benchmarks

* need to ref sp_std's vec.

* Remove From<u32> requirement when benchmarking

* impl BenchmarkHelper for ()

* only for runtime benchmarks

* MultiLocation: !MaybeDisplay

Looks like we might not need this bound from initial testing.

* Update frame/asset-conversion/src/lib.rs

Co-authored-by: Jegor Sidorenko <5252494+jsidorenko@users.noreply.github.com>

* Update frame/asset-conversion/src/lib.rs

Co-authored-by: Jegor Sidorenko <5252494+jsidorenko@users.noreply.github.com>

* Add documentation links

* add collision test

* Revert "[Enhancement] Throw an error when there are too many pallets (#13763)"

This reverts commit cc3152bc2f.

* [Enhancement] Throw an error when there are too many pallets (#13763)

* [Enhancement] Throw an error when there are too many pallets

* fix ui test

* fix PR comments

* Update frame/support/procedural/src/construct_runtime/mod.rs

Co-authored-by: Bastian Köcher <git@kchr.de>

* Update frame/support/procedural/src/construct_runtime/mod.rs

Co-authored-by: Bastian Köcher <git@kchr.de>

* ".git/.scripts/commands/fmt/fmt.sh"

---------

Co-authored-by: Bastian Köcher <git@kchr.de>
Co-authored-by: command-bot <>

* add benchmark helper

+ doc fix

* cargo fmt

* Fix adding liquidity to non-empty pool

* Fix compilation error

* Fix params ordering issue

* additional docs

* The swap path elements should be unique

* Fix account collision

* Validate all the pool in a swap path are unique

* Change the way we add liquidity to empty pools

* Improve docs

* remove unnessisary Display impl

* cargo fmt

* remove unused imports

* Make api consistent

* Chore

* Touch the pool account so it could hold the pair tokens

* Check the balance before touching the pool's account

* Introduce liquidity provision fee

* Touch the pool acc one more time

* Apply suggestions from code review

Co-authored-by: Sam Johnson <sam@durosoft.com>

* Update frame/asset-conversion/README.md

Co-authored-by: Sam Johnson <sam@durosoft.com>

* Use ContainsPair instead of the balance checker

* Remove old Currency trait

* Add liquidity withdrawal fee

* Update docs

* Use 0 withdrawal fee in mock

* Rename vars

* asset id not clone

* fix: shadow var was being used

* correct tests

* fix benches

* merge master

* neater

---------

Co-authored-by: Jegor Sidorenko <jegor@parity.io>
Co-authored-by: Jegor Sidorenko <5252494+jsidorenko@users.noreply.github.com>
Co-authored-by: parity-processbot <>
Co-authored-by: Roman Useinov <roman.useinov@gmail.com>
Co-authored-by: Bastian Köcher <git@kchr.de>
Co-authored-by: Sam Johnson <sam@durosoft.com>

substrate/frame/asset-conversion/src/benchmarking.rs

@@ -0,0 +1,287 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2020-2022 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.
+
+//! Asset Conversion pallet benchmarking.
+
+#![cfg(feature = "runtime-benchmarks")]
+
+use super::*;
+use frame_benchmarking::{benchmarks, whitelisted_caller};
+use frame_support::{
+	assert_ok,
+	storage::bounded_vec::BoundedVec,
+	traits::{
+		fungible::{Inspect as InspectFungible, Unbalanced},
+		fungibles::{Create, Inspect, Mutate},
+	},
+};
+use frame_system::RawOrigin as SystemOrigin;
+use sp_runtime::traits::{Bounded, StaticLookup};
+use sp_std::prelude::*;
+
+use crate::Pallet as AssetConversion;
+
+const INITIAL_ASSET_BALANCE: u128 = 1_000_000_000_000;
+type AccountIdLookupOf<T> = <<T as frame_system::Config>::Lookup as StaticLookup>::Source;
+type BalanceOf<T> =
+	<<T as Config>::Currency as InspectFungible<<T as frame_system::Config>::AccountId>>::Balance;
+
+fn get_lp_token_id<T: Config>() -> T::PoolAssetId
+where
+	T::PoolAssetId: Into<u32>,
+{
+	let next_id: u32 = AssetConversion::<T>::get_next_pool_asset_id().into();
+	(next_id - 1).into()
+}
+
+fn create_asset<T: Config>(asset: &T::MultiAssetId) -> (T::AccountId, AccountIdLookupOf<T>)
+where
+	T::AssetBalance: From<u128>,
+	T::Currency: Unbalanced<T::AccountId>,
+	T::Assets: Create<T::AccountId> + Mutate<T::AccountId>,
+{
+	let caller: T::AccountId = whitelisted_caller();
+	let caller_lookup = T::Lookup::unlookup(caller.clone());
+	if let Ok(asset_id) = T::MultiAssetIdConverter::try_convert(asset) {
+		assert_ok!(T::Currency::write_balance(&caller, BalanceOf::<T>::max_value()));
+		assert_ok!(T::Assets::create(asset_id.clone(), caller.clone(), true, 1.into()));
+		assert_ok!(T::Assets::mint_into(asset_id, &caller, INITIAL_ASSET_BALANCE.into()));
+	}
+	(caller, caller_lookup)
+}
+
+fn create_asset_and_pool<T: Config>(
+	asset1: &T::MultiAssetId,
+	asset2: &T::MultiAssetId,
+) -> (T::PoolAssetId, T::AccountId, AccountIdLookupOf<T>)
+where
+	T::AssetBalance: From<u128>,
+	T::Currency: Unbalanced<T::AccountId>,
+	T::Assets: Create<T::AccountId> + Mutate<T::AccountId>,
+	T::PoolAssetId: Into<u32>,
+{
+	let (_, _) = create_asset::<T>(asset1);
+	let (caller, caller_lookup) = create_asset::<T>(asset2);
+
+	assert_ok!(AssetConversion::<T>::create_pool(
+		SystemOrigin::Signed(caller.clone()).into(),
+		asset1.clone(),
+		asset2.clone()
+	));
+	let lp_token = get_lp_token_id::<T>();
+
+	(lp_token, caller, caller_lookup)
+}
+
+fn assert_last_event<T: Config>(generic_event: <T as Config>::RuntimeEvent) {
+	let events = frame_system::Pallet::<T>::events();
+	let system_event: <T as frame_system::Config>::RuntimeEvent = generic_event.into();
+	// compare to the last event record
+	let frame_system::EventRecord { event, .. } = &events[events.len() - 1];
+	assert_eq!(event, &system_event);
+}
+
+benchmarks! {
+	where_clause {
+		where
+			T::AssetBalance: From<u128> + Into<u128>,
+			T::Currency: Unbalanced<T::AccountId>,
+			T::Balance: From<u128> + Into<u128>,
+			T::Assets: Create<T::AccountId> + Mutate<T::AccountId>,
+			T::PoolAssetId: Into<u32>,
+	}
+
+	create_pool {
+		let asset1 = T::MultiAssetIdConverter::get_native();
+		let asset2 = T::MultiAssetIdConverter::into_multiasset_id(&T::BenchmarkHelper::asset_id(0_u32));
+		let (caller, _) = create_asset::<T>(&asset2);
+	}: _(SystemOrigin::Signed(caller.clone()), asset1.clone(), asset2.clone())
+	verify {
+		let lp_token = get_lp_token_id::<T>();
+		let pool_id = (asset1.clone(), asset2.clone());
+		assert_last_event::<T>(Event::PoolCreated { creator: caller.clone(), pool_id, lp_token }.into());
+	}
+
+	add_liquidity {
+		let asset1 = T::MultiAssetIdConverter::get_native();
+		let asset2 = T::MultiAssetIdConverter::into_multiasset_id(&T::BenchmarkHelper::asset_id(0));
+		let (lp_token, caller, _) = create_asset_and_pool::<T>(&asset1, &asset2);
+		let ed: u128 = T::Currency::minimum_balance().into();
+		let add_amount = 1000 + ed;
+	}: _(SystemOrigin::Signed(caller.clone()), asset1.clone(), asset2.clone(), add_amount.into(), 1000.into(), 0.into(), 0.into(), caller.clone())
+	verify {
+		let pool_id = (asset1.clone(), asset2.clone());
+		let lp_minted = AssetConversion::<T>::calc_lp_amount_for_zero_supply(&add_amount.into(), &1000.into()).unwrap().into();
+		assert_eq!(
+			T::PoolAssets::balance(lp_token, &caller),
+			lp_minted.into()
+		);
+		assert_eq!(
+			T::Currency::balance(&AssetConversion::<T>::get_pool_account(&pool_id)),
+			add_amount.into()
+		);
+		assert_eq!(
+			T::Assets::balance(T::BenchmarkHelper::asset_id(0), &AssetConversion::<T>::get_pool_account(&pool_id)),
+			1000.into()
+		);
+	}
+
+	remove_liquidity {
+		let asset1 = T::MultiAssetIdConverter::get_native();
+		let asset2 = T::MultiAssetIdConverter::into_multiasset_id(&T::BenchmarkHelper::asset_id(0));
+		let (lp_token, caller, _) = create_asset_and_pool::<T>(&asset1, &asset2);
+		let ed: u128 = T::Currency::minimum_balance().into();
+		let add_amount = 100 * ed;
+		let lp_minted = AssetConversion::<T>::calc_lp_amount_for_zero_supply(&add_amount.into(), &1000.into()).unwrap().into();
+		let remove_lp_amount = lp_minted.checked_div(10).unwrap();
+
+		AssetConversion::<T>::add_liquidity(
+			SystemOrigin::Signed(caller.clone()).into(),
+			asset1.clone(),
+			asset2.clone(),
+			add_amount.into(),
+			1000.into(),
+			0.into(),
+			0.into(),
+			caller.clone(),
+		)?;
+		let total_supply = <T::PoolAssets as Inspect<T::AccountId>>::total_issuance(lp_token.clone());
+	}: _(SystemOrigin::Signed(caller.clone()), asset1, asset2, remove_lp_amount.into(), 0.into(), 0.into(), caller.clone())
+	verify {
+		let new_total_supply = <T::PoolAssets as Inspect<T::AccountId>>::total_issuance(lp_token.clone());
+		assert_eq!(
+			new_total_supply,
+			total_supply - remove_lp_amount.into()
+		);
+	}
+
+	swap_exact_tokens_for_tokens {
+		let asset1 = T::MultiAssetIdConverter::get_native();
+		let asset2 = T::MultiAssetIdConverter::into_multiasset_id(&T::BenchmarkHelper::asset_id(0));
+		let asset3 = T::MultiAssetIdConverter::into_multiasset_id(&T::BenchmarkHelper::asset_id(1));
+		let asset4 = T::MultiAssetIdConverter::into_multiasset_id(&T::BenchmarkHelper::asset_id(2));
+
+		let (_, caller, _) = create_asset_and_pool::<T>(&asset1, &asset2);
+		let (_, _) = create_asset::<T>(&asset3);
+		AssetConversion::<T>::create_pool(SystemOrigin::Signed(caller.clone()).into(), asset2.clone(), asset3.clone())?;
+		let (_, _) = create_asset::<T>(&asset4);
+		AssetConversion::<T>::create_pool(SystemOrigin::Signed(caller.clone()).into(), asset3.clone(), asset4.clone())?;
+
+		let path: BoundedVec<_, T::MaxSwapPathLength> =
+			BoundedVec::try_from(vec![asset1.clone(), asset2.clone(), asset3.clone(), asset4.clone()]).unwrap();
+		let ed: u128 = T::Currency::minimum_balance().into();
+		let add_amount1 = 100 * ed;
+
+		AssetConversion::<T>::add_liquidity(
+			SystemOrigin::Signed(caller.clone()).into(),
+			asset1.clone(),
+			asset2.clone(),
+			add_amount1.into(),
+			200.into(),
+			0.into(),
+			0.into(),
+			caller.clone(),
+		)?;
+		AssetConversion::<T>::add_liquidity(
+			SystemOrigin::Signed(caller.clone()).into(),
+			asset2.clone(),
+			asset3.clone(),
+			200.into(),
+			2000.into(),
+			0.into(),
+			0.into(),
+			caller.clone(),
+		)?;
+		AssetConversion::<T>::add_liquidity(
+			SystemOrigin::Signed(caller.clone()).into(),
+			asset3.clone(),
+			asset4.clone(),
+			2000.into(),
+			2000.into(),
+			0.into(),
+			0.into(),
+			caller.clone(),
+		)?;
+		let asset1_balance = T::Currency::balance(&caller);
+	}: _(SystemOrigin::Signed(caller.clone()), path.clone(), ed.into(), 1.into(), caller.clone(), false)
+	verify {
+		let new_asset1_balance = T::Currency::balance(&caller);
+		assert_eq!(
+			new_asset1_balance,
+			asset1_balance - ed.into()
+		);
+	}
+
+	swap_tokens_for_exact_tokens {
+		let asset1 = T::MultiAssetIdConverter::get_native();
+		let asset2 = T::MultiAssetIdConverter::into_multiasset_id(&T::BenchmarkHelper::asset_id(0));
+		let asset3 = T::MultiAssetIdConverter::into_multiasset_id(&T::BenchmarkHelper::asset_id(1));
+		let asset4 = T::MultiAssetIdConverter::into_multiasset_id(&T::BenchmarkHelper::asset_id(2));
+
+		let (_, caller, _) = create_asset_and_pool::<T>(&asset1, &asset2);
+		let (_, _) = create_asset::<T>(&asset3);
+		AssetConversion::<T>::create_pool(SystemOrigin::Signed(caller.clone()).into(), asset2.clone(), asset3.clone())?;
+		let (_, _) = create_asset::<T>(&asset4);
+		AssetConversion::<T>::create_pool(SystemOrigin::Signed(caller.clone()).into(), asset3.clone(), asset4.clone())?;
+
+		let path: BoundedVec<_, T::MaxSwapPathLength> =
+			BoundedVec::try_from(vec![asset1.clone(), asset2.clone(), asset3.clone(), asset4.clone()]).unwrap();
+		let ed: u128 = T::Currency::minimum_balance().into();
+		let add_amount1 = 1000 + ed;
+
+		AssetConversion::<T>::add_liquidity(
+			SystemOrigin::Signed(caller.clone()).into(),
+			asset1.clone(),
+			asset2.clone(),
+			add_amount1.into(),
+			200.into(),
+			0.into(),
+			0.into(),
+			caller.clone(),
+		)?;
+		AssetConversion::<T>::add_liquidity(
+			SystemOrigin::Signed(caller.clone()).into(),
+			asset2.clone(),
+			asset3.clone(),
+			200.into(),
+			2000.into(),
+			0.into(),
+			0.into(),
+			caller.clone(),
+		)?;
+		AssetConversion::<T>::add_liquidity(
+			SystemOrigin::Signed(caller.clone()).into(),
+			asset3.clone(),
+			asset4.clone(),
+			2000.into(),
+			2000.into(),
+			0.into(),
+			0.into(),
+			caller.clone(),
+		)?;
+		let asset4_balance = T::Assets::balance(T::BenchmarkHelper::asset_id(2), &caller);
+	}: _(SystemOrigin::Signed(caller.clone()), path.clone(), 100.into(), add_amount1.into(), caller.clone(), false)
+	verify {
+		let new_asset4_balance = T::Assets::balance(T::BenchmarkHelper::asset_id(2), &caller);
+		assert_eq!(
+			new_asset4_balance,
+			asset4_balance + 100.into()
+		);
+	}
+
+	impl_benchmark_test_suite!(AssetConversion, crate::mock::new_test_ext(), crate::mock::Test);
+}

substrate/frame/asset-conversion/src/mock.rs

@@ -0,0 +1,197 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2019-2022 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.
+
+//! Test environment for Asset Conversion pallet.
+
+use super::*;
+use crate as pallet_asset_conversion;
+
+use frame_support::{
+	construct_runtime,
+	instances::{Instance1, Instance2},
+	ord_parameter_types, parameter_types,
+	traits::{AsEnsureOriginWithArg, ConstU128, ConstU32, ConstU64},
+	PalletId,
+};
+use frame_system::{EnsureSigned, EnsureSignedBy};
+use sp_arithmetic::Permill;
+use sp_core::H256;
+use sp_runtime::{
+	testing::Header,
+	traits::{AccountIdConversion, BlakeTwo256, IdentityLookup},
+};
+
+type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic<Test>;
+type Block = frame_system::mocking::MockBlock<Test>;
+
+construct_runtime!(
+	pub enum Test where
+		Block = Block,
+		NodeBlock = Block,
+		UncheckedExtrinsic = UncheckedExtrinsic,
+	{
+		System: frame_system,
+		Balances: pallet_balances,
+		Assets: pallet_assets::<Instance1>,
+		PoolAssets: pallet_assets::<Instance2>,
+		AssetConversion: pallet_asset_conversion,
+	}
+);
+
+impl frame_system::Config for Test {
+	type BaseCallFilter = frame_support::traits::Everything;
+	type BlockWeights = ();
+	type BlockLength = ();
+	type RuntimeOrigin = RuntimeOrigin;
+	type RuntimeCall = RuntimeCall;
+	type Index = u64;
+	type BlockNumber = u64;
+	type Hash = H256;
+	type Hashing = BlakeTwo256;
+	type AccountId = u128;
+	type Lookup = IdentityLookup<Self::AccountId>;
+	type Header = Header;
+	type RuntimeEvent = RuntimeEvent;
+	type BlockHashCount = ConstU64<250>;
+	type DbWeight = ();
+	type Version = ();
+	type PalletInfo = PalletInfo;
+	type AccountData = pallet_balances::AccountData<u128>;
+	type OnNewAccount = ();
+	type OnKilledAccount = ();
+	type SystemWeightInfo = ();
+	type SS58Prefix = ();
+	type OnSetCode = ();
+	type MaxConsumers = ConstU32<16>;
+}
+
+impl pallet_balances::Config for Test {
+	type Balance = u128;
+	type DustRemoval = ();
+	type RuntimeEvent = RuntimeEvent;
+	type ExistentialDeposit = ConstU128<100>;
+	type AccountStore = System;
+	type WeightInfo = ();
+	type MaxLocks = ();
+	type MaxReserves = ConstU32<50>;
+	type ReserveIdentifier = [u8; 8];
+	type FreezeIdentifier = ();
+	type MaxFreezes = ();
+	type RuntimeHoldReason = ();
+	type MaxHolds = ();
+}
+
+impl pallet_assets::Config<Instance1> for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type Balance = u128;
+	type RemoveItemsLimit = ConstU32<1000>;
+	type AssetId = u32;
+	type AssetIdParameter = u32;
+	type Currency = Balances;
+	type CreateOrigin = AsEnsureOriginWithArg<EnsureSigned<Self::AccountId>>;
+	type ForceOrigin = frame_system::EnsureRoot<Self::AccountId>;
+	type AssetDeposit = ConstU128<1>;
+	type AssetAccountDeposit = ConstU128<10>;
+	type MetadataDepositBase = ConstU128<1>;
+	type MetadataDepositPerByte = ConstU128<1>;
+	type ApprovalDeposit = ConstU128<1>;
+	type StringLimit = ConstU32<50>;
+	type Freezer = ();
+	type Extra = ();
+	type WeightInfo = ();
+	type CallbackHandle = ();
+	pallet_assets::runtime_benchmarks_enabled! {
+		type BenchmarkHelper = ();
+	}
+}
+
+impl pallet_assets::Config<Instance2> for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type Balance = u128;
+	type RemoveItemsLimit = ConstU32<1000>;
+	type AssetId = u32;
+	type AssetIdParameter = u32;
+	type Currency = Balances;
+	type CreateOrigin =
+		AsEnsureOriginWithArg<EnsureSignedBy<AssetConversionOrigin, Self::AccountId>>;
+	type ForceOrigin = frame_system::EnsureRoot<Self::AccountId>;
+	type AssetDeposit = ConstU128<0>;
+	type AssetAccountDeposit = ConstU128<0>;
+	type MetadataDepositBase = ConstU128<0>;
+	type MetadataDepositPerByte = ConstU128<0>;
+	type ApprovalDeposit = ConstU128<0>;
+	type StringLimit = ConstU32<50>;
+	type Freezer = ();
+	type Extra = ();
+	type WeightInfo = ();
+	type CallbackHandle = ();
+	pallet_assets::runtime_benchmarks_enabled! {
+		type BenchmarkHelper = ();
+	}
+}
+
+parameter_types! {
+	pub const AssetConversionPalletId: PalletId = PalletId(*b"py/ascon");
+	pub storage AllowMultiAssetPools: bool = true;
+	pub storage LiquidityWithdrawalFee: Permill = Permill::from_percent(0); // should be non-zero if AllowMultiAssetPools is true, otherwise can be zero
+}
+
+ord_parameter_types! {
+	pub const AssetConversionOrigin: u128 = AccountIdConversion::<u128>::into_account_truncating(&AssetConversionPalletId::get());
+}
+
+impl Config for Test {
+	type RuntimeEvent = RuntimeEvent;
+	type Currency = Balances;
+	type AssetBalance = <Self as pallet_balances::Config>::Balance;
+	type AssetId = u32;
+	type PoolAssetId = u32;
+	type Assets = Assets;
+	type PoolAssets = PoolAssets;
+	type PalletId = AssetConversionPalletId;
+	type WeightInfo = ();
+	type LPFee = ConstU32<3>; // means 0.3%
+	type PoolSetupFee = ConstU128<100>; // should be more or equal to the existential deposit
+	type PoolSetupFeeReceiver = AssetConversionOrigin;
+	type LiquidityWithdrawalFee = LiquidityWithdrawalFee;
+	type AllowMultiAssetPools = AllowMultiAssetPools;
+	type MaxSwapPathLength = ConstU32<4>;
+	type MintMinLiquidity = ConstU128<100>; // 100 is good enough when the main currency has 12 decimals.
+
+	type Balance = u128;
+	type HigherPrecisionBalance = sp_core::U256;
+
+	type MultiAssetId = NativeOrAssetId<u32>;
+	type MultiAssetIdConverter = NativeOrAssetIdConverter<u32>;
+
+	#[cfg(feature = "runtime-benchmarks")]
+	type BenchmarkHelper = ();
+}
+
+pub(crate) fn new_test_ext() -> sp_io::TestExternalities {
+	let mut t = frame_system::GenesisConfig::default().build_storage::<Test>().unwrap();
+
+	pallet_balances::GenesisConfig::<Test> {
+		balances: vec![(1, 10000), (2, 20000), (3, 30000), (4, 40000)],
+	}
+	.assimilate_storage(&mut t)
+	.unwrap();
+
+	let mut ext = sp_io::TestExternalities::new(t);
+	ext.execute_with(|| System::set_block_number(1));
+	ext
+}

substrate/frame/asset-conversion/src/types.rs

@@ -0,0 +1,131 @@
+// This file is part of Substrate.
+
+// Copyright (C) 2022 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.
+
+use super::*;
+use core::marker::PhantomData;
+use sp_std::cmp::Ordering;
+
+use codec::{Decode, Encode, MaxEncodedLen};
+use frame_support::traits::fungibles::Inspect;
+use scale_info::TypeInfo;
+
+pub(super) type AssetBalanceOf<T> =
+	<<T as Config>::Assets as Inspect<<T as frame_system::Config>::AccountId>>::Balance;
+pub(super) type PoolIdOf<T> = (<T as Config>::MultiAssetId, <T as Config>::MultiAssetId);
+
+/// Stores the lp_token asset id a particular pool has been assigned.
+#[derive(Decode, Encode, Default, PartialEq, Eq, MaxEncodedLen, TypeInfo)]
+pub struct PoolInfo<PoolAssetId> {
+	/// Liquidity pool asset
+	pub lp_token: PoolAssetId,
+}
+
+/// A trait that converts between a MultiAssetId and either the native currency or an AssetId.
+pub trait MultiAssetIdConverter<MultiAssetId, AssetId> {
+	/// Returns the MultiAssetId reperesenting the native currency of the chain.
+	fn get_native() -> MultiAssetId;
+
+	/// Returns true if the given MultiAssetId is the native currency.
+	fn is_native(asset: &MultiAssetId) -> bool;
+
+	/// If it's not native, returns the AssetId for the given MultiAssetId.
+	fn try_convert(asset: &MultiAssetId) -> Result<AssetId, ()>;
+
+	/// Wrapps an AssetId as a MultiAssetId.
+	fn into_multiasset_id(asset: &AssetId) -> MultiAssetId;
+}
+
+/// Benchmark Helper
+#[cfg(feature = "runtime-benchmarks")]
+pub trait BenchmarkHelper<AssetId> {
+	/// Returns an asset id from a given integer.
+	fn asset_id(asset_id: u32) -> AssetId;
+}
+
+#[cfg(feature = "runtime-benchmarks")]
+impl<AssetId> BenchmarkHelper<AssetId> for ()
+where
+	AssetId: From<u32>,
+{
+	fn asset_id(asset_id: u32) -> AssetId {
+		asset_id.into()
+	}
+}
+
+/// An implementation of MultiAssetId that can be either Native or an asset.
+#[derive(Decode, Encode, Default, MaxEncodedLen, TypeInfo, Clone, Copy, Debug)]
+pub enum NativeOrAssetId<AssetId>
+where
+	AssetId: Ord,
+{
+	/// Native asset. For example, on statemint this would be dot.
+	#[default]
+	Native,
+	/// A non-native asset id.
+	Asset(AssetId),
+}
+
+impl<AssetId: Ord> Ord for NativeOrAssetId<AssetId> {
+	fn cmp(&self, other: &Self) -> Ordering {
+		match (self, other) {
+			(Self::Native, Self::Native) => Ordering::Equal,
+			(Self::Native, Self::Asset(_)) => Ordering::Less,
+			(Self::Asset(_), Self::Native) => Ordering::Greater,
+			(Self::Asset(id1), Self::Asset(id2)) => <AssetId as Ord>::cmp(id1, id2),
+		}
+	}
+}
+impl<AssetId: Ord> PartialOrd for NativeOrAssetId<AssetId> {
+	fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+		Some(<Self as Ord>::cmp(self, other))
+	}
+}
+impl<AssetId: Ord> PartialEq for NativeOrAssetId<AssetId> {
+	fn eq(&self, other: &Self) -> bool {
+		self.cmp(other) == Ordering::Equal
+	}
+}
+impl<AssetId: Ord> Eq for NativeOrAssetId<AssetId> {}
+
+/// Converts between a MultiAssetId and an AssetId
+/// (or the native currency).
+pub struct NativeOrAssetIdConverter<AssetId> {
+	_phantom: PhantomData<AssetId>,
+}
+
+impl<AssetId: Ord + Clone> MultiAssetIdConverter<NativeOrAssetId<AssetId>, AssetId>
+	for NativeOrAssetIdConverter<AssetId>
+{
+	fn get_native() -> NativeOrAssetId<AssetId> {
+		NativeOrAssetId::Native
+	}
+
+	fn is_native(asset: &NativeOrAssetId<AssetId>) -> bool {
+		*asset == Self::get_native()
+	}
+
+	fn try_convert(asset: &NativeOrAssetId<AssetId>) -> Result<AssetId, ()> {
+		match asset {
+			NativeOrAssetId::Asset(asset) => Ok(asset.clone()),
+			NativeOrAssetId::Native => Err(()),
+		}
+	}
+
+	fn into_multiasset_id(asset: &AssetId) -> NativeOrAssetId<AssetId> {
+		NativeOrAssetId::Asset((*asset).clone())
+	}
+}

substrate/frame/asset-conversion/src/weights.rs

@@ -0,0 +1,245 @@
+// This file is part of Substrate.
+
+// 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.
+
+//! Autogenerated weights for pallet_dex
+//!
+//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
+//! DATE: 2023-03-24, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! WORST CASE MAP SIZE: `1000000`
+//! HOSTNAME: `bm3`, CPU: `Intel(R) Core(TM) i7-7700K CPU @ 4.20GHz`
+//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
+
+// Executed Command:
+// target/production/substrate
+// benchmark
+// pallet
+// --steps=50
+// --repeat=20
+// --extrinsic=*
+// --execution=wasm
+// --wasm-execution=compiled
+// --heap-pages=4096
+// --json-file=/var/lib/gitlab-runner/builds/zyw4fam_/0/parity/mirrors/substrate/.git/.artifacts/bench.json
+// --pallet=pallet_dex
+// --chain=dev
+// --header=./HEADER-APACHE2
+// --output=./frame/dex/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 sp_std::marker::PhantomData;
+
+/// Weight functions needed for pallet_dex.
+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_dex using the Substrate node and recommended hardware.
+pub struct SubstrateWeight<T>(PhantomData<T>);
+impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
+	/// Storage: Dex Pools (r:1 w:1)
+	/// Proof: Dex 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: Dex NextPoolAssetId (r:1 w:1)
+	/// Proof: Dex NextPoolAssetId (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: PoolAssets Asset (r:1 w:1)
+	/// Proof: PoolAssets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	fn create_pool() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `323`
+		//  Estimated: `14855`
+		// Minimum execution time: 72_228_000 picoseconds.
+		Weight::from_parts(72_932_000, 14855)
+			.saturating_add(T::DbWeight::get().reads(5_u64))
+			.saturating_add(T::DbWeight::get().writes(5_u64))
+	}
+	/// Storage: Dex Pools (r:1 w:0)
+	/// Proof: Dex 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: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Account (r:2 w:2)
+	/// Proof: Assets Account (max_values: None, max_size: Some(102), added: 2577, mode: MaxEncodedLen)
+	/// Storage: PoolAssets Asset (r:1 w:1)
+	/// Proof: PoolAssets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: PoolAssets Account (r:2 w:2)
+	/// Proof: PoolAssets Account (max_values: None, max_size: Some(102), added: 2577, mode: MaxEncodedLen)
+	fn add_liquidity() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1232`
+		//  Estimated: `26726`
+		// Minimum execution time: 137_656_000 picoseconds.
+		Weight::from_parts(138_526_000, 26726)
+			.saturating_add(T::DbWeight::get().reads(8_u64))
+			.saturating_add(T::DbWeight::get().writes(7_u64))
+	}
+	/// Storage: Dex Pools (r:1 w:0)
+	/// Proof: Dex Pools (max_values: None, max_size: Some(30), added: 2505, mode: MaxEncodedLen)
+	/// Storage: PoolAssets Asset (r:1 w:1)
+	/// Proof: PoolAssets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: PoolAssets Account (r:2 w:2)
+	/// Proof: PoolAssets Account (max_values: None, max_size: Some(102), added: 2577, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Account (r:2 w:2)
+	/// Proof: Assets Account (max_values: None, max_size: Some(102), added: 2577, mode: MaxEncodedLen)
+	fn remove_liquidity() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1496`
+		//  Estimated: `26726`
+		// Minimum execution time: 159_778_000 picoseconds.
+		Weight::from_parts(160_730_000, 26726)
+			.saturating_add(T::DbWeight::get().reads(8_u64))
+			.saturating_add(T::DbWeight::get().writes(7_u64))
+	}
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: Assets Asset (r:2 w:2)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Account (r:4 w:4)
+	/// Proof: Assets Account (max_values: None, max_size: Some(102), added: 2577, mode: MaxEncodedLen)
+	fn swap_exact_tokens_for_tokens() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1134`
+		//  Estimated: `21251`
+		// Minimum execution time: 136_852_000 picoseconds.
+		Weight::from_parts(137_764_000, 21251)
+			.saturating_add(T::DbWeight::get().reads(7_u64))
+			.saturating_add(T::DbWeight::get().writes(7_u64))
+	}
+	/// Storage: Assets Asset (r:2 w:2)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Account (r:4 w:4)
+	/// Proof: Assets Account (max_values: None, max_size: Some(102), added: 2577, 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:  `1134`
+		//  Estimated: `21251`
+		// Minimum execution time: 136_660_000 picoseconds.
+		Weight::from_parts(137_522_000, 21251)
+			.saturating_add(T::DbWeight::get().reads(7_u64))
+			.saturating_add(T::DbWeight::get().writes(7_u64))
+	}
+}
+
+// For backwards compatibility and tests
+impl WeightInfo for () {
+	/// Storage: Dex Pools (r:1 w:1)
+	/// Proof: Dex 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: Dex NextPoolAssetId (r:1 w:1)
+	/// Proof: Dex NextPoolAssetId (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: PoolAssets Asset (r:1 w:1)
+	/// Proof: PoolAssets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	fn create_pool() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `323`
+		//  Estimated: `14855`
+		// Minimum execution time: 72_228_000 picoseconds.
+		Weight::from_parts(72_932_000, 14855)
+			.saturating_add(RocksDbWeight::get().reads(5_u64))
+			.saturating_add(RocksDbWeight::get().writes(5_u64))
+	}
+	/// Storage: Dex Pools (r:1 w:0)
+	/// Proof: Dex 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: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Account (r:2 w:2)
+	/// Proof: Assets Account (max_values: None, max_size: Some(102), added: 2577, mode: MaxEncodedLen)
+	/// Storage: PoolAssets Asset (r:1 w:1)
+	/// Proof: PoolAssets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: PoolAssets Account (r:2 w:2)
+	/// Proof: PoolAssets Account (max_values: None, max_size: Some(102), added: 2577, mode: MaxEncodedLen)
+	fn add_liquidity() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1232`
+		//  Estimated: `26726`
+		// Minimum execution time: 137_656_000 picoseconds.
+		Weight::from_parts(138_526_000, 26726)
+			.saturating_add(RocksDbWeight::get().reads(8_u64))
+			.saturating_add(RocksDbWeight::get().writes(7_u64))
+	}
+	/// Storage: Dex Pools (r:1 w:0)
+	/// Proof: Dex Pools (max_values: None, max_size: Some(30), added: 2505, mode: MaxEncodedLen)
+	/// Storage: PoolAssets Asset (r:1 w:1)
+	/// Proof: PoolAssets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: PoolAssets Account (r:2 w:2)
+	/// Proof: PoolAssets Account (max_values: None, max_size: Some(102), added: 2577, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: Assets Asset (r:1 w:1)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Account (r:2 w:2)
+	/// Proof: Assets Account (max_values: None, max_size: Some(102), added: 2577, mode: MaxEncodedLen)
+	fn remove_liquidity() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1496`
+		//  Estimated: `26726`
+		// Minimum execution time: 159_778_000 picoseconds.
+		Weight::from_parts(160_730_000, 26726)
+			.saturating_add(RocksDbWeight::get().reads(8_u64))
+			.saturating_add(RocksDbWeight::get().writes(7_u64))
+	}
+	/// Storage: System Account (r:1 w:1)
+	/// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen)
+	/// Storage: Assets Asset (r:2 w:2)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Account (r:4 w:4)
+	/// Proof: Assets Account (max_values: None, max_size: Some(102), added: 2577, mode: MaxEncodedLen)
+	fn swap_exact_tokens_for_tokens() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `1134`
+		//  Estimated: `21251`
+		// Minimum execution time: 136_852_000 picoseconds.
+		Weight::from_parts(137_764_000, 21251)
+			.saturating_add(RocksDbWeight::get().reads(7_u64))
+			.saturating_add(RocksDbWeight::get().writes(7_u64))
+	}
+	/// Storage: Assets Asset (r:2 w:2)
+	/// Proof: Assets Asset (max_values: None, max_size: Some(210), added: 2685, mode: MaxEncodedLen)
+	/// Storage: Assets Account (r:4 w:4)
+	/// Proof: Assets Account (max_values: None, max_size: Some(102), added: 2577, 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:  `1134`
+		//  Estimated: `21251`
+		// Minimum execution time: 136_660_000 picoseconds.
+		Weight::from_parts(137_522_000, 21251)
+			.saturating_add(RocksDbWeight::get().reads(7_u64))
+			.saturating_add(RocksDbWeight::get().writes(7_u64))
+	}
+}