Struct pallet_balances::pallet::Pallet
source · pub struct Pallet<T, I = ()>(_);
Expand description
The pallet implementing the on-chain logic.
Implementations
sourceimpl<T: Config<I>, I: 'static> Pallet<T, I>
impl<T: Config<I>, I: 'static> Pallet<T, I>
sourcepub fn transfer(
origin: OriginFor<T>,
dest: <<T as Config>::Lookup as StaticLookup>::Source,
value: T::Balance
) -> DispatchResultWithPostInfo
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 astransfer
, 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.
sourcepub fn set_balance(
origin: OriginFor<T>,
who: <<T as Config>::Lookup as StaticLookup>::Source,
new_free: T::Balance,
new_reserved: T::Balance
) -> DispatchResultWithPostInfo
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
.
sourcepub 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
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
sourcepub fn transfer_keep_alive(
origin: OriginFor<T>,
dest: <<T as Config>::Lookup as StaticLookup>::Source,
value: T::Balance
) -> DispatchResultWithPostInfo
pub fn transfer_keep_alive(
origin: OriginFor<T>,
dest: <<T as Config>::Lookup as StaticLookup>::Source,
value: T::Balance
) -> DispatchResultWithPostInfo
sourcepub fn transfer_all(
origin: OriginFor<T>,
dest: <<T as Config>::Lookup as StaticLookup>::Source,
keep_alive: bool
) -> DispatchResult
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 thetransfer_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. #
sourcepub fn force_unreserve(
origin: OriginFor<T>,
who: <<T as Config>::Lookup as StaticLookup>::Source,
amount: T::Balance
) -> DispatchResult
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.
sourceimpl<T: Config<I>, I: 'static> Pallet<T, I>
impl<T: Config<I>, I: 'static> Pallet<T, I>
sourcepub fn total_issuance() -> T::Balance
pub fn total_issuance() -> T::Balance
The total units issued in the system.
sourceimpl<T: Config<I>, I: 'static> Pallet<T, I>
impl<T: Config<I>, I: 'static> Pallet<T, I>
sourcepub fn inactive_issuance() -> T::Balance
pub fn inactive_issuance() -> T::Balance
The total units of outstanding deactivated balance in the system.
sourceimpl<T: Config<I>, I: 'static> Pallet<T, I>
impl<T: Config<I>, I: 'static> Pallet<T, I>
sourcepub fn locks<KArg>(
k: KArg
) -> WeakBoundedVec<BalanceLock<T::Balance>, T::MaxLocks>where
KArg: EncodeLike<T::AccountId>,
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.
sourceimpl<T: Config<I>, I: 'static> Pallet<T, I>
impl<T: Config<I>, I: 'static> Pallet<T, I>
sourcepub fn reserves<KArg>(
k: KArg
) -> BoundedVec<ReserveData<T::ReserveIdentifier, T::Balance>, T::MaxReserves>where
KArg: EncodeLike<T::AccountId>,
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.
sourceimpl<T: Config<I>, I: 'static> Pallet<T, I>
impl<T: Config<I>, I: 'static> Pallet<T, I>
sourcepub fn free_balance(who: impl Borrow<T::AccountId>) -> T::Balance
pub fn free_balance(who: impl Borrow<T::AccountId>) -> T::Balance
Get the free balance of an account.
sourcepub fn usable_balance(who: impl Borrow<T::AccountId>) -> T::Balance
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
.
sourcepub fn usable_balance_for_fees(who: impl Borrow<T::AccountId>) -> T::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
.
sourcepub fn reserved_balance(who: impl Borrow<T::AccountId>) -> T::Balance
pub fn reserved_balance(who: impl Borrow<T::AccountId>) -> T::Balance
Get the reserved balance of an account.
sourcepub fn mutate_account<R>(
who: &T::AccountId,
f: impl FnOnce(&mut AccountData<T::Balance>) -> R
) -> Result<R, DispatchError>
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
sourceimpl<T: Config<I>, I: 'static> Benchmarking for Pallet<T, I>where
T: Config,
impl<T: Config<I>, I: 'static> Benchmarking for Pallet<T, I>where
T: Config,
sourcefn benchmarks(extra: bool) -> Vec<BenchmarkMetadata> ⓘ
fn benchmarks(extra: bool) -> Vec<BenchmarkMetadata> ⓘ
sourcefn run_benchmark(
extrinsic: &[u8],
c: &[(BenchmarkParameter, u32)],
whitelist: &[TrackedStorageKey],
verify: bool,
internal_repeats: u32
) -> Result<Vec<BenchmarkResult>, BenchmarkError>
fn run_benchmark(
extrinsic: &[u8],
c: &[(BenchmarkParameter, u32)],
whitelist: &[TrackedStorageKey],
verify: bool,
internal_repeats: u32
) -> Result<Vec<BenchmarkResult>, BenchmarkError>
sourceimpl<T: Config<I>, I: 'static> Currency<<T as Config>::AccountId> for Pallet<T, I>where
T::Balance: MaybeSerializeDeserialize + Debug,
impl<T: Config<I>, I: 'static> Currency<<T as Config>::AccountId> for Pallet<T, I>where
T::Balance: MaybeSerializeDeserialize + Debug,
sourcefn slash(
who: &T::AccountId,
value: Self::Balance
) -> (Self::NegativeImbalance, Self::Balance)
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.
sourcefn deposit_into_existing(
who: &T::AccountId,
value: Self::Balance
) -> Result<Self::PositiveImbalance, DispatchError>
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.
sourcefn deposit_creating(
who: &T::AccountId,
value: Self::Balance
) -> Self::PositiveImbalance
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 ofwho
to overflow.
sourcefn withdraw(
who: &T::AccountId,
value: Self::Balance,
reasons: WithdrawReasons,
liveness: ExistenceRequirement
) -> Result<Self::NegativeImbalance, DispatchError>
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.
sourcefn make_free_balance_be(
who: &T::AccountId,
value: Self::Balance
) -> SignedImbalance<Self::Balance, Self::PositiveImbalance>
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 PositiveImbalance = PositiveImbalance<T, I>
type PositiveImbalance = PositiveImbalance<T, I>
type NegativeImbalance = NegativeImbalance<T, I>
type NegativeImbalance = NegativeImbalance<T, I>
sourcefn total_balance(who: &T::AccountId) -> Self::Balance
fn total_balance(who: &T::AccountId) -> Self::Balance
who
.sourcefn can_slash(who: &T::AccountId, value: Self::Balance) -> bool
fn can_slash(who: &T::AccountId, value: Self::Balance) -> bool
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 moresourcefn total_issuance() -> Self::Balance
fn total_issuance() -> Self::Balance
sourcefn active_issuance() -> Self::Balance
fn active_issuance() -> Self::Balance
sourcefn deactivate(amount: Self::Balance)
fn deactivate(amount: Self::Balance)
sourcefn reactivate(amount: Self::Balance)
fn reactivate(amount: Self::Balance)
sourcefn minimum_balance() -> Self::Balance
fn minimum_balance() -> Self::Balance
Balances
module’s ExistentialDeposit
. Read moresourcefn burn(amount: Self::Balance) -> Self::PositiveImbalance
fn burn(amount: Self::Balance) -> Self::PositiveImbalance
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 moresourcefn issue(amount: Self::Balance) -> Self::NegativeImbalance
fn issue(amount: Self::Balance) -> Self::NegativeImbalance
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 moresourcefn free_balance(who: &T::AccountId) -> Self::Balance
fn free_balance(who: &T::AccountId) -> Self::Balance
sourcefn ensure_can_withdraw(
who: &T::AccountId,
amount: T::Balance,
reasons: WithdrawReasons,
new_balance: T::Balance
) -> DispatchResult
fn ensure_can_withdraw(
who: &T::AccountId,
amount: T::Balance,
reasons: WithdrawReasons,
new_balance: T::Balance
) -> DispatchResult
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 moresourcefn transfer(
transactor: &T::AccountId,
dest: &T::AccountId,
value: Self::Balance,
existence_requirement: ExistenceRequirement
) -> DispatchResult
fn transfer(
transactor: &T::AccountId,
dest: &T::AccountId,
value: Self::Balance,
existence_requirement: ExistenceRequirement
) -> DispatchResult
sourcefn pair(
amount: Self::Balance
) -> (Self::PositiveImbalance, Self::NegativeImbalance)
fn pair(
amount: Self::Balance
) -> (Self::PositiveImbalance, Self::NegativeImbalance)
sourcefn resolve_into_existing(
who: &AccountId,
value: Self::NegativeImbalance
) -> Result<(), Self::NegativeImbalance>
fn resolve_into_existing(
who: &AccountId,
value: Self::NegativeImbalance
) -> Result<(), Self::NegativeImbalance>
NegativeImbalance
and returns nothing on
success. Read moresourcefn resolve_creating(who: &AccountId, value: Self::NegativeImbalance)
fn resolve_creating(who: &AccountId, value: Self::NegativeImbalance)
NegativeImbalance
and returns nothing on
success. Read moresourcefn settle(
who: &AccountId,
value: Self::PositiveImbalance,
reasons: WithdrawReasons,
liveness: ExistenceRequirement
) -> Result<(), Self::PositiveImbalance>
fn settle(
who: &AccountId,
value: Self::PositiveImbalance,
reasons: WithdrawReasons,
liveness: ExistenceRequirement
) -> Result<(), Self::PositiveImbalance>
PositiveImbalance
and returns nothing on success.sourceimpl<T: Config<I>, I: 'static> GetStorageVersion for Pallet<T, I>
impl<T: Config<I>, I: 'static> GetStorageVersion for Pallet<T, I>
sourcefn current_storage_version() -> StorageVersion
fn current_storage_version() -> StorageVersion
sourcefn on_chain_storage_version() -> StorageVersion
fn on_chain_storage_version() -> StorageVersion
sourceimpl<T: Config<I>, I: 'static> Hooks<<T as Config>::BlockNumber> for Pallet<T, I>
impl<T: Config<I>, I: 'static> Hooks<<T as Config>::BlockNumber> for Pallet<T, I>
sourcefn on_finalize(_n: BlockNumber)
fn on_finalize(_n: BlockNumber)
sourcefn on_idle(_n: BlockNumber, _remaining_weight: Weight) -> Weight
fn on_idle(_n: BlockNumber, _remaining_weight: Weight) -> Weight
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 moresourcefn on_initialize(_n: BlockNumber) -> Weight
fn on_initialize(_n: BlockNumber) -> Weight
sourcefn on_runtime_upgrade() -> Weight
fn on_runtime_upgrade() -> Weight
sourcefn try_state(_n: BlockNumber) -> Result<(), &'static str>
fn try_state(_n: BlockNumber) -> Result<(), &'static str>
sourcefn pre_upgrade() -> Result<Vec<u8, Global>, &'static str>
fn pre_upgrade() -> Result<Vec<u8, Global>, &'static str>
sourcefn post_upgrade(_state: Vec<u8, Global>) -> Result<(), &'static str>
fn post_upgrade(_state: Vec<u8, Global>) -> Result<(), &'static str>
sourcefn offchain_worker(_n: BlockNumber)
fn offchain_worker(_n: BlockNumber)
sourcefn integrity_test()
fn integrity_test()
sourceimpl<T: Config<I>, I: 'static> Inspect<<T as Config>::AccountId> for Pallet<T, I>
impl<T: Config<I>, I: 'static> Inspect<<T as Config>::AccountId> for Pallet<T, I>
sourcefn total_issuance() -> Self::Balance
fn total_issuance() -> Self::Balance
sourcefn active_issuance() -> Self::Balance
fn active_issuance() -> Self::Balance
sourcefn minimum_balance() -> Self::Balance
fn minimum_balance() -> Self::Balance
sourcefn reducible_balance(who: &T::AccountId, keep_alive: bool) -> Self::Balance
fn reducible_balance(who: &T::AccountId, keep_alive: bool) -> Self::Balance
who
can withdraw/transfer successfully.sourcefn can_deposit(
who: &T::AccountId,
amount: Self::Balance,
mint: bool
) -> DepositConsequence
fn can_deposit(
who: &T::AccountId,
amount: Self::Balance,
mint: bool
) -> DepositConsequence
sourcefn can_withdraw(
who: &T::AccountId,
amount: Self::Balance
) -> WithdrawConsequence<Self::Balance>
fn can_withdraw(
who: &T::AccountId,
amount: Self::Balance
) -> WithdrawConsequence<Self::Balance>
Failed
if the balance of who
may not be decreased by amount
, otherwise
the consequence. Read moresourceimpl<T: Config<I>, I: 'static> IntegrityTest for Pallet<T, I>
impl<T: Config<I>, I: 'static> IntegrityTest for Pallet<T, I>
sourcefn integrity_test()
fn integrity_test()
sourceimpl<T: Config<I>, I: 'static> LockableCurrency<<T as Config>::AccountId> for Pallet<T, I>where
T::Balance: MaybeSerializeDeserialize + Debug,
impl<T: Config<I>, I: 'static> LockableCurrency<<T as Config>::AccountId> for Pallet<T, I>where
T::Balance: MaybeSerializeDeserialize + Debug,
type Moment = <T as Config>::BlockNumber
type Moment = <T as Config>::BlockNumber
BlockNumber
.type MaxLocks = <T as Config<I>>::MaxLocks
type MaxLocks = <T as Config<I>>::MaxLocks
sourcefn set_lock(
id: LockIdentifier,
who: &T::AccountId,
amount: T::Balance,
reasons: WithdrawReasons
)
fn set_lock(
id: LockIdentifier,
who: &T::AccountId,
amount: T::Balance,
reasons: WithdrawReasons
)
who
. Read moresourcefn extend_lock(
id: LockIdentifier,
who: &T::AccountId,
amount: T::Balance,
reasons: WithdrawReasons
)
fn extend_lock(
id: LockIdentifier,
who: &T::AccountId,
amount: T::Balance,
reasons: WithdrawReasons
)
id
) so that it becomes less liquid in all
parameters or creates a new one if it does not exist. Read moresourcefn remove_lock(id: LockIdentifier, who: &T::AccountId)
fn remove_lock(id: LockIdentifier, who: &T::AccountId)
sourceimpl<T: Config<I>, I: 'static> Mutate<<T as Config>::AccountId> for Pallet<T, I>
impl<T: Config<I>, I: 'static> Mutate<<T as Config>::AccountId> for Pallet<T, I>
sourcefn mint_into(who: &T::AccountId, amount: Self::Balance) -> DispatchResult
fn mint_into(who: &T::AccountId, amount: Self::Balance) -> DispatchResult
who
by exactly amount
, minting new tokens. If that isn’t
possible then an Err
is returned and nothing is changed. Read moresourcefn burn_from(
who: &T::AccountId,
amount: Self::Balance
) -> Result<Self::Balance, DispatchError>
fn burn_from(
who: &T::AccountId,
amount: Self::Balance
) -> Result<Self::Balance, DispatchError>
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 moresourcefn slash(
who: &AccountId,
amount: Self::Balance
) -> Result<Self::Balance, DispatchError>
fn slash(
who: &AccountId,
amount: Self::Balance
) -> Result<Self::Balance, DispatchError>
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 moresourceimpl<T: Config<I>, I: 'static> MutateHold<<T as Config>::AccountId> for Pallet<T, I>
impl<T: Config<I>, I: 'static> MutateHold<<T as Config>::AccountId> for Pallet<T, I>
sourceimpl<T: Config<I>, I: 'static> NamedReservableCurrency<<T as Config>::AccountId> for Pallet<T, I>where
T::Balance: MaybeSerializeDeserialize + Debug,
impl<T: Config<I>, I: 'static> NamedReservableCurrency<<T as Config>::AccountId> for Pallet<T, I>where
T::Balance: MaybeSerializeDeserialize + Debug,
sourcefn reserve_named(
id: &Self::ReserveIdentifier,
who: &T::AccountId,
value: Self::Balance
) -> DispatchResult
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.
sourcefn unreserve_named(
id: &Self::ReserveIdentifier,
who: &T::AccountId,
value: Self::Balance
) -> Self::Balance
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.
sourcefn slash_reserved_named(
id: &Self::ReserveIdentifier,
who: &T::AccountId,
value: Self::Balance
) -> (Self::NegativeImbalance, Self::Balance)
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.
sourcefn repatriate_reserved_named(
id: &Self::ReserveIdentifier,
slashed: &T::AccountId,
beneficiary: &T::AccountId,
value: Self::Balance,
status: Status
) -> Result<Self::Balance, DispatchError>
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 tobeneficiary
and thestatus
isReserved
.
type ReserveIdentifier = <T as Config<I>>::ReserveIdentifier
type ReserveIdentifier = <T as Config<I>>::ReserveIdentifier
sourcefn reserved_balance_named(
id: &Self::ReserveIdentifier,
who: &T::AccountId
) -> Self::Balance
fn reserved_balance_named(
id: &Self::ReserveIdentifier,
who: &T::AccountId
) -> Self::Balance
sourcefn ensure_reserved_named(
id: &Self::ReserveIdentifier,
who: &AccountId,
value: Self::Balance
) -> Result<(), DispatchError>
fn ensure_reserved_named(
id: &Self::ReserveIdentifier,
who: &AccountId,
value: Self::Balance
) -> Result<(), DispatchError>
value
. Read moresourcefn unreserve_all_named(
id: &Self::ReserveIdentifier,
who: &AccountId
) -> Self::Balance
fn unreserve_all_named(
id: &Self::ReserveIdentifier,
who: &AccountId
) -> Self::Balance
sourcefn slash_all_reserved_named(
id: &Self::ReserveIdentifier,
who: &AccountId
) -> Self::NegativeImbalance
fn slash_all_reserved_named(
id: &Self::ReserveIdentifier,
who: &AccountId
) -> Self::NegativeImbalance
sourcefn repatriate_all_reserved_named(
id: &Self::ReserveIdentifier,
slashed: &AccountId,
beneficiary: &AccountId,
status: BalanceStatus
) -> Result<(), DispatchError>
fn repatriate_all_reserved_named(
id: &Self::ReserveIdentifier,
slashed: &AccountId,
beneficiary: &AccountId,
status: BalanceStatus
) -> Result<(), DispatchError>
status
. If status
is Reserved
, the balance will be reserved with given id
. Read moresourceimpl<T: Config<I>, I: 'static> OffchainWorker<<T as Config>::BlockNumber> for Pallet<T, I>
impl<T: Config<I>, I: 'static> OffchainWorker<<T as Config>::BlockNumber> for Pallet<T, I>
sourcefn offchain_worker(n: <T as Config>::BlockNumber)
fn offchain_worker(n: <T as Config>::BlockNumber)
sourceimpl<T: Config<I>, I: 'static> OnFinalize<<T as Config>::BlockNumber> for Pallet<T, I>
impl<T: Config<I>, I: 'static> OnFinalize<<T as Config>::BlockNumber> for Pallet<T, I>
sourcefn on_finalize(n: <T as Config>::BlockNumber)
fn on_finalize(n: <T as Config>::BlockNumber)
sourceimpl<T: Config<I>, I: 'static> OnGenesis for Pallet<T, I>
impl<T: Config<I>, I: 'static> OnGenesis for Pallet<T, I>
sourcefn on_genesis()
fn on_genesis()
sourceimpl<T: Config<I>, I: 'static> OnIdle<<T as Config>::BlockNumber> for Pallet<T, I>
impl<T: Config<I>, I: 'static> OnIdle<<T as Config>::BlockNumber> for Pallet<T, I>
sourcefn on_idle(n: <T as Config>::BlockNumber, remaining_weight: Weight) -> Weight
fn on_idle(n: <T as Config>::BlockNumber, remaining_weight: Weight) -> Weight
remaining_weight
to make sure it is high enough to allow for
your pallet’s extra computation. Read moresourceimpl<T: Config<I>, I: 'static> OnInitialize<<T as Config>::BlockNumber> for Pallet<T, I>
impl<T: Config<I>, I: 'static> OnInitialize<<T as Config>::BlockNumber> for Pallet<T, I>
sourcefn on_initialize(n: <T as Config>::BlockNumber) -> Weight
fn on_initialize(n: <T as Config>::BlockNumber) -> Weight
sourceimpl<T: Config<I>, I: 'static> OnRuntimeUpgrade for Pallet<T, I>
impl<T: Config<I>, I: 'static> OnRuntimeUpgrade for Pallet<T, I>
sourcefn on_runtime_upgrade() -> Weight
fn on_runtime_upgrade() -> Weight
sourcefn pre_upgrade() -> Result<Vec<u8>, &'static str>
fn pre_upgrade() -> Result<Vec<u8>, &'static str>
sourceimpl<T: Config<I>, I: 'static> PalletInfoAccess for Pallet<T, I>
impl<T: Config<I>, I: 'static> PalletInfoAccess for Pallet<T, I>
sourcefn module_name() -> &'static str
fn module_name() -> &'static str
sourcefn crate_version() -> CrateVersion
fn crate_version() -> CrateVersion
sourceimpl<T: Config<I>, I: 'static> PalletsInfoAccess for Pallet<T, I>
impl<T: Config<I>, I: 'static> PalletsInfoAccess for Pallet<T, I>
sourceimpl<T: Config<I>, I: 'static> ReservableCurrency<<T as Config>::AccountId> for Pallet<T, I>where
T::Balance: MaybeSerializeDeserialize + Debug,
impl<T: Config<I>, I: 'static> ReservableCurrency<<T as Config>::AccountId> for Pallet<T, I>where
T::Balance: MaybeSerializeDeserialize + Debug,
sourcefn can_reserve(who: &T::AccountId, value: Self::Balance) -> bool
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.
sourcefn reserve(who: &T::AccountId, value: Self::Balance) -> DispatchResult
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.
sourcefn unreserve(who: &T::AccountId, value: Self::Balance) -> Self::Balance
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.
sourcefn slash_reserved(
who: &T::AccountId,
value: Self::Balance
) -> (Self::NegativeImbalance, Self::Balance)
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.
sourcefn repatriate_reserved(
slashed: &T::AccountId,
beneficiary: &T::AccountId,
value: Self::Balance,
status: Status
) -> Result<Self::Balance, DispatchError>
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 tobeneficiary
and thestatus
isReserved
.
sourcefn reserved_balance(who: &T::AccountId) -> Self::Balance
fn reserved_balance(who: &T::AccountId) -> Self::Balance
sourceimpl<T: Config<I>, I: 'static> StorageInfoTrait for Pallet<T, I>
impl<T: Config<I>, I: 'static> StorageInfoTrait for Pallet<T, I>
fn storage_info() -> Vec<StorageInfo> ⓘ
sourceimpl<T: Config<I>, I: 'static> Transfer<<T as Config>::AccountId> for Pallet<T, I>
impl<T: Config<I>, I: 'static> Transfer<<T as Config>::AccountId> for Pallet<T, I>
sourcefn transfer(
source: &T::AccountId,
dest: &T::AccountId,
amount: T::Balance,
keep_alive: bool
) -> Result<T::Balance, DispatchError>
fn transfer(
source: &T::AccountId,
dest: &T::AccountId,
amount: T::Balance,
keep_alive: bool
) -> Result<T::Balance, DispatchError>
sourcefn deactivate(amount: Self::Balance)
fn deactivate(amount: Self::Balance)
sourcefn reactivate(amount: Self::Balance)
fn reactivate(amount: Self::Balance)
sourceimpl<T: Config<I>, I: 'static> TryState<<T as Config>::BlockNumber> for Pallet<T, I>
impl<T: Config<I>, I: 'static> TryState<<T as Config>::BlockNumber> for Pallet<T, I>
sourcefn try_state(
n: <T as Config>::BlockNumber,
_s: TryStateSelect
) -> Result<(), &'static str>
fn try_state(
n: <T as Config>::BlockNumber,
_s: TryStateSelect
) -> Result<(), &'static str>
sourceimpl<T: Config<I>, I: 'static> Unbalanced<<T as Config>::AccountId> for Pallet<T, I>
impl<T: Config<I>, I: 'static> Unbalanced<<T as Config>::AccountId> for Pallet<T, I>
sourcefn set_balance(who: &T::AccountId, amount: Self::Balance) -> DispatchResult
fn set_balance(who: &T::AccountId, amount: Self::Balance) -> DispatchResult
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 moresourcefn set_total_issuance(amount: Self::Balance)
fn set_total_issuance(amount: Self::Balance)
amount
.sourcefn decrease_balance(
who: &AccountId,
amount: Self::Balance
) -> Result<Self::Balance, DispatchError>
fn decrease_balance(
who: &AccountId,
amount: Self::Balance
) -> Result<Self::Balance, DispatchError>
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 moresourcefn decrease_balance_at_most(
who: &AccountId,
amount: Self::Balance
) -> Self::Balance
fn decrease_balance_at_most(
who: &AccountId,
amount: Self::Balance
) -> Self::Balance
sourcefn increase_balance(
who: &AccountId,
amount: Self::Balance
) -> Result<Self::Balance, DispatchError>
fn increase_balance(
who: &AccountId,
amount: Self::Balance
) -> Result<Self::Balance, DispatchError>
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 moresourceimpl<T: Config<I>, I: 'static> WhitelistedStorageKeys for Pallet<T, I>
impl<T: Config<I>, I: 'static> WhitelistedStorageKeys for Pallet<T, I>
sourcefn whitelisted_storage_keys() -> Vec<TrackedStorageKey> ⓘ
fn whitelisted_storage_keys() -> Vec<TrackedStorageKey> ⓘ
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. Read moreimpl<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
sourceimpl<AccountId, U> Balanced<AccountId> for Uwhere
U: Unbalanced<AccountId>,
impl<AccountId, U> Balanced<AccountId> for Uwhere
U: Unbalanced<AccountId>,
type OnDropCredit = DecreaseIssuance<AccountId, U>
type OnDropCredit = DecreaseIssuance<AccountId, U>
Credit
is dropped without being
used. Read moretype OnDropDebt = IncreaseIssuance<AccountId, U>
type OnDropDebt = IncreaseIssuance<AccountId, U>
Debt
is dropped without being used.sourcefn rescind(
amount: <U as Inspect<AccountId>>::Balance
) -> Imbalance<<U as Inspect<AccountId>>::Balance, IncreaseIssuance<AccountId, U>, DecreaseIssuance<AccountId, U>>
fn rescind(
amount: <U as Inspect<AccountId>>::Balance
) -> Imbalance<<U as Inspect<AccountId>>::Balance, IncreaseIssuance<AccountId, U>, DecreaseIssuance<AccountId, U>>
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 moresourcefn issue(
amount: <U as Inspect<AccountId>>::Balance
) -> Imbalance<<U as Inspect<AccountId>>::Balance, DecreaseIssuance<AccountId, U>, IncreaseIssuance<AccountId, U>>
fn issue(
amount: <U as Inspect<AccountId>>::Balance
) -> Imbalance<<U as Inspect<AccountId>>::Balance, DecreaseIssuance<AccountId, U>, IncreaseIssuance<AccountId, U>>
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 moresourcefn slash(
who: &AccountId,
amount: <U as Inspect<AccountId>>::Balance
) -> (Imbalance<<U as Inspect<AccountId>>::Balance, DecreaseIssuance<AccountId, U>, IncreaseIssuance<AccountId, U>>, <U as Inspect<AccountId>>::Balance)
fn slash(
who: &AccountId,
amount: <U as Inspect<AccountId>>::Balance
) -> (Imbalance<<U as Inspect<AccountId>>::Balance, DecreaseIssuance<AccountId, U>, IncreaseIssuance<AccountId, U>>, <U as Inspect<AccountId>>::Balance)
sourcefn deposit(
who: &AccountId,
amount: <U as Inspect<AccountId>>::Balance
) -> Result<Imbalance<<U as Inspect<AccountId>>::Balance, IncreaseIssuance<AccountId, U>, DecreaseIssuance<AccountId, U>>, DispatchError>
fn deposit(
who: &AccountId,
amount: <U as Inspect<AccountId>>::Balance
) -> Result<Imbalance<<U as Inspect<AccountId>>::Balance, IncreaseIssuance<AccountId, U>, DecreaseIssuance<AccountId, U>>, DispatchError>
sourcefn withdraw(
who: &AccountId,
amount: <U as Inspect<AccountId>>::Balance
) -> Result<Imbalance<<U as Inspect<AccountId>>::Balance, DecreaseIssuance<AccountId, U>, IncreaseIssuance<AccountId, U>>, DispatchError>
fn withdraw(
who: &AccountId,
amount: <U as Inspect<AccountId>>::Balance
) -> Result<Imbalance<<U as Inspect<AccountId>>::Balance, DecreaseIssuance<AccountId, U>, IncreaseIssuance<AccountId, U>>, DispatchError>
sourcefn pair(
amount: Self::Balance
) -> (Imbalance<Self::Balance, Self::OnDropDebt, Self::OnDropCredit>, Imbalance<Self::Balance, Self::OnDropCredit, Self::OnDropDebt>)
fn pair(
amount: Self::Balance
) -> (Imbalance<Self::Balance, Self::OnDropDebt, Self::OnDropCredit>, Imbalance<Self::Balance, Self::OnDropCredit, Self::OnDropDebt>)
sourcefn resolve(
who: &AccountId,
credit: Imbalance<Self::Balance, Self::OnDropCredit, Self::OnDropDebt>
) -> Result<(), Imbalance<Self::Balance, Self::OnDropCredit, Self::OnDropDebt>>
fn resolve(
who: &AccountId,
credit: Imbalance<Self::Balance, Self::OnDropCredit, Self::OnDropDebt>
) -> Result<(), Imbalance<Self::Balance, Self::OnDropCredit, Self::OnDropDebt>>
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 moresourcefn 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>>
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>>
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 moresourceimpl<AccountId, T> BalancedHold<AccountId> for Twhere
T: Balanced<AccountId> + MutateHold<AccountId>,
impl<AccountId, T> BalancedHold<AccountId> for Twhere
T: Balanced<AccountId> + MutateHold<AccountId>,
sourcefn 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)
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)
sourceimpl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
sourceimpl<T> CheckedConversion for T
impl<T> CheckedConversion for T
sourcefn checked_from<T>(t: T) -> Option<Self>where
Self: TryFrom<T>,
fn checked_from<T>(t: T) -> Option<Self>where
Self: TryFrom<T>,
sourcefn checked_into<T>(self) -> Option<T>where
Self: TryInto<T>,
fn checked_into<T>(self) -> Option<T>where
Self: TryInto<T>,
impl<T> Downcast for Twhere
T: Any,
impl<T> Downcast for Twhere
T: Any,
fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>
fn into_any(self: Box<T, Global>) -> Box<dyn Any + 'static, Global>
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 morefn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>
Rc<Trait>
(where Trait: Downcast
) to Rc<Any>
. Rc<Any>
can then be
further downcast
into Rc<ConcreteType>
where ConcreteType
implements Trait
. Read morefn as_any(&self) -> &(dyn Any + 'static)
fn as_any(&self) -> &(dyn Any + 'static)
&Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &Any
’s vtable from &Trait
’s. Read morefn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
&mut Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &mut Any
’s vtable from &mut Trait
’s. Read moresourceimpl<Q, K> Equivalent<K> for Qwhere
Q: Eq + ?Sized,
K: Borrow<Q> + ?Sized,
impl<Q, K> Equivalent<K> for Qwhere
Q: Eq + ?Sized,
K: Borrow<Q> + ?Sized,
sourcefn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
key
and return true
if they are equal.impl<Q, K> Equivalent<K> for Qwhere
Q: Eq + ?Sized,
K: Borrow<Q> + ?Sized,
impl<Q, K> Equivalent<K> for Qwhere
Q: Eq + ?Sized,
K: Borrow<Q> + ?Sized,
fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
sourceimpl<T> Instrument for T
impl<T> Instrument for T
sourcefn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
sourcefn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
sourceimpl<T, Outer> IsWrappedBy<Outer> for Twhere
Outer: AsRef<T> + AsMut<T> + From<T>,
T: From<Outer>,
impl<T, Outer> IsWrappedBy<Outer> for Twhere
Outer: AsRef<T> + AsMut<T> + From<T>,
T: From<Outer>,
sourceimpl<T> PalletVersionToStorageVersionHelper for Twhere
T: GetStorageVersion + PalletInfoAccess,
impl<T> PalletVersionToStorageVersionHelper for Twhere
T: GetStorageVersion + PalletInfoAccess,
fn migrate(db_weight: &RuntimeDbWeight) -> Weight
impl<T> Pointable for T
impl<T> Pointable for T
sourceimpl<T> SaturatedConversion for T
impl<T> SaturatedConversion for T
sourcefn saturated_from<T>(t: T) -> Selfwhere
Self: UniqueSaturatedFrom<T>,
fn saturated_from<T>(t: T) -> Selfwhere
Self: UniqueSaturatedFrom<T>,
sourcefn saturated_into<T>(self) -> Twhere
Self: UniqueSaturatedInto<T>,
fn saturated_into<T>(self) -> Twhere
Self: UniqueSaturatedInto<T>,
T
. Read moreimpl<SS, SP> SupersetOf<SS> for SPwhere
SS: SubsetOf<SP>,
impl<SS, SP> SupersetOf<SS> for SPwhere
SS: SubsetOf<SP>,
fn to_subset(&self) -> Option<SS>
fn to_subset(&self) -> Option<SS>
self
from the equivalent element of its
superset. Read morefn is_in_subset(&self) -> bool
fn is_in_subset(&self) -> bool
self
is actually part of its subset T
(and can be converted to it).fn to_subset_unchecked(&self) -> SS
fn to_subset_unchecked(&self) -> SS
self.to_subset
but without any property checks. Always succeeds.fn from_subset(element: &SS) -> SP
fn from_subset(element: &SS) -> SP
self
to the equivalent element of its superset.sourceimpl<S, T> UncheckedInto<T> for Swhere
T: UncheckedFrom<S>,
impl<S, T> UncheckedInto<T> for Swhere
T: UncheckedFrom<S>,
sourcefn unchecked_into(self) -> T
fn unchecked_into(self) -> T
unchecked_from
.sourceimpl<T, S> UniqueSaturatedInto<T> for Swhere
T: Bounded,
S: TryInto<T>,
impl<T, S> UniqueSaturatedInto<T> for Swhere
T: Bounded,
S: TryInto<T>,
sourcefn unique_saturated_into(self) -> T
fn unique_saturated_into(self) -> T
T
.