Struct Pallet

pub struct Pallet<T>(/* private fields */);

The Pallet struct, the main type that implements traits and standalone functions within the pallet.

Implementations

impl<T: Config> Pallet<T>

Pallet’s callable functions.

pub fn create_pool( origin: OriginFor<T>, asset1: Box<T::AssetKind>, asset2: Box<T::AssetKind>, ) -> DispatchResult

Creates an empty liquidity pool and an associated new lp_token asset (the id of which is returned in the Event::PoolCreated event).

Once a pool is created, someone may Pallet::add_liquidity to it.

pub fn add_liquidity( origin: OriginFor<T>, asset1: Box<T::AssetKind>, asset2: Box<T::AssetKind>, amount1_desired: T::Balance, amount2_desired: T::Balance, amount1_min: T::Balance, amount2_min: T::Balance, mint_to: T::AccountId, ) -> DispatchResult

Provide liquidity into the pool of asset1 and asset2. NOTE: an optimal amount of asset1 and asset2 will be calculated and might be different than the provided amount1_desired/amount2_desired thus you should provide the min amount you’re happy to provide. Params amount1_min/amount2_min represent that. mint_to will be sent the liquidity tokens that represent this share of the pool.

NOTE: when encountering an incorrect exchange rate and non-withdrawable pool liquidity, batch an atomic call with Pallet::add_liquidity and Pallet::swap_exact_tokens_for_tokens or Pallet::swap_tokens_for_exact_tokens calls to render the liquidity withdrawable and rectify the exchange rate.

Once liquidity is added, someone may successfully call Pallet::swap_exact_tokens_for_tokens.

pub fn remove_liquidity( origin: OriginFor<T>, asset1: Box<T::AssetKind>, asset2: Box<T::AssetKind>, lp_token_burn: T::Balance, amount1_min_receive: T::Balance, amount2_min_receive: T::Balance, withdraw_to: T::AccountId, ) -> DispatchResult

Allows you to remove liquidity by providing the lp_token_burn tokens that will be burned in the process. With the usage of amount1_min_receive/amount2_min_receive it’s possible to control the min amount of returned tokens you’re happy with.

pub fn swap_exact_tokens_for_tokens( origin: OriginFor<T>, path: Vec<Box<T::AssetKind>>, amount_in: T::Balance, amount_out_min: T::Balance, send_to: T::AccountId, keep_alive: bool, ) -> DispatchResult

Swap the exact amount of asset1 into asset2. amount_out_min param allows you to specify the min amount of the asset2 you’re happy to receive.

AssetConversionApi::quote_price_exact_tokens_for_tokens runtime call can be called for a quote.

pub fn swap_tokens_for_exact_tokens( origin: OriginFor<T>, path: Vec<Box<T::AssetKind>>, amount_out: T::Balance, amount_in_max: T::Balance, send_to: T::AccountId, keep_alive: bool, ) -> DispatchResult

Swap any amount of asset1 to get the exact amount of asset2. amount_in_max param allows to specify the max amount of the asset1 you’re happy to provide.

AssetConversionApi::quote_price_tokens_for_exact_tokens runtime call can be called for a quote.

pub fn touch( origin: OriginFor<T>, asset1: Box<T::AssetKind>, asset2: Box<T::AssetKind>, ) -> DispatchResultWithPostInfo

Touch an existing pool to fulfill prerequisites before providing liquidity, such as ensuring that the pool’s accounts are in place. It is typically useful when a pool creator removes the pool’s accounts and does not provide a liquidity. This action may involve holding assets from the caller as a deposit for creating the pool’s accounts.

The origin must be Signed.

• asset1: The asset ID of an existing pool with a pair (asset1, asset2).
• asset2: The asset ID of an existing pool with a pair (asset1, asset2).

Emits Touched event when successful.

impl<T: Config> Pallet<T>

pub fn quote( amount: &T::Balance, reserve1: &T::Balance, reserve2: &T::Balance, ) -> Result<T::Balance, Error<T>>

Calculates the optimal amount from the reserves.

pub fn get_amount_out( amount_in: &T::Balance, reserve_in: &T::Balance, reserve_out: &T::Balance, ) -> Result<T::Balance, Error<T>>

Calculates amount out.

Given an input amount of an asset and pair reserves, returns the maximum output amount of the other asset.

