Struct pallet_balances::pallet::Pallet

impl<T: Config, I: 'static> Pallet<T, I>

pub fn transfer(
 origin: OriginFor<T>,
 dest: <<T as Config>::Lookup as StaticLookup>::Source,
 value: T::Balance
) -> DispatchResultWithPostInfo

Transfer some liquid free balance to another account.

transfer will set the FreeBalance of the sender and receiver. If the sender’s account is below the existential deposit as a result of the transfer, the account will be reaped.

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

Dependent on arguments but not critical, given proper implementations for input config types. See related functions below.
It contains a limited number of reads and writes internally and no complex computation.

Related functions:

ensure_can_withdraw is always called internally but has a bounded complexity.
Transferring balances to accounts that did not exist before will cause T::OnNewAccount::on_new_account to be called.
Removing enough funds from an account will trigger T::DustRemoval::on_unbalanced.
transfer_keep_alive works the same way as transfer, but has an additional check that the transfer will not kill the origin account.

Origin account is already in memory, so no DB operations for them.

pub fn set_balance(
 origin: OriginFor<T>,
 who: <<T as Config>::Lookup as StaticLookup>::Source,
 new_free: T::Balance,
 new_reserved: T::Balance
) -> DispatchResultWithPostInfo

Set the balances of a given account.

This will alter FreeBalance and ReservedBalance in storage. it will also alter the total issuance of the system (TotalIssuance) appropriately. If the new free or reserved balance is below the existential deposit, it will reset the account nonce (frame_system::AccountNonce).

The dispatch origin for this call is root.

pub fn force_transfer(
 origin: OriginFor<T>,
 source: <<T as Config>::Lookup as StaticLookup>::Source,
 dest: <<T as Config>::Lookup as StaticLookup>::Source,
 value: T::Balance
) -> DispatchResultWithPostInfo

Exactly as transfer, except the origin must be root and the source account may be specified.

Same as transfer, but additional read and write because the source account is not assumed to be in the overlay.

pub fn transfer_keep_alive(
 origin: OriginFor<T>,
 dest: <<T as Config>::Lookup as StaticLookup>::Source,
 value: T::Balance
) -> DispatchResultWithPostInfo

Same as the transfer call, but with a check that the transfer will not kill the origin account.

99% of the time you want transfer instead.

pub fn transfer_all(
 origin: OriginFor<T>,
 dest: <<T as Config>::Lookup as StaticLookup>::Source,
 keep_alive: bool
) -> DispatchResult

Transfer the entire transferable balance from the caller account.

NOTE: This function only attempts to transfer transferable balances. This means that any locked, reserved, or existential deposits (when keep_alive is true), will not be transferred by this function. To ensure that this function results in a killed account, you might need to prepare the account by removing any reference counters, storage deposits, etc…

The dispatch origin of this call must be Signed.

dest: The recipient of the transfer.
keep_alive: A boolean to determine if the transfer_all operation should send all of the funds the account has, causing the sender account to be killed (false), or transfer everything except at least the existential deposit, which will guarantee to keep the sender account alive (true). #
O(1). Just like transfer, but reading the user’s transferable balance first. #

pub fn force_unreserve(
 origin: OriginFor<T>,
 who: <<T as Config>::Lookup as StaticLookup>::Source,
 amount: T::Balance
) -> DispatchResult

Unreserve some balance from a user by force.

Can only be called by ROOT.

impl<T: Config, I: 'static> Pallet<T, I>

pub fn total_issuance() -> T::Balance

The total units issued in the system.

impl<T: Config, I: 'static> Pallet<T, I>

pub fn locks<KArg>(
k: KArg
) -> WeakBoundedVec<BalanceLock<T::Balance>, T::MaxLocks>where
KArg: EncodeLike<T::AccountId>,

Any liquidity locks on some account balances. NOTE: Should only be accessed when setting, changing and freeing a lock.

impl<T: Config, I: 'static> Pallet<T, I>

pub fn reserves<KArg>(
k: KArg
) -> BoundedVec<ReserveData<T::ReserveIdentifier, T::Balance>, T::MaxReserves>where
KArg: EncodeLike<T::AccountId>,

Named reserves on some account balances.

impl<T: Config, I: 'static> Pallet<T, I>

pub fn free_balance(who: impl Borrow<T::AccountId>) -> T::Balance

Get the free balance of an account.

pub fn usable_balance(who: impl Borrow<T::AccountId>) -> T::Balance

