pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-04-25 19:57:56 +00:00
Code Issues Packages Projects Releases Wiki Activity

Asset Conversion pallet (#12984)

Browse Source 
* 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>
This commit is contained in:
Squirrel
2023-05-25 19:51:13 +01:00
committed by GitHub
parent 7b10153633
commit ef1e4e8b2b
20 changed files with 3727 additions and 10 deletions
Download Patch File Download Diff File Expand all files Collapse all files
substrate/Cargo.lock
Generated
+36
View File
@@ -3525,6 +3525,17 @@ dependencies = [
"parity-scale-codec",
]
[[package]]
name = "impl-num-traits"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "951641f13f873bff03d4bf19ae8bec531935ac0ac2cc775f84d7edfdcfed3f17"
dependencies = [
"integer-sqrt",
"num-traits",
"uint",
]
[[package]]
name = "impl-serde"
version = "0.4.0"
@@ -3893,6 +3904,7 @@ dependencies = [
"log",
"node-primitives",
"pallet-alliance",
"pallet-asset-conversion",
"pallet-asset-rate",
"pallet-asset-tx-payment",
"pallet-assets",
@@ -3962,6 +3974,7 @@ dependencies = [
"pallet-vesting",
"pallet-whitelist",
"parity-scale-codec",
"primitive-types",
"scale-info",
"sp-api",
"sp-authority-discovery",
@@ -5242,6 +5255,7 @@ dependencies = [
"node-inspect",
"node-primitives",
"node-rpc",
"pallet-asset-conversion",
"pallet-asset-tx-payment",
"pallet-assets",
"pallet-balances",
@@ -5524,6 +5538,7 @@ dependencies = [
"log",
"node-executor",
"node-primitives",
"pallet-asset-conversion",
"pallet-asset-tx-payment",
"pallet-assets",
"pallet-transaction-payment",
@@ -5829,6 +5844,26 @@ dependencies = [
"sp-std",
]
[[package]]
name = "pallet-asset-conversion"
version = "4.0.0-dev"
dependencies = [
"frame-benchmarking",
"frame-support",
"frame-system",
"pallet-assets",
"pallet-balances",
"parity-scale-codec",
"primitive-types",
"scale-info",
"sp-api",
"sp-arithmetic",
"sp-core",
"sp-io",
"sp-runtime",
"sp-std",
]
[[package]]
name = "pallet-asset-rate"
version = "4.0.0-dev"
@@ -7912,6 +7947,7 @@ checksum = "9f3486ccba82358b11a77516035647c34ba167dfa53312630de83b12bd4f3d66"
dependencies = [
"fixed-hash",
"impl-codec",
"impl-num-traits",
"impl-serde",
"scale-info",
"uint",
substrate/Cargo.toml
+1
View File
@@ -74,6 +74,7 @@ members = [
"client/transaction-pool/api",
"client/utils",
"frame/alliance",
"frame/asset-conversion",
"frame/assets",
"frame/atomic-swap",
"frame/aura",
substrate/bin/node/cli/Cargo.toml
+1
View File
@@ -88,6 +88,7 @@ sc-storage-monitor = { version = "0.1.0", path = "../../../client/storage-monito
frame-system = { version = "4.0.0-dev", path = "../../../frame/system" }
frame-system-rpc-runtime-api = { version = "4.0.0-dev", path = "../../../frame/system/rpc/runtime-api" }
pallet-transaction-payment = { version = "4.0.0-dev", path = "../../../frame/transaction-payment" }
pallet-asset-conversion = { version = "4.0.0-dev", path = "../../../frame/asset-conversion" }
pallet-assets = { version = "4.0.0-dev", path = "../../../frame/assets/" }
pallet-asset-tx-payment = { version = "4.0.0-dev", path = "../../../frame/transaction-payment/asset-tx-payment/" }
pallet-im-online = { version = "4.0.0-dev", default-features = false, path = "../../../frame/im-online" }
substrate/bin/node/cli/src/chain_spec.rs
+1
View File
@@ -363,6 +363,7 @@ pub fn testnet_genesis(
assets: vec![(9, get_account_id_from_seed::<sr25519::Public>("Alice"), true, 1)],
..Default::default()
},
pool_assets: Default::default(),
transaction_storage: Default::default(),
transaction_payment: Default::default(),
alliance: Default::default(),
substrate/bin/node/runtime/Cargo.toml
+7
View File
@@ -24,6 +24,9 @@ scale-info = { version = "2.5.0", default-features = false, features = ["derive"
static_assertions = "1.1.0"
log = { version = "0.4.17", default-features = false }
# pallet-asset-conversion: turn on "num-traits" feature
primitive-types = { version = "0.12.0", default-features = false, features = ["codec", "scale-info", "num-traits"] }
# primitives
sp-authority-discovery = { version = "4.0.0-dev", default-features = false, path = "../../../primitives/authority-discovery" }
sp-consensus-babe = { version = "0.10.0-dev", default-features = false, path = "../../../primitives/consensus/babe" }
@@ -54,6 +57,7 @@ frame-election-provider-support = { version = "4.0.0-dev", default-features = fa
frame-system-rpc-runtime-api = { version = "4.0.0-dev", default-features = false, path = "../../../frame/system/rpc/runtime-api/" }
frame-try-runtime = { version = "0.10.0-dev", default-features = false, path = "../../../frame/try-runtime", optional = true }
pallet-alliance = { version = "4.0.0-dev", default-features = false, path = "../../../frame/alliance" }
pallet-asset-conversion = { version = "4.0.0-dev", default-features = false, path = "../../../frame/asset-conversion" }
pallet-asset-rate = { version = "4.0.0-dev", default-features = false, path = "../../../frame/asset-rate" }
pallet-assets = { version = "4.0.0-dev", default-features = false, path = "../../../frame/assets" }
pallet-authority-discovery = { version = "4.0.0-dev", default-features = false, path = "../../../frame/authority-discovery" }
@@ -137,6 +141,7 @@ std = [
"frame-system-benchmarking?/std",
"frame-election-provider-support/std",
"sp-authority-discovery/std",
"pallet-asset-conversion/std",
"pallet-assets/std",
"pallet-authority-discovery/std",
"pallet-authorship/std",
@@ -236,6 +241,7 @@ runtime-benchmarks = [
"frame-system/runtime-benchmarks",
"sp-runtime/runtime-benchmarks",
"pallet-alliance/runtime-benchmarks",
"pallet-asset-conversion/runtime-benchmarks",
"pallet-assets/runtime-benchmarks",
"pallet-babe/runtime-benchmarks",
"pallet-bags-list/runtime-benchmarks",
@@ -297,6 +303,7 @@ try-runtime = [
"frame-system/try-runtime",
"frame-support/try-runtime",
"pallet-alliance/try-runtime",
"pallet-asset-conversion/try-runtime",
"pallet-assets/try-runtime",
"pallet-authority-discovery/try-runtime",
"pallet-authorship/try-runtime",
substrate/bin/node/runtime/src/lib.rs
+93 -7
View File
@@ -29,6 +29,8 @@ use frame_election_provider_support::{
use frame_support::{
construct_runtime,
dispatch::DispatchClass,
instances::{Instance1, Instance2},
ord_parameter_types,
pallet_prelude::Get,
parameter_types,
traits::{
@@ -48,10 +50,11 @@ use frame_support::{
};
use frame_system::{
limits::{BlockLength, BlockWeights},
EnsureRoot, EnsureRootWithSuccess, EnsureSigned, EnsureWithSuccess,
EnsureRoot, EnsureRootWithSuccess, EnsureSigned, EnsureSignedBy, EnsureWithSuccess,
};
pub use node_primitives::{AccountId, Signature};
use node_primitives::{AccountIndex, Balance, BlockNumber, Hash, Index, Moment};
use pallet_asset_conversion::{NativeOrAssetId, NativeOrAssetIdConverter};
use pallet_election_provider_multi_phase::SolutionAccuracyOf;
use pallet_im_online::sr25519::AuthorityId as ImOnlineId;
use pallet_nfts::PalletFeatures;
@@ -69,8 +72,8 @@ use sp_runtime::{
curve::PiecewiseLinear,
generic, impl_opaque_keys,
traits::{
self, BlakeTwo256, Block as BlockT, Bounded, ConvertInto, NumberFor, OpaqueKeys,
SaturatedConversion, StaticLookup,
self, AccountIdConversion, BlakeTwo256, Block as BlockT, Bounded, ConvertInto, NumberFor,
OpaqueKeys, SaturatedConversion, StaticLookup,
},
transaction_validity::{TransactionPriority, TransactionSource, TransactionValidity},
ApplyExtrinsicResult, FixedPointNumber, FixedU128, Perbill, Percent, Permill, Perquintill,
@@ -482,7 +485,7 @@ impl pallet_asset_tx_payment::Config for Runtime {
type RuntimeEvent = RuntimeEvent;
type Fungibles = Assets;
type OnChargeAssetTransaction = pallet_asset_tx_payment::FungiblesAdapter<
pallet_assets::BalanceToAssetBalance<Balances, Runtime, ConvertInto>,
pallet_assets::BalanceToAssetBalance<Balances, Runtime, ConvertInto, Instance1>,
CreditToBlockAuthor,
>;
}
@@ -1473,7 +1476,7 @@ parameter_types! {
pub const MetadataDepositPerByte: Balance = 1 * DOLLARS;
}
impl pallet_assets::Config for Runtime {
impl pallet_assets::Config<Instance1> for Runtime {
type RuntimeEvent = RuntimeEvent;
type Balance = u128;
type AssetId = u32;
@@ -1496,6 +1499,66 @@ impl pallet_assets::Config for Runtime {
type BenchmarkHelper = ();
}
ord_parameter_types! {
pub const AssetConversionOrigin: AccountId = AccountIdConversion::<AccountId>::into_account_truncating(&AssetConversionPalletId::get());
}
impl pallet_assets::Config<Instance2> for Runtime {
type RuntimeEvent = RuntimeEvent;
type Balance = u128;
type AssetId = u32;
type AssetIdParameter = codec::Compact<u32>;
type Currency = Balances;
type CreateOrigin = AsEnsureOriginWithArg<EnsureSignedBy<AssetConversionOrigin, AccountId>>;
type ForceOrigin = EnsureRoot<AccountId>;
type AssetDeposit = AssetDeposit;
type AssetAccountDeposit = ConstU128<DOLLARS>;
type MetadataDepositBase = MetadataDepositBase;
type MetadataDepositPerByte = MetadataDepositPerByte;
type ApprovalDeposit = ApprovalDeposit;
type StringLimit = StringLimit;
type Freezer = ();
type Extra = ();
type WeightInfo = pallet_assets::weights::SubstrateWeight<Runtime>;
type RemoveItemsLimit = ConstU32<1000>;
type CallbackHandle = ();
#[cfg(feature = "runtime-benchmarks")]
type BenchmarkHelper = ();
}
parameter_types! {
pub const AssetConversionPalletId: PalletId = PalletId(*b"py/ascon");
pub AllowMultiAssetPools: bool = true;
pub const PoolSetupFee: Balance = 1 * DOLLARS; // should be more or equal to the existential deposit
pub const MintMinLiquidity: Balance = 100; // 100 is good enough when the main currency has 10-12 decimals.
pub const LiquidityWithdrawalFee: Permill = Permill::from_percent(0); // should be non-zero if AllowMultiAssetPools is true, otherwise can be zero.
}
impl pallet_asset_conversion::Config for Runtime {
type RuntimeEvent = RuntimeEvent;
type Currency = Balances;
type AssetBalance = <Self as pallet_balances::Config>::Balance;
type HigherPrecisionBalance = sp_core::U256;
type Assets = Assets;
type Balance = u128;
type PoolAssets = PoolAssets;
type AssetId = <Self as pallet_assets::Config<Instance1>>::AssetId;
type MultiAssetId = NativeOrAssetId<u32>;
type PoolAssetId = <Self as pallet_assets::Config<Instance2>>::AssetId;
type PalletId = AssetConversionPalletId;
type LPFee = ConstU32<3>; // means 0.3%
type PoolSetupFee = PoolSetupFee;
type PoolSetupFeeReceiver = AssetConversionOrigin;
type LiquidityWithdrawalFee = LiquidityWithdrawalFee;
type WeightInfo = pallet_asset_conversion::weights::SubstrateWeight<Runtime>;
type AllowMultiAssetPools = AllowMultiAssetPools;
type MaxSwapPathLength = ConstU32<4>;
type MintMinLiquidity = MintMinLiquidity;
type MultiAssetIdConverter = NativeOrAssetIdConverter<u32>;
#[cfg(feature = "runtime-benchmarks")]
type BenchmarkHelper = ();
}
parameter_types! {
pub const QueueCount: u32 = 300;
pub const MaxQueueLen: u32 = 1000;
@@ -1617,7 +1680,7 @@ impl pallet_nft_fractionalization::Config for Runtime {
type NftCollectionId = <Self as pallet_nfts::Config>::CollectionId;
type NftId = <Self as pallet_nfts::Config>::ItemId;
type AssetBalance = <Self as pallet_balances::Config>::Balance;
type AssetId = <Self as pallet_assets::Config>::AssetId;
type AssetId = <Self as pallet_assets::Config<Instance1>>::AssetId;
type Assets = Assets;
type Nfts = Nfts;
type PalletId = NftFractionalizationPalletId;
@@ -1838,7 +1901,8 @@ construct_runtime!(
Multisig: pallet_multisig,
Bounties: pallet_bounties,
Tips: pallet_tips,
Assets: pallet_assets,
Assets: pallet_assets::<Instance1>,
PoolAssets: pallet_assets::<Instance2>,
Mmr: pallet_mmr,
Lottery: pallet_lottery,
Nis: pallet_nis,
@@ -1861,6 +1925,7 @@ construct_runtime!(
NominationPools: pallet_nomination_pools,
RankedPolls: pallet_referenda::<Instance2>,
RankedCollective: pallet_ranked_collective,
AssetConversion: pallet_asset_conversion,
FastUnstake: pallet_fast_unstake,
MessageQueue: pallet_message_queue,
Pov: frame_benchmarking_pallet_pov,
@@ -1951,6 +2016,7 @@ mod benches {
[pallet_contracts, Contracts]
[pallet_core_fellowship, CoreFellowship]
[pallet_democracy, Democracy]
[pallet_asset_conversion, AssetConversion]
[pallet_election_provider_multi_phase, ElectionProviderMultiPhase]
[pallet_election_provider_support_benchmarking, EPSBench::<Runtime>]
[pallet_elections_phragmen, Elections]
@@ -2288,6 +2354,26 @@ impl_runtime_apis! {
}
}
impl pallet_asset_conversion::AssetConversionApi<
Block,
Balance,
u128,
NativeOrAssetId<u32>
> for Runtime
{
fn quote_price_exact_tokens_for_tokens(asset1: NativeOrAssetId<u32>, asset2: NativeOrAssetId<u32>, amount: u128, include_fee: bool) -> Option<Balance> {
AssetConversion::quote_price_exact_tokens_for_tokens(asset1, asset2, amount, include_fee)
}
fn quote_price_tokens_for_exact_tokens(asset1: NativeOrAssetId<u32>, asset2: NativeOrAssetId<u32>, amount: u128, include_fee: bool) -> Option<Balance> {
AssetConversion::quote_price_tokens_for_exact_tokens(asset1, asset2, amount, include_fee)
}
fn get_reserves(asset1: NativeOrAssetId<u32>, asset2: NativeOrAssetId<u32>) -> Option<(Balance, Balance)> {
AssetConversion::get_reserves(&asset1, &asset2).ok()
}
}
impl pallet_transaction_payment_rpc_runtime_api::TransactionPaymentCallApi<Block, Balance, RuntimeCall>
for Runtime
{
substrate/bin/node/testing/Cargo.toml
+1
View File
@@ -22,6 +22,7 @@ frame-system = { version = "4.0.0-dev", path = "../../../frame/system" }
node-executor = { version = "3.0.0-dev", path = "../executor" }
node-primitives = { version = "2.0.0", path = "../primitives" }
kitchensink-runtime = { version = "3.0.0-dev", path = "../runtime" }
pallet-asset-conversion = { version = "4.0.0-dev", path = "../../../frame/asset-conversion" }
pallet-assets = { version = "4.0.0-dev", path = "../../../frame/assets" }
pallet-asset-tx-payment = { version = "4.0.0-dev", path = "../../../frame/transaction-payment/asset-tx-payment" }
pallet-transaction-payment = { version = "4.0.0-dev", path = "../../../frame/transaction-payment" }
substrate/bin/node/testing/src/genesis.rs
+1
View File
@@ -89,6 +89,7 @@ pub fn config_endowed(code: Option<&[u8]>, extra_endowed: Vec<AccountId>) -> Gen
society: SocietyConfig { members: vec![alice(), bob()], pot: 0, max_members: 999 },
vesting: Default::default(),
assets: AssetsConfig { assets: vec![(9, alice(), true, 1)], ..Default::default() },
pool_assets: Default::default(),
transaction_storage: Default::default(),
transaction_payment: Default::default(),
alliance: Default::default(),
substrate/frame/asset-conversion/Cargo.toml
+52
View File
@@ -0,0 +1,52 @@
[package]
name = "pallet-asset-conversion"
version = "4.0.0-dev"
authors = ["Parity Technologies <admin@parity.io>"]
edition = "2021"
license = "Apache-2.0"
homepage = "https://substrate.io"
repository = "https://github.com/paritytech/substrate/"
description = "FRAME asset conversion pallet"
readme = "README.md"
[package.metadata.docs.rs]
targets = ["x86_64-unknown-linux-gnu"]
[dependencies]
codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = ["derive"] }
frame-support = { version = "4.0.0-dev", default-features = false, path = "../support" }
frame-system = { version = "4.0.0-dev", default-features = false, path = "../system" }
frame-benchmarking = { version = "4.0.0-dev", default-features = false, path = "../benchmarking", optional = true }
scale-info = { version = "2.0.0", default-features = false, features = ["derive"] }
sp-api = { version = "4.0.0-dev", default-features = false, path = "../../primitives/api" }
sp-io = { version = "7.0.0", default-features = false, path = "../../primitives/io" }
sp-std = { version = "5.0.0", default-features = false, path = "../../primitives/std" }
sp-runtime = { version = "7.0.0", default-features = false, path = "../../primitives/runtime" }
sp-arithmetic = { version = "6.0.0", default-features = false, path = "../../primitives/arithmetic" }
[dev-dependencies]
pallet-balances = { version = "4.0.0-dev", path = "../balances" }
pallet-assets = { version = "4.0.0-dev", path = "../assets" }
primitive-types = { version = "0.12.0", default-features = false, features = ["codec", "scale-info", "num-traits"] }
sp-std = { version = "5.0.0", path = "../../primitives/std" }
sp-core = { version = "7.0.0", path = "../../primitives/core" }
sp-io = { version = "7.0.0", path = "../../primitives/io" }
[features]
default = ["std"]
std = [
"codec/std",
"frame-benchmarking?/std",
"frame-support/std",
"frame-system/std",
"scale-info/std",
"sp-std/std",
"sp-runtime/std",
"sp-arithmetic/std"
]
runtime-benchmarks = [
"frame-benchmarking/runtime-benchmarks",
"frame-system/runtime-benchmarks",
"sp-runtime/runtime-benchmarks",
]
try-runtime = ["frame-support/try-runtime"]
substrate/frame/asset-conversion/README.md
+25
View File
@@ -0,0 +1,25 @@
# asset-conversion
## A swap pallet
This pallet allows assets to be converted from one type to another by means of a constant product formula.
The pallet based is based on [Uniswap V2](https://github.com/Uniswap/v2-core) logic.
### Overview
This pallet allows you to:
- create a liquidity pool for 2 assets
- provide the liquidity and receive back an LP token
- exchange the LP token back to assets
- swap 2 assets if there is a pool created
- query for an exchange price via a new runtime call endpoint
- query the size of a liquidity pool.
Please see the rust module documentation for full details:
`cargo doc -p pallet-asset-conversion --open`
### License
License: Apache-2.0
substrate/frame/asset-conversion/src/benchmarking.rs
+287
View File
@@ -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/lib.rs
+1193
View File
File diff suppressed because it is too large Load Diff
substrate/frame/asset-conversion/src/mock.rs
+197
View File
@@ -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/tests.rs
+1413
View File
File diff suppressed because it is too large Load Diff
substrate/frame/asset-conversion/src/types.rs
+131
View File
@@ -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
Generated
+245
View File
@@ -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))
}
}
substrate/frame/support/src/traits.rs
+2 -2
View File
@@ -90,8 +90,8 @@ pub use hooks::{
pub mod schedule;
mod storage;
pub use storage::{
Instance, PartialStorageInfoTrait, StorageInfo, StorageInfoTrait, StorageInstance,
TrackedStorageKey, WhitelistedStorageKeys,
Incrementable, Instance, PartialStorageInfoTrait, StorageInfo, StorageInfoTrait,
StorageInstance, TrackedStorageKey, WhitelistedStorageKeys,
};
mod dispatch;
substrate/frame/support/src/traits/storage.rs
+27
View File
@@ -20,6 +20,7 @@
use crate::sp_std::collections::btree_set::BTreeSet;
use impl_trait_for_tuples::impl_for_tuples;
pub use sp_core::storage::TrackedStorageKey;
use sp_runtime::traits::Saturating;
use sp_std::prelude::*;
/// An instance of a pallet in the storage.
@@ -120,3 +121,29 @@ impl WhitelistedStorageKeys for Tuple {
combined_keys.into_iter().collect::<Vec<_>>()
}
}
macro_rules! impl_incrementable {
($($type:ty),+) => {
$(
impl Incrementable for $type {
fn increment(&self) -> Self {
let mut val = self.clone();
val.saturating_inc();
val
}
fn initial_value() -> Self {
0
}
}
)+
};
}
/// For example: allows new identifiers to be created in a linear fashion.
pub trait Incrementable {
fn increment(&self) -> Self;
fn initial_value() -> Self;
}
impl_incrementable!(u8, u16, u32, u64, u128, i8, i16, i32, i64, i128);
substrate/frame/support/src/traits/tokens/fungibles/mod.rs
+1 -1
View File
@@ -36,5 +36,5 @@ pub use hold::{
pub use imbalance::{Credit, Debt, HandleImbalanceDrop, Imbalance};
pub use lifetime::{Create, Destroy};
pub use regular::{
Balanced, DecreaseIssuance, Dust, IncreaseIssuance, Inspect, Mutate, Unbalanced,
Balanced, DecreaseIssuance, Dust, IncreaseIssuance, Inspect, Mutate, SwapForNative, Unbalanced,
};
substrate/frame/support/src/traits/tokens/fungibles/regular.rs
+13
View File
@@ -583,3 +583,16 @@ pub trait Balanced<AccountId>: Inspect<AccountId> + Unbalanced<AccountId> {
fn done_deposit(_asset: Self::AssetId, _who: &AccountId, _amount: Self::Balance) {}
fn done_withdraw(_asset: Self::AssetId, _who: &AccountId, _amount: Self::Balance) {}
}
/// Use an on-chain exchange to convert the asset to the equivalent in native tokens.
pub trait SwapForNative<Origin, AccountId, Balance, AssetBalance, AssetId> {
// If successful returns the amount in native tokens.
fn swap_tokens_for_exact_native(
sender: AccountId,
asset_id: AssetId,
amount_out: Balance,
amount_in_max: Option<AssetBalance>,
send_to: AccountId,
keep_alive: bool,
) -> Result<AssetBalance, DispatchError>;
}