Struct serp_tes::module::Pallet

pub struct Pallet<T>(_);

Implementations

impl<T: Config> Pallet<T>

pub fn transfer(
    origin: OriginFor<T>,
    dest: <T::Lookup as StaticLookup>::Source,
    currency_id: <<T as Config>::Stp258Currency as Stp258Currency<<T as Config>::AccountId>>::CurrencyId,
    amount: <<T as Config>::Stp258Currency as Stp258Currency<<T as Config>::AccountId>>::Balance
) -> DispatchResultWithPostInfo

Transfer some balance to another account under currency_id.

The dispatch origin for this call must be Signed by the transactor.

pub fn transfer_native_currency(
    origin: OriginFor<T>,
    dest: <T::Lookup as StaticLookup>::Source,
    amount: <<T as Config>::Stp258Currency as Stp258Currency<<T as Config>::AccountId>>::Balance
) -> DispatchResultWithPostInfo

Transfer some native currency to another account.

The dispatch origin for this call must be Signed by the transactor.

pub fn update_balance(
    origin: OriginFor<T>,
    who: <T::Lookup as StaticLookup>::Source,
    currency_id: <<T as Config>::Stp258Currency as Stp258Currency<<T as Config>::AccountId>>::CurrencyId,
    amount: <<T as Config>::Stp258Currency as Stp258CurrencyExtended<<T as Config>::AccountId>>::Amount
) -> DispatchResultWithPostInfo

update amount of account who under currency_id.

The dispatch origin of this call must be Root.

Trait Implementations

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.

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

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

fn current_version() -> PalletVersion

Returns the current version of the pallet.

fn storage_version() -> Option<PalletVersion>

Returns the version of the pallet that is stored in storage.

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

pub fn on_finalize(_n: BlockNumber)

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

pub fn on_initialize(_n: BlockNumber) -> u64

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

pub fn on_runtime_upgrade() -> u64

Perform a module upgrade.

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

pub fn integrity_test()

Run integrity test.

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

fn integrity_test()

Run integrity test.

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

fn merge_account(source: &T::AccountId, dest: &T::AccountId) -> DispatchResult

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

fn metadata() -> &'static [ErrorMetadata]

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

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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

fn expand_supply(
    native_currency_id: Self::CurrencyId,
    stable_currency_id: Self::CurrencyId,
    expand_by: Self::Balance,
    quote_price: Self::Balance
) -> DispatchResult

Called when expand_supply is received from the SERP by the SerpTes through the on_expand_supply trigger. Implementation should deposit the amount to serpup_to, then amount will be slashed from serpup_from and update new_supply. quote_price is the price ( relative to the settcurrency) of the native_currency used to expand settcurrency supply. who is the account to serp with. quote_price here is sampled from mock and can be connected to an oracle.

fn contract_supply(
    native_currency_id: Self::CurrencyId,
    stable_currency_id: Self::CurrencyId,
    contract_by: Self::Balance,
    quote_price: Self::Balance
) -> DispatchResult

Called when contract_supply is received from the SERP by the SerpTes through the on_contract_supply trigger. Implementation should deposit the base_currency_id (The Native Currency) of amount to serpup_to, then amount will be slashed from serpup_from and update new_supply. quote_price is the price ( relative to the settcurrency) of the native_currency used to contract settcurrency supply. who is the account to serp with. quote_price here is sampled from mock and can be connected to an oracle.

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

type BlockNumber = <<T as Config>::Stp258Currency as SerpTes<<T as Config>::AccountId>>::BlockNumber

fn on_serp_block(
    now: Self::BlockNumber,
    stable_currency_id: Self::CurrencyId,
    stable_currency_price: Self::Balance,
    native_currency_id: Self::CurrencyId,
    native_currency_price: Self::Balance
) -> DispatchResult

Contracts or expands the currency supply based on conditions. Filters through the conditions to see whether it’s time to adjust supply or not.

fn supply_change(
    currency_id: Self::CurrencyId,
    new_price: Self::Balance
) -> Self::Balance

Calculate the amount of supply change from a fraction.

fn serp_elast(
    stable_currency_id: Self::CurrencyId,
    stable_currency_price: Self::Balance,
    native_currency_id: Self::CurrencyId,
    native_currency_price: Self::Balance
) -> DispatchResult

Expands (if the price is above pegbase) or contracts (if the price is below pegbase) the supply of SettCurrencies.

Weight:

• complexity: O(S + C)
  • S being the complexity of executing either expand_supply or contract_supply
  • C being a constant amount of storage reads for SettCurrency supply
• DB access:
  • 1 read for total_issuance
  • execute expand_supply OR execute contract_supply which have DB accesses

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

type CurrencyId = <<T as Config>::Stp258Currency as Stp258Currency<<T as Config>::AccountId>>::CurrencyId

