Struct pallet_xyk::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>

pub fn create_pool( origin: OriginFor<T>, first_asset_id: CurrencyIdOf<T>, first_asset_amount: BalanceOf<T>, second_asset_id: CurrencyIdOf<T>, second_asset_amount: BalanceOf<T> ) -> DispatchResultWithPostInfo

pub fn sell_asset( origin: OriginFor<T>, sold_asset_id: CurrencyIdOf<T>, bought_asset_id: CurrencyIdOf<T>, sold_asset_amount: BalanceOf<T>, min_amount_out: BalanceOf<T> ) -> DispatchResultWithPostInfo

👎Deprecated: multiswap_sell_asset should be used instead

Executes sell_asset swap. First the swap is prevalidated, if it is successful then the extrinsic is accepted. Beyond this point the exchange commission will be charged. The sold amount of the sold asset is used to determine the bought asset amount. If the bought asset amount is lower than the min_amount_out then it will fail on slippage. The percentage exchange commission is still charged even if the swap fails on slippage. Though the swap itself will be a no-op. The slippage is calculated based upon the sold_asset_amount. Upon slippage failure, the extrinsic is marked “successful”, but an event for the failure is emitted

Args:

• sold_asset_id - The token being sold
• bought_asset_id - The token being bought
• sold_asset_amount: The amount of the sold token being sold
• min_amount_out - The minimum amount of bought asset that must be bought in order to not fail on slippage. Slippage failures still charge exchange commission.

pub fn multiswap_sell_asset( origin: OriginFor<T>, swap_token_list: Vec<CurrencyIdOf<T>>, sold_asset_amount: BalanceOf<T>, min_amount_out: BalanceOf<T> ) -> DispatchResultWithPostInfo

Executes a multiswap sell asset in a series of sell asset atomic swaps.

Multiswaps must fee lock instead of paying transaction fees.

First the multiswap is prevalidated, if it is successful then the extrinsic is accepted and the exchange commission will be charged upon execution on the first swap using sold_asset_amount.

Upon failure of an atomic swap or bad slippage, all the atomic swaps are reverted and the exchange commission is charged. Upon such a failure, the extrinsic is marked “successful”, but an event for the failure is emitted

Args:

• swap_token_list - This list of tokens is the route of the atomic swaps, starting with the asset sold and ends with the asset finally bought
• sold_asset_amount: The amount of the first asset sold
• min_amount_out - The minimum amount of last asset that must be bought in order to not fail on slippage. Slippage failures still charge exchange commission.

pub fn buy_asset( origin: OriginFor<T>, sold_asset_id: CurrencyIdOf<T>, bought_asset_id: CurrencyIdOf<T>, bought_asset_amount: BalanceOf<T>, max_amount_in: BalanceOf<T> ) -> DispatchResultWithPostInfo

👎Deprecated: multiswap_buy_asset should be used instead

Executes buy_asset swap. First the swap is prevalidated, if it is successful then the extrinsic is accepted. Beyond this point the exchange commission will be charged. The bought of the bought asset is used to determine the sold asset amount. If the sold asset amount is higher than the max_amount_in then it will fail on slippage. The percentage exchange commission is still charged even if the swap fails on slippage. Though the swap itself will be a no-op. The slippage is calculated based upon the sold asset amount. Upon slippage failure, the extrinsic is marked “successful”, but an event for the failure is emitted

Args:

• sold_asset_id - The token being sold
• bought_asset_id - The token being bought
• bought_asset_amount: The amount of the bought token being bought
• max_amount_in - The maximum amount of sold asset that must be sold in order to not fail on slippage. Slippage failures still charge exchange commission.

pub fn multiswap_buy_asset( origin: OriginFor<T>, swap_token_list: Vec<CurrencyIdOf<T>>, bought_asset_amount: BalanceOf<T>, max_amount_in: BalanceOf<T> ) -> DispatchResultWithPostInfo

Executes a multiswap buy asset in a series of buy asset atomic swaps.

