Struct multicollateral_bonding_curve_pool::pallet::Pallet

pub struct Pallet<T>(_);

The pallet implementing the on-chain logic.

Implementations

impl<T: Config> Pallet<T>

pub fn initialize_pool( origin: OriginFor<T>, collateral_asset_id: T::AssetId ) -> DispatchResultWithPostInfo

Enable exchange path on the pool for pair BaseAsset-CollateralAsset.

pub fn set_reference_asset( origin: OriginFor<T>, reference_asset_id: T::AssetId ) -> DispatchResultWithPostInfo

Change reference asset which is used to determine collateral assets value. Inteded to be e.g. stablecoin DAI.

pub fn set_optional_reward_multiplier( origin: OriginFor<T>, collateral_asset_id: T::AssetId, multiplier: Option<Fixed> ) -> DispatchResultWithPostInfo

Set multiplier which is applied to rewarded amount when depositing particular collateral assets. None value indicates reward without change, same as Some(1.0).

pub fn set_price_bias( origin: OriginFor<T>, price_bias: Balance ) -> DispatchResultWithPostInfo

Changes initial_price used as bias in XOR-DAI(reference asset) price calculation

pub fn set_price_change_config( origin: OriginFor<T>, price_change_rate: Balance, price_change_step: Balance ) -> DispatchResultWithPostInfo

Changes price change rate and step

impl<T: Config> Pallet<T>

pub fn reserves_account_id() -> T::TechAccountId

Technical account used to store collateral tokens.

impl<T: Config> Pallet<T>

pub fn free_reserves_account_id() -> Option<T::AccountId>

impl<T: Config> Pallet<T>

pub fn pending_free_reserves() -> Vec<(T::AssetId, Balance)>

impl<T: Config> Pallet<T>

pub fn initial_price() -> Fixed

Buy price starting constant. This is the price users pay for new XOR.

impl<T: Config> Pallet<T>

pub fn price_change_step() -> Fixed

Cofficients in buy price function.

impl<T: Config> Pallet<T>

pub fn price_change_rate() -> Fixed

impl<T: Config> Pallet<T>

pub fn sell_price_coefficient() -> Fixed

Sets the sell function as a fraction of the buy function, so there is margin between the two functions.

impl<T: Config> Pallet<T>

pub fn always_distribute_coefficient() -> Fixed

Coefficient which determines the fraction of input collateral token to be exchanged to XOR and be distributed to predefined accounts. Relevant for the Buy function (when a user buys new XOR).

impl<T: Config> Pallet<T>

pub fn base_fee() -> Fixed

Base fee in XOR which is deducted on all trades, currently it’s burned: 0.3%

impl<T: Config> Pallet<T>

pub fn distribution_accounts( ) -> DistributionAccounts<DistributionAccountData<DistributionAccount<T::AccountId, T::TechAccountId>>>

Accounts that receive 20% buy/sell margin according to predefined proportions

impl<T: Config> Pallet<T>

pub fn enabled_targets() -> BTreeSet<T::AssetId>

Collateral Assets allowed to be sold by the token bonding curve

impl<T: Config> Pallet<T>

pub fn reference_asset_id() -> T::AssetId

Asset that is used to compare collateral assets by value, e.g., DAI

impl<T: Config> Pallet<T>

pub fn rewards<KArg>(k: KArg) -> (Balance, Balance)where KArg: EncodeLike<T::AccountId>,

Registry to store information about rewards owned by users in PSWAP. (claim_limit, available_rewards)

impl<T: Config> Pallet<T>

pub fn total_rewards() -> Balance

Total amount of PSWAP owned by accounts

impl<T: Config> Pallet<T>

pub fn incentivised_currencies_num() -> u32

Number of reserve currencies selling which user will get rewards, namely all registered collaterals except PSWAP and VAL

impl<T: Config> Pallet<T>

pub fn incentives_account_id() -> Option<T::AccountId>

Account which stores actual PSWAP intended for rewards

impl<T: Config> Pallet<T>

pub fn buy_function( main_asset_id: &T::AssetId, collateral_asset_id: &T::AssetId, price_variant: PriceVariant, delta: Fixed ) -> Result<Fixed, DispatchError>

Buy function with regards to asset total supply and its change delta. It represents the amount of input collateral required from the User to receive the requested XOR amount, i.e., the price the User buys XOR at.

XOR is also referred as main asset. Value of delta is assumed to be either positive or negative. For every price_change_step tokens the price goes up by price_change_rate.

buy_price_usd = (xor_total_supply + xor_supply_delta) / (price_change_step * price_change_rate) + initial_price_usd