pub fn get_amount_in( amount_out: &T::Balance, reserve_in: &T::Balance, reserve_out: &T::Balance, ) -> Result<T::Balance, Error<T>>

Calculates amount in.

Given an output amount of an asset and pair reserves, returns a required input amount of the other asset.

pub fn get_next_pool_asset_id() -> T::PoolAssetId

Returns the next pool asset id for benchmark purposes only.

impl<T: Config> Pallet<T>

pub fn get_reserves( asset1: T::AssetKind, asset2: T::AssetKind, ) -> Result<(T::Balance, T::Balance), Error<T>>

Returns the balance of each asset in the pool. The tuple result is in the order requested (not necessarily the same as pool order).

pub fn quote_price_exact_tokens_for_tokens( asset1: T::AssetKind, asset2: T::AssetKind, amount: T::Balance, include_fee: bool, ) -> Option<T::Balance>

Gets a quote for swapping an exact amount of asset1 for asset2.

If include_fee is true, the quote will include the liquidity provider fee. If the pool does not exist or has no liquidity, None is returned. Note that the price may have changed by the time the transaction is executed. (Use amount_out_min to control slippage.) Returns Some(quoted_amount) on success.

pub fn quote_price_tokens_for_exact_tokens( asset1: T::AssetKind, asset2: T::AssetKind, amount: T::Balance, include_fee: bool, ) -> Option<T::Balance>

Gets a quote for swapping amount of asset1 for an exact amount of asset2.

If include_fee is true, the quote will include the liquidity provider fee. If the pool does not exist or has no liquidity, None is returned. Note that the price may have changed by the time the transaction is executed. (Use amount_in_max to control slippage.) Returns Some(quoted_amount) on success.

Trait Implementations

impl<T: Config> BeforeAllRuntimeMigrations for Pallet<T>

fn before_all_runtime_migrations() -> Weight

Something that should happen before runtime migrations are executed.

impl<T> Benchmarking for Pallet<T>

where T: Config + Config, T::Assets: Create<T::AccountId> + Mutate<T::AccountId>, T::PoolAssetId: Into<u32>,

fn benchmarks(extra: bool) -> Vec<BenchmarkMetadata>

Get the benchmarks available for this pallet. Generally there is one benchmark per extrinsic, so these are sometimes just called “extrinsics”.

fn run_benchmark( extrinsic: &[u8], c: &[(BenchmarkParameter, u32)], whitelist: &[TrackedStorageKey], verify: bool, internal_repeats: u32, ) -> Result<Vec<BenchmarkResult>, BenchmarkError>

Run the benchmarks for this pallet.

impl<T: Config> Callable<T> for Pallet<T>

type RuntimeCall = Call<T>

impl<T> Clone for Pallet<T>

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Debug for Pallet<T>

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Config> DispatchViewFunction for Pallet<T>

fn dispatch_view_function<O: Output>( id: &ViewFunctionId, input: &mut &[u8], output: &mut O, ) -> Result<(), ViewFunctionDispatchError>

impl<T: Config> GetStorageVersion for Pallet<T>

type InCodeStorageVersion = NoStorageVersionSet

This type is generated by the pallet macro.

fn in_code_storage_version() -> Self::InCodeStorageVersion

Returns the in-code storage version as specified in the storage_version attribute, or [NoStorageVersionSet] if the attribute is missing.

fn on_chain_storage_version() -> StorageVersion

Returns the storage version of the pallet as last set in the actual on-chain storage.

fn current_storage_version() -> Self::InCodeStorageVersion

👎Deprecated: This method has been renamed to in_code_storage_version and will be removed after March 2024.

DEPRECATED: Use [Self::current_storage_version] instead.

impl<T: Config> Hooks<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>

fn integrity_test()

Check the integrity of this pallet’s configuration.

fn on_initialize(_n: BlockNumber) -> Weight

Block initialization hook. This is called at the very beginning of block execution.

fn on_finalize(_n: BlockNumber)

Block finalization hook. This is called at the very end of block execution.

fn on_idle(_n: BlockNumber, _remaining_weight: Weight) -> Weight

Hook to consume a block’s idle time. This will run when the block is being finalized (before [Hooks::on_finalize]).

fn on_poll(_n: BlockNumber, _weight: &mut WeightMeter)

A hook to run logic after inherent application.

fn on_runtime_upgrade() -> Weight

Hook executed when a code change (aka. a “runtime upgrade”) is detected by the FRAME Executive pallet.