Multiswaps must fee lock instead of paying transaction fees.

First the multiswap is prevalidated, if it is successful then the extrinsic is accepted and the exchange commission will be charged upon execution on the first swap using max_amount_in. multiswap_buy_asset cannot have two (or more) atomic swaps on the same pool. multiswap_buy_asset prevaildation only checks for whether there are enough funds to pay for the exchange commission. Failure to have the required amount of first asset funds will result in failure (and charging of the exchange commission).

Upon failure of an atomic swap or bad slippage, all the atomic swaps are reverted and the exchange commission is charged. Upon such a failure, the extrinsic is marked “successful”, but an event for the failure is emitted

Args:

• swap_token_list - This list of tokens is the route of the atomic swaps, starting with the asset sold and ends with the asset finally bought
• bought_asset_amount: The amount of the last asset bought
• max_amount_in - The maximum amount of first asset that can be sold in order to not fail on slippage. Slippage failures still charge exchange commission.

pub fn mint_liquidity_using_vesting_native_tokens_by_vesting_index( origin: OriginFor<T>, native_asset_vesting_index: u32, vesting_native_asset_unlock_some_amount_or_all: Option<BalanceOf<T>>, second_asset_id: CurrencyIdOf<T>, expected_second_asset_amount: BalanceOf<T> ) -> DispatchResultWithPostInfo

pub fn mint_liquidity_using_vesting_native_tokens( origin: OriginFor<T>, vesting_native_asset_amount: BalanceOf<T>, second_asset_id: CurrencyIdOf<T>, expected_second_asset_amount: BalanceOf<T> ) -> DispatchResultWithPostInfo

pub fn mint_liquidity( origin: OriginFor<T>, first_asset_id: CurrencyIdOf<T>, second_asset_id: CurrencyIdOf<T>, first_asset_amount: BalanceOf<T>, expected_second_asset_amount: BalanceOf<T> ) -> DispatchResultWithPostInfo

pub fn compound_rewards( origin: OriginFor<T>, liquidity_asset_id: CurrencyIdOf<T>, amount_permille: Permill ) -> DispatchResultWithPostInfo

pub fn provide_liquidity_with_conversion( origin: OriginFor<T>, liquidity_asset_id: CurrencyIdOf<T>, provided_asset_id: CurrencyIdOf<T>, provided_asset_amount: BalanceOf<T> ) -> DispatchResultWithPostInfo

pub fn burn_liquidity( origin: OriginFor<T>, first_asset_id: CurrencyIdOf<T>, second_asset_id: CurrencyIdOf<T>, liquidity_asset_amount: BalanceOf<T> ) -> DispatchResultWithPostInfo

impl<T: Config> Pallet<T>

pub fn asset_pool<KArg>(k: KArg) -> (BalanceOf<T>, BalanceOf<T>)where KArg: EncodeLike<(CurrencyIdOf<T>, CurrencyIdOf<T>)>,

An auto-generated getter for Pools.

impl<T: Config> Pallet<T>

pub fn liquidity_asset<KArg>(k: KArg) -> Option<CurrencyIdOf<T>>where KArg: EncodeLike<(CurrencyIdOf<T>, CurrencyIdOf<T>)>,

An auto-generated getter for LiquidityAssets.

impl<T: Config> Pallet<T>

pub fn liquidity_pool<KArg>( k: KArg ) -> Option<(CurrencyIdOf<T>, CurrencyIdOf<T>)>where KArg: EncodeLike<CurrencyIdOf<T>>,

An auto-generated getter for LiquidityPools.

impl<T: Config> Pallet<T>

pub fn get_max_instant_burn_amount( user: &<T as Config>::AccountId, liquidity_asset_id: CurrencyIdOf<T> ) -> BalanceOf<T>

pub fn get_max_instant_unreserve_amount( user: &<T as Config>::AccountId, liquidity_asset_id: CurrencyIdOf<T> ) -> BalanceOf<T>