pub fn buy_price( main_asset_id: &T::AssetId, collateral_asset_id: &T::AssetId, quantity: QuoteAmount<Balance> ) -> Result<Fixed, DispatchError>

Calculates and returns the current buy price, assuming that input is the collateral asset and output is the main asset.

To calculate price for a specific amount of assets (with desired main asset output), one needs to calculate the area of a right trapezoid.

AB : buy_function(xor_total_supply) CD : buy_function(xor_total_supply + xor_supply_delta)

         ..  C
       ..  │
  B  ..    │
    │   S  │
    │      │
  A └──────┘ D

1. Amount of collateral tokens needed in USD to get xor_supply_delta(AD) XOR tokens

S = ((AB + CD) / 2) * AD

or

buy_price_usd = ((buy_function(xor_total_supply) + buy_function(xor_total_supply + xor_supply_delta)) / 2) * xor_supply_delta

2. Amount of XOR tokens received by depositing S collateral tokens in USD:

Solving right trapezoid area formula with respect to xor_supply_delta (AD), actual square S is known and represents collateral amount. We have a quadratic equation:

buy_function(x) = price_change_coefficient * x + initial_price
Assume `M` = 1 / price_change_coefficient = 1 / 1337
Assume `P` = price_change_coefficient = 1337

M * AD² + 2 * AB * AD - 2 * S = 0
equation with two solutions, taking only positive one:
AD = (√((AB * 2 / M)² + 8 * S / M) - 2 * AB / M) / 2 (old formula)

AD = √(P * (AB² * P + 2 * S)) - AB * P (new formula)

or

(old)
xor_supply_delta = (√((buy_function(xor_total_supply) * 2 / price_change_coeff)²
                   + 8 * buy_price_usd / price_change_coeff) - 2 * buy_function(xor_total_supply)
                   / price_change_coeff) / 2

(new)
xor_supply_delta = √price_change_coefficient * √(buy_function(xor_total_supply)² * price_change_coefficient + 2 * buy_price_usd)
                   - buy_function(xor_total_supply) * price_change_coefficient

pub fn sell_price( main_asset_id: &T::AssetId, collateral_asset_id: &T::AssetId, quantity: QuoteAmount<Balance> ) -> Result<Fixed, DispatchError>

Calculates and returns the current sell price, assuming that input is the main asset and output is the collateral asset.

To calculate sell price for a specific amount of assets:

1. Current reserves of collateral token are taken
2. Same amount by value is assumed for main asset 2.1 Values are compared via getting prices for both main and collateral tokens with regard to another token called reference token which is set for particular pair. This should be e.g. stablecoin DAI. 2.2 Reference price for base token is taken as 80% of current bonding curve buy price. 2.3 Reference price for collateral token is taken as current market price, i.e. price for 1 token on liquidity proxy.
3. Given known reserves for main and collateral, output collateral amount is calculated by applying x*y=k model resulting in curve-like dependency.

pub fn sell_function( main_asset_id: &T::AssetId, collateral_asset_id: &T::AssetId, delta: Fixed ) -> Result<Fixed, DispatchError>

Sell function with regards to asset total supply and its change delta. It represents the amount of output collateral tokens received by User by indicating exact sold XOR amount. I.e. the price User sells at.

Value of delta is assumed to be either positive or negative. Sell function is sell_price_coefficient% of buy function (see buy_function).

sell_price = sell_price_coefficient * buy_price

pub fn set_reserves_account_id( account: T::TechAccountId ) -> Result<(), DispatchError>

Assign account id that is used to store deposited collateral tokens.

pub fn set_distribution_accounts( distribution_accounts: DistributionAccounts<DistributionAccountData<DistributionAccount<T::AccountId, T::TechAccountId>>> )

Assign accounts list to be used for free reserves distribution in config.

pub fn calculate_buy_reward( reserves_account_id: &T::AccountId, collateral_asset_id: &T::AssetId, _collateral_asset_amount: Balance, main_asset_amount: Balance ) -> Result<Balance, DispatchError>

Calculate amount of PSWAP rewarded for collateralizing XOR in TBC.

ideal_reserves_before = sell_function(0 to xor_total_supply_before_trade) ideal_reserves_after = sell_function(0 to xor_total_supply_after_trade) actual_reserves_before = collateral_asset_reserves * collateral_asset_usd_price actual_reserves_after = actual_reserves_before + collateral_asset_input_amount * collateral_asset_usd_price

unfunded_liabilities = (ideal_reserves_before - actual_reserves_before) a = unfunded_liabilities / ideal_reserves_before b = unfunded_liabilities / ideal_reserves_after P = initial_pswap_rewards N = enabled reserve currencies except PSWAP and VAL