Get the balance of an account that can be used for transfers, reservations, or any other non-locking, non-transaction-fee activity. Will be at most free_balance.

pub fn usable_balance_for_fees(who: impl Borrow<T::AccountId>) -> T::Balance

Get the balance of an account that can be used for paying transaction fees (not tipping, or any other kind of fees, though). Will be at most free_balance.

pub fn reserved_balance(who: impl Borrow<T::AccountId>) -> T::Balance

Get the reserved balance of an account.

pub fn mutate_account<R>(
who: &T::AccountId,
f: impl FnOnce(&mut AccountData<T::Balance>) -> R
) -> Result<R, DispatchError>

Mutate an account to some new value, or delete it entirely with None. Will enforce ExistentialDeposit law, annulling the account as needed.

NOTE: Doesn’t do any preparatory work for creating a new account, so should only be used when it is known that the account already exists.

NOTE: LOW-LEVEL: This will not attempt to maintain total issuance. It is expected that the caller will do this.

Trait Implementations§

impl<T, I: 'static> Benchmarking for Pallet<T, I>where
T: Config + 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”. Read more

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.

fn clone(&self) -> Self

Returns a copy of the value. Read more

1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more

impl<T: Config, I: 'static> Currency<<T as Config>::AccountId> for Pallet<T, I>where
T::Balance: MaybeSerializeDeserialize + Debug,

fn slash(
who: &T::AccountId,
value: Self::Balance
) -> (Self::NegativeImbalance, Self::Balance)

Slash a target account who, returning the negative imbalance created and any left over amount that could not be slashed.

Is a no-op if value to be slashed is zero or the account does not exist.

NOTE: slash() prefers free balance, but assumes that reserve balance can be drawn from in extreme circumstances. can_slash() should be used prior to slash() to avoid having to draw from reserved funds, however we err on the side of punishment if things are inconsistent or can_slash wasn’t used appropriately.

fn deposit_into_existing(
who: &T::AccountId,
value: Self::Balance
) -> Result<Self::PositiveImbalance, DispatchError>

Deposit some value into the free balance of an existing target account who.

Is a no-op if the value to be deposited is zero.

fn deposit_creating(
who: &T::AccountId,
value: Self::Balance
) -> Self::PositiveImbalance

Deposit some value into the free balance of who, possibly creating a new account.

This function is a no-op if:

the value to be deposited is zero; or
the value to be deposited is less than the required ED and the account does not yet exist; or
the deposit would necessitate the account to exist and there are no provider references; or
value is so large it would cause the balance of who to overflow.

fn withdraw(
 who: &T::AccountId,
 value: Self::Balance,
 reasons: WithdrawReasons,
 liveness: ExistenceRequirement
) -> Result<Self::NegativeImbalance, DispatchError>

Withdraw some free balance from an account, respecting existence requirements.

Is a no-op if value to be withdrawn is zero.

fn make_free_balance_be(
who: &T::AccountId,
value: Self::Balance
) -> SignedImbalance<Self::Balance, Self::PositiveImbalance>

Force the new free balance of a target account who to some new value balance.

type Balance = <T as Config>::Balance

The balance of an account.

type PositiveImbalance = PositiveImbalance<T, I>

The opaque token type for an imbalance. This is returned by unbalanced operations and must be dealt with. It may be dropped but cannot be cloned. Read more

type NegativeImbalance = NegativeImbalance<T, I>

The opaque token type for an imbalance. This is returned by unbalanced operations and must be dealt with. It may be dropped but cannot be cloned. Read more

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

The combined balance of who.

fn can_slash(who: &T::AccountId, value: Self::Balance) -> bool