fn try_state(_n: BlockNumber) -> Result<(), DispatchError>

Execute the sanity checks of this pallet, per block.

fn pre_upgrade() -> Result<Vec<u8>, DispatchError>

Execute some pre-checks prior to a runtime upgrade.

fn post_upgrade(_state: Vec<u8>) -> Result<(), DispatchError>

Execute some post-checks after a runtime upgrade.

fn offchain_worker(_n: BlockNumber)

Implementing this function on a pallet allows you to perform long-running tasks that are dispatched as separate threads, and entirely independent of the main blockchain execution.

impl<T: Config> IntegrityTest for Pallet<T>

fn integrity_test()

See [Hooks::integrity_test].

impl<T: Config> MutateLiquidity<<T as Config>::AccountId> for Pallet<T>

type Balance = <T as Config>::Balance

The balance type for assets.

type AssetKind = <T as Config>::AssetKind

The type used to identify assets.

type PoolId = <T as Config>::PoolId

The type used to identify a liquidity pool.

fn create_pool( creator: &T::AccountId, asset1: T::AssetKind, asset2: T::AssetKind, ) -> Result<T::PoolId, DispatchError>

Creates a new liquidity pool for the given assets.

fn add_liquidity( who: &T::AccountId, asset1: AddLiquidityAsset<Self::AssetKind, Self::Balance>, asset2: AddLiquidityAsset<Self::AssetKind, Self::Balance>, mint_to: &T::AccountId, ) -> Result<T::Balance, DispatchError>

Adds liquidity to an existing pool.

fn remove_liquidity( who: &T::AccountId, asset1: T::AssetKind, asset2: T::AssetKind, lp_token_burn: T::Balance, amount1_min_receive: T::Balance, amount2_min_receive: T::Balance, withdraw_to: &T::AccountId, ) -> Result<(T::Balance, T::Balance), DispatchError>

Removes liquidity from a pool.

impl<T: Config> OffchainWorker<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>

fn offchain_worker(n: BlockNumberFor<T>)

This function is being called after every block import (when fully synced).

impl<T: Config> OnFinalize<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>

fn on_finalize(n: BlockNumberFor<T>)

See [Hooks::on_finalize].

impl<T: Config> OnGenesis for Pallet<T>

fn on_genesis()

Something that should happen at genesis.

impl<T: Config> OnIdle<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>

fn on_idle(n: BlockNumberFor<T>, remaining_weight: Weight) -> Weight

See [Hooks::on_idle].

impl<T: Config> OnInitialize<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>

fn on_initialize(n: BlockNumberFor<T>) -> Weight

See [Hooks::on_initialize].

impl<T: Config> OnPoll<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>

fn on_poll(n: BlockNumberFor<T>, weight: &mut WeightMeter)

Code to execute every now and then at the beginning of the block after inherent application.

impl<T: Config> OnRuntimeUpgrade for Pallet<T>

fn on_runtime_upgrade() -> Weight

See [Hooks::on_runtime_upgrade].

fn pre_upgrade() -> Result<Vec<u8>, TryRuntimeError>

See [Hooks::pre_upgrade].

fn post_upgrade(state: Vec<u8>) -> Result<(), TryRuntimeError>

See [Hooks::post_upgrade].

fn try_on_runtime_upgrade(checks: bool) -> Result<Weight, DispatchError>

The expected and default behavior of this method is to handle executing pre_upgrade -> on_runtime_upgrade -> post_upgrade hooks for a migration.

impl<T: Config> PalletInfoAccess for Pallet<T>

fn index() -> usize

Index of the pallet as configured in the runtime.

fn name() -> &'static str

Name of the pallet as configured in the runtime.

fn name_hash() -> [u8; 16]

Two128 hash of name.

fn module_name() -> &'static str

Name of the Rust module containing the pallet.

fn crate_version() -> CrateVersion

Version of the crate containing the pallet.

impl<T: Config> PalletsInfoAccess for Pallet<T>

fn count() -> usize

The number of pallets’ information that this type represents.

fn infos() -> Vec<PalletInfoData>

All of the pallets’ information that this type represents.

impl<T> PartialEq for Pallet<T>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Config> QuotePrice for Pallet<T>

type Balance = <T as Config>::Balance

Measurement units of the asset classes for pricing.

type AssetKind = <T as Config>::AssetKind

Type representing the kind of assets for which the price is being quoted.

