Struct pallet_asset_index::pallet::Pallet

pub struct Pallet<T>(_);

The pallet implementing the on-chain logic.

Implementations

impl<T: Config> Pallet<T>

pub fn add_asset(
    origin: OriginFor<T>,
    asset_id: T::AssetId,
    units: T::Balance,
    amount: T::Balance
) -> DispatchResult

Callable by the governance committee to add new liquid assets to the index and mint the given amount IndexToken. The amount of PINT minted and awarded to the LP is specified as part of the associated proposal Caller’s balance is updated to allocate the correct amount of the IndexToken. The given amount of assets must already exist in the caller’s account, they are then transferred to the treasury account.

The Governance committee decides the tokens that comprise the index, as well as the allocation of each and their value.

pub fn force_add_asset(
    origin: OriginFor<T>,
    asset_id: T::AssetId,
    units: T::Balance,
    amount: T::Balance,
    recipient: T::AccountId
) -> DispatchResult

Add liquid asset with root origin, see add_asset

pub fn remove_asset(
    origin: OriginFor<T>,
    asset_id: T::AssetId,
    units: T::Balance,
    recipient: Option<T::AccountId>
) -> DispatchResult

Dispatches transfer to move assets out of the index’s account, if a liquid asset is specified Callable by an admin.

Updates the index to reflect the removed assets (units) by burning index token accordingly. If the given asset is liquid, an xcm transfer will be dispatched to transfer the given units into the sovereign account of either:

• the given recipient if provided
• the caller’s account if recipient is None

pub fn force_remove_asset(
    origin: OriginFor<T>,
    who: T::AccountId,
    asset_id: T::AssetId,
    units: T::Balance,
    recipient: Option<T::AccountId>
) -> DispatchResult

Remove liquid asset with root origin

pub fn register_asset(
    origin: OriginFor<T>,
    asset_id: T::AssetId,
    availability: AssetAvailability
) -> DispatchResult

Registers a new asset in the index together with its availability

Only callable by the admin origin and for assets that are not yet registered.

pub fn set_deposit_range(
    origin: OriginFor<T>,
    new_range: DepositRange<T::Balance>
) -> DispatchResult

Updates the range for how much a deposit must be worth in index token in order to be accpedted. Only callable by the admin origin

Parameters:

• new_range: The new valid range for deposits.

pub fn update_redemption_fees(
    origin: OriginFor<T>,
    new_range: RedemptionFeeRange<T::BlockNumber>
) -> DispatchResult

Updates the range for redemption fee

Only callable by the admin origin

Parameters:

• new_range: The new valid range for redemption fee.

pub fn set_lockup_period(
    origin: OriginFor<T>,
    lockup_period: T::BlockNumber
) -> DispatchResult

Updates the lockup period

Only callable by the admin origin

Parameters:

• lockup_period: how long will the depositing assets will be locked

pub fn set_metadata(
    origin: OriginFor<T>,
    id: T::AssetId,
    name: Vec<u8>,
    symbol: Vec<u8>,
    decimals: u8
) -> DispatchResult

Force the metadata for an asset to some value.

Origin must be ForceOrigin.

Any deposit is left alone.

• id: The identifier of the asset to update.
• name: The user friendly name of this asset. Limited in length by StringLimit.
• symbol: The exchange symbol for this asset. Limited in length by StringLimit.
• decimals: The number of decimals this asset uses to represent one unit.

Emits MetadataSet.

Weight: O(N + S) where N and S are the length of the name and symbol respectively.

pub fn deposit(
    origin: OriginFor<T>,
    asset_id: T::AssetId,
    units: T::Balance
) -> DispatchResult

Initiate a transfer from the user’s sovereign account into the index.

This will withdraw the given amount from the user’s sovereign account and mints PINT proportionally using the latest available price pairs

pub fn withdraw(origin: OriginFor<T>, amount: T::Balance) -> DispatchResult

Starts the withdraw process for the given amount of PINT to redeem for a distribution of underlying assets.