Same result as slash(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. Read more

fn total_issuance() -> Self::Balance

The total amount of issuance in the system.

fn minimum_balance() -> Self::Balance

The minimum balance any single account may have. This is equivalent to the Balances module’s ExistentialDeposit. Read more

fn burn(amount: Self::Balance) -> Self::PositiveImbalance

Reduce the total issuance by amount and return the according imbalance. The imbalance will typically be used to reduce an account by the same amount with e.g. settle. Read more

fn issue(amount: Self::Balance) -> Self::NegativeImbalance

Increase the total issuance by amount and return the according imbalance. The imbalance will typically be used to increase an account by the same amount with e.g. resolve_into_existing or resolve_creating. Read more

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

The ‘free’ balance of a given account. Read more

fn ensure_can_withdraw(
    who: &T::AccountId,
    amount: T::Balance,
    reasons: WithdrawReasons,
    new_balance: T::Balance
) -> DispatchResult

Returns Ok iff the account is able to make a withdrawal of the given amount for the given reason. Basically, it’s just a dry-run of withdraw. Read more

fn transfer(
    transactor: &T::AccountId,
    dest: &T::AccountId,
    value: Self::Balance,
    existence_requirement: ExistenceRequirement
) -> DispatchResult

Transfer some liquid free balance to another staker. Read more

fn pair(
amount: Self::Balance
) -> (Self::PositiveImbalance, Self::NegativeImbalance)

Produce a pair of imbalances that cancel each other out exactly. Read more

fn resolve_into_existing(
who: &AccountId,
value: Self::NegativeImbalance
) -> Result<(), Self::NegativeImbalance>

Similar to deposit_creating, only accepts a NegativeImbalance and returns nothing on success. Read more

fn resolve_creating(who: &AccountId, value: Self::NegativeImbalance)

Similar to deposit_creating, only accepts a NegativeImbalance and returns nothing on success. Read more

fn settle(
 who: &AccountId,
 value: Self::PositiveImbalance,
 reasons: WithdrawReasons,
 liveness: ExistenceRequirement
) -> Result<(), Self::PositiveImbalance>

Similar to withdraw, only accepts a PositiveImbalance and returns nothing on success.

impl<T, I> Debug for Pallet<T, I>

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more

impl<T: Config, I: 'static> GetStorageVersion for Pallet<T, I>

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, I: 'static> Hooks<<T as Config>::BlockNumber> for Pallet<T, I>

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

fn on_initialize(_n: BlockNumber) -> Weight

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

fn on_runtime_upgrade() -> Weight

Perform a module upgrade. Read more

fn try_state(_n: BlockNumber) -> Result<(), &'static str>

Execute the sanity checks of this pallet, per block. Read more

fn pre_upgrade() -> Result<(), &'static str>

Execute some pre-checks prior to a runtime upgrade. Read more

fn post_upgrade() -> Result<(), &'static str>

Execute some post-checks after a runtime upgrade. Read more

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

fn integrity_test()

Run integrity test. Read more

impl<T: Config, I: 'static> Inspect<<T as Config>::AccountId> for Pallet<T, I>

type Balance = <T as Config>::Balance

Scalar type for representing balance of an account.

fn total_issuance() -> Self::Balance

The total amount of issuance in the system.

fn minimum_balance() -> Self::Balance

The minimum balance any single account may have.

fn balance(who: &T::AccountId) -> Self::Balance

Get the balance of who.

fn reducible_balance(who: &T::AccountId, keep_alive: bool) -> Self::Balance

Get the maximum amount that who can withdraw/transfer successfully.

fn can_deposit(
    who: &T::AccountId,
    amount: Self::Balance,
    mint: bool
) -> DepositConsequence

Returns true if the balance of who may be increased by amount. Read more

fn can_withdraw(
who: &T::AccountId,
amount: Self::Balance
) -> WithdrawConsequence<Self::Balance>

Returns Failed if the balance of who may not be decreased by amount, otherwise the consequence. Read more

impl<T: Config, I: 'static> InspectHold<<T as Config>::AccountId> for Pallet<T, I>

fn balance_on_hold(who: &T::AccountId) -> T::Balance

Amount of funds held in reserve by who.

fn can_hold(who: &T::AccountId, amount: T::Balance) -> bool

Check to see if some amount of funds of who may be placed on hold.

impl<T: Config, I: 'static> IntegrityTest for Pallet<T, I>

fn integrity_test()

Run integrity test. Read more

impl<T: Config, I: 'static> LockableCurrency<<T as Config>::AccountId> for Pallet<T, I>where
T::Balance: MaybeSerializeDeserialize + Debug,

type Moment = <T as Config>::BlockNumber

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

type MaxLocks = <T as Config>::MaxLocks

The maximum number of locks a user should have on their account.

fn set_lock(
    id: LockIdentifier,
    who: &T::AccountId,
    amount: T::Balance,
    reasons: WithdrawReasons
)

Create a new balance lock on account who. Read more

fn extend_lock(
    id: LockIdentifier,
    who: &T::AccountId,
    amount: T::Balance,
    reasons: WithdrawReasons
)

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

fn remove_lock(id: LockIdentifier, who: &T::AccountId)

Remove an existing lock.

impl<T: Config, I: 'static> Mutate<<T as Config>::AccountId> for Pallet<T, I>

fn mint_into(who: &T::AccountId, amount: Self::Balance) -> DispatchResult

Increase the balance of who by exactly amount, minting new tokens. If that isn’t possible then an Err is returned and nothing is changed. Read more

fn burn_from(
who: &T::AccountId,
amount: Self::Balance
) -> Result<Self::Balance, DispatchError>

Decrease the balance of who by at least amount, possibly slightly more in the case of minimum_balance requirements, burning the tokens. If that isn’t possible then an Err is returned and nothing is changed. If successful, the amount of tokens reduced is returned. Read more

fn slash(
who: &AccountId,
amount: Self::Balance
) -> Result<Self::Balance, DispatchError>

Attempt to reduce the balance of who by as much as possible up to amount, and possibly slightly more due to minimum_balance requirements. If no decrease is possible then an Err is returned and nothing is changed. If successful, the amount of tokens reduced is returned. Read more

fn teleport(
 source: &AccountId,
 dest: &AccountId,
 amount: Self::Balance
) -> Result<Self::Balance, DispatchError>

Transfer funds from one account into another. The default implementation uses mint_into and burn_from and may generate unwanted events. Read more

impl<T: Config, I: 'static> MutateHold<<T as Config>::AccountId> for Pallet<T, I>

fn hold(who: &T::AccountId, amount: Self::Balance) -> DispatchResult

Hold some funds in an account.

fn release(
 who: &T::AccountId,
 amount: Self::Balance,
 best_effort: bool
) -> Result<T::Balance, DispatchError>

Release up to amount held funds in an account. Read more

fn transfer_held(
 source: &T::AccountId,
 dest: &T::AccountId,
 amount: Self::Balance,
 best_effort: bool,
 on_hold: bool
) -> Result<Self::Balance, DispatchError>

Transfer held funds into a destination account. Read more

impl<T: Config, I: 'static> NamedReservableCurrency<<T as Config>::AccountId> for Pallet<T, I>where
T::Balance: MaybeSerializeDeserialize + Debug,

fn reserve_named(
    id: &Self::ReserveIdentifier,
    who: &T::AccountId,
    value: Self::Balance
) -> DispatchResult

Move value from the free balance from who to a named reserve balance.

Is a no-op if value to be reserved is zero.

fn unreserve_named(
    id: &Self::ReserveIdentifier,
    who: &T::AccountId,
    value: Self::Balance
) -> Self::Balance

Unreserve some funds, returning any amount that was unable to be unreserved.

Is a no-op if the value to be unreserved is zero.

fn slash_reserved_named(
    id: &Self::ReserveIdentifier,
    who: &T::AccountId,
    value: Self::Balance
) -> (Self::NegativeImbalance, Self::Balance)

Slash from reserved balance, returning the negative imbalance created, and any amount that was unable to be slashed.

Is a no-op if the value to be slashed is zero.

fn repatriate_reserved_named(
 id: &Self::ReserveIdentifier,
 slashed: &T::AccountId,
 beneficiary: &T::AccountId,
 value: Self::Balance,
 status: Status
) -> Result<Self::Balance, DispatchError>

Move the reserved balance of one account into the balance of another, according to status. If status is Reserved, the balance will be reserved with given id.

Is a no-op if:

the value to be moved is zero; or
the slashed id equal to beneficiary and the status is Reserved.

type ReserveIdentifier = <T as Config>::ReserveIdentifier

An identifier for a reserve. Used for disambiguating different reserves so that they can be individually replaced or removed. Read more

fn reserved_balance_named(
id: &Self::ReserveIdentifier,
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. Read more

fn ensure_reserved_named(
 id: &Self::ReserveIdentifier,
 who: &AccountId,
 value: Self::Balance
) -> Result<(), DispatchError>

Ensure the reserved balance is equal to value. Read more

fn unreserve_all_named(
id: &Self::ReserveIdentifier,
who: &AccountId
) -> Self::Balance

Unreserve all the named reserved balances, returning unreserved amount. Read more

fn slash_all_reserved_named(
id: &Self::ReserveIdentifier,
who: &AccountId
) -> Self::NegativeImbalance

Slash all the reserved balance, returning the negative imbalance created. Read more

fn repatriate_all_reserved_named(
 id: &Self::ReserveIdentifier,
 slashed: &AccountId,
 beneficiary: &AccountId,
 status: BalanceStatus
) -> Result<(), DispatchError>

Move all the named reserved balance of one account into the balance of another, according to status. If status is Reserved, the balance will be reserved with given id. Read more

impl<T: Config, I: 'static> OffchainWorker<<T as Config>::BlockNumber> for Pallet<T, I>

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

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

impl<T: Config, I: 'static> OnFinalize<<T as Config>::BlockNumber> for Pallet<T, I>

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

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

impl<T: Config, I: 'static> OnGenesis for Pallet<T, I>

fn on_genesis()

Something that should happen at genesis.

impl<T: Config, I: 'static> OnIdle<<T as Config>::BlockNumber> for Pallet<T, I>

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

impl<T: Config, I: 'static> OnInitialize<<T as Config>::BlockNumber> for Pallet<T, I>

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

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

impl<T: Config, I: 'static> OnRuntimeUpgrade for Pallet<T, I>

fn on_runtime_upgrade() -> Weight

Perform a module upgrade. Read more

fn pre_upgrade() -> Result<(), &'static str>

Execute some pre-checks prior to a runtime upgrade. Read more

fn post_upgrade() -> Result<(), &'static str>

Execute some post-checks after a runtime upgrade. Read more

impl<T: Config, I: 'static> PalletInfoAccess for Pallet<T, I>

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, I: 'static> PalletsInfoAccess for Pallet<T, I>

fn count() -> usize

The number of pallets’ information that this type represents. Read more

fn infos() -> Vec<PalletInfoData> ⓘ

All of the pallets’ information that this type represents.

impl<T, I> PartialEq<Pallet<T, I>> for Pallet<T, I>

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

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

1.0.0 · source§

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

impl<T: Config, I: 'static> ReservableCurrency<<T as Config>::AccountId> for Pallet<T, I>where
T::Balance: MaybeSerializeDeserialize + Debug,

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

Check if who can reserve value from their free balance.

Always true if value to be reserved is zero.

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

Move value from the free balance from who to their reserved balance.

Is a no-op if value to be reserved is zero.

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

Unreserve some funds, returning any amount that was unable to be unreserved.

Is a no-op if the value to be unreserved is zero or the account does not exist.

NOTE: returns amount value which wasn’t successfully unreserved.

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

Slash from reserved balance, returning the negative imbalance created, and any amount that was unable to be slashed.

Is a no-op if the value to be slashed is zero or the account does not exist.

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

Move the reserved balance of one account into the balance of another, according to status.

Is a no-op if:

the value to be moved is zero; or
the slashed id equal to beneficiary and the status is Reserved.

fn reserved_balance(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. Read more

impl<T: Config, I: 'static> StorageInfoTrait for Pallet<T, I>

fn storage_info() -> Vec<StorageInfo> ⓘ

impl<T: Config, I: 'static> Transfer<<T as Config>::AccountId> for Pallet<T, I>

fn transfer(
 source: &T::AccountId,
 dest: &T::AccountId,
 amount: T::Balance,
 keep_alive: bool
) -> Result<T::Balance, DispatchError>

Transfer funds from one account into another.

impl<T: Config, I: 'static> TryState<<T as Config>::BlockNumber> for Pallet<T, I>

fn try_state(
n: <T as Config>::BlockNumber,
_s: TryStateSelect
) -> Result<(), &'static str>

Execute the state checks.

impl<T: Config, I: 'static> Unbalanced<<T as Config>::AccountId> for Pallet<T, I>

fn set_balance(who: &T::AccountId, amount: Self::Balance) -> DispatchResult

Set the balance of who to amount. If this cannot be done for some reason (e.g. because the account cannot be created or an overflow) then an Err is returned. Read more

fn set_total_issuance(amount: Self::Balance)

Set the total issuance to amount.

fn decrease_balance(
who: &AccountId,
amount: Self::Balance
) -> Result<Self::Balance, DispatchError>

Reduce the balance of who by amount. If it cannot be reduced by that amount for some reason, return Err and don’t reduce it at all. If Ok, return the imbalance. Read more

fn decrease_balance_at_most(
who: &AccountId,
amount: Self::Balance
) -> Self::Balance

Reduce the balance of who by the most that is possible, up to amount. Read more

fn increase_balance(
who: &AccountId,
amount: Self::Balance
) -> Result<Self::Balance, DispatchError>

Increase the balance of who by amount. If it cannot be increased by that amount for some reason, return Err and don’t increase it at all. If Ok, return the imbalance. Read more

fn increase_balance_at_most(
who: &AccountId,
amount: Self::Balance
) -> Self::Balance

Increase the balance of who by the most that is possible, up to amount. Read more

impl<T, I> Eq for Pallet<T, I>

Auto Trait Implementations§

impl<T, I> RefUnwindSafe for Pallet<T, I>where
I: RefUnwindSafe,
T: RefUnwindSafe,

impl<T, I> Send for Pallet<T, I>where
I: Send,
T: Send,

impl<T, I> Sync for Pallet<T, I>where
I: Sync,
T: Sync,

impl<T, I> Unpin for Pallet<T, I>where
I: Unpin,
T: Unpin,

impl<T, I> UnwindSafe for Pallet<T, I>where
I: UnwindSafe,
T: UnwindSafe,

Blanket Implementations§

impl<T> Any for Twhere
T: 'static + ?Sized,

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<AccountId, U> Balanced<AccountId> for Uwhere
U: Unbalanced<AccountId>,

type OnDropCredit = DecreaseIssuance<AccountId, U>

The type for managing what happens when an instance of Credit is dropped without being used. Read more

type OnDropDebt = IncreaseIssuance<AccountId, U>

The type for managing what happens when an instance of Debt is dropped without being used.

fn rescind(
amount: >::Balance
) -> Imbalance<>::Balance, IncreaseIssuance<AccountId, U>, DecreaseIssuance<AccountId, U>>

Reduce the total issuance by amount and return the according imbalance. The imbalance will typically be used to reduce an account by the same amount with e.g. settle. Read more

fn issue(
amount: >::Balance
) -> Imbalance<>::Balance, DecreaseIssuance<AccountId, U>, IncreaseIssuance<AccountId, U>>

Increase the total issuance by amount and return the according imbalance. The imbalance will typically be used to increase an account by the same amount with e.g. resolve_into_existing or resolve_creating. Read more

fn slash(
who: &AccountId,
amount: >::Balance
) -> (Imbalance<>::Balance, DecreaseIssuance<AccountId, U>, IncreaseIssuance<AccountId, U>>, >::Balance)

Deducts up to value from the combined balance of who. This function cannot fail. Read more

fn deposit(
who: &AccountId,
amount: >::Balance
) -> Result<Imbalance<>::Balance, IncreaseIssuance<AccountId, U>, DecreaseIssuance<AccountId, U>>, DispatchError>

Mints exactly value into the account of who. Read more

fn withdraw(
who: &AccountId,
amount: >::Balance
) -> Result<Imbalance<>::Balance, DecreaseIssuance<AccountId, U>, IncreaseIssuance<AccountId, U>>, DispatchError>

Removes value balance from who account if possible. Read more

fn pair(
amount: Self::Balance
) -> (Imbalance<Self::Balance, Self::OnDropDebt, Self::OnDropCredit>, Imbalance<Self::Balance, Self::OnDropCredit, Self::OnDropDebt>)

Produce a pair of imbalances that cancel each other out exactly. Read more

fn resolve(
who: &AccountId,
credit: Imbalance<Self::Balance, Self::OnDropCredit, Self::OnDropDebt>
) -> Result<(), Imbalance<Self::Balance, Self::OnDropCredit, Self::OnDropDebt>>

The balance of who is increased in order to counter credit. If the whole of credit cannot be countered, then nothing is changed and the original credit is returned in an Err. Read more

fn settle(
who: &AccountId,
debt: Imbalance<Self::Balance, Self::OnDropDebt, Self::OnDropCredit>
) -> Result<Imbalance<Self::Balance, Self::OnDropCredit, Self::OnDropDebt>, Imbalance<Self::Balance, Self::OnDropDebt, Self::OnDropCredit>>

The balance of who is decreased in order to counter debt. If the whole of debt cannot be countered, then nothing is changed and the original debt is returned in an Err. Read more

impl<AccountId, T> BalancedHold<AccountId> for Twhere
T: Balanced<AccountId> + MutateHold<AccountId>,

fn slash_held(
who: &AccountId,
amount: <T as Inspect<AccountId>>::Balance
) -> (Imbalance<<T as Inspect<AccountId>>::Balance, <T as Balanced<AccountId>>::OnDropCredit, <T as Balanced<AccountId>>::OnDropDebt>, <T as Inspect<AccountId>>::Balance)

Reduce the balance of some funds on hold in an account. Read more

impl<T> Borrow<T> for Twhere
T: ?Sized,

const: unstable · source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for Twhere
T: ?Sized,

const: unstable · source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

impl<T> CheckedConversion for T

fn checked_from<T>(t: T) -> Option<Self>where
Self: TryFrom<T>,

Convert from a value of T into an equivalent instance of Option<Self>. Read more

fn checked_into<T>(self) -> Option<T>where
Self: TryInto<T>,

Consume self to return Some equivalent value of Option<T>. Read more

impl<T> Conv for T

fn conv<T>(self) -> Twhere
Self: Into<T>,

Converts self into T using Into<T>. Read more

impl<T> Downcast for Twhere
T: Any,

fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can then be further downcast into Box<ConcreteType> where ConcreteType implements Trait. Read more

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait. Read more

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s. Read more

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s. Read more

impl<T> DowncastSync for Twhere
T: Any + Send + Sync,

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync + 'static>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be further downcast into Arc<ConcreteType> where ConcreteType implements Trait. Read more

impl<T> DynClone for Twhere
T: Clone,

fn __clone_box(&self, _: Private) -> *mut ()

impl<Q, K> Equivalent<K> for Qwhere
Q: Eq + ?Sized,
K: Borrow<Q> + ?Sized,

fn equivalent(&self, key: &K) -> bool

Compare self to key and return true if they are equal.

impl<T> FmtForward for T

fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,

Causes self to use its Binary implementation when Debug-formatted. Read more

fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,

Causes self to use its Display implementation when Debug-formatted. Read more

fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,

Causes self to use its LowerExp implementation when Debug-formatted. Read more

fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,

Causes self to use its LowerHex implementation when Debug-formatted. Read more

fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,

Causes self to use its Octal implementation when Debug-formatted. Read more

fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,

Causes self to use its Pointer implementation when Debug-formatted. Read more

fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,

Causes self to use its UpperExp implementation when Debug-formatted. Read more

fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,

Causes self to use its UpperHex implementation when Debug-formatted. Read more

fn fmt_list(self) -> FmtList<Self>where
&'a Self: for<'a> IntoIterator,

Formats each item in a sequence. Read more

impl<T> From<T> for T

const: unstable · source§

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> Instrument for T

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

impl<T, U> Into for Twhere
U: From<T>,

const: unstable · source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

impl<T> IsType<T> for T

fn from_ref(t: &T) -> &T

Cast reference.

fn into_ref(&self) -> &T

Cast reference.

fn from_mut(t: &mut T) -> &mut T

Cast mutable reference.

fn into_mut(&mut self) -> &mut T

Cast mutable reference.

impl<T, Outer> IsWrappedBy<Outer> for Twhere
Outer: AsRef<T> + AsMut<T> + From<T>,
T: From<Outer>,

fn from_ref(outer: &Outer) -> &T

Get a reference to the inner from the outer.

fn from_mut(outer: &mut Outer) -> &mut T

Get a mutable reference to the inner from the outer.

impl OnRuntimeUpgradeHelpersExt for Uwhere
U: OnRuntimeUpgrade,

fn storage_key(ident: &str) -> [u8; 32]

Generate a storage key unique to this runtime upgrade. Read more

fn get_temp_storage<T>(at: &str) -> Option<T>where
T: Decode,

Get temporary storage data written by Self::set_temp_storage. Read more

fn set_temp_storage<T>(data: T, at: &str)where
T: Encode,

Write some temporary data to a specific storage that can be read (potentially in post-upgrade hook) via Self::get_temp_storage. Read more

impl<T> PalletVersionToStorageVersionHelper for Twhere
T: GetStorageVersion + PalletInfoAccess,

fn migrate(db_weight: &RuntimeDbWeight) -> Weight

impl<T> Pipe for Twhere
T: ?Sized,

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,

Pipes by value. This is generally the method you want to use. Read more

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,

Borrows self and passes that borrow into the pipe function. Read more

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,

Mutably borrows self and passes that borrow into the pipe function. Read more

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> Rwhere
 Self: Borrow,
 B: 'a + ?Sized,
 R: 'a,

Borrows self, then passes self.borrow() into the pipe function. Read more

fn pipe_borrow_mut<'a, B, R>(
 &'a mut self,
 func: impl FnOnce(&'a mut B) -> R
) -> Rwhere
 Self: BorrowMut,
 B: 'a + ?Sized,
 R: 'a,

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> Rwhere
 Self: AsRef,
 U: 'a + ?Sized,
 R: 'a,

Borrows self, then passes self.as_ref() into the pipe function.

fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> Rwhere
 Self: AsMut,
 U: 'a + ?Sized,
 R: 'a,

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> Rwhere
 Self: Deref<Target = T>,
 T: 'a + ?Sized,
 R: 'a,

Borrows self, then passes self.deref() into the pipe function.

fn pipe_deref_mut<'a, T, R>(&'a mut self, func: impl FnOnce(&'a mut T) -> R) -> Rwhere
 Self: DerefMut<Target = T> + Deref,
 T: 'a + ?Sized,
 R: 'a,

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

impl<T> Pointable for T

const ALIGN: usize = mem::align_of::<T>()

The alignment of pointer.

type Init = T

The type for initializers.

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more

impl<T> Same<T> for T

type Output = T

Should always be Self

impl<T> SaturatedConversion for T

fn saturated_from<T>(t: T) -> Selfwhere
Self: UniqueSaturatedFrom<T>,

Convert from a value of T into an equivalent instance of Self. Read more

fn saturated_into<T>(self) -> Twhere
Self: UniqueSaturatedInto<T>,

Consume self to return an equivalent value of T. Read more

impl<SS, SP> SupersetOf<SS> for SPwhere
SS: SubsetOf<SP>,

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its superset. Read more

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.

impl<T> Tap for T

fn tap(self, func: impl FnOnce(&Self)) -> Self

Immutable access to a value. Read more

fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self

Mutable access to a value. Read more

fn tap_borrow(self, func: impl FnOnce(&B)) -> Selfwhere
Self: Borrow,
B: ?Sized,

Immutable access to the Borrow of a value. Read more

fn tap_borrow_mut(self, func: impl FnOnce(&mut B)) -> Selfwhere
Self: BorrowMut,
B: ?Sized,

Mutable access to the BorrowMut of a value. Read more

fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Selfwhere
Self: AsRef<R>,
R: ?Sized,

Immutable access to the AsRef<R> view of a value. Read more

fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Selfwhere
Self: AsMut<R>,
R: ?Sized,

Mutable access to the AsMut<R> view of a value. Read more

fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Selfwhere
Self: Deref<Target = T>,
T: ?Sized,

Immutable access to the Deref::Target of a value. Read more

fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Selfwhere
Self: DerefMut<Target = T> + Deref,
T: ?Sized,

Mutable access to the Deref::Target of a value. Read more

fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self

Calls .tap() only in debug builds, and is erased in release builds.

fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

fn tap_borrow_dbg(self, func: impl FnOnce(&B)) -> Selfwhere
Self: Borrow,
B: ?Sized,

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

fn tap_borrow_mut_dbg(self, func: impl FnOnce(&mut B)) -> Selfwhere
Self: BorrowMut,
B: ?Sized,

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Selfwhere
Self: AsRef<R>,
R: ?Sized,

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Selfwhere
Self: AsMut<R>,
R: ?Sized,

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Selfwhere
Self: Deref<Target = T>,
T: ?Sized,

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Selfwhere
Self: DerefMut<Target = T> + Deref,
T: ?Sized,

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

impl<T> ToOwned for Twhere
T: Clone,

type Owned = T

The resulting type after obtaining ownership.

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more

impl<T> TryConv for T

fn try_conv<T>(self) -> Result<T, Self::Error>where
Self: TryInto<T>,

Attempts to convert self into T using TryInto<T>. Read more

impl<T, U> TryFrom for Twhere
U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

const: unstable · source§

fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Performs the conversion.

impl<T, U> TryInto for Twhere
U: TryFrom<T>,

type Error = >::Error

The type returned in the event of a conversion error.

const: unstable · source§

fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

impl<S, T> UncheckedInto<T> for Swhere
T: UncheckedFrom<S>,

fn unchecked_into(self) -> T

The counterpart to unchecked_from.

impl<T, S> UniqueSaturatedInto<T> for Swhere
T: Bounded,
S: TryInto<T>,

fn unique_saturated_into(self) -> T

Consume self to return an equivalent value of T.

impl<V, T> VZip<V> for Twhere
V: MultiLane<T>,

fn vzip(self) -> V

impl<T> WithSubscriber for T

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where
S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more

impl<T> MaybeDebug for Twhere
T: Debug,

impl<T> MaybeDebug for Twhere
T: Debug,

impl<T> MaybeRefUnwindSafe for Twhere
T: RefUnwindSafe,