pub fn set_liquidity_asset_info( liquidity_asset_id: CurrencyIdOf<T>, first_asset_id: CurrencyIdOf<T>, second_asset_id: CurrencyIdOf<T> ) -> DispatchResult

pub fn calculate_sell_price( input_reserve: BalanceOf<T>, output_reserve: BalanceOf<T>, sell_amount: BalanceOf<T> ) -> Result<BalanceOf<T>, DispatchError>

pub fn calculate_sell_price_no_fee( input_reserve: BalanceOf<T>, output_reserve: BalanceOf<T>, sell_amount: BalanceOf<T> ) -> Result<BalanceOf<T>, DispatchError>

pub fn calculate_buy_price( input_reserve: BalanceOf<T>, output_reserve: BalanceOf<T>, buy_amount: BalanceOf<T> ) -> Result<BalanceOf<T>, DispatchError>

pub fn calculate_balanced_sell_amount( total_amount: BalanceOf<T>, reserve_amount: BalanceOf<T> ) -> Result<BalanceOf<T>, DispatchError>

pub fn get_liq_tokens_for_trading( ) -> Result<Vec<CurrencyIdOf<T>>, DispatchError>

pub fn get_liquidity_asset( first_asset_id: CurrencyIdOf<T>, second_asset_id: CurrencyIdOf<T> ) -> Result<CurrencyIdOf<T>, DispatchError>

pub fn calculate_sell_price_id( sold_token_id: CurrencyIdOf<T>, bought_token_id: CurrencyIdOf<T>, sell_amount: BalanceOf<T> ) -> Result<BalanceOf<T>, DispatchError>

pub fn calculate_buy_price_id( sold_token_id: CurrencyIdOf<T>, bought_token_id: CurrencyIdOf<T>, buy_amount: BalanceOf<T> ) -> Result<BalanceOf<T>, DispatchError>

pub fn get_reserves( first_asset_id: CurrencyIdOf<T>, second_asset_id: CurrencyIdOf<T> ) -> Result<(BalanceOf<T>, BalanceOf<T>), DispatchError>

pub fn set_reserves( first_asset_id: CurrencyIdOf<T>, first_asset_amount: BalanceOf<T>, second_asset_id: CurrencyIdOf<T>, second_asset_amount: BalanceOf<T> ) -> DispatchResult

worst case scenario MAX: 2R 1W

pub fn get_burn_amount( first_asset_id: CurrencyIdOf<T>, second_asset_id: CurrencyIdOf<T>, liquidity_asset_amount: BalanceOf<T> ) -> Result<(BalanceOf<T>, BalanceOf<T>), DispatchError>

pub fn get_burn_amount_reserves( first_asset_reserve: BalanceOf<T>, second_asset_reserve: BalanceOf<T>, liquidity_asset_id: CurrencyIdOf<T>, liquidity_asset_amount: BalanceOf<T> ) -> Result<(BalanceOf<T>, BalanceOf<T>), DispatchError>

Trait Implementations

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

fn integrity_test()

Check the integrity of this pallet’s configuration.

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.

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> PoolCreateApi<<T as Config>::AccountId, <<T as Config>::Currency as MultiTokenCurrency<<T as Config>::AccountId>>::Balance, <<T as Config>::Currency as MultiTokenCurrency<<T as Config>::AccountId>>::CurrencyId> for Pallet<T>

fn pool_exists(first: CurrencyIdOf<T>, second: CurrencyIdOf<T>) -> bool

fn pool_create( account: T::AccountId, first: CurrencyIdOf<T>, first_amount: BalanceOf<T>, second: CurrencyIdOf<T>, second_amount: BalanceOf<T> ) -> Option<(CurrencyIdOf<T>, BalanceOf<T>)>

impl<T: Config> PreValidateSwaps<<T as Config>::AccountId, <<T as Config>::Currency as MultiTokenCurrency<<T as Config>::AccountId>>::Balance, <<T as Config>::Currency as MultiTokenCurrency<<T as Config>::AccountId>>::CurrencyId> for Pallet<T>