All withdrawals undergo an unlocking period after which the assets can be withdrawn. A withdrawal fee will be deducted from the PINT being redeemed by the LP depending on how long the assets remained in the index. The remaining PINT will be burned to match the new NAV after this withdrawal.

The distribution of the underlying assets will be equivalent to the ratio of the liquid assets in the index.

pub fn complete_withdraw(origin: OriginFor<T>) -> DispatchResult

Attempts to complete all currently pending redemption processes started by the withdraw extrinsic.

This checks every pending withdrawal within PendingWithdrawal and tries to close it. Completing a withdrawal will succeed if following conditions are met:

• the LockupPeriod has passed since the withdrawal was initiated
• the treasury can cover the asset transfer to the caller’s account, from which the caller then can initiate an Xcm::Withdraw to remove the assets from the PINT parachain entirely, if xcm transfers are supported.

NOTE: All individual withdrawals that resulted from “Withdraw” will be completed separately, however, the entire record of pending withdrawals will not be fully closed until the last withdrawal is completed. This means that a single AssetWithdrawal will be closed as soon as the aforementioned conditions are met, regardless of whether the other AssetWithdrawals in the same PendingWithdrawal set can also be closed successfully.

pub fn unlock(origin: OriginFor<T>) -> DispatchResult

Updates the index token locks of the caller.

This removes expired locks and updates the caller’s index token balance accordingly.

impl<T: Config> Pallet<T>

pub fn treasury_account() -> <T as Config>::AccountId

The account of the treausry that keeps track of all the assets contributed to the index

pub fn index_token_balance(account: &T::AccountId) -> T::Balance

The amount of index tokens held by the given user

pub fn index_token_issuance() -> T::Balance

The amount of index tokens

pub fn free_asset_balance(
    asset: T::AssetId,
    account: &T::AccountId
) -> T::Balance

The free balance of the given account for the given asset.

pub fn total_asset_balance(
    asset: T::AssetId,
    account: &T::AccountId
) -> T::Balance

The combined balance of the given account for the given asset.

pub fn index_total_asset_balance(asset: T::AssetId) -> T::Balance

The combined balance of the treasury account for the given asset.

pub fn index_free_asset_balance(asset: T::AssetId) -> T::Balance

The free balance of the treasury account for the given asset.

pub fn liquid_assets() -> impl Iterator<Item = T::AssetId>

Iterates over all liquid assets

pub fn saft_assets() -> impl Iterator<Item = T::AssetId>

Iterates over all SAFT assets

pub fn liquid_asset_redemptions(
    redeem: u128
) -> Result<AssetRedemption<T::AssetId, T::Balance>, DispatchError>

Calculates the pure asset redemption for the given amount of the index token to be redeemed for all the liquid tokens in the index

NOTE:

• This does not account for fees
• This is a no-op for redeem == 0

pub fn ensure_deposit_in_bounds(amount: T::Balance) -> DispatchResult

Ensures the given lies within the configured deposit range

impl<T: Config> Pallet<T>

pub fn error_metadata() -> Option<PalletErrorMetadata>

impl<T: Config> Pallet<T>

pub fn assets<KArg>(k: KArg) -> Option<AssetAvailability> where
    KArg: EncodeLike<T::AssetId>, 

(AssetId) -> AssetAvailability

impl<T: Config> Pallet<T>

pub fn deposits<KArg>(
    k: KArg
) -> BoundedVec<(T::Balance, T::BlockNumber), T::MaxActiveDeposits> where
    KArg: EncodeLike<T::AccountId>, 

All timestamped deposits of an account.

This tracks all deposits, the index token a LP received upon deposit. This will be used to calculate a withdrawal fee depending on how long the deposit remained in the index.

impl<T: Config> Pallet<T>

pub fn pending_withrawals<KArg>(
    k: KArg
) -> Option<Vec<PendingRedemption<T::AssetId, T::Balance, BlockNumberFor<T>>>> where
    KArg: EncodeLike<T::AccountId>, 

All currently pending withdrawal sets for an account. Where a single PendingRedemption is the result of a withdraw call.

