Struct pallet_asset_conversion::pallet::Pallet

pub struct Pallet<T>(_);

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: T::MultiAssetId, asset2: T::MultiAssetId ) -> 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: T::MultiAssetId, asset2: T::MultiAssetId, amount1_desired: T::AssetBalance, amount2_desired: T::AssetBalance, amount1_min: T::AssetBalance, amount2_min: T::AssetBalance, 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.

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

pub fn remove_liquidity( origin: OriginFor<T>, asset1: T::MultiAssetId, asset2: T::MultiAssetId, lp_token_burn: T::AssetBalance, amount1_min_receive: T::AssetBalance, amount2_min_receive: T::AssetBalance, 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: BoundedVec<T::MultiAssetId, T::MaxSwapPathLength>, amount_in: T::AssetBalance, amount_out_min: T::AssetBalance, 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: BoundedVec<T::MultiAssetId, T::MaxSwapPathLength>, amount_out: T::AssetBalance, amount_in_max: T::AssetBalance, 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.

impl<T: Config> Pallet<T>

pub fn do_swap_exact_tokens_for_tokens( sender: T::AccountId, path: BoundedVec<T::MultiAssetId, T::MaxSwapPathLength>, amount_in: T::AssetBalance, amount_out_min: Option<T::AssetBalance>, send_to: T::AccountId, keep_alive: bool ) -> Result<T::AssetBalance, DispatchError>

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

Withdraws the path[0] asset from sender, deposits the path[1] asset to send_to, respecting keep_alive.

If successful, returns the amount of path[1] acquired for the amount_in.

pub fn do_swap_tokens_for_exact_tokens( sender: T::AccountId, path: BoundedVec<T::MultiAssetId, T::MaxSwapPathLength>, amount_out: T::AssetBalance, amount_in_max: Option<T::AssetBalance>, send_to: T::AccountId, keep_alive: bool ) -> Result<T::AssetBalance, DispatchError>

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

Withdraws path[0] asset from sender, deposits the path[1] asset to send_to, respecting keep_alive.

If successful returns the amount of the path[0] taken to provide path[1].

pub fn get_pool_account( pool_id: &(<T as Config>::MultiAssetId, <T as Config>::MultiAssetId) ) -> T::AccountId

The account ID of the pool.

This actually does computation. If you need to keep using it, then make sure you cache the value and only call this once.

pub fn get_pool_id( asset1: T::MultiAssetId, asset2: T::MultiAssetId ) -> (<T as Config>::MultiAssetId, <T as Config>::MultiAssetId)

Returns a pool id constructed from 2 assets.

1. Native asset should be lower than the other asset ids.
2. Two native or two non-native assets are compared by their Ord implementation.

We expect deterministic order, so (asset1, asset2) or (asset2, asset1) returns the same result.

pub fn get_reserves( asset1: &T::MultiAssetId, asset2: &T::MultiAssetId ) -> Result<(T::AssetBalance, T::AssetBalance), 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::MultiAssetId, asset2: T::MultiAssetId, amount: T::AssetBalance, include_fee: bool ) -> Option<T::AssetBalance>

Used by the RPC service to provide current prices.

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

Used by the RPC service to provide current prices.

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

Calculates the optimal amount from the reserves.

pub fn get_amount_out( amount_in: &T::AssetBalance, reserve_in: &T::AssetBalance, reserve_out: &T::AssetBalance ) -> Result<T::AssetBalance, 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::AssetBalance, reserve_in: &T::AssetBalance, reserve_out: &T::AssetBalance ) -> Result<T::AssetBalance, 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.

Trait Implementations

impl<T> Benchmarking for Pallet<T>where T: Config + Config, 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>,

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> GetStorageVersion for Pallet<T>

type CurrentStorageVersion = NoStorageVersionSet

This will be filled out by the pallet macro.

fn current_storage_version() -> Self::CurrentStorageVersion

Returns the current storage version as supported by the pallet.

fn on_chain_storage_version() -> StorageVersion

Returns the on-chain storage version of the pallet as stored in the storage.

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_runtime_upgrade() -> Weight

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

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

Execute the sanity checks of this pallet, per block.

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

Execute some pre-checks prior to a runtime upgrade.

fn post_upgrade(_state: Vec<u8, Global>) -> 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 wasm runtime.

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

fn integrity_test()

See Hooks::integrity_test.

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> 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 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<Pallet<T>> for Pallet<T>

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

This method tests for self and other values to be equal, and is used by ==.

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

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

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

fn storage_info() -> Vec<StorageInfo>

impl<T: Config> Swap<<T as Config>::AccountId, <T as Config>::HigherPrecisionBalance, <T as Config>::MultiAssetId> for Pallet<T>

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

Swap exactly amount_in of asset path[0] for asset path[1]. 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<T::MultiAssetId>, amount_out: T::HigherPrecisionBalance, amount_in_max: Option<T::HigherPrecisionBalance>, send_to: T::AccountId, keep_alive: bool ) -> Result<T::HigherPrecisionBalance, DispatchError>

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

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> 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>