fn pre_validate_multiswap_sell_asset( sender: &T::AccountId, swap_token_list: Vec<CurrencyIdOf<T>>, sold_asset_amount: BalanceOf<T>, _min_amount_out: BalanceOf<T> ) -> Result<(BalanceOf<T>, BalanceOf<T>, BalanceOf<T>, BalanceOf<T>, BalanceOf<T>, CurrencyIdOf<T>, CurrencyIdOf<T>), DispatchError>

We only validate the first atomic swap’s ability to accept fees

fn pre_validate_multiswap_buy_asset( sender: &T::AccountId, swap_token_list: Vec<CurrencyIdOf<T>>, final_bought_asset_amount: BalanceOf<T>, max_amount_in: BalanceOf<T> ) -> Result<(BalanceOf<T>, BalanceOf<T>, BalanceOf<T>, BalanceOf<T>, BalanceOf<T>, CurrencyIdOf<T>, CurrencyIdOf<T>), DispatchError>

We only validate the first atomic swap’s ability to accept fees

fn pre_validate_sell_asset( sender: &T::AccountId, sold_asset_id: CurrencyIdOf<T>, bought_asset_id: CurrencyIdOf<T>, sold_asset_amount: BalanceOf<T>, _min_amount_out: BalanceOf<T> ) -> Result<(BalanceOf<T>, BalanceOf<T>, BalanceOf<T>, BalanceOf<T>, BalanceOf<T>, BalanceOf<T>), DispatchError>

fn pre_validate_buy_asset( sender: &T::AccountId, sold_asset_id: CurrencyIdOf<T>, bought_asset_id: CurrencyIdOf<T>, bought_asset_amount: BalanceOf<T>, _max_amount_in: BalanceOf<T> ) -> Result<(BalanceOf<T>, BalanceOf<T>, BalanceOf<T>, BalanceOf<T>, BalanceOf<T>, BalanceOf<T>), DispatchError>

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

fn storage_info() -> Vec<StorageInfo>

impl<T: Config> Valuate<<<T as Config>::Currency as MultiTokenCurrency<<T as Config>::AccountId>>::Balance, <<T as Config>::Currency as MultiTokenCurrency<<T as Config>::AccountId>>::CurrencyId> for Pallet<T>

fn get_liquidity_asset( first_asset_id: CurrencyIdOf<T>, second_asset_id: CurrencyIdOf<T> ) -> Result<CurrencyIdOf<T>, DispatchError>

fn get_liquidity_token_mga_pool( liquidity_token_id: CurrencyIdOf<T> ) -> Result<(CurrencyIdOf<T>, CurrencyIdOf<T>), DispatchError>

fn valuate_liquidity_token( liquidity_token_id: CurrencyIdOf<T>, liquidity_token_amount: BalanceOf<T> ) -> BalanceOf<T>

fn valuate_non_liquidity_token( non_liquidity_token_id: CurrencyIdOf<T>, amount: BalanceOf<T> ) -> BalanceOf<T>

fn scale_liquidity_by_mga_valuation( mga_valuation: BalanceOf<T>, liquidity_token_amount: BalanceOf<T>, mga_token_amount: BalanceOf<T> ) -> BalanceOf<T>

fn get_pool_state( liquidity_token_id: CurrencyIdOf<T> ) -> Option<(BalanceOf<T>, BalanceOf<T>)>

fn get_reserves( first_asset_id: CurrencyIdOf<T>, second_asset_id: CurrencyIdOf<T> ) -> Result<(BalanceOf<T>, BalanceOf<T>), DispatchError>

fn is_liquidity_token(liquidity_asset_id: CurrencyIdOf<T>) -> bool

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: Config> XykFunctionsTrait<<T as Config>::AccountId, <<T as Config>::Currency as MultiTokenCurrency<<T as Config>::AccountId>>::Balance, <<T as Config>::Currency as MultiTokenCurrency<<T as Config>::AccountId>>::CurrencyId> for Pallet<T>