The currency identifier.

type Balance = <<T as Config>::Stp258Currency as Stp258Currency<<T as Config>::AccountId>>::Balance

The balance of an account.

fn base_unit(currency_id: Self::CurrencyId) -> Self::Balance

base_unit of currency_id.

fn minimum_balance(currency_id: Self::CurrencyId) -> Self::Balance

Existential deposit of currency_id.

fn total_issuance(currency_id: Self::CurrencyId) -> Self::Balance

The total amount of issuance of currency_id.

fn total_balance(
    currency_id: Self::CurrencyId,
    who: &T::AccountId
) -> Self::Balance

fn free_balance(
    currency_id: Self::CurrencyId,
    who: &T::AccountId
) -> Self::Balance

fn ensure_can_withdraw(
    currency_id: Self::CurrencyId,
    who: &T::AccountId,
    amount: Self::Balance
) -> DispatchResult

A dry-run of withdraw. Returns Ok iff the account is able to make a withdrawal of the given amount.

fn transfer(
    currency_id: Self::CurrencyId,
    from: &T::AccountId,
    to: &T::AccountId,
    amount: Self::Balance
) -> DispatchResult

Transfer some amount from one account to another.

fn deposit(
    currency_id: Self::CurrencyId,
    who: &T::AccountId,
    amount: Self::Balance
) -> DispatchResult

Add amount to the balance of who under currency_id and increase total issuance.

fn withdraw(
    currency_id: Self::CurrencyId,
    who: &T::AccountId,
    amount: Self::Balance
) -> DispatchResult

Remove amount from the balance of who under currency_id and reduce total issuance.

fn can_slash(
    currency_id: Self::CurrencyId,
    who: &T::AccountId,
    amount: Self::Balance
) -> bool

Same result as slash(currency_id, who, value) (but without the side-effects) assuming there are no balance changes in the meantime and only the reserved balance is not taken into account.

fn slash(
    currency_id: Self::CurrencyId,
    who: &T::AccountId,
    amount: Self::Balance
) -> Self::Balance

Deduct the balance of who by up to amount.

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

type Amount = <<T as Config>::Stp258Currency as Stp258CurrencyExtended<<T as Config>::AccountId>>::Amount

The type for balance related operations, typically signed int.

fn update_balance(
    currency_id: Self::CurrencyId,
    who: &T::AccountId,
    by_amount: Self::Amount
) -> DispatchResult

Add or remove abs(by_amount) from the balance of who under currency_id. If positive by_amount, do add, else do remove.

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

type Moment = T::BlockNumber

The quantity used to denote time; usually just a BlockNumber.

fn set_lock(
    lock_id: LockIdentifier,
    currency_id: Self::CurrencyId,
    who: &T::AccountId,
    amount: Self::Balance
) -> DispatchResult

Create a new balance lock on account who.

fn extend_lock(
    lock_id: LockIdentifier,
    currency_id: Self::CurrencyId,
    who: &T::AccountId,
    amount: Self::Balance
) -> DispatchResult

Changes a balance lock (selected by lock_id) so that it becomes less liquid in all parameters or creates a new one if it does not exist.

fn remove_lock(
    lock_id: LockIdentifier,
    currency_id: Self::CurrencyId,
    who: &T::AccountId
) -> DispatchResult

Remove an existing lock.

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

fn can_reserve(
    currency_id: Self::CurrencyId,
    who: &T::AccountId,
    value: Self::Balance
) -> bool

Same result as reserve(who, value) (but without the side-effects) assuming there are no balance changes in the meantime.

fn slash_reserved(
    currency_id: Self::CurrencyId,
    who: &T::AccountId,
    value: Self::Balance
) -> Self::Balance

Deducts up to value from reserved balance of who. This function cannot fail.

fn reserved_balance(
    currency_id: Self::CurrencyId,
    who: &T::AccountId
) -> Self::Balance

The amount of the balance of a given account that is externally reserved; this can still get slashed, but gets slashed last of all.

fn reserve(
    currency_id: Self::CurrencyId,
    who: &T::AccountId,
    value: Self::Balance
) -> DispatchResult

Moves value from balance to reserved balance.

fn unreserve(
    currency_id: Self::CurrencyId,
    who: &T::AccountId,
    value: Self::Balance
) -> Self::Balance

Moves up to value from reserved balance to free balance. This function cannot fail.

fn repatriate_reserved(
    currency_id: Self::CurrencyId,
    slashed: &T::AccountId,
    beneficiary: &T::AccountId,
    value: Self::Balance,
    status: BalanceStatus
) -> Result<Self::Balance, DispatchError>

Moves up to value from reserved balance of account slashed to balance of account beneficiary. beneficiary must exist for this to succeed. If it does not, Err will be returned. Funds will be placed in either the free balance or the reserved balance, depending on the status.