(AccountId) -> Vec

impl<T: Config> Pallet<T>

pub fn index_token_locks<KArg>(
    k: KArg
) -> Vec<IndexTokenLock<T::BlockNumber, T::Balance>> where
    KArg: EncodeLike<T::AccountId>, 

Tracks the locks of the minted index token that are locked up until their LockupPeriod is over (AccountId) -> Vec

impl<T: Config> Pallet<T>

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

Tracks the amount of the currently locked index token per user. This is equal to the sum(IndexTokenLocks[AccountId]) (AccountId) -> Balance

impl<T: Config> Pallet<T>

pub fn deposit_bounds() -> DepositRange<T::Balance>

The range of the index token equivalent a deposit must be in in order to be allowed.

A valid deposit lies within [deposit_bounds.minimum, deposit_bounds.maximum].

impl<T: Config> Pallet<T>

pub fn asset_metadata<KArg>(
    k: KArg
) -> AssetMetadata<BoundedVec<u8, T::StringLimit>> where
    KArg: EncodeLike<T::AssetId>, 

Metadata of an asset ( for reversed usage now ).

Trait Implementations

impl<T: Config> AssetRecorder<<T as Config>::AccountId, <T as Config>::AssetId, <T as Config>::Balance> for Pallet<T>

fn add_liquid(
    caller: &T::AccountId,
    asset_id: T::AssetId,
    units: T::Balance,
    nav: T::Balance
) -> DispatchResult

Creates an entry in the assets map and contributes the given amount of asset to the treasury.

fn add_saft(
    caller: &T::AccountId,
    asset_id: T::AssetId,
    units: T::Balance,
    saft_nav: T::Balance
) -> DispatchResult

Mints the SAFT into the index and awards the caller with given amount of PINT token. If an asset with the given AssetId does not already exist, it will be registered as SAFT. Fails if the availability of the asset is liquid.

fn insert_asset_availability(
    asset_id: T::AssetId,
    availability: AssetAvailability
) -> Option<AssetAvailability>

Sets the availability of the given asset. If the asset was already registered, the old AssetAvailability is returned.

fn remove_liquid(
    who: &T::AccountId,
    asset_id: T::AssetId,
    units: T::Balance,
    nav: T::Balance,
    recipient: Option<T::AccountId>
) -> DispatchResult

Dispatches transfer to move liquid assets out of the index’s account. Updates the index by burning the given amount of index token from the caller’s account.

fn remove_saft(
    who: &T::AccountId,
    asset_id: T::AssetId,
    units: T::Balance,
    saft_nav: T::Balance
) -> DispatchResult

Burns the given amount of SAFT token from the index and the nav from the caller’s account

impl<T: Config> AssetRecorderBenchmarks<<T as Config>::AssetId, <T as Config>::Balance> for Pallet<T>

fn add_asset(
    asset_id: T::AssetId,
    units: T::Balance,
    location: MultiLocation,
    amount: T::Balance
) -> DispatchResult

create feed and add new liquid asset

fn deposit_saft_equivalent(saft_nav: T::Balance) -> DispatchResult

deposit index tokens to the testing account with saft_nav

impl<T: Config> Benchmarking for Pallet<T> where
    T: Config, 

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

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_finalize(_n: BlockNumber)

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

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

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_initialize(_n: BlockNumber) -> u64

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

fn on_runtime_upgrade() -> u64

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

fn native_asset_location(asset: &T::AssetId) -> Option<MultiLocation>

Determines the relative location of the consensus system where the given asset is native from the point of view of the current system

fn is_liquid_asset(asset: &T::AssetId) -> bool

Whether the given identifier is currently supported as a liquid asset

impl<T: Config> NavProvider<<T as Config>::AssetId, <T as Config>::Balance> for Pallet<T>

fn index_token_equivalent(
    asset: T::AssetId,
    units: T::Balance
) -> Result<T::Balance, DispatchError>

Calculates the amount of index tokens that the given units of the asset are worth.