fn create_pool( sender: T::AccountId, first_asset_id: CurrencyIdOf<T>, first_asset_amount: BalanceOf<T>, second_asset_id: CurrencyIdOf<T>, second_asset_amount: BalanceOf<T> ) -> DispatchResult

fn sell_asset( sender: T::AccountId, sold_asset_id: CurrencyIdOf<T>, bought_asset_id: CurrencyIdOf<T>, sold_asset_amount: BalanceOf<T>, min_amount_out: BalanceOf<T>, err_upon_bad_slippage: bool ) -> Result<BalanceOf<T>, DispatchError>

fn do_multiswap_sell_asset( sender: T::AccountId, swap_token_list: Vec<CurrencyIdOf<T>>, sold_asset_amount: BalanceOf<T>, min_amount_out: BalanceOf<T> ) -> Result<BalanceOf<T>, DispatchError>

fn multiswap_sell_asset( sender: T::AccountId, swap_token_list: Vec<CurrencyIdOf<T>>, sold_asset_amount: BalanceOf<T>, min_amount_out: BalanceOf<T>, _err_upon_bad_slippage: bool, _err_upon_non_slippage_fail: bool ) -> Result<BalanceOf<T>, DispatchError>

fn buy_asset( sender: T::AccountId, sold_asset_id: CurrencyIdOf<T>, bought_asset_id: CurrencyIdOf<T>, bought_asset_amount: BalanceOf<T>, max_amount_in: BalanceOf<T>, err_upon_bad_slippage: bool ) -> Result<BalanceOf<T>, DispatchError>

fn do_multiswap_buy_asset( sender: T::AccountId, swap_token_list: Vec<CurrencyIdOf<T>>, bought_asset_amount: BalanceOf<T>, max_amount_in: BalanceOf<T> ) -> Result<BalanceOf<T>, DispatchError>

fn multiswap_buy_asset( sender: T::AccountId, swap_token_list: Vec<CurrencyIdOf<T>>, bought_asset_amount: BalanceOf<T>, max_amount_in: BalanceOf<T>, _err_upon_bad_slippage: bool, _err_upon_non_slippage_fail: bool ) -> Result<BalanceOf<T>, DispatchError>

fn mint_liquidity( sender: T::AccountId, first_asset_id: CurrencyIdOf<T>, second_asset_id: CurrencyIdOf<T>, first_asset_amount: BalanceOf<T>, expected_second_asset_amount: BalanceOf<T>, activate_minted_liquidity: bool ) -> Result<(CurrencyIdOf<T>, BalanceOf<T>), DispatchError>

fn do_compound_rewards( sender: T::AccountId, liquidity_asset_id: CurrencyIdOf<T>, amount_permille: Permill ) -> DispatchResult

fn provide_liquidity_with_conversion( sender: T::AccountId, first_asset_id: CurrencyIdOf<T>, second_asset_id: CurrencyIdOf<T>, provided_asset_id: CurrencyIdOf<T>, provided_asset_amount: BalanceOf<T>, activate_minted_liquidity: bool ) -> Result<(CurrencyIdOf<T>, BalanceOf<T>), DispatchError>

fn burn_liquidity( sender: T::AccountId, first_asset_id: CurrencyIdOf<T>, second_asset_id: CurrencyIdOf<T>, liquidity_asset_amount: BalanceOf<T> ) -> DispatchResult

fn get_tokens_required_for_minting( liquidity_asset_id: CurrencyIdOf<T>, liquidity_token_amount: BalanceOf<T> ) -> Result<(CurrencyIdOf<T>, BalanceOf<T>, CurrencyIdOf<T>, BalanceOf<T>), DispatchError>

fn is_liquidity_token(liquidity_asset_id: CurrencyIdOf<T>) -> bool

impl<T> Eq for Pallet<T>