reward_pswap = ((a - b) * mean(a, b) * P) / N

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> GetMarketInfo<<T as Config>::AssetId> for Pallet<T>

fn buy_price( base_asset: &T::AssetId, collateral_asset: &T::AssetId ) -> Result<Fixed, DispatchError>

The price in terms of the target_asset at which one can buy a unit of the base_asset on the primary market (e.g. from the bonding curve pool or xst).

fn sell_price( base_asset: &T::AssetId, collateral_asset: &T::AssetId ) -> Result<Fixed, DispatchError>

The price in terms of the target_asset at which one can sell a unit of the base_asset on the primary market (e.g. to the bonding curve pool or xst).

fn enabled_target_assets() -> BTreeSet<T::AssetId>

Returns set of enabled collateral/synthetic/reserve assets on bonding curve.

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

fn current_storage_version() -> StorageVersion

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

fn on_initialize(block_number: T::BlockNumber) -> Weight

The block is being initialized. Implement to have something happen.

fn on_finalize(_n: BlockNumber)

The block is being finalized. Implement to have something happen.

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

This will be run when the block is being finalized (before on_finalize). Implement to have something happen using the remaining weight. Will not fire if the remaining weight is 0. Return the weight used, the hook will subtract it from current weight used and pass the result to the next on_idle hook if it exists.

fn on_runtime_upgrade() -> Weight

Perform a module upgrade.

fn offchain_worker(_n: BlockNumber)

Implementing this function on a module allows you to perform long-running tasks that make (by default) validators generate transactions that feed results of those long-running computations back on chain.

fn integrity_test()

Run integrity test.

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

fn integrity_test()

Run integrity test.

impl<T: Config> LiquiditySource<<T as Config>::DEXId, <T as Config>::AccountId, <T as Config>::AssetId, u128, DispatchError> for Pallet<T>

fn can_exchange( dex_id: &T::DEXId, input_asset_id: &T::AssetId, output_asset_id: &T::AssetId ) -> bool

Check if liquidity source provides an exchange from given input asset to output asset.

fn quote( dex_id: &T::DEXId, input_asset_id: &T::AssetId, output_asset_id: &T::AssetId, amount: QuoteAmount<Balance>, deduce_fee: bool ) -> Result<(SwapOutcome<Balance>, Weight), DispatchError>

Get spot price of tokens based on desired amount.

fn exchange( sender: &T::AccountId, receiver: &T::AccountId, dex_id: &T::DEXId, input_asset_id: &T::AssetId, output_asset_id: &T::AssetId, desired_amount: SwapAmount<Balance> ) -> Result<(SwapOutcome<Balance>, Weight), DispatchError>

Perform exchange based on desired amount.

fn check_rewards( dex_id: &T::DEXId, input_asset_id: &T::AssetId, output_asset_id: &T::AssetId, input_amount: Balance, output_amount: Balance ) -> Result<(Vec<(Balance, T::AssetId, RewardReason)>, Weight), DispatchError>

Get rewards that are given for perfoming given exchange.

fn quote_without_impact( dex_id: &T::DEXId, input_asset_id: &T::AssetId, output_asset_id: &T::AssetId, amount: QuoteAmount<Balance>, deduce_fee: bool ) -> Result<SwapOutcome<Balance>, DispatchError>

Get spot price of tokens based on desired amount, ignoring non-linearity of underlying liquidity source.

fn quote_weight() -> Weight

Get weight of quote

fn exchange_weight() -> Weight

Get weight of exchange

fn check_rewards_weight() -> Weight

Get weight of exchange

impl<T: Config> OffchainWorker<<T as Config>::BlockNumber> for Pallet<T>

fn offchain_worker(n: <T as Config>::BlockNumber)

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

impl<T: Config> OnFinalize<<T as Config>::BlockNumber> for Pallet<T>

fn on_finalize(n: <T as Config>::BlockNumber)

The block is being finalized. Implement to have something happen.

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

fn on_genesis()

Something that should happen at genesis.

impl<T: Config> OnIdle<<T as Config>::BlockNumber> for Pallet<T>

fn on_idle(n: <T as Config>::BlockNumber, remaining_weight: Weight) -> Weight

The block is being finalized. Implement to have something happen in case there is leftover weight. Check the passed remaining_weight to make sure it is high enough to allow for your pallet’s extra computation.

impl<T: Config> OnInitialize<<T as Config>::BlockNumber> for Pallet<T>

fn on_initialize(n: <T as Config>::BlockNumber) -> Weight

The block is being initialized. Implement to have something happen.

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

fn on_runtime_upgrade() -> Weight

Perform a module 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> StorageInfoTrait for Pallet<T>

fn storage_info() -> Vec<StorageInfo>

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>