fn quote_price_exact_tokens_for_tokens( asset1: Self::AssetKind, asset2: Self::AssetKind, amount: Self::Balance, include_fee: bool, ) -> Option<Self::Balance>

Quotes the amount of asset2 resulting from swapping the exact amount of asset1.

fn quote_price_tokens_for_exact_tokens( asset1: Self::AssetKind, asset2: Self::AssetKind, amount: Self::Balance, include_fee: bool, ) -> Option<Self::Balance>

Quotes the amount of asset1 required to obtain the exact amount of asset2.

impl<T: Config> StorageInfoTrait for Pallet<T>

fn storage_info() -> Vec<StorageInfo>

impl<T: Config> Swap<<T as Config>::AccountId> for Pallet<T>

type Balance = <T as Config>::Balance

Measure units of the asset classes for swapping.

type AssetKind = <T as Config>::AssetKind

Kind of assets that are going to be swapped.

fn max_path_len() -> u32

Returns the upper limit on the length of the swap path.

fn swap_exact_tokens_for_tokens( sender: T::AccountId, path: Vec<Self::AssetKind>, amount_in: Self::Balance, amount_out_min: Option<Self::Balance>, send_to: T::AccountId, keep_alive: bool, ) -> Result<Self::Balance, DispatchError>

Swap exactly amount_in of asset path[0] for asset path[last]. If an amount_out_min is specified, it will return an error if it is unable to acquire the amount desired.

fn swap_tokens_for_exact_tokens( sender: T::AccountId, path: Vec<Self::AssetKind>, amount_out: Self::Balance, amount_in_max: Option<Self::Balance>, send_to: T::AccountId, keep_alive: bool, ) -> Result<Self::Balance, DispatchError>

Take the path[0] asset and swap some amount for amount_out of the path[last]. If an amount_in_max is specified, it will return an error if acquiring amount_out would be too costly.

impl<T: Config> SwapCredit<<T as Config>::AccountId> for Pallet<T>

type Balance = <T as Config>::Balance

Measure units of the asset classes for swapping.

type AssetKind = <T as Config>::AssetKind

Kind of assets that are going to be swapped.

type Credit = Imbalance<<<T as Config>::Assets as Inspect<<T as Config>::AccountId>>::AssetId, <<T as Config>::Assets as Inspect<<T as Config>::AccountId>>::Balance, <<T as Config>::Assets as Balanced<<T as Config>::AccountId>>::OnDropCredit, <<T as Config>::Assets as Balanced<<T as Config>::AccountId>>::OnDropDebt>

Credit implying a negative imbalance in the system that can be placed into an account or alter the total supply.

fn max_path_len() -> u32

Returns the upper limit on the length of the swap path.

fn swap_exact_tokens_for_tokens( path: Vec<Self::AssetKind>, credit_in: Self::Credit, amount_out_min: Option<Self::Balance>, ) -> Result<Self::Credit, (Self::Credit, DispatchError)>

Swap exactly credit_in of asset path[0] for asset path[last]. If amount_out_min is provided and the swap can’t achieve at least this amount, an error is returned.

fn swap_tokens_for_exact_tokens( path: Vec<Self::AssetKind>, credit_in: Self::Credit, amount_out: Self::Balance, ) -> Result<(Self::Credit, Self::Credit), (Self::Credit, DispatchError)>

Swaps a portion of credit_in of path[0] asset to obtain the desired amount_out of the path[last] asset. The provided credit_in must be adequate to achieve the target amount_out, or an error will occur.

impl<T: Config> TryDecodeEntireStorage for Pallet<T>

fn try_decode_entire_state() -> Result<usize, Vec<TryDecodeEntireStorageError>>

Decode the entire data under the given storage, returning Ok(bytes_decoded) if success.

impl<T: Config> TryState<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>

fn try_state( n: BlockNumberFor<T>, _s: TryStateSelect, ) -> Result<(), TryRuntimeError>

Execute the state checks.

impl<T: Config> ViewFunctionIdPrefix for Pallet<T>

fn prefix() -> [u8; 16]

impl<T: Config> WhitelistedStorageKeys for Pallet<T>

fn whitelisted_storage_keys() -> Vec<TrackedStorageKey>

Returns a Vec<TrackedStorageKey> indicating the storage keys that should be whitelisted during benchmarking. This means that those keys will be excluded from the benchmarking performance calculation.

impl<T> Eq for Pallet<T>