fn asset_equivalent(
    index_tokens: T::Balance,
    asset: T::AssetId
) -> Result<T::Balance, DispatchError>

Calculates the units of the given asset that the given number of index_tokens are worth. This is the reverse of index_token_equivalent.

fn relative_asset_price(
    asset: T::AssetId
) -> Result<AssetPricePair<T::AssetId>, DispatchError>

Returns the price of the asset relative to the NAV of the index token.

fn calculate_net_asset_value(
    asset: T::AssetId,
    units: T::Balance
) -> Result<T::Balance, DispatchError>

Calculates the net value of the given units of the given asset.

fn calculate_net_liquid_value(
    asset: T::AssetId,
    units: T::Balance
) -> Result<T::Balance, DispatchError>

Calculates the net value of the given units of the given liquid asset.

fn calculate_net_saft_value(
    asset: T::AssetId,
    units: T::Balance
) -> Result<T::Balance, DispatchError>

Calculates the net value of the given units of the given SAFT.

fn total_net_liquid_value() -> Result<U256, DispatchError>

Calculates the net value of all liquid assets combined.

fn total_net_saft_value() -> Result<U256, DispatchError>

Calculates the net value of all SAFT combined.

fn total_net_asset_value() -> Result<U256, DispatchError>

Calculates the net asset value of all the index tokens which is equal to the sum of the total value of all assets.

fn net_asset_value(asset: T::AssetId) -> Result<T::Balance, DispatchError>

Calculates the net value of the given asset that were contributed to the index.

fn nav() -> Result<Price, DispatchError>

Calculates the NAV of the index token, consisting of liquid assets and SAFT.

fn liquid_nav() -> Result<Price, DispatchError>

Calculates the NAV of the index token solely for the liquid assets. This is a per token value: the value of a single unit of index token for the funds total liquid value.

fn saft_nav() -> Result<Price, DispatchError>

Calculates the NAV of the index token solely for the SAFT This is a per token value: the value of a single unit of index token for the funds total SAFT value.

fn asset_proportion(asset: T::AssetId) -> Result<Ratio, DispatchError>

Returns the share of the asset in the total value of the index: Asset Value / Total Net Asset Value

fn liquid_asset_proportion(asset: T::AssetId) -> Result<Ratio, DispatchError>

Returns the share of the liquid asset in the total value of all liquid assets in the index: Asset Value / Liquid Net Asset Value

fn saft_asset_proportion(asset: T::AssetId) -> Result<Ratio, DispatchError>

Returns the share of the asset in the total value of all SAFTs of the asset in the index: Asset Value / SAFT Net Asset Value

fn asset_proportions() -> Result<AssetProportions<T::AssetId>, DispatchError>

Returns the proportions for each asset in the index

fn liquid_asset_proportions(
) -> Result<AssetProportions<T::AssetId>, DispatchError>

Returns the proportions for each liquid asset in total value of liquid assets in the index

fn saft_asset_proportions(
) -> Result<AssetProportions<T::AssetId>, DispatchError>

Returns the proportions for each saft asset in total value of SAFTs in the index

fn index_token_issuance() -> T::Balance

The total supply of index tokens currently in circulation.

fn asset_balance(asset: T::AssetId) -> T::Balance

The amount of the given asset currently held in the index.

fn net_liquid_value(asset: AssetId) -> Result<Balance, DispatchError>

Calculates the net value of the given liquid asset.

fn navs() -> Result<(FixedU128, FixedU128), DispatchError>

Returns the per token NAV of the index token split to (liquid, saft).

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 accumulate(acc: &mut Vec<PalletInfoData>)

Extend the given vector by all of the pallets’ information that this type represents.

fn infos() -> Vec<PalletInfoData, Global>

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

impl<T: Config> SaftRegistry<<T as Config>::AssetId, <T as Config>::Balance> for Pallet<T>

fn net_saft_value(asset: T::AssetId) -> T::Balance

Returns the value of the assets currently secured by the SAFTS

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

fn storage_info() -> Vec<StorageInfo>

impl<T> Eq for Pallet<T>