gsdk 1.10.0

meta=sp_corecrypto,AccountId32
 [u8; 32] 0frame_system,AccountInfoNonce
,AccountData

nonce
Nonce
$consumers
 RefCount
$providers
 RefCount
,sufficients
 RefCount
data
,AccountData<pallet_balancestypes,AccountDataBalance

free
Balance
 reserved
Balance
frozen
Balance
flags
(ExtraFlags<pallet_balancestypes(ExtraFlags
u128 $4frame_support dispatch@PerDispatchClassT
(
normal(
T
,operational(
T
$mandatory(
T((sp_weights$weight_v2Weight
 ref_time,
u64
(proof_size,
u64,004<primitive_typesH256
 [u8; 32]8<(sp_runtimegenericdigestDigest
logs@
<Vec<DigestItem>@DD(sp_runtimegenericdigest(DigestItem
(PreRuntimeH
DConsensusEngineId8
Vec<u8>$ConsensusH
DConsensusEngineId8
Vec<u8>SealH
DConsensusEngineId8
Vec<u8>Other8
Vec<u8>dRuntimeEnvironmentUpdatedHLPP0frame_system,EventRecordE
TT
4
phase�
Phase
eventT
E
topics=
Vec<T>T0vara_runtime0RuntimeEvent
�SystemX
pframe_system::Event<Runtime>Grandpa|
Tpallet_grandpa::Event Balances�
|pallet_balances::Event<Runtime>HTransactionPayment�
�pallet_transaction_payment::Event<Runtime>Session�
Tpallet_session::EventUtility�
Tpallet_utility::EventVesting�
xpallet_vesting::Event<Runtime>
 BagsList�
�pallet_bags_list::Event<Runtime, pallet_bags_list::Instance1> ImOnline�
�pallet_im_online::Event<Runtime>Staking�
xpallet_staking::Event<Runtime>
 Treasury�
|pallet_treasury::Event<Runtime>@ConvictionVoting�
�pallet_conviction_voting::Event<Runtime>$Referenda�
�pallet_referenda::Event<Runtime>PFellowshipCollective�
9
pallet_ranked_collective::Event<Runtime, pallet_ranked_collective::
Instance1>LFellowshipReferenda�
�pallet_referenda::Event<Runtime, pallet_referenda::Instance2>$Whitelist�
�pallet_whitelist::Event<Runtime>$Scheduler�
�pallet_scheduler::Event<Runtime> Preimage�
|pallet_preimage::Event<Runtime> Identity�
|pallet_identity::Event<Runtime>Proxy�
ppallet_proxy::Event<Runtime> Multisig�
|pallet_multisig::Event<Runtime>hElectionProviderMultiPhase�
�pallet_election_provider_multi_phase::Event<Runtime> Offences�
Xpallet_offences::Event Bounties�
|pallet_bounties::Event<Runtime>4ChildBounties�
�pallet_child_bounties::Event<Runtime><NominationPools�
�pallet_nomination_pools::Event<Runtime>Sudo�
lpallet_sudo::Event<Runtime>cGear�
lpallet_gear::Event<Runtime>h8StakingRewardse
�pallet_gear_staking_rewards::Event<Runtime>j,GearVoucherm
�pallet_gear_voucher::Event<Runtime>k4GearEthBridgeq
�pallet_gear_eth_bridge::Event<Runtime>n4GrandpaSigner�
�pallet_grandpa_signer::Event<Runtime>oX0frame_systempalletEventT
@ExtrinsicSuccess
4dispatch_info\
0DispatchInfo�An extrinsic completed successfully.<ExtrinsicFailed
8dispatch_errorh
4DispatchError
4dispatch_info\
0DispatchInfo
PAn extrinsic failed.,CodeUpdatedP`:code` was updated.(NewAccount
account
0T::AccountIdhA new account was created.4KilledAccount
account
0T::AccountIdXAn account was reaped. Remarked
sender
0T::AccountId
hash4
T::HashpOn on-chain remark happened.DUpgradeAuthorized
$code_hash4
T::Hash
4check_version 
boolhAn upgrade was authorized.pEvent for the System pallet.\4frame_support dispatch0DispatchInfo
weight(
Weight
class`
4DispatchClass
 pays_feed
Pays`4frame_support dispatch4DispatchClass
Normal,Operational
$Mandatoryd4frame_support dispatchPays
YesNo
h(sp_runtime4DispatchError
8Other0CannotLookup
$BadOriginModulel
,ModuleErrorDConsumerRemaining,NoProviders@TooManyConsumersTokenp
(TokenError(Arithmetict
<ArithmeticError4Transactionalx
HTransactionalError	$Exhausted
(Corruption,Unavailable8RootNotAllowed
l(sp_runtime,ModuleError
index
u8
errorH
�[u8; MAX_MODULE_ERROR_ENCODED_SIZE]p(sp_runtime(TokenError
(@FundsUnavailable0OnlyProvider
0BelowMinimum0CannotCreate0UnknownAssetFrozen,Unsupported@CannotCreateHold4NotExpendableBlocked	t4sp_arithmetic<ArithmeticError
$Underflow Overflow
8DivisionByZerox(sp_runtimeHTransactionalError
0LimitReachedNoLayer
|8pallet_grandpapalletEvent
8NewAuthorities
4authority_set�
4AuthorityList�New authority set has been applied.Paused
�Current authority set has been paused.Resumed�Current authority set has been resumed.|The `Event` enum of this pallet����0�Psp_consensus_grandpaappPublic
<ed25519::Public�<pallet_balancespalletEventTI
XEndowed
account
0T::AccountId
0free_balance
(T::Balance�An account was created with some free balance. DustLost
account
0T::AccountId
amount
(T::Balance
=
An account was removed whose balance was non-zero but below ExistentialDeposit,xresulting in an outright loss. Transfer
from
0T::AccountId
to
0T::AccountId
amount
(T::BalanceLTransfer succeeded.(BalanceSet
who
0T::AccountId
free
(T::BalancehA balance was set by root. Reserved
who
0T::AccountId
amount
(T::Balance�Some balance was reserved (moved from free to reserved).(Unreserved
who
0T::AccountId
amount
(T::Balance�Some balance was unreserved (moved from reserved to free).HReserveRepatriated
from
0T::AccountId
to
0T::AccountId
amount
(T::Balance
Hdestination_status�
StatusM
Some balance was moved from the reserve of the first account to the second account.�Final argument indicates the destination balance type.Deposit
who
0T::AccountId
amount
(T::Balance�Some amount was deposited (e.g. for transaction fees). Withdraw
who
0T::AccountId
amount
(T::Balance
Some amount was withdrawn from the account (e.g. for transaction fees).Slashed
who
0T::AccountId
amount
(T::Balance	

Some amount was removed from the account (e.g. for misbehavior).Minted
who
0T::AccountId
amount
(T::Balance
�Some amount was minted into an account.Burned
who
0T::AccountId
amount
(T::Balance�Some amount was burned from an account.$Suspended
who
0T::AccountId
amount
(T::Balance
Some amount was suspended from an account (it can be restored later). Restored
who
0T::AccountId
amount
(T::Balance
�Some amount was restored into an account. Upgraded
who
0T::AccountId`An account was upgraded.Issued
amount
(T::Balance-
Total issuance was increased by `amount`, creating a credit to be balanced.$Rescinded
amount
(T::Balance%
Total issuance was decreased by `amount`, creating a debt to be balanced.Locked
who
0T::AccountId
amount
(T::Balance`Some balance was locked. Unlocked
who
0T::AccountId
amount
(T::BalancehSome balance was unlocked.Frozen
who
0T::AccountId
amount
(T::Balance`Some balance was frozen.Thawed
who
0T::AccountId
amount
(T::Balance`Some balance was thawed.LTotalIssuanceForced
old
(T::Balance
new
(T::Balance�The `TotalIssuance` was forcefully changed.|The `Event` enum of this pallet�4frame_supporttraitstokensmisc4BalanceStatus
Free Reserved
�hpallet_transaction_paymentpalletEventT
HTransactionFeePaid
who
0T::AccountId
(actual_fee
0BalanceOf<T>
tip
0BalanceOf<T>Y
A transaction fee `actual_fee`, of which `tip` was added to the minimum inclusion fee,\has been paid by `who`.|The `Event` enum of this pallet�8pallet_sessionpalletEvent
(NewSession
4session_index
0SessionIndex9
New session has happened. Note that the argument is the session index, not the�block number as the type might suggest.|The `Event` enum of this pallet�8pallet_utilitypalletEvent
@BatchInterrupted
index
u32
errorh
4DispatchErrorU
Batch of dispatches did not complete fully. Index of first failing dispatch given, asHwell as the error.8BatchCompleted
�Batch of dispatches completed fully with no error.`BatchCompletedWithErrors�Batch of dispatches completed but has errors.4ItemCompleted
A single item within a Batch of dispatches has completed with no error.(ItemFailed
errorh
4DispatchError
A single item within a Batch of dispatches has completed with error.0DispatchedAs
result�
8DispatchResultXA call was dispatched.|The `Event` enum of this pallet�ResultT
�E
h
Ok�Errh
��8pallet_vestingpalletEventT
8VestingUpdated
account
0T::AccountId
 unvested
0BalanceOf<T>Q
The amount vested has been updated. This could indicate a change in funds available.%
The balance given is the amount which is left unvested (and thus locked).@VestingCompleted
account
0T::AccountId
�An \[account\] has become fully vested.|The `Event` enum of this pallet�@pallet_bags_listpalletEventTI
 Rebagged
who
0T::AccountId
from0
 T::Score
to0
 T::Score�Moved an account from one bag to another.0ScoreUpdated
who
0T::AccountId
$new_score0
 T::Score
�Updated the score of some account to the given amount.|The `Event` enum of this pallet�@pallet_im_onlinepalletEventT
DHeartbeatReceived
0authority_id�
8T::AuthorityId�A new heartbeat was received from `AuthorityId`.AllGood
�At the end of the session, no offence was committed.,SomeOffline
offline�
lVec<IdentificationTuple<T>>)
At the end of the session, at least one validator was found to be offline.|The `Event` enum of this pallet�@pallet_im_onlinesr25519,app_sr25519Public
<sr25519::Public�����(sp_staking Exposure$AccountId
Balance

total�
Balance
own�
Balance
others�
�Vec<IndividualExposure<AccountId, Balance>>����(sp_stakingHIndividualExposure$AccountId
Balance

who
$AccountId
value�
Balance�8pallet_stakingpalletpalletEventT
HEraPaid
$era_index
 EraIndex
@validator_payout
0BalanceOf<T>
$remainder
0BalanceOf<T>U
The era payout has been set; the first balance is the validator-payout; the second is�the remainder from the maximum amount of reward. Rewarded
stash
0T::AccountId
dest�
|RewardDestination<T::AccountId>
amount
0BalanceOf<T>


The nominator has been rewarded by this amount to this destination.Slashed
staker
0T::AccountId
amount
0BalanceOf<T>
A staker (validator or nominator) has been slashed by the given amount.4SlashReported
$validator
0T::AccountId
 fraction�
Perbill
$slash_era
 EraIndexY
A slash for the given validator, for the given percentage of their stake, at the givenTera as been reported.hOldSlashingReportDiscarded
4session_index
0SessionIndex
An old slashing report from a prior era was discarded because it couldDnot be processed.8StakersElected�A new set of stakers was elected.Bonded
stash
0T::AccountId
amount
0BalanceOf<T>�An account has bonded this amount. \[stash, amount\]M
NOTE: This event is only emitted when funds are bonded via a dispatchable. Notably,!
it will not be emitted for staking rewards when they are added to stake. Unbonded
stash
0T::AccountId
amount
0BalanceOf<T>�An account has unbonded this amount.$Withdrawn
stash
0T::AccountId
amount
0BalanceOf<T>Y
An account has called `withdraw_unbonded` and removed unbonding chunks worth `Balance`dfrom the unlocking queue.Kicked
$nominator
0T::AccountId
stash
0T::AccountId	�A nominator has been kicked from a validator.TStakingElectionFailed
�The election failed. No new era is planned.Chilled
stash
0T::AccountId!
An account has stopped participating as either a validator or nominator.4PayoutStarted
$era_index
 EraIndex
<validator_stash
0T::AccountId�The stakers' rewards are getting paid.DValidatorPrefsSet
stash
0T::AccountId
prefs�
8ValidatorPrefs
�A validator has set their preferences.hSnapshotVotersSizeExceeded
size
u32hVoters size limit reached.lSnapshotTargetsSizeExceeded
size
u32lTargets size limit reached. ForceEra
mode�
ForcingtA new force era mode was set.dControllerBatchDeprecated
 failures
u32�Report of a controller batch deprecation.|The `Event` enum of this pallet�8pallet_stakingDRewardDestination$AccountId

StakedStash
(ControllerAccount
$AccountIdNone�4sp_arithmetic(per_thingsPerbill
u32�8pallet_staking8ValidatorPrefs
(commission�
Perbill
blocked 
bool���8pallet_stakingForcing
(NotForcing ForceNew
$ForceNone,ForceAlways�<pallet_treasurypalletEventTI
0 Spending
@budget_remaining
<BalanceOf<T, I>�We have ended a spend period and will now allocate funds.Awarded
8proposal_index
4ProposalIndex
award
<BalanceOf<T, I>
account
0T::AccountId
|Some funds have been allocated.Burnt
,burnt_funds
<BalanceOf<T, I>�Some of our funds have been burnt. Rollover
@rollover_balance
<BalanceOf<T, I>-
Spending has finished; this is the amount that rolls over until next spend.Deposit
value
<BalanceOf<T, I>|Some funds have been deposited.4SpendApproved
8proposal_index
4ProposalIndex
amount
<BalanceOf<T, I>
,beneficiary
0T::AccountId�A new spend proposal has been approved.<UpdatedInactive
,reactivated
<BalanceOf<T, I>
,deactivated
<BalanceOf<T, I>�The inactive funds of the pallet have been updated.HAssetSpendApproved
index
(SpendIndex
(asset_kind�
0T::AssetKind
amount
PAssetBalanceOf<T, I>
,beneficiary
8T::Beneficiary
(valid_from
DBlockNumberFor<T>
$expire_at
DBlockNumberFor<T>�A new asset spend proposal has been approved.@AssetSpendVoided
index
(SpendIndextAn approved spend was voided.Paid
index
(SpendIndex
(payment_id�
d<T::Paymaster as Pay>::Id	LA payment happened.4PaymentFailed
index
(SpendIndex
(payment_id�
d<T::Paymaster as Pay>::Id
�A payment failed and can be retried.8SpendProcessed
index
(SpendIndexM
A spend was processed and removed from the storage. It might have been successfullyppaid or it may have expired.|The `Event` enum of this pallet�`pallet_conviction_votingpalletEventTI
$Delegated
0T::AccountId
0T::AccountId
An account has delegated their vote to another account. \[who, target\],Undelegated
0T::AccountId
�An \[account\] has cancelled a previous delegation operation.Voted
who
0T::AccountId
vote�
pAccountVote<BalanceOf<T, I>>dAn account that has voted,VoteRemoved
who
0T::AccountId
vote�
pAccountVote<BalanceOf<T, I>>`A vote that been removed|The `Event` enum of this pallet�`pallet_conviction_votingvote,AccountVoteBalance

 Standard
vote�
Vote
balance
BalanceSplit
aye
Balance
nay
Balance
0SplitAbstain
aye
Balance
nay
Balance
abstain
Balance�`pallet_conviction_votingvoteVote�@pallet_referendapalletEventTI
@$Submitted
index
<ReferendumIndex`Index of the referendum.
track�
<TrackIdOf<T, I>%
The track (and by extension proposal dispatch origin) of this referendum.
 proposal


LBoundedCallOf<T, I>�The proposal for the referendum.�A referendum has been submitted.TDecisionDepositPlaced
index
<ReferendumIndex`Index of the referendum.
who
0T::AccountId�The account who placed the deposit.
amount
<BalanceOf<T, I>�The amount placed by the account.
�The decision deposit has been placed.\DecisionDepositRefunded
index
<ReferendumIndex`Index of the referendum.
who
0T::AccountId�The account who placed the deposit.
amount
<BalanceOf<T, I>�The amount placed by the account.�The decision deposit has been refunded.8DepositSlashed
who
0T::AccountId�The account who placed the deposit.
amount
<BalanceOf<T, I>�The amount placed by the account.lA deposit has been slashed.<DecisionStarted
index
<ReferendumIndex`Index of the referendum.
track�
<TrackIdOf<T, I>%
The track (and by extension proposal dispatch origin) of this referendum.
 proposal


LBoundedCallOf<T, I>�The proposal for the referendum.
tally�
 T::Tally�The current tally of votes in this referendum.�A referendum has moved into the deciding phase.8ConfirmStarted
index
<ReferendumIndex`Index of the referendum.8ConfirmAborted
index
<ReferendumIndex`Index of the referendum.$Confirmed
index
<ReferendumIndex`Index of the referendum.
tally�
 T::Tally�The final tally of votes in this referendum.!
A referendum has ended its confirmation phase and is ready for approval. Approved
index
<ReferendumIndex`Index of the referendum.

A referendum has been approved and its proposal has been scheduled. Rejected
index
<ReferendumIndex`Index of the referendum.
tally�
 T::Tally�The final tally of votes in this referendum.	�A proposal has been rejected by referendum. TimedOut
index
<ReferendumIndex`Index of the referendum.
tally�
 T::Tally�The final tally of votes in this referendum.
�A referendum has been timed out without being decided.$Cancelled
index
<ReferendumIndex`Index of the referendum.
tally�
 T::Tally�The final tally of votes in this referendum.�A referendum has been cancelled.Killed
index
<ReferendumIndex`Index of the referendum.
tally�
 T::Tally�The final tally of votes in this referendum.tA referendum has been killed.dSubmissionDepositRefunded
index
<ReferendumIndex`Index of the referendum.
who
0T::AccountId�The account who placed the deposit.
amount
<BalanceOf<T, I>�The amount placed by the account.
�The submission deposit has been refunded.,MetadataSet
index
<ReferendumIndex`Index of the referendum.
hash4
T::Hash8Preimage hash.�Metadata for a referendum has been set.<MetadataCleared
index
<ReferendumIndex`Index of the referendum.
hash4
T::Hash8Preimage hash.�Metadata for a referendum has been cleared.|The `Event` enum of this pallet�

4frame_supporttraits$preimagesBoundedT

H
�
Legacy
hash4
$H::OutputInline�
4BoundedInline
Lookup
hash4
$H::Output
len
u32
0vara_runtime,RuntimeCall
�System	

�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<System, Runtime>$Timestamp

�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Timestamp, Runtime>
Babe

�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Babe, Runtime>GrandpaE

�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Grandpa, Runtime> Balancesq

�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Balances, Runtime>Session�

�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Session, Runtime>Utility�

�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Utility, Runtime>Vesting�

�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Vesting, Runtime>
 BagsList�

�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<BagsList, Runtime> ImOnline�

�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<ImOnline, Runtime>Staking�

�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Staking, Runtime>
 Treasury

�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Treasury, Runtime>@ConvictionVoting	
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<ConvictionVoting, Runtime>$Referenda
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Referenda, Runtime>PFellowshipCollective!
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<FellowshipCollective, Runtime>LFellowshipReferenda%
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<FellowshipReferenda, Runtime>$Whitelist)
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Whitelist, Runtime>$Scheduler-
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Scheduler, Runtime> Preimage9
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Preimage, Runtime> IdentityA
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Identity, Runtime>Proxy�
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Proxy, Runtime> Multisig�
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Multisig, Runtime>hElectionProviderMultiPhase	
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<ElectionProviderMultiPhase, Runtime> Bounties�
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Bounties, Runtime>4ChildBounties

�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<ChildBounties, Runtime><NominationPools
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<NominationPools, Runtime>Sudo9
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Sudo, Runtime>cGear=
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Gear, Runtime>h8StakingRewardsU
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<StakingRewards, Runtime>j,GearVoucherY
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<GearVoucher, Runtime>k4GearEthBridgey
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<GearEthBridge, Runtime>n4GrandpaSigner�
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<GrandpaSigner, Runtime>o	
0frame_systempalletCallT
,remark
remark8
Vec<u8>hMake some on-chain remark.�Can be executed by every `origin`.8set_heap_pages
pages0
u64
�Set the number of pages in the WebAssembly environment's heap. set_code
code8
Vec<u8>dSet the new runtime code.\set_code_without_checks
code8
Vec<u8>
Set the new runtime code without doing any checks of the given `code`.Q
Note that runtime upgrades will not run if this is called with a not-increasing spec version!,set_storage
items


4Vec<KeyValue>hSet some items of storage.0kill_storage
keys

 Vec<Key>tKill some items from storage.,kill_prefix
prefix8
Key
subkeys
u32
Kill all storage items with a key that starts with the given prefix.9
**NOTE:** We rely on the Root origin to provide us the number of subkeys under=
the prefix we are removing to accurately calculate the weight of this function.Dremark_with_event
remark8
Vec<u8>�Make some on-chain remark and emit event.Dauthorize_upgrade
$code_hash4
T::Hash	a
Authorize an upgrade to a given `code_hash` for the runtime. The runtime can be suppliedlater.|This call requires Root origin.�authorize_upgrade_without_checks
$code_hash4
T::Hash
 a
Authorize an upgrade to a given `code_hash` for the runtime. The runtime can be suppliedlater.]
WARNING: This authorizes an upgrade that will take place without any safety checks, forY
example that the spec name remains the same and that the version number increases. Not�recommended for normal use. Use `authorize_upgrade` instead.|This call requires Root origin.`apply_authorized_upgrade
code8
Vec<u8>$U
Provide the preimage (runtime binary) `code` for an upgrade that has been authorized.I
If the authorization required a version check, this call will ensure the spec name�remains unchanged and that the spec version has increased.Y
Depending on the runtime's `OnSetCode` configuration, this function may directly apply
the new `code` in the same block or attempt to schedule the upgrade.`All origins are allowed.

Contains a variant per dispatchable extrinsic that this pallet has.



88
8
@pallet_timestamppalletCallT
set
now,
$T::MomentLTSet the current time.U
This call should be invoked exactly once per block. It will panic at the finalization�phase, if this call hasn't been invoked by that time.A
The timestamp should be greater than the previous one by the amount specified byh[`Config::MinimumPeriod`].�The dispatch origin for this call must be _None_.Q
This dispatch class is _Mandatory_ to ensure it gets executed in the block. Be awareQ
that changing the complexity of this call could result exhausting the resources in a�block to execute any other calls.4## Complexity1
- `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`)U
- 1 storage read and 1 storage mutation (codec `O(1)` because of `DidUpdate::take` in@  `on_finalize`)�- 1 event handler `on_timestamp_set`. Must be `O(1)`.

Contains a variant per dispatchable extrinsic that this pallet has.
,pallet_babepalletCallT
Lreport_equivocation
Hequivocation_proof!

�Box<EquivocationProof<HeaderFor<T>>>
<key_owner_proof5

@T::KeyOwnerProof	
Report authority equivocation/misbehavior. This method will verify
the equivocation proof and validate the given key ownership proof

against the extracted offender. If both are valid, the offence will0be reported.preport_equivocation_unsigned
Hequivocation_proof!

�Box<EquivocationProof<HeaderFor<T>>>
<key_owner_proof5

@T::KeyOwnerProof
 	
Report authority equivocation/misbehavior. This method will verify
the equivocation proof and validate the given key ownership proof

against the extracted offender. If both are valid, the offence will0be reported.

This extrinsic must be called unsigned and it is expected that only
block authors will call it (validated in `ValidateUnsigned`), as such
if the block author is defined it will be defined as the equivocation$reporter.Hplan_config_change
config9

PNextConfigDescriptor]
Plan an epoch config change. The epoch config change is recorded and will be enacted onQ
the next call to `enact_epoch_change`. The config will be activated one epoch after.Y
Multiple calls to this method will replace any existing planned config change that hadTnot been enacted yet.

Contains a variant per dispatchable extrinsic that this pallet has.!
Hsp_consensus_slotsDEquivocationProofHeader
%
Id
-

 offender-

Id
slot1

Slot
0first_header%

Header
4second_header%

Header%
(sp_runtimegenericheaderHeaderNumber
Hash
,parent_hash4
0Hash::Output
number)

Number
(state_root4
0Hash::Output
<extrinsics_root4
0Hash::Output
digest<
Digest)
-
Dsp_consensus_babeappPublic
<sr25519::Public1
Hsp_consensus_slotsSlot0
u645
(sp_session<MembershipProof
session
0SessionIndex
(trie_nodes

0Vec<Vec<u8>>
<validator_count
8ValidatorCount9
Dsp_consensus_babedigestsPNextConfigDescriptor
V1
c=

((u64, u64)
4allowed_slotsA

0AllowedSlots
=
00A
Dsp_consensus_babe0AllowedSlots
0PrimarySlotstPrimaryAndSecondaryPlainSlots
lPrimaryAndSecondaryVRFSlotsE
8pallet_grandpapalletCallT
Lreport_equivocation
Hequivocation_proofI

�Box<EquivocationProof<T::Hash, BlockNumberFor<T>>>
<key_owner_proof5

@T::KeyOwnerProof	
Report voter equivocation/misbehavior. This method will verify the�equivocation proof and validate the given key ownership proof�against the extracted offender. If both are valid, the offenceDwill be reported.preport_equivocation_unsigned
Hequivocation_proofI

�Box<EquivocationProof<T::Hash, BlockNumberFor<T>>>
<key_owner_proof5

@T::KeyOwnerProof
$	
Report voter equivocation/misbehavior. This method will verify the�equivocation proof and validate the given key ownership proof�against the extracted offender. If both are valid, the offenceDwill be reported.

This extrinsic must be called unsigned and it is expected that only
block authors will call it (validated in `ValidateUnsigned`), as such
if the block author is defined it will be defined as the equivocation$reporter.0note_stalled
delay
DBlockNumberFor<T>
lbest_finalized_block_number
DBlockNumberFor<T>0=
Note that the current authority set of the GRANDPA finality gadget has stalled.a
This will trigger a forced authority set change at the beginning of the next session, toa
be enacted `delay` blocks after that. The `delay` should be high enough to safely assumeI
that the block signalling the forced change will not be re-orged e.g. 1000 blocks.]
The block production rate (which may be slowed down because of finality lagging) shouldQ
be taken into account when choosing the `delay`. The GRANDPA voters based on the newU
authority will start voting on top of `best_finalized_block_number` for new finalizedM
blocks. `best_finalized_block_number` should be the highest of the latest finalized�block of all validators of the new authority set.XOnly callable by root.

Contains a variant per dispatchable extrinsic that this pallet has.I
Psp_consensus_grandpaDEquivocationProofH
4N

set_id0
SetId
0equivocationM

HEquivocation<H, N>M
Psp_consensus_grandpa0EquivocationH
4N

PrevoteQ

�
finality_grandpa::Equivocation<AuthorityId, finality_grandpa::Prevote<
H, N>, AuthoritySignature,>$Precommite

�
finality_grandpa::Equivocation<AuthorityId, finality_grandpa::Precommit
<H, N>, AuthoritySignature,>
Q
@finality_grandpa0EquivocationId
�V
U
S
Y

0round_number0
u64
 identity�
Id
firsta

(V, S)
seconda

(V, S)U
@finality_grandpaPrevoteH
4N

,target_hash4
H
4target_number
NY
Psp_consensus_grandpaapp$Signature]

Hed25519::Signature]
@a
U
Y
e
@finality_grandpa0EquivocationId
�V
i
S
Y

0round_number0
u64
 identity�
Id
firstm

(V, S)
secondm

(V, S)i
@finality_grandpa$PrecommitH
4N

,target_hash4
H
4target_number
Nm
i
Y
q
<pallet_balancespalletCallTI
$Ptransfer_allow_death
destu

PAccountIdLookupOf<T>
value�
(T::Balance�Transfer some liquid free balance to another account.5
`transfer_allow_death` 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.8force_transfer
sourceu

PAccountIdLookupOf<T>
destu

PAccountIdLookupOf<T>
value�
(T::Balancea
Exactly as `transfer_allow_death`, except the origin must be root and the source accountDmay be specified.Ltransfer_keep_alive
destu

PAccountIdLookupOf<T>
value�
(T::BalanceY
Same as the [`transfer_allow_death`] call, but with a check that the transfer will not`kill the origin account.�99% of the time you want [`transfer_allow_death`] instead.�[`transfer_allow_death`]: struct.Pallet.html#method.transfer0transfer_all
destu

PAccountIdLookupOf<T>
(keep_alive 
bool<
Transfer the entire transferable balance from the caller account.Y
NOTE: This function only attempts to transfer _transferable_ balances. This means thata
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,E
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.Y
- `keep_alive`: A boolean to determine if the `transfer_all` operation should send allM
  of the funds the account has, causing the sender account to be killed (false), orY
  transfer everything except at least the existential deposit, which will guarantee to�  keep the sender account alive (true).<force_unreserve
whou

PAccountIdLookupOf<T>
amount
(T::Balance�Unreserve some balance from a user by force.lCan only be called by ROOT.@upgrade_accounts
who�

DVec<T::AccountId> pUpgrade a specified account.t- `origin`: Must be `Signed`.�- `who`: The account to be upgraded.U
This will waive the transaction fee if at least all but 10% of the accounts needed toA
be upgraded. (We let some not have to be upgraded just in order to allow for theXpossibility of churn).Dforce_set_balance
whou

PAccountIdLookupOf<T>
 new_free�
(T::Balance�Set the regular balance of a given account.�The dispatch origin for this call is `root`.lforce_adjust_total_issuance
$direction�

LAdjustmentDirection
delta�
(T::Balance	�Adjust the total issuance in a saturating way.�Can only be called by root and always needs a positive `delta`.$# Exampleburn
value�
(T::Balance
(keep_alive 
bool
�Burn the specified liquid free balance from the origin account.%
If the origin's account ends up below the existential deposit as a result	
of the burn and `keep_alive` is false, the account will be reaped.Q
Unlike sending funds to a _burn_ address, which merely makes the funds inaccessible,!
this `burn` operation will reduce total issuance by the amount _burned_.

Contains a variant per dispatchable extrinsic that this pallet has.u
(sp_runtime0multiaddress0MultiAddress$AccountId
0AccountIndex
�
Id
$AccountIdIndexy

0AccountIndex
Raw8
Vec<u8>$Address32
 [u8; 32]$Address20}

 [u8; 20]y
�}
�
�
<pallet_balancestypesLAdjustmentDirection
 Increase Decrease
�
8pallet_sessionpalletCallT
 set_keys
keys�

T::Keys
proof8
Vec<u8>$�Sets the session key(s) of the function caller to `keys`.
Allows an account to set its session key prior to becoming a validator.�This doesn't take effect until the next session.�The dispatch origin of this function must be signed.4## ComplexityY
- `O(1)`. Actual cost depends on the number of length of `T::Keys::key_ids()` which is   fixed.(purge_keys
0�Removes any session key(s) of the function caller.�This doesn't take effect until the next session.U
The dispatch origin of this function must be Signed and the account must be either be]
convertible to a validator ID using the chain's typical addressing system (this usuallyQ
means being a controller account) or directly convertible into a validator ID (which�usually means being a stash account).4## Complexity=
- `O(1)` in number of key types. Actual cost depends on the number of length of�  `T::Keys::key_ids()` which is fixed.

Contains a variant per dispatchable extrinsic that this pallet has.�
0vara_runtime,SessionKeys
babe-

�<Babe as $crate::BoundToRuntimeAppPublic>::Public
grandpa�
�<Grandpa as $crate::BoundToRuntimeAppPublic>::Public
$im_online�
�<ImOnline as $crate::BoundToRuntimeAppPublic>::Public
Lauthority_discovery�

�<AuthorityDiscovery as $crate::BoundToRuntimeAppPublic>::Public�
Xsp_authority_discoveryappPublic
<sr25519::Public�
8pallet_utilitypalletCallT
batch
calls�

|Vec<<T as Config>::RuntimeCall>H|Send a batch of dispatch calls.�May be called from any origin except `None`.]
- `calls`: The calls to be dispatched from the same origin. The number of call must not9
  exceed the constant: `batched_calls_limit` (available in constant metadata).U
If origin is root then the calls are dispatched without checking origin filter. (This�includes bypassing `frame_system::Config::BaseCallFilter`).4## Complexity�- O(C) where C is the number of calls to be batched.U
This will return `Ok` in all circumstances. To determine the success of the batch, an1
event is deposited. If a call failed and the batch was interrupted, then theU
`BatchInterrupted` event is deposited, along with the number of successful calls madeM
and the error of the failed call. If all were successful, then the `BatchCompleted`Levent is deposited.4as_derivative
index�
u16
call

|Box<<T as Config>::RuntimeCall>
4�Send a call through an indexed pseudonym of the sender.U
Filter from origin are passed along. The call will be dispatched with an origin which�use the same filter as the origin of this call.E
NOTE: If you need to ensure that any account-based filtering is not honored (i.e.a
because you expect `proxy` to have been used prior in the call stack and you do not wantQ
the call restrictions to apply to any sub-accounts), then use `as_multi_threshold_1`|in the Multisig pallet instead.�NOTE: Prior to version *12, this was called `as_limited_sub`.�The dispatch origin for this call must be _Signed_.$batch_all
calls�

|Vec<<T as Config>::RuntimeCall>4�Send a batch of dispatch calls and atomically execute them.!
The whole transaction will rollback and fail if any of the calls failed.�May be called from any origin except `None`.]
- `calls`: The calls to be dispatched from the same origin. The number of call must not9
  exceed the constant: `batched_calls_limit` (available in constant metadata).U
If origin is root then the calls are dispatched without checking origin filter. (This�includes bypassing `frame_system::Config::BaseCallFilter`).4## Complexity�- O(C) where C is the number of calls to be batched.,dispatch_as
$as_origin�

TBox<T::PalletsOrigin>
call

|Box<<T as Config>::RuntimeCall>�Dispatches a function call with a provided origin.�The dispatch origin for this call must be _Root_.4## Complexity- O(1).,force_batch
calls�

|Vec<<T as Config>::RuntimeCall>4|Send a batch of dispatch calls.�Unlike `batch`, it allows errors and won't interrupt.�May be called from any origin except `None`.]
- `calls`: The calls to be dispatched from the same origin. The number of call must not9
  exceed the constant: `batched_calls_limit` (available in constant metadata).M
If origin is root then the calls are dispatch without checking origin filter. (This�includes bypassing `frame_system::Config::BaseCallFilter`).4## Complexity�- O(C) where C is the number of calls to be batched.,with_weight
call

|Box<<T as Config>::RuntimeCall>
weight(
Weight�Dispatch a function call with a specified weight.-
This function does not check the weight of the call, and instead allows the�Root origin to specify the weight of the call.�The dispatch origin for this call must be _Root_.

Contains a variant per dispatchable extrinsic that this pallet has.�

�
0vara_runtime0OriginCaller
system�

tframe_system::Origin<Runtime>Origins�

tpallet_custom_origins::OriginVoid�

A
self::sp_api_hidden_includes_construct_runtime::hidden_include::
__private::Void�
4frame_support dispatch$RawOrigin$AccountId

RootSigned
$AccountId
None�
0vara_runtime(governanceoriginsTpallet_custom_originsOrigin
d0StakingAdmin$Treasurer
<FellowshipAdmin0GeneralAdminLReferendumCanceller@ReferendumKiller,SmallTipper$BigTipper0SmallSpender4MediumSpender	(BigSpender
DWhitelistedCallerLFellowshipInitiatesFellows
DFellowshipExpertsDFellowshipMasters8Fellowship1Dan8Fellowship2Dan8Fellowship3Dan8Fellowship4Dan8Fellowship5Dan8Fellowship6Dan8Fellowship7Dan8Fellowship8Dan8Fellowship9Dan�
sp_coreVoid
�
8pallet_vestingpalletCallT
vest$�Unlock any vested funds of the sender account.]
The dispatch origin for this call must be _Signed_ and the sender must have funds stilldlocked under this pallet.�Emits either `VestingCompleted` or `VestingUpdated`.4## Complexity$- `O(1)`.(vest_other
targetu

PAccountIdLookupOf<T>
,�Unlock any vested funds of a `target` account.�The dispatch origin for this call must be _Signed_.Q
- `target`: The account whose vested funds should be unlocked. Must have funds stilldlocked under this pallet.�Emits either `VestingCompleted` or `VestingUpdated`.4## Complexity$- `O(1)`.<vested_transfer
targetu

PAccountIdLookupOf<T>
 schedule�

�VestingInfo<BalanceOf<T>, BlockNumberFor<T>>4dCreate a vested transfer.�The dispatch origin for this call must be _Signed_.�- `target`: The account receiving the vested funds.�- `schedule`: The vesting schedule attached to the transfer.\Emits `VestingCreated`.�NOTE: This will unlock all schedules through the current block.4## Complexity$- `O(1)`.Tforce_vested_transfer
sourceu

PAccountIdLookupOf<T>
targetu

PAccountIdLookupOf<T>
 schedule�

�VestingInfo<BalanceOf<T>, BlockNumberFor<T>>8`Force a vested transfer.�The dispatch origin for this call must be _Root_.�- `source`: The account whose funds should be transferred.
- `target`: The account that should be transferred the vested funds.�- `schedule`: The vesting schedule attached to the transfer.\Emits `VestingCreated`.�NOTE: This will unlock all schedules through the current block.4## Complexity$- `O(1)`.<merge_schedules
<schedule1_index
u32
<schedule2_index
u32T]
Merge two vesting schedules together, creating a new vesting schedule that unlocks overU
the highest possible start and end blocks. If both schedules have already started theY
current block will be used as the schedule start; with the caveat that if one schedule]
is finished by the current block, the other will be treated as the new merged schedule,,unmodified.�NOTE: If `schedule1_index == schedule2_index` this is a no-op.A
NOTE: This will unlock all schedules through the current block prior to merging.a
NOTE: If both schedules have ended by the current block, no new schedule will be createddand both will be removed.lMerged schedule attributes:5
- `starting_block`: `MAX(schedule1.starting_block, scheduled2.starting_block,H  current_block)`.!
- `ending_block`: `MAX(schedule1.ending_block, schedule2.ending_block)`.Y
- `locked`: `schedule1.locked_at(current_block) + schedule2.locked_at(current_block)`.�The dispatch origin for this call must be _Signed_.�- `schedule1_index`: index of the first schedule to merge.�- `schedule2_index`: index of the second schedule to merge.tforce_remove_vesting_schedule
targetu

�<T::Lookup as StaticLookup>::Source
8schedule_index
u32|Force remove a vesting schedule�The dispatch origin for this call must be _Root_.�- `target`: An account that has a vesting schedule
- `schedule_index`: The vesting schedule index that should be removed

Contains a variant per dispatchable extrinsic that this pallet has.�
8pallet_vesting0vesting_info,VestingInfoBalance
,BlockNumber

locked
Balance
$per_block
Balance
8starting_block
,BlockNumber�
@pallet_bags_listpalletCallTI
rebag
(dislocatedu

PAccountIdLookupOf<T>(Y
Declare that some `dislocated` account has, through rewards or penalties, sufficientlyQ
changed its score that it should properly fall into a different bag than its currentone.
Anyone can call this function about any potentially dislocated account.I
Will always update the stored score of `dislocated` to the correct score, based on@`ScoreProvider`.�If `dislocated` does not exists, it returns an error.<put_in_front_of
lighteru

PAccountIdLookupOf<T>
(�Move the caller's Id directly in front of `lighter`.Y
The dispatch origin for this call must be _Signed_ and can only be called by the Id of5
the account going in front of `lighter`. Fee is payed by the origin under all8circumstances.8Only works if:�- both nodes are within the same bag,�- and `origin` has a greater `Score` than `lighter`.Tput_in_front_of_other
heavieru

PAccountIdLookupOf<T>
lighteru

PAccountIdLookupOf<T>
Same as [`Pallet::put_in_front_of`], but it can be called by anyone.�Fee is paid by the origin under all circumstances.

Contains a variant per dispatchable extrinsic that this pallet has.�
@pallet_im_onlinepalletCallT
$heartbeat
$heartbeat�

pHeartbeat<BlockNumberFor<T>>
$signature�

�<T::AuthorityId as RuntimeAppPublic>::Signature8## Complexity:�- `O(K)` where K is length of `Keys` (heartbeat.validators_len)�  - `O(K)`: decoding of length `K`

Contains a variant per dispatchable extrinsic that this pallet has.�
@pallet_im_online$Heartbeat,BlockNumber

0block_number
,BlockNumber
4session_index
0SessionIndex
<authority_index
$AuthIndex
8validators_len
u32�
@pallet_im_onlinesr25519,app_sr25519$Signature]

Hsr25519::Signature�
8pallet_stakingpalletpalletCallT
xbond
value�
0BalanceOf<T>
payee�
|RewardDestination<T::AccountId>@a
Take the origin account as a stash and lock up `value` of its balance. `controller` will�be the account that controls it.-
`value` must be more than the `minimum_balance` specified by `T::Currency`.!
The dispatch origin for this call must be _Signed_ by the stash account.<Emits `Bonded`.4## Complexity�- Independent of the arguments. Moderate complexity.- O(1).d- Three extra DB entries.M
NOTE: Two of the storage writes (`Self::bonded`, `Self::payee`) are _never_ cleanedY
unless the `origin` falls below _existential deposit_ (or equal to 0) and gets removed as dust.(bond_extra
8max_additional�
0BalanceOf<T>
8a
Add some extra amount that have appeared in the stash `free_balance` into the balance up0for staking.Q
The dispatch origin for this call must be _Signed_ by the stash, not the controller.M
Use this if there are additional funds in your stash account that you wish to bond.U
Unlike [`bond`](Self::bond) or [`unbond`](Self::unbond) this function does not impose�any limitation on the amount that can be added.<Emits `Bonded`.4## Complexity�- Independent of the arguments. Insignificant complexity.- O(1).unbond
value�
0BalanceOf<T>LQ
Schedule a portion of the stash to be unlocked ready for transfer out after the bond�period ends. If this leaves an amount actively bonded less than!
T::Currency::minimum_balance(), then it is increased to the full amount.Q
The dispatch origin for this call must be _Signed_ by the controller, not the stash.E
Once the unlock period is done, you can call `withdraw_unbonded` to actually move�the funds out of management ready for transfer.1
No more than a limited number of unlocking chunks (see `MaxUnlockingChunks`)A
can co-exists at the same time. If there are no unlocking chunks slots availableE
[`Call::withdraw_unbonded`] is called to remove some of the chunks (if possible).9
If a user encounters the `InsufficientBond` error when calling this extrinsic,
they should call `chill` first in order to free up their bonded funds.DEmits `Unbonded`.�See also [`Call::withdraw_unbonded`].Dwithdraw_unbonded
Hnum_slashing_spans
u32\)
Remove any unlocked chunks from the `unlocking` queue from our management.U
This essentially frees up that balance to be used by the stash account to do whatever$it wants.
The dispatch origin for this call must be _Signed_ by the controller.HEmits `Withdrawn`.hSee also [`Call::unbond`].4## ParametersQ
- `num_slashing_spans` indicates the number of metadata slashing spans to clear whenU
this call results in a complete removal of all the data related to the stash account.=
In this case, the `num_slashing_spans` must be larger or equal to the number of]
slashing spans associated with the stash account in the [`SlashingSpans`] storage type,%
otherwise the call will fail. The call weight is directly proportional toT`num_slashing_spans`.4## Complexity�O(S) where S is the number of slashing spans to remove	
NOTE: Weight annotation is the kill scenario, we refund otherwise. validate
prefs�
8ValidatorPrefs�Declare the desire to validate for the origin controller.�Effects will be felt at the beginning of the next era.Q
The dispatch origin for this call must be _Signed_ by the controller, not the stash. nominate
targets�

dVec<AccountIdLookupOf<T>>(

Declare the desire to nominate `targets` for the origin controller.�Effects will be felt at the beginning of the next era.Q
The dispatch origin for this call must be _Signed_ by the controller, not the stash.4## Complexity-
- The transaction's complexity is proportional to the size of `targets` (N)
which is capped at CompactAssignments::LIMIT (T::MaxNominations).�- Both the reads and writes follow a similar pattern.chill(�Declare no desire to either validate or nominate.�Effects will be felt at the beginning of the next era.Q
The dispatch origin for this call must be _Signed_ by the controller, not the stash.4## Complexity�- Independent of the arguments. Insignificant complexity.P- Contains one read.�- Writes are limited to the `origin` account key.$set_payee
payee�
|RewardDestination<T::AccountId>0�(Re-)set the payment target for a controller.Q
Effects will be felt instantly (as soon as this function is completed successfully).Q
The dispatch origin for this call must be _Signed_ by the controller, not the stash.4## Complexity- O(1)�- Independent of the arguments. Insignificant complexity.�- Contains a limited number of reads.�- Writes are limited to the `origin` account key.$---------8set_controller8E
(Re-)sets the controller of a stash to the stash itself. This function previouslyM
accepted a `controller` argument to set the controller to an account other than theY
stash itself. This functionality has now been removed, now only setting the controller�to the stash, if it is not already.Q
Effects will be felt instantly (as soon as this function is completed successfully).Q
The dispatch origin for this call must be _Signed_ by the stash, not the controller.4## ComplexityO(1)�- Independent of the arguments. Insignificant complexity.�- Contains a limited number of reads.�- Writes are limited to the `origin` account key.Lset_validator_count
new)

u32	�Sets the ideal number of validators.�The dispatch origin must be Root.4## ComplexityO(1)`increase_validator_count
(additional)

u32
�Increments the ideal number of validators up to maximum of�`ElectionProviderBase::MaxWinners`.�The dispatch origin must be Root.4## Complexity�Same as [`Self::set_validator_count`].Tscale_validator_count
factor�

Percent
Scale up the ideal number of validators by a factor up to maximum of�`ElectionProviderBase::MaxWinners`.�The dispatch origin must be Root.4## Complexity�Same as [`Self::set_validator_count`].4force_no_eras4�Force there to be no new eras indefinitely.�The dispatch origin must be Root.$# Warning
The election process starts multiple blocks before the end of the era.9
Thus the election process may be ongoing when this is called. In this case the�election will continue until the next era is triggered.4## Complexity<- No arguments.8- Weight: O(1)4force_new_era
8I
Force there to be a new era at the end of the next session. After this, it will be�reset to normal (non-forced) behaviour.�The dispatch origin must be Root.$# Warning
The election process starts multiple blocks before the end of the era.I
If this is called just before a new era is triggered, the election process may not�have enough blocks to get a result.4## Complexity<- No arguments.8- Weight: O(1)Dset_invulnerables
4invulnerables�

DVec<T::AccountId>�Set the validators who cannot be slashed (if any).�The dispatch origin must be Root.4force_unstake
stash
0T::AccountId
Hnum_slashing_spans
u32 	
Force a current staker to become completely unstaked, immediately.�The dispatch origin must be Root.4## ParametersE
- `num_slashing_spans`: Refer to comments on [`Call::withdraw_unbonded`] for more details.Pforce_new_era_always$

Force there to be a new era at the end of sessions indefinitely.�The dispatch origin must be Root.$# Warning
The election process starts multiple blocks before the end of the era.I
If this is called just before a new era is triggered, the election process may not�have enough blocks to get a result.Tcancel_deferred_slash
era
 EraIndex
4slash_indices�

 Vec<u32>�Cancel enactment of a deferred slash.�Can be called by the `T::AdminOrigin`.

Parameters: era and indices of the slashes for that era to kill.8payout_stakers
<validator_stash
0T::AccountId
era
 EraIndex4
Pay out next page of the stakers behind a validator for the given era.�- `validator_stash` is the stash account of the validator.1
- `era` may be any era between `[current_era - history_depth; current_era]`.U
The origin of this call must be _Signed_. Any account can call this function, even iftit is not one of the stakers.I
The reward payout could be paged in case there are too many nominators backing the]
`validator_stash`. This call will payout unpaid pages in an ascending order. To claim a�specific page, use `payout_stakers_by_page`.`�If all pages are claimed, it returns an error `InvalidPage`.rebond
value�
0BalanceOf<T>�Rebond a portion of the stash scheduled to be unlocked.�The dispatch origin must be signed by the controller.4## Complexity�- Time complexity: O(L), where L is unlocking chunks�- Bounded by `MaxUnlockingChunks`.(reap_stash
stash
0T::AccountId
Hnum_slashing_spans
u32H]
Remove all data structures concerning a staker/stash once it is at a state where it can
be considered `dust` in the staking system. The requirements are:
1. the `total_balance` of the stash is below existential deposit.
2. or, the `ledger.total` of the stash is below existential deposit.a
3. or, existential deposit is zero and either `total_balance` or `ledger.total` is zero.U
The former can happen in cases like a slash; the latter when a fully unbonded account	
is still receiving staking rewards in `RewardDestination::Staked`.1
It can be called by anyone, as long as `stash` meets the above requirements.�Refunds the transaction fees upon successful execution.4## ParametersE
- `num_slashing_spans`: Refer to comments on [`Call::withdraw_unbonded`] for more details.kick
who�

dVec<AccountIdLookupOf<T>>,�Remove the given nominations from the calling validator.�Effects will be felt at the beginning of the next era.Q
The dispatch origin for this call must be _Signed_ by the controller, not the stash.M
- `who`: A list of nominator stash accounts who are nominating this validator which�  should no longer be nominating this validator.U
Note: Making this call only makes sense if you first set the validator preferences toxblock any further nominations.Lset_staking_configs
Hmin_nominator_bond�

XConfigOp<BalanceOf<T>>
Hmin_validator_bond�

XConfigOp<BalanceOf<T>>
Lmax_nominator_count�

4ConfigOp<u32>
Lmax_validator_count�

4ConfigOp<u32>
<chill_threshold�

DConfigOp<Percent>
8min_commission�

DConfigOp<Perbill>
Hmax_staked_rewards�

DConfigOp<Percent>D�Update the various staking configurations .%
* `min_nominator_bond`: The minimum active bond needed to be a nominator.%
* `min_validator_bond`: The minimum active bond needed to be a validator.U
* `max_nominator_count`: The max number of users who can be a nominator at once. When�  set to `None`, no limit is enforced.U
* `max_validator_count`: The max number of users who can be a validator at once. When�  set to `None`, no limit is enforced.Y
* `chill_threshold`: The ratio of `max_nominator_count` or `max_validator_count` which
  should be filled in order for the `chill_other` transaction to work.a
* `min_commission`: The minimum amount of commission that each validators must maintain.U
  This is checked only upon calling `validate`. Existing validators are not affected.�RuntimeOrigin must be Root to call this function.5
NOTE: Existing nominators and validators will not be affected by this update.
to kick people under the new limits, `chill_other` should be called.,chill_other
stash
0T::AccountIdhA
Declare a `controller` to stop participating as either a validator or nominator.�Effects will be felt at the beginning of the next era.A
The dispatch origin for this call must be _Signed_, but can be called by anyone.Y
If the caller is the same as the controller being targeted, then no further checks are�enforced, and this function behaves just like `chill`.]
If the caller is different than the controller being targeted, the following conditions0must be met:
* `controller` must belong to a nominator who has become non-decodable,Or:=
* A `ChillThreshold` must be set and checked which defines how close to the maxU
  nominators or validators we must reach before users can start chilling one-another.Y
* A `MaxNominatorCount` and `MaxValidatorCount` must be set which is used to determine�  how close we are to the threshold.]
* A `MinNominatorBond` and `MinValidatorBond` must be set and checked, which determinesQ
  if this is a person that should be chilled because they have not met the threshold@  bond required.U
This can be helpful if bond requirements are updated, and we need to remove old users�who do not satisfy these requirements.hforce_apply_min_commission
<validator_stash
0T::AccountIdE
Force a validator to have at least the minimum commission. This will not affect aa
validator who already has a commission greater than or equal to the minimum. Any account8can call this.Hset_min_commission
new�
Perbill%
Sets the minimum amount of commission that each validators must maintain.Y
This call has lower privilege requirements than `set_staking_config` and can be called�by the `T::AdminOrigin`. Root can always call this.Xpayout_stakers_by_page
<validator_stash
0T::AccountId
era
 EraIndex
page
PageD1
Pay out a page of the stakers behind a validator for the given era and page.�- `validator_stash` is the stash account of the validator.1
- `era` may be any era between `[current_era - history_depth; current_era]`.1
- `page` is the page index of nominators to pay out with value between 0 and�  `num_nominators / T::MaxExposurePageSize`.U
The origin of this call must be _Signed_. Any account can call this function, even iftit is not one of the stakers.=
If a validator has more than [`Config::MaxExposurePageSize`] nominators backing)
them, then the list of nominators is paged, with each page being capped atU
[`Config::MaxExposurePageSize`.] If a validator has more than one page of nominators,I
the call needs to be made for each page separately in order for all the nominatorsU
backing a validator to receive the reward. The nominators are not sorted across pagesa
and so it should not be assumed the highest staker would be on the topmost page and viceI
versa. If rewards are not claimed in [`Config::HistoryDepth`] eras, they are lost.0update_payee
(controller
0T::AccountId�Migrates an account's `RewardDestination::Controller` to�`RewardDestination::Account(controller)`.Q
Effects will be felt instantly (as soon as this function is completed successfully).1
This will waive the transaction fee if the `payee` is successfully migrated.hdeprecate_controller_batch
,controllers�

�BoundedVec<T::AccountId, T::MaxControllersInDeprecationBatch>]
Updates a batch of controller accounts to their corresponding stash account if they area
not the same. Ignores any controller accounts that do not exist, and does not operate if�the stash and controller are already the same.Q
Effects will be felt instantly (as soon as this function is completed successfully).�The dispatch origin must be `T::AdminOrigin`.8restore_ledger
stash
0T::AccountId
@maybe_controller�

POption<T::AccountId>
,maybe_total�

POption<BalanceOf<T>>
<maybe_unlocking�


Option<BoundedVec<UnlockChunk<BalanceOf<T>>, T::
MaxUnlockingChunks>>,
Restores the state of a ledger which is in an inconsistent state.�The requirements to restore a ledger are the following:d* The stash is bonded; or

* The stash is not bonded but it has a staking lock left behind; or%
* If the stash has an associated ledger and its state is inconsistent; or
* If the ledger is not corrupted *but* its staking lock is out of sync.a
The `maybe_*` input parameters will overwrite the corresponding data and metadata of theY
ledger associated with the stash. If the input parameters are not set, the ledger will�be reset values from on-chain state.

Contains a variant per dispatchable extrinsic that this pallet has.�
u
�
4sp_arithmetic(per_thingsPercent
u8�
�
8pallet_stakingpalletpallet ConfigOpT

NoopSet
T
Remove�
8pallet_stakingpalletpallet ConfigOpT

NoopSet
T
Remove�
8pallet_stakingpalletpallet ConfigOpT
�

NoopSet�

T
Remove�
8pallet_stakingpalletpallet ConfigOpT
�
NoopSet�
T
Remove�
Lbounded_collections,bounded_vec(BoundedVecT
S�

Vec<T>�
OptionT

NoneSome
�
OptionT

NoneSome
�
OptionT
�

NoneSome�

�
Lbounded_collections,bounded_vec(BoundedVecT
�
S�

Vec<T>�
8pallet_staking,UnlockChunkBalance

value�
Balance
era)

 EraIndex�
�

<pallet_treasurypalletCallTI
,spend_local
amount�
<BalanceOf<T, I>
,beneficiaryu

PAccountIdLookupOf<T>D�Propose and approve a spend of treasury funds.H## Dispatch OriginE
Must be [`Config::SpendOrigin`] with the `Success` value being at least `amount`.,### DetailsE
NOTE: For record-keeping purposes, the proposer is deemed to be equivalent to the0beneficiary.8### ParametersA
- `amount`: The amount to be transferred from the treasury to the `beneficiary`.�- `beneficiary`: The destination account for the transfer.$## Events�Emits [`Event::SpendApproved`] if successful.<remove_approval
,proposal_id)

4ProposalIndexT-
Force a previously approved proposal to be removed from the approval queue.H## Dispatch Origin�Must be [`Config::RejectOrigin`].(## Details�The original deposit will no longer be returned.8### Parameters�- `proposal_id`: The index of a proposal8### Complexity�- O(A) where `A` is the number of approvals(### ErrorsE
- [`Error::ProposalNotApproved`]: The `proposal_id` supplied was not found in theQ
  approval queue, i.e., the proposal has not been approved. This could also mean theY
  proposal does not exist altogether, thus there is no way it would have been approvedT  in the first place.spend
(asset_kind�
DBox<T::AssetKind>
amount�
PAssetBalanceOf<T, I>
,beneficiary
xBox<BeneficiaryLookupOf<T, I>>
(valid_from
dOption<BlockNumberFor<T>>h�Propose and approve a spend of treasury funds.H## Dispatch Origin
Must be [`Config::SpendOrigin`] with the `Success` value being at leastU
`amount` of `asset_kind` in the native asset. The amount of `asset_kind` is converted�for assertion using the [`Config::BalanceConverter`].(## DetailsI
Create an approved spend for transferring a specific `amount` of `asset_kind` to aa
designated beneficiary. The spend must be claimed using the `payout` dispatchable withintthe [`Config::PayoutPeriod`].8### Parameters
- `asset_kind`: An indicator of the specific asset class to be spent.A
- `amount`: The amount to be transferred from the treasury to the `beneficiary`.�- `beneficiary`: The beneficiary of the spend.U
- `valid_from`: The block number from which the spend can be claimed. It can refer to
  the past if the resulting spend has not yet expired according to theE
  [`Config::PayoutPeriod`]. If `None`, the spend can be claimed immediately after,  approval.$## Events�Emits [`Event::AssetSpendApproved`] if successful.payout
index
(SpendIndexL8Claim a spend.H## Dispatch Origin8Must be signed(## DetailsU
Spends must be claimed within some temporal bounds. A spend may be claimed within one�[`Config::PayoutPeriod`] from the `valid_from` block.U
In case of a payout failure, the spend status must be updated with the `check_status`�dispatchable before retrying with the current function.8### Parametersl- `index`: The spend index.$## Events�Emits [`Event::Paid`] if successful.0check_status
index
(SpendIndexL)
Check the status of the spend and remove it from the storage if processed.H## Dispatch Origin<Must be signed.(## Details

The status check is a prerequisite for retrying a failed payout.I
If a spend has either succeeded or expired, it is removed from the storage by this�function. In such instances, transaction fees are refunded.8### Parametersl- `index`: The spend index.$## Events�Emits [`Event::PaymentFailed`] if the spend payout has failed.

Emits [`Event::SpendProcessed`] if the spend payout has succeed.(void_spend
index
(SpendIndex@|Void previously approved spend.H## Dispatch Origin�Must be [`Config::RejectOrigin`].(## Details
A spend void is only possible if the payout has not been attempted yet.8### Parametersl- `index`: The spend index.$## Events�Emits [`Event::AssetSpendVoided`] if successful.

Contains a variant per dispatchable extrinsic that this pallet has.OptionT

NoneSome
	`pallet_conviction_votingpalletCallTI
vote
(poll_index)

DPollIndexOf<T, I>
vote�
pAccountVote<BalanceOf<T, I>>$
Vote in a poll. If `vote.is_aye()`, the vote is to enact the proposal;�otherwise it is a vote to keep the status quo.�The dispatch origin of this call must be _Signed_.�- `poll_index`: The index of the poll to vote for.�- `vote`: The vote configuration.
Weight: `O(R)` where R is the number of polls the voter has voted on. delegate
class�
4ClassOf<T, I>
tou

PAccountIdLookupOf<T>
(conviction

(Conviction
balance
<BalanceOf<T, I>
\M
Delegate the voting power (with some given conviction) of the sending account for ahparticular class of polls.U
The balance delegated is locked for as long as it's delegated, and thereafter for the�time appropriate for the conviction's lock period.]
The dispatch origin of this call must be _Signed_, and the signing account must either:t  - be delegating already; orE
  - have no voting activity (if there is, then it will need to be removed throughL    `remove_vote`).E
- `to`: The account whose voting the `target` account's voting power will follow.]
- `class`: The class of polls to delegate. To delegate multiple classes, multiple calls�  to this function are required.U
- `conviction`: The conviction that will be attached to the delegated votes. When theA
  account is undelegated, the funds will be locked for the corresponding period.a
- `balance`: The amount of the account's balance to be used in delegating. This must not�  be more than the account's current balance.HEmits `Delegated`.%
Weight: `O(R)` where R is the number of polls the voter delegating to hasM
  voted on. Weight is initially charged as if maximum votes, but is refunded later.(undelegate
class�
4ClassOf<T, I>8M
Undelegate the voting power of the sending account for a particular class of polls.]
Tokens may be unlocked following once an amount of time consistent with the lock period	
of the conviction with which the delegation was issued has passed.E
The dispatch origin of this call must be _Signed_ and the signing account must beTcurrently delegating.�- `class`: The class of polls to remove the delegation from.PEmits `Undelegated`.%
Weight: `O(R)` where R is the number of polls the voter delegating to hasM
  voted on. Weight is initially charged as if maximum votes, but is refunded later.unlock
class�
4ClassOf<T, I>
targetu

PAccountIdLookupOf<T>$]
Remove the lock caused by prior voting/delegating which has expired within a particularclass.�The dispatch origin of this call must be _Signed_.�- `class`: The class of polls to unlock.�- `target`: The account to remove the lock on.�Weight: `O(R)` with R number of vote of target.,remove_vote
class
TOption<ClassOf<T, I>>
index
DPollIndexOf<T, I>tdRemove a vote for a poll.If:p- the poll was cancelled, ord- the poll is ongoing, orx- the poll has ended such that�  - the vote of the account was in opposition to the result; or�  - there was no conviction to the account's vote; or�  - the account made a split vote]
...then the vote is removed cleanly and a following call to `unlock` may result in moreXfunds being available.�If, however, the poll has ended and:�- it finished corresponding to the vote of the account, and�- the account made a standard vote with conviction, and�- the lock period of the conviction is not overY
...then the lock will be aggregated into the overall account's lock, which may involveY
*overlocking* (where the two locks are combined into a single lock that is the maximum�of both the amount locked and the time is it locked for).I
The dispatch origin of this call must be _Signed_, and the signer must have a votepregistered for poll `index`.�- `index`: The index of poll of the vote to be removed.U
- `class`: Optional parameter, if given it indicates the class of the poll. For polls�  which have finished or are cancelled, this must be `Some`.E
Weight: `O(R + log R)` where R is the number of polls that `target` has voted on.�  Weight is calculated for the maximum number of vote.Dremove_other_vote
targetu

PAccountIdLookupOf<T>
class�
4ClassOf<T, I>
index
DPollIndexOf<T, I>@dRemove a vote for a poll.M
If the `target` is equal to the signer, then this function is exactly equivalent to-
`remove_vote`. If not equal to the signer, then the vote must have expired,%
either because the poll was cancelled, because the voter lost the poll or�because the conviction period is over.�The dispatch origin of this call must be _Signed_.a
- `target`: The account of the vote to be removed; this account must have voted for poll(  `index`.�- `index`: The index of poll of the vote to be removed.�- `class`: The class of the poll.E
Weight: `O(R + log R)` where R is the number of polls that `target` has voted on.�  Weight is calculated for the maximum number of vote.

Contains a variant per dispatchable extrinsic that this pallet has.
`pallet_conviction_voting(conviction(Conviction
None Locked1x
 Locked2x Locked3x Locked4x Locked5x Locked6xOptionT
�
NoneSome�
@pallet_referendapalletCallTI
$submit
<proposal_origin�

\Box<PalletsOriginOf<T>>
 proposal


LBoundedCallOf<T, I>
@enactment_moment
|DispatchTime<BlockNumberFor<T>>$�Propose a referendum on a privileged action.Y
- `origin`: must be `SubmitOrigin` and the account must have `SubmissionDeposit` funds0  available.-
- `proposal_origin`: The origin from which the proposal should be executed.l- `proposal`: The proposal.
- `enactment_moment`: The moment that the proposal should be enacted.HEmits `Submitted`.Xplace_decision_deposit
index
<ReferendumIndex
 �Post the Decision Deposit for a referendum.9
- `origin`: must be `Signed` and the account must have funds available for the�  referendum's track's Decision Deposit.Q
- `index`: The index of the submitted referendum whose Decision Deposit is yet to be$  posted.xEmits `DecisionDepositPlaced`.\refund_decision_deposit
index
<ReferendumIndex)
Refund the Decision Deposit for a closed referendum back to the depositor.�- `origin`: must be `Signed` or `Root`.M
- `index`: The index of a closed referendum whose Decision Deposit has not yet been,  refunded.�Emits `DecisionDepositRefunded`.cancel
index
<ReferendumIndextCancel an ongoing referendum.�- `origin`: must be the `CancelOrigin`.�- `index`: The index of the referendum to be cancelled.HEmits `Cancelled`.kill
index
<ReferendumIndex�Cancel an ongoing referendum and slash the deposits.�- `origin`: must be the `KillOrigin`.�- `index`: The index of the referendum to be cancelled.�Emits `Killed` and `DepositSlashed`.@nudge_referendum
index
<ReferendumIndex
Advance a referendum onto its next logical state. Only used internally.l- `origin`: must be `Root`.�- `index`: the referendum to be advanced.Hone_fewer_deciding
track�
<TrackIdOf<T, I>$	
Advance a track onto its next logical state. Only used internally.l- `origin`: must be `Root`.�- `track`: the track to be advanced.Q
Action item for when there is now one fewer referendum in the deciding phase and the
`DecidingCount` is not yet updated. This means that we should either:%
- begin deciding another referendum (and leave `DecidingCount` alone); orp- decrement `DecidingCount`.drefund_submission_deposit
index
<ReferendumIndex1
Refund the Submission Deposit for a closed referendum back to the depositor.�- `origin`: must be `Signed` or `Root`.U
- `index`: The index of a closed referendum whose Submission Deposit has not yet been,  refunded.�Emits `SubmissionDepositRefunded`.0set_metadata
index
<ReferendumIndex
(maybe_hash
<Option<T::Hash>�Set or clear metadata of a referendum.,Parameters:E
- `origin`: Must be `Signed` by a creator of a referendum or by anyone to clear a�  metadata of a finished referendum.

- `index`:  The index of a referendum to set or clear metadata for.Q
- `maybe_hash`: The hash of an on-chain stored preimage. `None` to clear a metadata.

Contains a variant per dispatchable extrinsic that this pallet has.4frame_supporttraits schedule0DispatchTime,BlockNumber

At
,BlockNumberAfter
,BlockNumber
OptionT
4
NoneSome4
!`pallet_ranked_collectivepalletCallTI
(add_member
whou

PAccountIdLookupOf<T>\Introduce a new member.�- `origin`: Must be the `AddOrigin`.�- `who`: Account of non-member which will become a member.8Weight: `O(1)`8promote_member
whou

PAccountIdLookupOf<T>
�Increment the rank of an existing member by one.�- `origin`: Must be the `PromoteOrigin`.�- `who`: Account of existing member.8Weight: `O(1)`4demote_member
whou

PAccountIdLookupOf<T>]
Decrement the rank of an existing member by one. If the member is already at rank zero,|then they are removed entirely.�- `origin`: Must be the `DemoteOrigin`.�- `who`: Account of existing member of rank greater than zero.	
Weight: `O(1)`, less if the member's index is highest in its rank.4remove_member
whou

PAccountIdLookupOf<T>
 min_rank�
RanklRemove the member entirely.�- `origin`: Must be the `RemoveOrigin`.�- `who`: Account of existing member of rank greater than zero.�- `min_rank`: The rank of the member or greater.XWeight: `O(min_rank)`.vote
poll
DPollIndexOf<T, I>
aye 
bool,�Add an aye or nay vote for the sender to the given proposal.�- `origin`: Must be `Signed` by a member account.�- `poll`: Index of a poll which is ongoing.)
- `aye`: `true` if the vote is to approve the proposal, `false` otherwise.E
Transaction fees are be waived if the member is voting on any particular proposalQ
for the first time and the call is successful. Subsequent vote changes will charge afee.5
Weight: `O(1)`, less if there was no previous vote on the poll by the member.0cleanup_poll
(poll_index
DPollIndexOf<T, I>
max
u32(�Remove votes from the given poll. It must have ended.�- `origin`: Must be `Signed` by any account.I
- `poll_index`: Index of a poll which is completed and for which votes continue to   exist.�- `max`: Maximum number of vote items from remove in this call.�Transaction fees are waived if the operation is successful.
Weight `O(max)` (less if there are fewer items to remove than `max`).<exchange_member
whou

PAccountIdLookupOf<T>
new_whou

PAccountIdLookupOf<T>
Exchanges a member with a new account and the same existing rank.�- `origin`: Must be the `ExchangeOrigin`.9
- `who`: Account of existing member of rank greater than zero to be exchanged.Y
- `new_who`: New Account of existing member of rank greater than zero to exchanged to.

Contains a variant per dispatchable extrinsic that this pallet has.%@pallet_referendapalletCallTI
$submit
<proposal_origin�

\Box<PalletsOriginOf<T>>
 proposal


LBoundedCallOf<T, I>
@enactment_moment
|DispatchTime<BlockNumberFor<T>>$�Propose a referendum on a privileged action.Y
- `origin`: must be `SubmitOrigin` and the account must have `SubmissionDeposit` funds0  available.-
- `proposal_origin`: The origin from which the proposal should be executed.l- `proposal`: The proposal.
- `enactment_moment`: The moment that the proposal should be enacted.HEmits `Submitted`.Xplace_decision_deposit
index
<ReferendumIndex
 �Post the Decision Deposit for a referendum.9
- `origin`: must be `Signed` and the account must have funds available for the�  referendum's track's Decision Deposit.Q
- `index`: The index of the submitted referendum whose Decision Deposit is yet to be$  posted.xEmits `DecisionDepositPlaced`.\refund_decision_deposit
index
<ReferendumIndex)
Refund the Decision Deposit for a closed referendum back to the depositor.�- `origin`: must be `Signed` or `Root`.M
- `index`: The index of a closed referendum whose Decision Deposit has not yet been,  refunded.�Emits `DecisionDepositRefunded`.cancel
index
<ReferendumIndextCancel an ongoing referendum.�- `origin`: must be the `CancelOrigin`.�- `index`: The index of the referendum to be cancelled.HEmits `Cancelled`.kill
index
<ReferendumIndex�Cancel an ongoing referendum and slash the deposits.�- `origin`: must be the `KillOrigin`.�- `index`: The index of the referendum to be cancelled.�Emits `Killed` and `DepositSlashed`.@nudge_referendum
index
<ReferendumIndex
Advance a referendum onto its next logical state. Only used internally.l- `origin`: must be `Root`.�- `index`: the referendum to be advanced.Hone_fewer_deciding
track�
<TrackIdOf<T, I>$	
Advance a track onto its next logical state. Only used internally.l- `origin`: must be `Root`.�- `track`: the track to be advanced.Q
Action item for when there is now one fewer referendum in the deciding phase and the
`DecidingCount` is not yet updated. This means that we should either:%
- begin deciding another referendum (and leave `DecidingCount` alone); orp- decrement `DecidingCount`.drefund_submission_deposit
index
<ReferendumIndex1
Refund the Submission Deposit for a closed referendum back to the depositor.�- `origin`: must be `Signed` or `Root`.U
- `index`: The index of a closed referendum whose Submission Deposit has not yet been,  refunded.�Emits `SubmissionDepositRefunded`.0set_metadata
index
<ReferendumIndex
(maybe_hash
<Option<T::Hash>�Set or clear metadata of a referendum.,Parameters:E
- `origin`: Must be `Signed` by a creator of a referendum or by anyone to clear a�  metadata of a finished referendum.

- `index`:  The index of a referendum to set or clear metadata for.Q
- `maybe_hash`: The hash of an on-chain stored preimage. `None` to clear a metadata.

Contains a variant per dispatchable extrinsic that this pallet has.)@pallet_whitelistpalletCallT
8whitelist_call
$call_hash4
T::Hash\remove_whitelisted_call
$call_hash4
T::Hash
ddispatch_whitelisted_call
$call_hash4
T::Hash
@call_encoded_len
u32
Lcall_weight_witness(
Weight�dispatch_whitelisted_call_with_preimage
call

|Box<<T as Config>::RuntimeCall>

Contains a variant per dispatchable extrinsic that this pallet has.-@pallet_schedulerpalletCallT
( schedule
when
DBlockNumberFor<T>
8maybe_periodic1
�Option<schedule::Period<BlockNumberFor<T>>>
 priority
Hschedule::Priority
call

|Box<<T as Config>::RuntimeCall>pAnonymously schedule a task.cancel
when
DBlockNumberFor<T>
index
u32
�Cancel an anonymously scheduled task.8schedule_named
id
 TaskName
when
DBlockNumberFor<T>
8maybe_periodic1
�Option<schedule::Period<BlockNumberFor<T>>>
 priority
Hschedule::Priority
call

|Box<<T as Config>::RuntimeCall>XSchedule a named task.0cancel_named
id
 TaskNamexCancel a named scheduled task.8schedule_after
after
DBlockNumberFor<T>
8maybe_periodic1
�Option<schedule::Period<BlockNumberFor<T>>>
 priority
Hschedule::Priority
call

|Box<<T as Config>::RuntimeCall>�Anonymously schedule a task after a delay.Pschedule_named_after
id
 TaskName
after
DBlockNumberFor<T>
8maybe_periodic1
�Option<schedule::Period<BlockNumberFor<T>>>
 priority
Hschedule::Priority
call

|Box<<T as Config>::RuntimeCall>�Schedule a named task after a delay.$set_retry
task5
xTaskAddress<BlockNumberFor<T>>
retries
u8
period
DBlockNumberFor<T>0Y
Set a retry configuration for a task so that, in case its scheduled run fails, it willU
be retried after `period` blocks, for a total amount of `retries` retries or until it$succeeds.U
Tasks which need to be scheduled for a retry are still subject to weight metering andQ
agenda space, same as a regular task. If a periodic task fails, it will be scheduled�normally while the task is retrying.Q
Tasks scheduled as a result of a retry for a periodic task are unnamed, non-periodic=
clones of the original task. Their retry configuration will be derived from theM
original task's configuration, but will have a lower value for `remaining` than thedoriginal `total_retries`.<set_retry_named
id
 TaskName
retries
u8
period
DBlockNumberFor<T>0]
Set a retry configuration for a named task so that, in case its scheduled run fails, it]
will be retried after `period` blocks, for a total amount of `retries` retries or until0it succeeds.U
Tasks which need to be scheduled for a retry are still subject to weight metering andQ
agenda space, same as a regular task. If a periodic task fails, it will be scheduled�normally while the task is retrying.Q
Tasks scheduled as a result of a retry for a periodic task are unnamed, non-periodic=
clones of the original task. Their retry configuration will be derived from theM
original task's configuration, but will have a lower value for `remaining` than thedoriginal `total_retries`.0cancel_retry
task5
xTaskAddress<BlockNumberFor<T>>�Removes the retry configuration of a task.Hcancel_retry_named
id
 TaskName	�Cancel the retry configuration of a named task.

Contains a variant per dispatchable extrinsic that this pallet has.1OptionT
5
NoneSome5
59<pallet_preimagepalletCallT
4note_preimage
bytes8
Vec<u8>tRegister a preimage on-chain.U
If the preimage was previously requested, no fees or deposits are taken for providingU
the preimage. Otherwise, a deposit is taken proportional to the size of the preimage.<unnote_preimage
hash4
T::Hash
�Clear an unrequested preimage from the runtime storage.�If `len` is provided, then it will be a much cheaper operation.

- `hash`: The hash of the preimage to be removed from the store.�- `len`: The length of the preimage of `hash`.@request_preimage
hash4
T::HashA
Request a preimage be uploaded to the chain without paying any fees or deposits.U
If the preimage requests has already been provided on-chain, we unreserve any deposit9
a user may have paid, and take the control of the preimage out of their hands.Hunrequest_preimage
hash4
T::Hash�Clear a previously made request for a preimage.-
NOTE: THIS MUST NOT BE CALLED ON `hash` MORE TIMES THAN `request_preimage`.8ensure_updated
hashes=
0Vec<T::Hash>�Ensure that the a bulk of pre-images is upgraded.=
The caller pays no fee if at least 90% of pre-images were successfully updated.

Contains a variant per dispatchable extrinsic that this pallet has.=4A<pallet_identitypalletCallT
X4add_registrar
accountu

PAccountIdLookupOf<T>xAdd a registrar to the system.�The dispatch origin for this call must be `T::RegistrarOrigin`.�- `account`: the account of the registrar.�Emits `RegistrarAdded` if successful.0set_identity
infoE
lBox<T::IdentityInformation>
()
Set an account's identity information and reserve the appropriate deposit.U
If the account already has identity information, the deposit is taken as part paymentPfor the new deposit.�The dispatch origin for this call must be _Signed_.�- `info`: The identity information.�Emits `IdentitySet` if successful. set_subs
subs�
dVec<(T::AccountId, Data)>$�Set the sub-accounts of the sender.U
Payment: Any aggregate balance reserved by previous `set_subs` calls will be returned-
and an amount `SubAccountDeposit` will be reserved for each item in `subs`.a
The dispatch origin for this call must be _Signed_ and the sender must have a registered$identity.�- `subs`: The identity's (new) sub-accounts.8clear_identity 9
Clear an account's identity info and all sub-accounts and return all deposits.�Payment: All reserved balances on the account are returned.a
The dispatch origin for this call must be _Signed_ and the sender must have a registered$identity.�Emits `IdentityCleared` if successful.Drequest_judgement
$reg_index)

8RegistrarIndex
max_fee�
0BalanceOf<T>@�Request a judgement from a registrar.U
Payment: At most `max_fee` will be reserved for payment to the registrar if judgementgiven.5
The dispatch origin for this call must be _Signed_ and the sender must have aPregistered identity.
- `reg_index`: The index of the registrar whose judgement is requested.U
- `max_fee`: The maximum fee that may be paid. This should just be auto-populated as:0```nocompile�Registrars::<T>::get().get(reg_index).unwrap().fee```�Emits `JudgementRequested` if successful.8cancel_request
$reg_index
8RegistrarIndex(hCancel a previous request.�Payment: A previously reserved deposit is returned on success.5
The dispatch origin for this call must be _Signed_ and the sender must have aPregistered identity.E
- `reg_index`: The index of the registrar whose judgement is no longer requested.�Emits `JudgementUnrequested` if successful.set_fee
index)

8RegistrarIndex
fee�
0BalanceOf<T>
Set the fee required for a judgement to be requested from a registrar.U
The dispatch origin for this call must be _Signed_ and the sender must be the account�of the registrar whose index is `index`.�- `index`: the index of the registrar whose fee is to be set.T- `fee`: the new fee.8set_account_id
index)

8RegistrarIndex
newu

PAccountIdLookupOf<T>�Change the account associated with a registrar.U
The dispatch origin for this call must be _Signed_ and the sender must be the account�of the registrar whose index is `index`.�- `index`: the index of the registrar whose fee is to be set.p- `new`: the new account ID.(set_fields
index)

8RegistrarIndex
fields0
)
<T::IdentityInformation as IdentityInformationProvider>::
FieldsIdentifier�Set the field information for a registrar.U
The dispatch origin for this call must be _Signed_ and the sender must be the account�of the registrar whose index is `index`.�- `index`: the index of the registrar whose fee is to be set.

- `fields`: the fields that the registrar concerns themselves with.Dprovide_judgement
$reg_index)

8RegistrarIndex
targetu

PAccountIdLookupOf<T>
$judgement�
\Judgement<BalanceOf<T>>
 identity4
T::Hash	<�Provide a judgement for an account's identity.U
The dispatch origin for this call must be _Signed_ and the sender must be the account�of the registrar whose index is `reg_index`.!
- `reg_index`: the index of the registrar whose judgement is being made.U
- `target`: the account whose identity the judgement is upon. This must be an accountt  with a registered identity.I
- `judgement`: the judgement of the registrar of index `reg_index` about `target`.]
- `identity`: The hash of the [`IdentityInformationProvider`] for that the judgement is,  provided.�Note: Judgements do not apply to a username.�Emits `JudgementGiven` if successful.4kill_identity
targetu

PAccountIdLookupOf<T>
0A
Remove an account's identity and sub-account information and slash the deposits.a
Payment: Reserved balances from `set_subs` and `set_identity` are slashed and handled byE
`Slash`. Verification request deposits are not returned; they should be cancelled�manually using `cancel_request`.�The dispatch origin for this call must match `T::ForceOrigin`.U
- `target`: the account whose identity the judgement is upon. This must be an accountt  with a registered identity.�Emits `IdentityKilled` if successful.add_sub
subu

PAccountIdLookupOf<T>
dataQ
Data�Add the given account to the sender's subs.]
Payment: Balance reserved by a previous `set_subs` call for one sub will be repatriated8to the sender.a
The dispatch origin for this call must be _Signed_ and the sender must have a registeredXsub identity of `sub`.(rename_sub
subu

PAccountIdLookupOf<T>
dataQ
Data�Alter the associated name of the given sub-account.a
The dispatch origin for this call must be _Signed_ and the sender must have a registeredXsub identity of `sub`.(remove_sub
subu

PAccountIdLookupOf<T>
�Remove the given account from the sender's subs.]
Payment: Balance reserved by a previous `set_subs` call for one sub will be repatriated8to the sender.a
The dispatch origin for this call must be _Signed_ and the sender must have a registeredXsub identity of `sub`. quit_sub(�Remove the sender as a sub-account.]
Payment: Balance reserved by a previous `set_subs` call for one sub will be repatriated�to the sender (*not* the original depositor).a
The dispatch origin for this call must be _Signed_ and the sender must have a registered<super-identity.E
NOTE: This should not normally be used, but is provided in the case that the non-
controller of an account is maliciously registered as a sub-account.Xadd_username_authority
$authorityu

PAccountIdLookupOf<T>
suffix8
Vec<u8>
(allocation
u32U
Add an `AccountId` with permission to grant usernames with a given `suffix` appended.Y
The authority can grant up to `allocation` usernames. To top up their allocation, theyI
should just issue (or request via governance) a new `add_username_authority` call.dremove_username_authority
$authorityu

PAccountIdLookupOf<T>�Remove `authority` from the username authorities.@set_username_for
whou

PAccountIdLookupOf<T>
 username8
Vec<u8>
$signature�
pOption<T::OffchainSignature>$

Set the username for `who`. Must be called by a username authority.U
The authority must have an `allocation`. Users can either pre-sign their usernames orHaccept them later.<Usernames must:�  - Only contain lowercase ASCII characters or digits.5
  - When combined with the suffix of the issuing authority be _less than_ the`    `MaxUsernameLength`.<accept_username
 username�
,Username<T>M
Accept a given username that an `authority` granted. The call must include the full�username, as in `username.suffix`.\remove_expired_approval
 username�
,Username<T>a
Remove an expired username approval. The username was approved by an authority but neverU
accepted by the user and must now be beyond its expiration. The call must include the�full username, as in `username.suffix`.Pset_primary_username
 username�
,Username<T>1
Set a given username as the primary. The username should include the suffix.`remove_dangling_username
 username�
,Username<T>U
Remove a username that corresponds to an account with no identity. Exists when a user�gets a username but then calls `clear_identity`.pIdentity pallet declaration.E<pallet_identitylegacy0IdentityInfo(FieldLimit$
(additionalI
�BoundedVec<(Data, Data), FieldLimit>
displayQ
Data
legalQ
Data
webQ
Data
riotQ
Data
emailQ
Data
<pgp_fingerprint�
@Option<[u8; 20]>
imageQ
Data
twitterQ
DataILbounded_collections,bounded_vec(BoundedVecT
MS�
Vec<T>MQQQ<pallet_identitytypesData
�NoneRaw0U
Raw1YRaw2]Raw3aRaw4HRaw5eRaw6iRaw7mRaw8q	Raw9u
Raw10yRaw11}Raw12�
Raw13�Raw14�Raw15�Raw16�Raw17�Raw18�Raw19�Raw20}
Raw21�Raw22�Raw23�Raw24�Raw25�Raw26�Raw27�Raw28�Raw29�Raw30�Raw31� Raw32!,BlakeTwo256"Sha256#$Keccak256$,ShaThree256%UY
]aeimqu	y
}��
������������������M�OptionT
}

NoneSome}

���Q�<pallet_identitytypes$JudgementBalance

UnknownFeePaid
Balance
(Reasonable$KnownGood$OutOfDate(LowQuality$Erroneous�OptionT
�
NoneSome�
�(sp_runtime8MultiSignature
Ed25519]

Hed25519::SignatureSr25519]

Hsr25519::Signature
Ecdsa�
@ecdsa::Signature�A�Lbounded_collections,bounded_vec(BoundedVecT
S8
Vec<T>�0pallet_proxypalletCallT
(proxy
realu

PAccountIdLookupOf<T>
@force_proxy_type�
POption<T::ProxyType>
call

|Box<<T as Config>::RuntimeCall>$M
Dispatch the given `call` from an account that the sender is authorised for through0`add_proxy`.�The dispatch origin for this call must be _Signed_.,Parameters:

- `real`: The account that the proxy will make a call on behalf of.a
- `force_proxy_type`: Specify the exact proxy type to be used and checked for this call.�- `call`: The call to be made by the `real` account.$add_proxy
 delegateu

PAccountIdLookupOf<T>
(proxy_type�
0T::ProxyType
delay
DBlockNumberFor<T>
$E
Register a proxy account for the sender that is able to make calls on its behalf.�The dispatch origin for this call must be _Signed_.,Parameters:
- `proxy`: The account that the `caller` would like to make a proxy.�- `proxy_type`: The permissions allowed for this proxy account.M
- `delay`: The announcement period required of the initial proxy. Will generally bezero.0remove_proxy
 delegateu

PAccountIdLookupOf<T>
(proxy_type�
0T::ProxyType
delay
DBlockNumberFor<T>�Unregister a proxy account for the sender.�The dispatch origin for this call must be _Signed_.,Parameters:%
- `proxy`: The account that the `caller` would like to remove as a proxy.A
- `proxy_type`: The permissions currently enabled for the removed proxy account.8remove_proxies�Unregister all proxy accounts for the sender.�The dispatch origin for this call must be _Signed_.A
WARNING: This may be called on accounts created by `pure`, however if done, thenY
the unreserved fees will be inaccessible. **All access to this account will be lost.**,create_pure
(proxy_type�
0T::ProxyType
delay
DBlockNumberFor<T>
index�
u16H9
Spawn a fresh new account that is guaranteed to be otherwise inaccessible, and�initialize it with a proxy of `proxy_type` for `origin` sender.lRequires a `Signed` origin.Q
- `proxy_type`: The type of the proxy that the sender will be registered as over theM
new account. This will almost always be the most permissive `ProxyType` possible toxallow for maximum flexibility.Q
- `index`: A disambiguation index, in case this is called multiple times in the same]
transaction (e.g. with `utility::batch`). Unless you're using `batch` you probably just@want to use `0`.M
- `delay`: The announcement period required of the initial proxy. Will generally bezero.Q
Fails with `Duplicate` if this has already been called in this transaction, from the�same sender, with the same parameters.�Fails if there are insufficient funds to pay for deposit.$kill_pure
spawneru

PAccountIdLookupOf<T>
(proxy_type�
0T::ProxyType
index�
u16
height)

DBlockNumberFor<T>
$ext_index)

u32@�Removes a previously spawned pure proxy.I
WARNING: **All access to this account will be lost.** Any funds held in it will be4inaccessible.Y
Requires a `Signed` origin, and the sender account must have been created by a call to�`pure` with corresponding parameters.9
- `spawner`: The account that originally called `pure` to create this account.9
- `index`: The disambiguation index originally passed to `pure`. Probably `0`.�- `proxy_type`: The proxy type originally passed to `pure`.)
- `height`: The height of the chain when the call to `pure` was processed.5
- `ext_index`: The extrinsic index in which the call to `pure` was processed.5
Fails with `NoPermission` in case the caller is not a previously created pure�account whose `pure` call has corresponding parameters. announce
realu

PAccountIdLookupOf<T>
$call_hash4
4CallHashOf<T><
Publish the hash of a proxy-call that will be made in the future.]
This must be called some number of blocks before the corresponding `proxy` is attempted%
if the delay associated with the proxy relationship is greater than zero.
No more than `MaxPending` announcements may be made at any one time.	
This will take a deposit of `AnnouncementDepositFactor` as well as
`AnnouncementDepositBase` if there are no other pending announcements.%
The dispatch origin for this call must be _Signed_ and a proxy of `real`.,Parameters:

- `real`: The account that the proxy will make a call on behalf of.
- `call_hash`: The hash of the call to be made by the `real` account.Lremove_announcement
realu

PAccountIdLookupOf<T>
$call_hash4
4CallHashOf<T>(pRemove a given announcement.Y
May be called by a proxy account to remove a call they previously announced and return0the deposit.�The dispatch origin for this call must be _Signed_.,Parameters:

- `real`: The account that the proxy will make a call on behalf of.
- `call_hash`: The hash of the call to be made by the `real` account.Lreject_announcement
 delegateu

PAccountIdLookupOf<T>
$call_hash4
4CallHashOf<T>(�Remove the given announcement of a delegate.a
May be called by a target (proxied) account to remove a call that one of their delegates%
(`delegate`) has announced they want to execute. The deposit is returned.�The dispatch origin for this call must be _Signed_.,Parameters:�- `delegate`: The account that previously announced the call.�- `call_hash`: The hash of the call to be made.<proxy_announced
 delegateu

PAccountIdLookupOf<T>
realu

PAccountIdLookupOf<T>
@force_proxy_type�
POption<T::ProxyType>
call

|Box<<T as Config>::RuntimeCall>	,M
Dispatch the given `call` from an account that the sender is authorized for through0`add_proxy`.�Removes any corresponding announcement(s).�The dispatch origin for this call must be _Signed_.,Parameters:

- `real`: The account that the proxy will make a call on behalf of.a
- `force_proxy_type`: Specify the exact proxy type to be used and checked for this call.�- `call`: The call to be made by the `real` account.

Contains a variant per dispatchable extrinsic that this pallet has.�OptionT
�
NoneSome�
�0vara_runtime$ProxyType
Any,NonTransfer
(GovernanceStakingDIdentityJudgement,CancelProxy�<pallet_multisigpalletCallT
Pas_multi_threshold_1
Dother_signatories�

DVec<T::AccountId>
call

|Box<<T as Config>::RuntimeCall>0Q
Immediately dispatch a multi-signature call using a single approval from the caller.�The dispatch origin for this call must be _Signed_.=
- `other_signatories`: The accounts (other than the sender) who are part of the

multi-signature, but do not participate in the approval process.�- `call`: The call to be executed.�Result is equivalent to the dispatched result.4## Complexity
O(Z + C) where Z is the length of the call and C its execution weight. as_multi
$threshold�
u16
Dother_signatories�

DVec<T::AccountId>
<maybe_timepoint

�Option<Timepoint<BlockNumberFor<T>>>
call

|Box<<T as Config>::RuntimeCall>
(max_weight(
Weight
�U
Register approval for a dispatch to be made from a deterministic composite account if�approved by a total of `threshold - 1` of `other_signatories`.�If there are enough, then dispatch the call.-
Payment: `DepositBase` will be reserved if this is the first approval, plus=
`threshold` times `DepositFactor`. It is returned once this dispatch happens or4is cancelled.�The dispatch origin for this call must be _Signed_.U
- `threshold`: The total number of approvals for this dispatch before it is executed.A
- `other_signatories`: The accounts (other than the sender) who can approve thisldispatch. May not be empty.Y
- `maybe_timepoint`: If this is the first approval, then this must be `None`. If it isQ
not the first approval, then it must be `Some`, with the timepoint (block number and�transaction index) of the first approval transaction.�- `call`: The call to be executed.
NOTE: Unless this is the final approval, you will generally want to use
`approve_as_multi` instead, since it only requires a hash of the call.Y
Result is equivalent to the dispatched result if `threshold` is exactly `1`. OtherwiseU
on success, result is `Ok` and the result from the interior call, if it was executed,�may be found in the deposited `MultisigExecuted` event.4## ComplexityP- `O(S + Z + Call)`.�- Up to one balance-reserve or unreserve operation.=
- One passthrough operation, one insert, both `O(S)` where `S` is the number ofE
  signatories. `S` is capped by `MaxSignatories`, with weight being proportional.!
- One call encode & hash, both of complexity `O(Z)` where `Z` is tx-len.�- One encode & hash, both of complexity `O(S)`.�- Up to one binary search and insert (`O(logS + S)`).�- I/O: 1 read `O(S)`, up to 1 mutate `O(S)`. Up to one remove.0- One event.l- The weight of the `call`.M
- Storage: inserts one item, value size bounded by `MaxSignatories`, with a deposit
  taken for its lifetime of `DepositBase + threshold * DepositFactor`.@approve_as_multi
$threshold�
u16
Dother_signatories�

DVec<T::AccountId>
<maybe_timepoint

�Option<Timepoint<BlockNumberFor<T>>>
$call_hash
 [u8; 32]
(max_weight(
WeightxU
Register approval for a dispatch to be made from a deterministic composite account if�approved by a total of `threshold - 1` of `other_signatories`.-
Payment: `DepositBase` will be reserved if this is the first approval, plus=
`threshold` times `DepositFactor`. It is returned once this dispatch happens or4is cancelled.�The dispatch origin for this call must be _Signed_.U
- `threshold`: The total number of approvals for this dispatch before it is executed.A
- `other_signatories`: The accounts (other than the sender) who can approve thisldispatch. May not be empty.Y
- `maybe_timepoint`: If this is the first approval, then this must be `None`. If it isQ
not the first approval, then it must be `Some`, with the timepoint (block number and�transaction index) of the first approval transaction.�- `call_hash`: The hash of the call to be executed.5
NOTE: If this is the final approval, you will want to use `as_multi` instead.4## Complexity$- `O(S)`.�- Up to one balance-reserve or unreserve operation.=
- One passthrough operation, one insert, both `O(S)` where `S` is the number ofE
  signatories. `S` is capped by `MaxSignatories`, with weight being proportional.�- One encode & hash, both of complexity `O(S)`.�- Up to one binary search and insert (`O(logS + S)`).�- I/O: 1 read `O(S)`, up to 1 mutate `O(S)`. Up to one remove.0- One event.M
- Storage: inserts one item, value size bounded by `MaxSignatories`, with a deposit
  taken for its lifetime of `DepositBase + threshold * DepositFactor`.<cancel_as_multi
$threshold�
u16
Dother_signatories�

DVec<T::AccountId>
$timepoint
pTimepoint<BlockNumberFor<T>>
$call_hash
 [u8; 32]TU
Cancel a pre-existing, on-going multisig transaction. Any deposit reserved previously�for this operation will be unreserved on success.�The dispatch origin for this call must be _Signed_.U
- `threshold`: The total number of approvals for this dispatch before it is executed.A
- `other_signatories`: The accounts (other than the sender) who can approve thisldispatch. May not be empty.]
- `timepoint`: The timepoint (block number and transaction index) of the first approvalxtransaction for this dispatch.�- `call_hash`: The hash of the call to be executed.4## Complexity$- `O(S)`.�- Up to one balance-reserve or unreserve operation.=
- One passthrough operation, one insert, both `O(S)` where `S` is the number ofE
  signatories. `S` is capped by `MaxSignatories`, with weight being proportional.�- One encode & hash, both of complexity `O(S)`.0- One event.�- I/O: 1 read `O(S)`, one remove.p- Storage: removes one item.

Contains a variant per dispatchable extrinsic that this pallet has.
OptionT

NoneSome
<pallet_multisig$Timepoint,BlockNumber

height
,BlockNumber
index
u32	�pallet_election_provider_multi_phasepalletCallT
<submit_unsigned
0raw_solution

�Box<RawSolution<SolutionOf<T::MinerConfig>>>
witness�
XSolutionOrSnapshotSize8�Submit a solution for the unsigned phase.�The dispatch origin fo this call must be __none__.=
This submission is checked on the fly. Moreover, this unsigned solution is onlyU
validated when submitted to the pool from the **local** node. Effectively, this means]
that only active validators can submit this transaction when authoring a block (similar@to an inherent).Y
To prevent any incorrect solution (and thus wasted time/weight), this transaction willM
panic if the solution submitted by the validator is invalid in any way, effectively�putting their authoring reward at risk.�No deposit or reward is associated with this submission.lset_minimum_untrusted_score
@maybe_next_score�
TOption<ElectionScore>
�Set a new value for `MinimumUntrustedScore`.�Dispatch origin must be aligned with `T::ForceOrigin`.�This check can be turned off by setting the value to `None`.tset_emergency_election_result
 supports�
XSupports<T::AccountId> Y
Set a solution in the queue, to be handed out to the client of this pallet in the next�call to `ElectionProvider::elect`.E
This can only be set by `T::ForceOrigin`, and only when the phase is `Emergency`.a
The solution is not checked for any feasibility and is assumed to be trustworthy, as anyQ
feasibility check itself can in principle cause the election process to fail (due tohmemory/weight constrains).submit
0raw_solution

�Box<RawSolution<SolutionOf<T::MinerConfig>>>$�Submit a solution for the signed phase.�The dispatch origin fo this call must be __signed__.]
The solution is potentially queued, based on the claimed score and processed at the endPof the signed phase.]
A deposit is reserved and recorded for the solution. Based on the outcome, the solution
might be rewarded, slashed, or get all or a part of the deposit back.Lgovernance_fallback
@maybe_max_voters
,Option<u32>
Dmaybe_max_targets
,Option<u32>�Trigger the governance fallback.I
This can only be called when [`Phase::Emergency`] is enabled, as an alternative to�calling [`Call::set_emergency_election_result`].

Contains a variant per dispatchable extrinsic that this pallet has.
�pallet_election_provider_multi_phase,RawSolutionS

 solution
S
score�
4ElectionScore
round
u320vara_runtime8NposSolution16@
votes1
votes2!
votes35
votes4A
votes5M
votes6Y
votes7e
votes8q
votes9}
votes10�
votes11�
votes12�
votes13�
votes14�
votes15�
votes16�)
�!%%)
))--114sp_arithmetic(per_thingsPerU16�
u16599)
==)AEE)
II)MQQ)
UU)Y]])
aa)eii)
mm)quu)
yy)}��)
��)���)
��	)���)
��
)���)
��)���)
��)���)
��
)���)
��)���)
��)�Dsp_npos_elections4ElectionScore
4minimal_stake
<ExtendedBalance
$sum_stake
<ExtendedBalance
Dsum_stake_squared
<ExtendedBalance��pallet_election_provider_multi_phaseXSolutionOrSnapshotSize
voters)

u32
targets)

u32�OptionT
�
NoneSome�
�����Dsp_npos_electionsSupport$AccountId

total
<ExtendedBalance
voters�
�Vec<(AccountId, ExtendedBalance)>����<pallet_bountiespalletCallTI
$8propose_bounty
value�
<BalanceOf<T, I>
,description8
Vec<u8>0TPropose a new bounty.�The dispatch origin for this call must be _Signed_.Q
Payment: `TipReportDepositBase` will be reserved from the origin account, as well asQ
`DataDepositPerByte` for each byte in `reason`. It will be unreserved upon approval,dor slashed when rejected.�- `curator`: The curator account whom will manage this bounty.d- `fee`: The curator fee.%
- `value`: The total payment amount of this bounty, curator fee included.�- `description`: The description of this bounty.8approve_bounty
$bounty_id)

,BountyIndex
]
Approve a bounty proposal. At a later time, the bounty will be funded and become active�and the original deposit will be returned.�May only be called from `T::SpendOrigin`.4## Complexity- O(1).<propose_curator
$bounty_id)

,BountyIndex
curatoru

PAccountIdLookupOf<T>
fee�
<BalanceOf<T, I>�Propose a curator to a funded bounty.�May only be called from `T::SpendOrigin`.4## Complexity- O(1).@unassign_curator
$bounty_id)

,BountyIndexD|Unassign curator from a bounty.
This function can only be called by the `RejectOrigin` a signed origin.=
If this function is called by the `RejectOrigin`, we assume that the curator is1
malicious or inactive. As a result, we will slash the curator when possible.a
If the origin is the curator, we take this as a sign they are unable to do their job and]
they willingly give up. We could slash them, but for now we allow them to recover their5
deposit and exit without issue. (We may want to change this if it is abused.)]
Finally, the origin can be anyone if and only if the curator is "inactive". This allowsa
anyone in the community to call out that a curator is not doing their due diligence, and9
we should pick a new curator. In this case the curator should also be slashed.4## Complexity- O(1).8accept_curator
$bounty_id)

,BountyIndex�Accept the curator role for a bounty.)
A deposit will be reserved from curator and refund upon successful payout.�May only be called from the curator.4## Complexity- O(1).0award_bounty
$bounty_id)

,BountyIndex
,beneficiaryu

PAccountIdLookupOf<T>(Y
Award bounty to a beneficiary account. The beneficiary will be able to claim the funds8after a delay.
The dispatch origin for this call must be the curator of this bounty.�- `bounty_id`: Bounty ID to award.
- `beneficiary`: The beneficiary account whom will receive the payout.4## Complexity- O(1).0claim_bounty
$bounty_id)

,BountyIndex �Claim the payout from an awarded bounty after payout delay.%
The dispatch origin for this call must be the beneficiary of this bounty.�- `bounty_id`: Bounty ID to claim.4## Complexity- O(1).0close_bounty
$bounty_id)

,BountyIndex$9
Cancel a proposed or active bounty. All the funds will be sent to treasury and�the curator deposit will be unreserved if possible.�Only `T::RejectOrigin` is able to cancel a bounty.�- `bounty_id`: Bounty ID to cancel.4## Complexity- O(1).Pextend_bounty_expiry
$bounty_id)

,BountyIndex
remark8
Vec<u8>$�Extend the expiry time of an active bounty.
The dispatch origin for this call must be the curator of this bounty.�- `bounty_id`: Bounty ID to extend.�- `remark`: additional information.4## Complexity- O(1).

Contains a variant per dispatchable extrinsic that this pallet has.
Tpallet_child_bountiespalletCallT
@add_child_bounty
@parent_bounty_id)

,BountyIndex
value�
0BalanceOf<T>
,description8
Vec<u8>L\Add a new child-bounty.�The dispatch origin for this call must be the curator of parent�bounty and the parent bounty must be in "active" state.
Child-bounty gets added successfully & fund gets transferred from	
parent bounty to child-bounty account, if parent bounty has enoughlfunds, else the call fails.

Upper bound to maximum number of active  child bounties that can be�added are managed via runtime trait config�[`Config::MaxActiveChildBountyCount`].

If the call is success, the status of child-bounty is updated to "Added".M
- `parent_bounty_id`: Index of parent bounty for which child-bounty is being added.�- `value`: Value for executing the proposal.�- `description`: Text description for the child-bounty.<propose_curator
@parent_bounty_id)

,BountyIndex
<child_bounty_id)

,BountyIndex
curatoru

PAccountIdLookupOf<T>
fee�
0BalanceOf<T>
<�Propose curator for funded child-bounty.

The dispatch origin for this call must be curator of parent bounty.
Parent bounty must be in active state, for this child-bounty call towork.

Child-bounty must be in "Added" state, for processing the call. And
state of child-bounty is moved to "CuratorProposed" on successful@call completion.�- `parent_bounty_id`: Index of parent bounty.�- `child_bounty_id`: Index of child bounty.�- `curator`: Address of child-bounty curator.�- `fee`: payment fee to child-bounty curator for execution.8accept_curator
@parent_bounty_id)

,BountyIndex
<child_bounty_id)

,BountyIndexL�Accept the curator role for the child-bounty.�The dispatch origin for this call must be the curator of this4child-bounty.�A deposit will be reserved from the curator and refund upon�successful payout or cancellation.�Fee for curator is deducted from curator fee of parent bounty.
Parent bounty must be in active state, for this child-bounty call towork.

Child-bounty must be in "CuratorProposed" state, for processing the	
call. And state of child-bounty is moved to "Active" on successful@call completion.�- `parent_bounty_id`: Index of parent bounty.�- `child_bounty_id`: Index of child bounty.@unassign_curator
@parent_bounty_id)

,BountyIndex
<child_bounty_id)

,BountyIndex��Unassign curator from a child-bounty.	
The dispatch origin for this call can be either `RejectOrigin`, or�the curator of the parent bounty, or any signed origin.�For the origin other than T::RejectOrigin and the child-bounty

curator, parent bounty must be in active state, for this call to	
work. We allow child-bounty curator and T::RejectOrigin to execute�this call irrespective of the parent bounty state.�If this function is called by the `RejectOrigin` or the
parent bounty curator, we assume that the child-bounty curator is

malicious or inactive. As a result, child-bounty curator deposit is slashed.
If the origin is the child-bounty curator, we take this as a sign	
that they are unable to do their job, and are willingly giving up.	
We could slash the deposit, but for now we allow them to unreserve
their deposit and exit without issue. (We may want to change this if8it is abused.)
Finally, the origin can be anyone iff the child-bounty curator is	
"inactive". Expiry update due of parent bounty is used to estimate�inactive state of child-bounty curator.

This allows anyone in the community to call out that a child-bounty	
curator is not doing their due diligence, and we should pick a new�one. In this case the child-bounty curator deposit is slashed.

State of child-bounty is moved to Added state on successful call,completion.�- `parent_bounty_id`: Index of parent bounty.�- `child_bounty_id`: Index of child bounty.Haward_child_bounty
@parent_bounty_id)

,BountyIndex
<child_bounty_id)

,BountyIndex
,beneficiaryu

PAccountIdLookupOf<T>D�Award child-bounty to a beneficiary.�The beneficiary will be able to claim the funds after a delay.�The dispatch origin for this call must be the parent curator ortcurator of this child-bounty.
Parent bounty must be in active state, for this child-bounty call towork.	
Child-bounty must be in active state, for processing the call. And
state of child-bounty is moved to "PendingPayout" on successful call,completion.�- `parent_bounty_id`: Index of parent bounty.�- `child_bounty_id`: Index of child bounty.�- `beneficiary`: Beneficiary account.Hclaim_child_bounty
@parent_bounty_id)

,BountyIndex
<child_bounty_id)

,BountyIndex@
Claim the payout from an awarded child-bounty after payout delay.�The dispatch origin for this call may be any signed origin.
Call works independent of parent bounty state, No need for parenttbounty to be in active state.
The Beneficiary is paid out with agreed bounty value. Curator fee is�paid & curator deposit is unreserved.
Child-bounty must be in "PendingPayout" state, for processing the�call. And instance of child-bounty is removed from the state onlsuccessful call completion.�- `parent_bounty_id`: Index of parent bounty.�- `child_bounty_id`: Index of child bounty.Hclose_child_bounty
@parent_bounty_id)

,BountyIndex
<child_bounty_id)

,BountyIndexX
Cancel a proposed or active child-bounty. Child-bounty account funds	
are transferred to parent bounty account. The child-bounty curator�deposit may be unreserved if possible.	
The dispatch origin for this call must be either parent curator orH`T::RejectOrigin`.�If the state of child-bounty is `Active`, curator deposit is,unreserved.�If the state of child-bounty is `PendingPayout`, call fails &xreturns `PendingPayout` error.

For the origin other than T::RejectOrigin, parent bounty must be in�active state, for this child-bounty call to work. For origin�T::RejectOrigin execution is forced.

Instance of child-bounty is removed from the state on successful@call completion.�- `parent_bounty_id`: Index of parent bounty.�- `child_bounty_id`: Index of child bounty.

Contains a variant per dispatchable extrinsic that this pallet has.\pallet_nomination_poolspalletCallT
hjoin
amount�
0BalanceOf<T>
pool_id
PoolId<Y
Stake funds with a pool. The amount to bond is transferred from the member to the pool�account and immediately increases the pools bond.)
The method of transferring the amount to the pool account is determined by

[`adapter::StakeStrategyType`]. If the pool is configured to use1
[`adapter::StakeStrategyType::Delegate`], the funds remain in the account of1
the `origin`, while the pool gains the right to use these funds for staking.# Note�* An account can only be a member of a single pool.�* An account cannot join the same pool multiple times.A
* This call will *not* dust the member account, so the member must have at least�  `existential deposit + amount` in their account.�* Only a pool with [`PoolState::Open`] can be joined(bond_extra
extra	
\BondExtra<BalanceOf<T>>
E
Bond `extra` more funds from `origin` into the pool to which they already belong.I
Additional funds can come from either the free balance of the account, of from the�accumulated rewards, see [`BondExtra`].=
Bonding extra funds implies an automatic payout of all pending rewards as well.	
See `bond_extra_other` to bond pending rewards of `other` members.0claim_payout U
A bonded member can use this to claim their payout based on the rewards that the poola
has accumulated since their last claimed payout (OR since joining if this is their first=
time claiming rewards). The payout will be transferred to the member's account.I
The member will earn rewards pro rata based on the members stake vs the sum of the�members in the pools stake. Rewards do not "expire".A
See `claim_payout_other` to claim rewards on behalf of some `other` pool member.unbond
8member_accountu

PAccountIdLookupOf<T>
@unbonding_points�
0BalanceOf<T>|E
Unbond up to `unbonding_points` of the `member_account`'s funds from the pool. ItE
implicitly collects the rewards one last time, since not doing so would mean somelrewards would be forfeited.M
Under certain conditions, this call can be dispatched permissionlessly (i.e. by any$account).�# Conditions for a permissionless dispatch.]
* The pool is blocked and the caller is either the root or bouncer. This is refereed to0  as a kick.�* The pool is destroying and the member is not the depositor.U
* The pool is destroying, the member is the depositor and no other members are in the  pool.
## Conditions for permissioned dispatch (i.e. the caller is also theH`member_account`):�* The caller is not the depositor.U
* The caller is the depositor, the pool is destroying and no other members are in the  pool.# Note
If there are too many unlocking chunks to unbond with the pool account,Q
[`Call::pool_withdraw_unbonded`] can be called to try and minimize unlocking chunks.Y
The [`StakingInterface::unbond`] will implicitly call [`Call::pool_withdraw_unbonded`]U
to try to free chunks if necessary (ie. if unbound was called and no unlocking chunksa
are available). However, it may not be possible to release the current unlocking chunks,]
in which case, the result of this call will likely be the `NoMoreChunks` error from the<staking system.Xpool_withdraw_unbonded
pool_id
PoolId
Hnum_slashing_spans
u32U
Call `withdraw_unbonded` for the pools account. This call can be made by any account.A
This is useful if there are too many unlocking chunks to call `unbond`, and somea
can be cleared by withdrawing. In the case there are too many unlocking chunks, the userQ
would probably see an error like `NoMoreChunks` emitted from the staking system when\they attempt to unbond.Dwithdraw_unbonded
8member_accountu

PAccountIdLookupOf<T>
Hnum_slashing_spans
u32XU
Withdraw unbonded funds from `member_account`. If no bonded funds can be unbonded, anHerror is returned.M
Under certain conditions, this call can be dispatched permissionlessly (i.e. by any$account).�# Conditions for a permissionless dispatch	
* The pool is in destroy mode and the target is not the depositor.1
* The target is the depositor and they are the only member in the sub pools.

* The pool is blocked and the caller is either the root or bouncer.�# Conditions for permissioned dispatch�* The caller is the target and they are not the depositor.# Note�- If the target is the depositor, the pool will be destroyed.a
- If the pool has any pending slash, we also try to slash the member before letting them]
withdraw. This calculation adds some weight overhead and is only defensive. In reality,U
pool slashes must have been already applied via permissionless [`Call::apply_slash`].create
amount�
0BalanceOf<T>
rootu

PAccountIdLookupOf<T>
$nominatoru

PAccountIdLookupOf<T>
bounceru

PAccountIdLookupOf<T>DtCreate a new delegation pool.,# ArgumentsU
* `amount` - The amount of funds to delegate to the pool. This also acts of a sort ofM
  deposit since the pools creator cannot fully unbond funds until the pool is being0  destroyed.Q
* `index` - A disambiguation index for creating the account. Likely only useful when�  creating multiple pools in the same extrinsic.�* `root` - The account to set as [`PoolRoles::root`].

* `nominator` - The account to set as the [`PoolRoles::nominator`].�* `bouncer` - The account to set as the [`PoolRoles::bouncer`].# Notea
In addition to `amount`, the caller will transfer the existential deposit; so the caller

needs at have at least `amount + existential_deposit` transferable.Lcreate_with_pool_id
amount�
0BalanceOf<T>
rootu

PAccountIdLookupOf<T>
$nominatoru

PAccountIdLookupOf<T>
bounceru

PAccountIdLookupOf<T>
pool_id
PoolId�Create a new delegation pool with a previously used pool id,# Arguments�same as `create` with the inclusion ofx* `pool_id` - `A valid PoolId. nominate
pool_id
PoolId
(validators�

DVec<T::AccountId>0|Nominate on behalf of the pool.E
The dispatch origin of this call must be signed by the pool nominator or the pool(root role.I
This directly forward the call to the staking pallet, on behalf of the pool bonded account.# Note]
In addition to a `root` or `nominator` role of `origin`, pool's depositor needs to have�at least `depositor_min_bond` in the pool to start nominating.$set_state
pool_id
PoolId
state

$PoolState	(tSet a new state for the pool.U
If a pool is already in the `Destroying` state, then under no condition can its state4change again.�The dispatch origin of this call must be either:�1. signed by the bouncer, or the root role of the pool,]
2. if the pool conditions to be open are NOT met (as described by `ok_to_be_open`), and9
   then the state of the pool can be permissionlessly changed to `Destroying`.0set_metadata
pool_id
PoolId
 metadata8
Vec<u8>
�Set a new metadata for the pool.]
The dispatch origin of this call must be signed by the bouncer, or the root role of thepool.,set_configs
4min_join_bond
XConfigOp<BalanceOf<T>>
<min_create_bond
XConfigOp<BalanceOf<T>>
$max_pools
4ConfigOp<u32>
,max_members
4ConfigOp<u32>
Pmax_members_per_pool
4ConfigOp<u32>
Tglobal_max_commission
DConfigOp<Perbill>,A
Update configurations for the nomination pools. The origin for this call must be`[`Config::AdminOrigin`].,# Arguments�* `min_join_bond` - Set [`MinJoinBond`].�* `min_create_bond` - Set [`MinCreateBond`].�* `max_pools` - Set [`MaxPools`].�* `max_members` - Set [`MaxPoolMembers`].�* `max_members_per_pool` - Set [`MaxPoolMembersPerPool`].�* `global_max_commission` - Set [`GlobalMaxCommission`].0update_roles
pool_id
PoolId
 new_root
XConfigOp<T::AccountId>
4new_nominator
XConfigOp<T::AccountId>
,new_bouncer
XConfigOp<T::AccountId>tUpdate the roles of the pool.=
The root is the only entity that can change any of the roles, including itself,�excluding the depositor, who can never change.Q
It emits an event, notifying UIs of the role change. This event is quite relevant to
most pool members and they should be informed of changes to pool roles.chill
pool_id
PoolId
@pChill on behalf of the pool.A
The dispatch origin of this call can be signed by the pool nominator or the pool�root role, same as [`Pallet::nominate`].M
Under certain conditions, this call can be dispatched permissionlessly (i.e. by any$account).�# Conditions for a permissionless dispatch:Y
* When pool depositor has less than `MinNominatorBond` staked, otherwise  pool members\  are unable to unbond.�# Conditions for permissioned dispatch:�* The caller has a nominator or root role of the pool.I
This directly forward the call to the staking pallet, on behalf of the pool bonded account.@bond_extra_other
memberu

PAccountIdLookupOf<T>
extra	
\BondExtra<BalanceOf<T>>$U
`origin` bonds funds from `extra` for some pool member `member` into their respectivepools.I
`origin` can bond extra funds from free balance or pending rewards when `origin ==other`.E
In the case of `origin != other`, `origin` can only bond extra pending rewards of
`other` members assuming set_claim_permission for the given member is�`PermissionlessCompound` or `PermissionlessAll`.Pset_claim_permission
(permission!
<ClaimPermissionI
Allows a pool member to set a claim permission to allow or disallow permissionless`bonding and withdrawing.,# Argumentsx* `origin` - Member of a pool.�* `permission` - The permission to be applied.Hclaim_payout_other
other
0T::AccountId

`origin` can claim payouts on some pool member `other`'s behalf.U
Pool member `other` must have a `PermissionlessWithdraw` or `PermissionlessAll` claim�permission for this call to be successful.8set_commission
pool_id
PoolId
8new_commission%
|Option<(Perbill, T::AccountId)>tSet the commission of a pool.U
Both a commission percentage and a commission payee must be provided in the `current`]
tuple. Where a `current` of `None` is provided, any current commission will be removed.M
- If a `None` is supplied to `new_commission`, existing commission will be removed.Hset_commission_max
pool_id
PoolId
8max_commission�
Perbill�Set the maximum commission of a pool.9
- Initial max can be set to any `Perbill`, and only smaller values thereafter.5
- Current commission will be lowered in the event it is higher than a new max4  commission.hset_commission_change_rate
pool_id
PoolId
,change_rate-
�CommissionChangeRate<BlockNumberFor<T>>�Set the commission change rate for a pool.=
Initial change rate is not bounded, whereas subsequent updates can only be moretrestrictive than the current.@claim_commission
pool_id
PoolIddClaim pending commission.]
The dispatch origin of this call must be signed by the `root` role of the pool. Pending]
commission is paid out and added to total claimed commission`. Total pending commissionxis reset to zero. the current.Ladjust_pool_deposit
pool_id
PoolId�Top up the deficit or withdraw the excess ED from the pool.Q
When a pool is created, the pool depositor transfers ED to the reward account of theU
pool. ED is subject to change and over time, the deposit in the reward account may beQ
insufficient to cover the ED deficit of the pool or vice-versa where there is excess1
deposit to the pool. This call allows anyone to adjust the ED deposit of the�pool by either topping up the deficit or claiming the excess.|set_commission_claim_permission
pool_id
PoolId
(permission1
�Option<CommissionClaimPermission<T::AccountId>>�Set or remove a pool's commission claim permission.a
Determines who can claim the pool's pending commission. Only the `Root` role of the pool�is able to configure commission claim permissions.,apply_slash
8member_accountu

PAccountIdLookupOf<T>�Apply a pending slash on a member.%
Fails unless [`crate::pallet::Config::StakeAdapter`] is of strategy type:�[`adapter::StakeStrategyType::Delegate`].U
This call can be dispatched permissionlessly (i.e. by any account). If the member has
slash to be applied, caller may be rewarded with the part of the slash.Hmigrate_delegation
8member_accountu

PAccountIdLookupOf<T>$
Migrates delegated funds from the pool account to the `member_account`.%
Fails unless [`crate::pallet::Config::StakeAdapter`] is of strategy type:�[`adapter::StakeStrategyType::Delegate`].)
This is a permission-less call and refunds any fee if claim is successful.]
If the pool has migrated to delegation based staking, the staked tokens of pool members)
can be moved and held in their own account. See [`adapter::DelegateStake`]xmigrate_pool_to_delegate_stake
pool_id
PoolId$�Migrate pool from [`adapter::StakeStrategyType::Transfer`] to�[`adapter::StakeStrategyType::Delegate`].%
Fails unless [`crate::pallet::Config::StakeAdapter`] is of strategy type:�[`adapter::StakeStrategyType::Delegate`].A
This call can be dispatched permissionlessly, and refunds any fee if successful.I
If the pool has already migrated to delegation based staking, this call will fail.

Contains a variant per dispatchable extrinsic that this pallet has.	\pallet_nomination_pools$BondExtraBalance

,FreeBalance
BalanceRewards

\pallet_nomination_pools$PoolState
OpenBlocked
(Destroying\pallet_nomination_pools ConfigOpT

NoopSet
T
Remove\pallet_nomination_pools ConfigOpT

NoopSet
T
Remove\pallet_nomination_pools ConfigOpT
�
NoopSet�
T
Remove\pallet_nomination_pools ConfigOpT

NoopSet
T
Remove!\pallet_nomination_pools<ClaimPermission
0PermissionedXPermissionlessCompound
XPermissionlessWithdrawDPermissionlessAll%OptionT
)
NoneSome)
)�-\pallet_nomination_poolsPCommissionChangeRate,BlockNumber

0max_increase�
Perbill
$min_delay
,BlockNumber1OptionT
5
NoneSome5
5\pallet_nomination_poolsdCommissionClaimPermission$AccountId

8PermissionlessAccount
$AccountId
9,pallet_sudopalletCallT
sudo
call

|Box<<T as Config>::RuntimeCall>5
Authenticates the sudo key and dispatches a function call with `Root` origin.Tsudo_unchecked_weight
call

|Box<<T as Config>::RuntimeCall>
weight(
Weight
5
Authenticates the sudo key and dispatches a function call with `Root` origin.-
This function does not check the weight of the call, and instead allows the�Sudo user to specify the weight of the call.�The dispatch origin for this call must be _Signed_.set_key
newu

PAccountIdLookupOf<T>]
Authenticates the current sudo key and sets the given AccountId (`new`) as the new sudokey.sudo_as
whou

PAccountIdLookupOf<T>
call

|Box<<T as Config>::RuntimeCall>M
Authenticates the sudo key and dispatches a function call with `Signed` origin from@a given account.�The dispatch origin for this call must be _Signed_.(remove_key�Permanently removes the sudo key.l**This cannot be un-done.**

Contains a variant per dispatchable extrinsic that this pallet has.=,pallet_gearpalletCallT
(,upload_code
code8
Vec<u8>@�Saves program `code` in storage.E
The extrinsic was created to provide _deploy program from program_ functionality.�
Anyone who wants to define a "factory" logic in program should first store the code and metadata for the "child"program in storage. So the code for the child will be initialized by program initialization request only if it exists in storage.
More precisely, the code and its metadata are actually saved in the storage under the hash of the `code`. The code hash is computedas Blake256 hash. At the time of the call the `code` hash should not be in the storage. If it was stored previously, call will end up%with an `CodeAlreadyExists` error. In this case user can be sure, that he can actually use the hash of his program's code bytes to define�"program factory" logic in his program.(Parameters�- `code`: wasm code of a program as a byte vector.lEmits the following events:�- `SavedCode(H256)` - when the code is saved in storage.8upload_program
code8
Vec<u8>
salt8
Vec<u8>
0init_payload8
Vec<u8>
$gas_limit0
u64
value
0BalanceOf<T>
(keep_alive 
bool
��
Creates program initialization request (message), that is scheduled to be run in the same block.y
There are no guarantees that initialization message will be run in the same block due to block�
gas limit restrictions. For example, when it will be the message's turn, required gas limit for it�
could be more than remaining block gas limit. Therefore, the message processing will be postponedTuntil the next block.�
`ActorId` is computed as Blake256 hash of concatenated bytes of `code` + `salt`. (todo #512 `code_hash` + `salt`)9
Such `ActorId` must not exist in the Program Storage at the time of this call.=
There is the same guarantee here as in `upload_code`. That is, future program'sM
`code` and metadata are stored before message was added to the queue and processed.)
The origin must be Signed and the sender must have sufficient funds to pay

for `gas` and `value` (in case the latter is being transferred).Q
Gear runtime guarantees that an active program always has an account to store value.]
If the underlying account management platform (e.g. Substrate's System pallet) requiresY
an existential deposit to keep an account alive, the related overhead is considered an]
extra cost related with a program instantiation and is charged to the program's creator

and is released back to the creator when the program is removed.m
In context of the above, the `value` parameter represents the so-called `reducible` balanceY
a program should have at its disposal upon instantiation. It is not used to offset the�existential deposit required for an account creation.,Parameters:�- `code`: wasm code of a program as a byte vector.!
- `salt`: randomness term (a seed) to allow programs with identical codex  to be created independently.!
- `init_payload`: encoded parameters of the wasm module `init` function.=
- `gas_limit`: maximum amount of gas the program can spend before it is halted.-
- `value`: balance to be transferred to the program once it's been created.lEmits the following events:9
- `InitMessageEnqueued(MessageInfo)` when init message is placed in the queue.# Note�
Faulty (uninitialized) programs still have a valid addresses (program ids) that can deterministically be derived on the�
caller's side upfront. It means that if messages are sent to such an address, they might still linger in the queue.
In order to mitigate the risk of users' funds being sent to an address,�where a valid program should have resided, while it's not,
such "failed-to-initialize" programs are not silently deleted from the�program storage but rather marked as "ghost" programs.-
Ghost program can be removed by their original author via an explicit call.I
The funds stored by a ghost program will be release to the author once the programDhas been removed.8create_program
code_idA
CodeId
salt8
Vec<u8>
0init_payload8
Vec<u8>
$gas_limit0
u64
value
0BalanceOf<T>
(keep_alive 
bool@�Creates program via `code_id` from storage.,Parameters:�- `code_id`: wasm code id in the code storage.!
- `salt`: randomness term (a seed) to allow programs with identical codex  to be created independently.!
- `init_payload`: encoded parameters of the wasm module `init` function.=
- `gas_limit`: maximum amount of gas the program can spend before it is halted.-
- `value`: balance to be transferred to the program once it's been created.lEmits the following events:9
- `InitMessageEnqueued(MessageInfo)` when init message is placed in the queue.# NOTE�For the details of this extrinsic, see `upload_code`.0send_message
,destinationE
ActorId
payload8
Vec<u8>
$gas_limit0
u64
value
0BalanceOf<T>
(keep_alive 
boolD�Sends a message to a program or to another account.)
The origin must be Signed and the sender must have sufficient funds to pay

for `gas` and `value` (in case the latter is being transferred).-
To avoid an undefined behavior a check is made that the destination address
is not a program in uninitialized state. If the opposite holds true,�the message is not enqueued for processing.,Parameters:�- `destination`: the message destination.M
- `payload`: in case of a program destination, parameters of the `handle` function.=
- `gas_limit`: maximum amount of gas the program can spend before it is halted.-
- `value`: balance to be transferred to the program once it's been created.lEmits the following events:Y
- `DispatchMessageEnqueued(MessageInfo)` when dispatch message is placed in the queue.(send_reply
,reply_to_idI
$MessageId
payload8
Vec<u8>
$gas_limit0
u64
value
0BalanceOf<T>
(keep_alive 
bool4�Send reply on message in `Mailbox`.�Removes message by given `MessageId` from callers `Mailbox`:�rent funds become free, associated with the message value�transfers from message sender to extrinsic caller.�Generates reply on removed message with given parameters�and pushes it in `MessageQueue`.	
NOTE: source of the message in mailbox guaranteed to be a program.	
NOTE: only user who is destination of the message, can claim value�or reply on the message from mailbox.,claim_value
(message_idI
$MessageId �Claim value from message in `Mailbox`.�Removes message by given `MessageId` from callers `Mailbox`:�rent funds become free, associated with the message value�transfers from message sender to extrinsic caller.	
NOTE: only user who is destination of the message, can claim value�or reply on the message from mailbox.run
max_gasM
\Option<GasBalanceOf<T>>TProcess message queuePset_execute_inherent
value 
boolpSets `ExecuteInherent` flag.	
Requires root origin (eventually, will only be set via referendum)`claim_value_to_inheritor
(program_idE
ActorId
depthQ
0NonZero<u32>LM
Transfers value from chain of terminated or exited programs to its final inheritor.�`depth` parameter is how far to traverse to inheritor.�A value of 10 is sufficient for most cases.H# Example of chain%
- Program #1 exits (e.g `gr_exit syscall) with argument pointing to user.�Balance of program #1 has been sent to user.�- Program #2 exits with inheritor pointing to program #1.�Balance of program #2 has been sent to exited program #1.�- Program #3 exits with inheritor pointing to program #2�Balance of program #1 has been sent to exited program #2.I
So chain of inheritors looks like: Program #3 -> Program #2 -> Program #1 -> User.�We have programs #1 and #2 with stuck value on their balances.e
The balances should've been transferred to user (final inheritor) according to the chain.m
But protocol doesn't traverse the chain automatically, so user have to call this extrinsic.\exhaust_block_resources
 fraction�

Lsp_runtime::Percent��A dummy extrinsic with programmatically set weight.�Used in tests to exhaust block resources.,Parameters:%
- `fraction`: the fraction of the `max_extrinsic` the extrinsic will use.

Contains a variant per dispatchable extrinsic that this pallet has.A,gprimitivesCodeId
 [u8; 32]E,gprimitivesActorId
 [u8; 32]I,gprimitives$MessageId
 [u8; 32]MOptionT
0
NoneSome0
Q(NonZeroU32Ulpallet_gear_staking_rewardspalletCallT
refill
value
0BalanceOf<T>0force_refill
fromu

PAccountIdLookupOf<T>
value
0BalanceOf<T>
 withdraw
tou

PAccountIdLookupOf<T>
value
0BalanceOf<T>Pset_target_inflation
p0
u64
n0
u64\set_ideal_staking_ratio
p0
u64
n0
u64

Contains a variant per dispatchable extrinsic that this pallet has.YLpallet_gear_voucherpalletCallT
issue
spender
8AccountIdOf<T>
balance
0BalanceOf<T>
 programs]
dOption<BTreeSet<ActorId>>
8code_uploading 
bool
 duration
DBlockNumberFor<T>PPIssue a new voucher.�Deposits event `VoucherIssued`, that contains `VoucherId` to be�used by spender for balance-less on-chain interactions.(Arguments:�* spender:  user id that is eligible to use the voucher;�* balance:  voucher balance could be used for transactionsd            fees and gas;�* programs: pool of programs spender can interact with,�            if None - means any program,�            limited by Config param;D* code_uploading:�            allow voucher to be used as payer for `upload_code`t            transactions fee;�* duration: amount of blocks voucher could be used by spender�            and couldn't be revoked by owner.

            Must be out in [MinDuration; MaxDuration] constants.�            Expiration block of the voucher calculates as:�            current bn (extrinsic exec bn) + duration + 1.call
(voucher_idi
$VoucherId
callm
dPrepaidCall<BalanceOf<T>>
�Execute prepaid call with given voucher id.(Arguments:�* voucher_id: associated with origin existing vouchers id,�              that should be used to pay for fees and gasx              within the call;�* call:       prepaid call that is requested to execute.revoke
spender
8AccountIdOf<T>
(voucher_idi
$VoucherId4`Revoke existing voucher.
This extrinsic revokes existing voucher, if current block is greater�than expiration block of the voucher (it is no longer valid).
Currently it means sending of all balance from voucher account to

voucher owner without voucher removal from storage map, but this

behavior may change in future, as well as the origin validation:�only owner is able to revoke voucher now.(Arguments:�* spender:    account id of the voucher spender;�* voucher_id: voucher id to be revoked.update
spender
8AccountIdOf<T>
(voucher_idi
$VoucherId
8move_ownership�

XOption<AccountIdOf<T>>
8balance_top_up�

POption<BalanceOf<T>>
<append_programsq
�Option<Option<BTreeSet<ActorId>>>
8code_uploadingu
0Option<bool>
@prolong_duration
dOption<BlockNumberFor<T>>h`Update existing voucher.
This extrinsic updates existing voucher: it can only extend vouchers	
rights in terms of balance, validity or programs to interact pool.�Can only be called by the voucher owner.(Arguments:�* spender:          account id of the voucher spender;�* voucher_id:       voucher id to be updated;	
* move_ownership:   optionally moves ownership to another account;	
* balance_top_up:   optionally top ups balance of the voucher from�                    origins balance;�* append_programs:  optionally extends pool of programs by�                    `Some(programs_set)` passed or allows�                    it to interact with any program by�                    `None` passed;�* code_uploading:   optionally allows voucher to be used to pay�                    fees for `upload_code` extrinsics;�* prolong_duration: optionally increases expiry block number.
                    If voucher is expired, prolongs since current bn.
                    Validity prolongation (since current block number

                    for expired or since storage written expiry)
                    should be in [MinDuration; MaxDuration], in other

                    words voucher couldn't have expiry greater than�                    current block number + MaxDuration.decline
(voucher_idi
$VoucherId�Decline existing and not expired voucher.

This extrinsic expires voucher of the caller, if it's still active,hallowing it to be revoked.(Arguments:�* voucher_id:   voucher id to be declined.

Contains a variant per dispatchable extrinsic that this pallet has.]OptionT
a
NoneSomea
a BTreeSetT
EeeEiLpallet_gear_voucher internal$VoucherId
 [u8; 32]mLpallet_gear_voucher internal,PrepaidCallBalance

,SendMessage
,destinationE
ActorId
payload8
Vec<u8>
$gas_limit0
u64
value
Balance
(keep_alive 
bool$SendReply
,reply_to_idI
$MessageId
payload8
Vec<u8>
$gas_limit0
u64
value
Balance
(keep_alive 
bool
(UploadCode
code8
Vec<u8>8DeclineVoucherqOptionT
]
NoneSome]
uOptionT
 
NoneSome 
yXpallet_gear_eth_bridgepalletCallT
pause�Root extrinsic that pauses pallet.�When paused, no new messages could be queued.unpause
�Root extrinsic that unpauses pallet.�When paused, no new messages could be queued.@send_eth_message
,destination}
H160
payload8
Vec<u8>�Extrinsic that inserts message in a bridging queue,�updating queue merkle root at the end of the block.set_fee
fee
0BalanceOf<T>�Root extrinsic that sets fee for the transport of messages.Xreset_overflowed_queue
Xencoded_finality_proof8
Vec<u8>�Extrinsic that verifies some block finality that resets�overflowed within the current era queue.

Contains a variant per dispatchable extrinsic that this pallet has.}<primitive_typesH160}

 [u8; 20]�Tpallet_grandpa_signerpalletCallT
@schedule_request
payload8
Vec<u8>
set_idM
4Option<SetId>
(expires_at
dOption<BlockNumberFor<T>>�Schedule a signing request for the current GRANDPA set.@submit_signature
(request_id
$RequestId
$authority
8T::AuthorityId
$signature]

TT::AuthoritySignature
�Submit a GRANDPA signature for a scheduled request (unsigned).

Contains a variant per dispatchable extrinsic that this pallet has.�(sp_runtimetraits,BlakeTwo256�Lbounded_collections,bounded_vec(BoundedVecT
S8
Vec<T>�`pallet_conviction_votingtypesTallyVotes
Total
ayes
Votes
nays
Votes
support
Votes�`pallet_ranked_collectivepalletEventTI
,MemberAdded
who
0T::AccountIdxA member `who` has been added.,RankChanged
who
0T::AccountId
rank�
Rank
�The member `who`se rank has been changed to the given `rank`.4MemberRemoved
who
0T::AccountId
rank�
Rank
The member `who` of given `rank` has been removed from the collective.Voted
who
0T::AccountId
poll
DPollIndexOf<T, I>
vote�
(VoteRecord
tally�
4TallyOf<T, I>U
The member `who` has voted for the `poll` with the given `vote` leading to an updated `tally`.<MemberExchanged
who
0T::AccountId
new_who
0T::AccountId�The member `who` had their `AccountId` changed to `new_who`.|The `Event` enum of this pallet�`pallet_ranked_collective(VoteRecord
Aye
VotesNay
Votes
�`pallet_ranked_collectiveTallyTIM
$bare_ayes
,MemberIndex
ayes
Votes
nays
Votes�@pallet_referendapalletEventTI
@$Submitted
index
<ReferendumIndex`Index of the referendum.
track�
<TrackIdOf<T, I>%
The track (and by extension proposal dispatch origin) of this referendum.
 proposal


LBoundedCallOf<T, I>�The proposal for the referendum.�A referendum has been submitted.TDecisionDepositPlaced
index
<ReferendumIndex`Index of the referendum.
who
0T::AccountId�The account who placed the deposit.
amount
<BalanceOf<T, I>�The amount placed by the account.
�The decision deposit has been placed.\DecisionDepositRefunded
index
<ReferendumIndex`Index of the referendum.
who
0T::AccountId�The account who placed the deposit.
amount
<BalanceOf<T, I>�The amount placed by the account.�The decision deposit has been refunded.8DepositSlashed
who
0T::AccountId�The account who placed the deposit.
amount
<BalanceOf<T, I>�The amount placed by the account.lA deposit has been slashed.<DecisionStarted
index
<ReferendumIndex`Index of the referendum.
track�
<TrackIdOf<T, I>%
The track (and by extension proposal dispatch origin) of this referendum.
 proposal


LBoundedCallOf<T, I>�The proposal for the referendum.
tally�
 T::Tally�The current tally of votes in this referendum.�A referendum has moved into the deciding phase.8ConfirmStarted
index
<ReferendumIndex`Index of the referendum.8ConfirmAborted
index
<ReferendumIndex`Index of the referendum.$Confirmed
index
<ReferendumIndex`Index of the referendum.
tally�
 T::Tally�The final tally of votes in this referendum.!
A referendum has ended its confirmation phase and is ready for approval. Approved
index
<ReferendumIndex`Index of the referendum.

A referendum has been approved and its proposal has been scheduled. Rejected
index
<ReferendumIndex`Index of the referendum.
tally�
 T::Tally�The final tally of votes in this referendum.	�A proposal has been rejected by referendum. TimedOut
index
<ReferendumIndex`Index of the referendum.
tally�
 T::Tally�The final tally of votes in this referendum.
�A referendum has been timed out without being decided.$Cancelled
index
<ReferendumIndex`Index of the referendum.
tally�
 T::Tally�The final tally of votes in this referendum.�A referendum has been cancelled.Killed
index
<ReferendumIndex`Index of the referendum.
tally�
 T::Tally�The final tally of votes in this referendum.tA referendum has been killed.dSubmissionDepositRefunded
index
<ReferendumIndex`Index of the referendum.
who
0T::AccountId�The account who placed the deposit.
amount
<BalanceOf<T, I>�The amount placed by the account.
�The submission deposit has been refunded.,MetadataSet
index
<ReferendumIndex`Index of the referendum.
hash4
T::Hash8Preimage hash.�Metadata for a referendum has been set.<MetadataCleared
index
<ReferendumIndex`Index of the referendum.
hash4
T::Hash8Preimage hash.�Metadata for a referendum has been cleared.|The `Event` enum of this pallet�@pallet_whitelistpalletEventT
<CallWhitelisted
$call_hash4
T::HashXWhitelistedCallRemoved
$call_hash4
T::Hash
dWhitelistedCallDispatched
$call_hash4
T::Hash
result�
hDispatchResultWithPostInfo|The `Event` enum of this pallet�ResultT
�E
�
Ok�Err�
�4frame_support dispatch@PostDispatchInfo
4actual_weight�
8Option<Weight>
 pays_feed
Pays�OptionT
(
NoneSome(
�(sp_runtimedDispatchErrorWithPostInfoInfo
�
$post_info�
Info
errorh
4DispatchError�@pallet_schedulerpalletEventT
$$Scheduled
when
DBlockNumberFor<T>
index
u32PScheduled some task. Canceled
when
DBlockNumberFor<T>
index
u32
LCanceled some task.(Dispatched
task5
xTaskAddress<BlockNumberFor<T>>
id�
@Option<TaskName>
result�
8DispatchResultTDispatched some task. RetrySet
task5
xTaskAddress<BlockNumberFor<T>>
id�
@Option<TaskName>
period
DBlockNumberFor<T>
retries
u8�Set a retry configuration for some task.8RetryCancelled
task5
xTaskAddress<BlockNumberFor<T>>
id�
@Option<TaskName>�Cancel a retry configuration for some task.<CallUnavailable
task5
xTaskAddress<BlockNumberFor<T>>
id�
@Option<TaskName>)
The call for the provided hash was not found so the task has been aborted.8PeriodicFailed
task5
xTaskAddress<BlockNumberFor<T>>
id�
@Option<TaskName>=
The given task was unable to be renewed since the agenda is full at that block.,RetryFailed
task5
xTaskAddress<BlockNumberFor<T>>
id�
@Option<TaskName>]
The given task was unable to be retried since the agenda is full at that block or there�was not enough weight to reschedule it.TPermanentlyOverweight
task5
xTaskAddress<BlockNumberFor<T>>
id�
@Option<TaskName>�The given task can never be executed since it is overweight.0Events type.�OptionT

NoneSome
�<pallet_preimagepalletEventT
Noted
hash4
T::HashhA preimage has been noted.$Requested
hash4
T::Hash
xA preimage has been requested.Cleared
hash4
T::HashlA preimage has ben cleared.|The `Event` enum of this pallet�<pallet_identitypalletEventT
D,IdentitySet
who
0T::AccountId�A name was set or reset (which will remove all judgements).<IdentityCleared
who
0T::AccountId
deposit
0BalanceOf<T>
�A name was cleared, and the given balance returned.8IdentityKilled
who
0T::AccountId
deposit
0BalanceOf<T>�A name was removed and the given balance slashed.HJudgementRequested
who
0T::AccountId
<registrar_index
8RegistrarIndex�A judgement was asked from a registrar.PJudgementUnrequested
who
0T::AccountId
<registrar_index
8RegistrarIndex�A judgement request was retracted.8JudgementGiven
target
0T::AccountId
<registrar_index
8RegistrarIndex�A judgement was given by a registrar.8RegistrarAdded
<registrar_index
8RegistrarIndexXA registrar was added.@SubIdentityAdded
sub
0T::AccountId
main
0T::AccountId
deposit
0BalanceOf<T>�A sub-identity was added to an identity and the deposit paid.HSubIdentityRemoved
sub
0T::AccountId
main
0T::AccountId
deposit
0BalanceOf<T>	
A sub-identity was removed from an identity and the deposit freed.HSubIdentityRevoked
sub
0T::AccountId
main
0T::AccountId
deposit
0BalanceOf<T>	
A sub-identity was cleared, and the given deposit repatriated from the�main identity account to the sub-identity account.8AuthorityAdded
$authority
0T::AccountId
|A username authority was added.@AuthorityRemoved
$authority
0T::AccountId�A username authority was removed.,UsernameSet
who
0T::AccountId
 username�
,Username<T>tA username was set for `who`.8UsernameQueued
who
0T::AccountId
 username�
,Username<T>
(expiration
DBlockNumberFor<T>

A username was queued, but `who` must accept it prior to `expiration`.HPreapprovalExpired
whose
0T::AccountId9
A queued username passed its expiration without being claimed and was removed.HPrimaryUsernameSet
who
0T::AccountId
 username�
,Username<T>

A username was set as a primary and can be looked up from `who`.\DanglingUsernameRemoved
who
0T::AccountId
 username�
,Username<T>]
A dangling username (as in, a username corresponding to an account that has removed itslidentity) has been removed.|The `Event` enum of this pallet�0pallet_proxypalletEventT
4ProxyExecuted
result�
8DispatchResult�A proxy was executed correctly, with the given.,PureCreated
pure
0T::AccountId
who
0T::AccountId
(proxy_type�
0T::ProxyType
Pdisambiguation_index�
u16
�A pure account has been created by new proxy with given�disambiguation index and proxy type.$Announced
real
0T::AccountId
proxy
0T::AccountId
$call_hash4
4CallHashOf<T>�An announcement was placed to make a call in the future.(ProxyAdded
$delegator
0T::AccountId
$delegatee
0T::AccountId
(proxy_type�
0T::ProxyType
delay
DBlockNumberFor<T>HA proxy was added.0ProxyRemoved
$delegator
0T::AccountId
$delegatee
0T::AccountId
(proxy_type�
0T::ProxyType
delay
DBlockNumberFor<T>PA proxy was removed.|The `Event` enum of this pallet�<pallet_multisigpalletEventT
,NewMultisig
$approving
0T::AccountId
 multisig
0T::AccountId
$call_hash
 CallHash�A new multisig operation has begun.@MultisigApproval
$approving
0T::AccountId
$timepoint
pTimepoint<BlockNumberFor<T>>
 multisig
0T::AccountId
$call_hash
 CallHash
�A multisig operation has been approved by someone.@MultisigExecuted
$approving
0T::AccountId
$timepoint
pTimepoint<BlockNumberFor<T>>
 multisig
0T::AccountId
$call_hash
 CallHash
result�
8DispatchResult�A multisig operation has been executed.DMultisigCancelled
(cancelling
0T::AccountId
$timepoint
pTimepoint<BlockNumberFor<T>>
 multisig
0T::AccountId
$call_hash
 CallHash�A multisig operation has been cancelled.|The `Event` enum of this pallet��pallet_election_provider_multi_phasepalletEventT
8SolutionStored
compute�
<ElectionCompute
origin�

POption<T::AccountId>
0prev_ejected 
bool�A solution was stored with the given compute.Q
The `origin` indicates the origin of the solution. If `origin` is `Some(AccountId)`,Y
the stored solution was submitted in the signed phase by a miner with the `AccountId`.%
Otherwise, the solution was stored either during the unsigned phase or byM
`T::ForceOrigin`. The `bool` is `true` when a previous solution was ejected to makeHroom for this one.DElectionFinalized
compute�
<ElectionCompute
score�
4ElectionScore

The election has been finalized, with the given computation and score.8ElectionFailedLAn election failed.

Not much can be said about which computes failed in the process. Rewarded
account
�<T as frame_system::Config>::AccountId
value
0BalanceOf<T>%
An account has been rewarded for their signed submission being finalized.Slashed
account
�<T as frame_system::Config>::AccountId
value
0BalanceOf<T>!
An account has been slashed for submitting an invalid signed submission.DPhaseTransitioned
from�
`Phase<BlockNumberFor<T>>
to�
`Phase<BlockNumberFor<T>>
round
u32�There was a phase transition in a given round.|The `Event` enum of this pallet��pallet_election_provider_multi_phase<ElectionCompute
OnChainSigned
 Unsigned Fallback$Emergency��pallet_election_provider_multi_phasePhaseBn

OffSigned
 Unsigned�
((bool, Bn)$Emergency� �<pallet_offencespalletEvent
Offence
kind�
Kind
 timeslot8
8OpaqueTimeSlotQ
There is an offence reported of the given `kind` happened at the `session_index` and5
(kind-specific) time slot. This event is not deposited for duplicate slashes.L\[kind, timeslot\].0Events type.�<pallet_bountiespalletEventTI
,8BountyProposed
index
,BountyIndexPNew bounty proposal.8BountyRejected
index
,BountyIndex
bond
<BalanceOf<T, I>
�A bounty proposal was rejected; funds were slashed.HBountyBecameActive
index
,BountyIndex�A bounty proposal is funded and became active.4BountyAwarded
index
,BountyIndex
,beneficiary
0T::AccountId�A bounty is awarded to a beneficiary.4BountyClaimed
index
,BountyIndex
payout
<BalanceOf<T, I>
,beneficiary
0T::AccountId�A bounty is claimed by beneficiary.8BountyCanceled
index
,BountyIndexXA bounty is cancelled.8BountyExtended
index
,BountyIndexpA bounty expiry is extended.8BountyApproved
index
,BountyIndexTA bounty is approved.<CuratorProposed
$bounty_id
,BountyIndex
curator
0T::AccountIdtA bounty curator is proposed.DCuratorUnassigned
$bounty_id
,BountyIndex	|A bounty curator is unassigned.<CuratorAccepted
$bounty_id
,BountyIndex
curator
0T::AccountId
tA bounty curator is accepted.|The `Event` enum of this pallet�Tpallet_child_bountiespalletEventT
Added
index
,BountyIndex
,child_index
,BountyIndex`A child-bounty is added.Awarded
index
,BountyIndex
,child_index
,BountyIndex
,beneficiary
0T::AccountId
�A child-bounty is awarded to a beneficiary.Claimed
index
,BountyIndex
,child_index
,BountyIndex
payout
0BalanceOf<T>
,beneficiary
0T::AccountId�A child-bounty is claimed by beneficiary. Canceled
index
,BountyIndex
,child_index
,BountyIndexpA child-bounty is cancelled.|The `Event` enum of this pallet�\pallet_nomination_poolspalletEventT
HCreated
$depositor
0T::AccountId
pool_id
PoolId`A pool has been created.Bonded
member
0T::AccountId
pool_id
PoolId
bonded
0BalanceOf<T>
joined 
bool
�A member has became bonded in a pool.PaidOut
member
0T::AccountId
pool_id
PoolId
payout
0BalanceOf<T>�A payout has been made to a member. Unbonded
member
0T::AccountId
pool_id
PoolId
balance
0BalanceOf<T>
points
0BalanceOf<T>
era
 EraIndex,�A member has unbonded from their pool.9
- `balance` is the corresponding balance of the number of points that has beenU
  requested to be unbonded (the argument of the `unbond` transaction) from the bonded  pool.E
- `points` is the number of points that are issued as a result of `balance` being�dissolved into the corresponding unbonding pool.�- `era` is the era in which the balance will be unbonded.U
In the absence of slashing, these values will match. In the presence of slashing, theM
number of points that are issued in the unbonding pool will be less than the amountdrequested to be unbonded.$Withdrawn
member
0T::AccountId
pool_id
PoolId
balance
0BalanceOf<T>
points
0BalanceOf<T>�A member has withdrawn from their pool.!
The given number of `points` have been dissolved in return of `balance`.Y
Similar to `Unbonded` event, in the absence of slashing, the ratio of point to balance(will be 1.$Destroyed
pool_id
PoolIdhA pool has been destroyed.0StateChanged
pool_id
PoolId
$new_state

$PoolState|The state of a pool has changed4MemberRemoved
pool_id
PoolId
member
0T::AccountId
@released_balance
0BalanceOf<T>�A member has been removed from a pool.Q
The removal can be voluntary (withdrawn all unbonded funds) or involuntary (kicked).I
Any funds that are still delegated (i.e. dangling delegation) are released and are�represented by `released_balance`.0RolesUpdated
root�

POption<T::AccountId>
bouncer�

POption<T::AccountId>
$nominator�

POption<T::AccountId>U
The roles of a pool have been updated to the given new roles. Note that the depositorDcan never change.,PoolSlashed
pool_id
PoolId
balance
0BalanceOf<T>	

The active balance of pool `pool_id` has been slashed to `balance`.PUnbondingPoolSlashed
pool_id
PoolId
era
 EraIndex
balance
0BalanceOf<T>
%
The unbond pool at `era` of pool `pool_id` has been slashed to `balance`.TPoolCommissionUpdated
pool_id
PoolId
current%
|Option<(Perbill, T::AccountId)>�A pool's commission setting has been changed.`PoolMaxCommissionUpdated
pool_id
PoolId
8max_commission�
Perbill�A pool's maximum commission setting has been changed.|PoolCommissionChangeRateUpdated
pool_id
PoolId
,change_rate-
�CommissionChangeRate<BlockNumberFor<T>>
�A pool's commission `change_rate` has been changed.�PoolCommissionClaimPermissionUpdated
pool_id
PoolId
(permission1
�Option<CommissionClaimPermission<T::AccountId>>�Pool commission claim permission has been updated.TPoolCommissionClaimed
pool_id
PoolId
(commission
0BalanceOf<T>�Pool commission has been claimed.dMinBalanceDeficitAdjusted
pool_id
PoolId
amount
0BalanceOf<T>�Topped up deficit in frozen ED of the reward pool.`MinBalanceExcessAdjusted
pool_id
PoolId
amount
0BalanceOf<T>�Claimed excess frozen ED of af the reward pool.XEvents of this pallet.�,pallet_sudopalletEventT
Sudid
,sudo_result�
8DispatchResult�The result of the call made by the sudo user.pA sudo call just took place.(KeyChanged
old�

POption<T::AccountId>�The old sudo key (if one was previously set).
new
0T::AccountId�The new sudo key (if one was set).
xThe sudo key has been updated.(KeyRemoved�The key was permanently removed.(SudoAsDone
,sudo_result�
8DispatchResult�The result of the call made by the sudo user.�A [sudo_as](Pallet::sudo_as) call just took place.|The `Event` enum of this pallet�,pallet_gearpalletEventT
$4MessageQueued
idI
$MessageIdpGenerated id of the message.
source
0T::AccountId�Account id of the source of the message.
,destinationE
ActorId�Program id, who is the message's destination.
entry�
0MessageEntry�Entry point for processing of the message.�On the sending stage, the processing function|of the program is always known.�User sends message to program, which was successfully�added to the Gear message queue.<UserMessageSent
message�
,UserMessage4Message sent.
(expiration
dOption<BlockNumberFor<T>> �Block number of expiration from `Mailbox`.�Equals `Some(_)` with block number when message�will be removed from `Mailbox` due to some�reasons (see #642, #646 and #1010).�Equals `None` if message wasn't inserted to�`Mailbox` and appears as only `Event`.
�Somebody sent a message to the user.<UserMessageRead
idI
$MessageId\Id of the message read.
reason
TUserMessageReadReason�The reason for the reading (removal from `Mailbox`).�NOTE: See more docs about reasons at `gear_common::event`.�Message marked as "read" and removes it from `Mailbox`.�This event only affects messages that werexalready inserted in `Mailbox`.HMessagesDispatched
total
XMessengerCapacityOf<T>�Total amount of messages removed from message queue.
 statuses)
�BTreeMap<MessageId, DispatchStatus>�Execution statuses of the messages, which were already known�by `Event::MessageQueued` (sent from user to program).
4state_changesa
DBTreeSet<ActorId>�Ids of programs, which state changed during queue processing.�The result of processing the messages within the block.4MessageWaited
idI
$MessageIddId of the message waited.
origin9
�Option<GasNodeId<MessageId, ReservationId>>�Origin message id, which started messaging chain with programs,�where currently waited message was created.�Used to identify by the user that this message associated�with him and the concrete initial message.
reasonE
LMessageWaitedReason�The reason of the waiting (addition to `Waitlist`).�NOTE: See more docs about reasons at `gear_common::event`.
(expiration
DBlockNumberFor<T>�Block number of expiration from `Waitlist`.

Equals block number when message will be removed from `Waitlist`�due to some reasons (see #642, #646 and #1010).�Messages execution delayed (waited) and successfully\added to gear waitlist.0MessageWoken
idI
$MessageId`Id of the message woken.
reasonQ
HMessageWokenReason�The reason of the waking (removal from `Waitlist`).�NOTE: See more docs about reasons at `gear_common::event`.�Message is ready to continue its execution�and was removed from `Waitlist`.,CodeChanged
idA
CodeId`Id of the code affected.
change]
�CodeChangeKind<BlockNumberFor<T>>�Change applied on code with current id.�NOTE: See more docs about change kinds at `gear_common::event`.�Any data related to program codes changed.8ProgramChanged
idE
ActorIdlId of the program affected.
changea
�ProgramChangeKind<BlockNumberFor<T>>�Change applied on program with current id.�NOTE: See more docs about change kinds at `gear_common::event`.�Any data related to programs changed.DQueueNotProcessedU
The pseudo-inherent extrinsic that runs queue processing rolled back or not executed.|The `Event` enum of this pallet�,gear_commonevent0MessageEntry
InitHandle
ReplyI
$MessageIdSignal�$gear_coremessageuser,UserMessage
idI
$MessageId
sourceE
ActorId
,destinationE
ActorId
payload�
Payload
value�
Value
details

POption<ReplyDetails>�$gear_corelimitedvec(LimitedVecT
8
Vec<T>
OptionT

NoneSome
$gear_coremessagecommon0ReplyDetails
toI
$MessageId
code	
$ReplyCode	@gear_core_errorssimple$ReplyCode
Success

HSuccessReplyReasonError
@ErrorReplyReason
,Unsupported�
@gear_core_errorssimpleHSuccessReplyReason
AutoManual
,Unsupported�@gear_core_errorssimple@ErrorReplyReason
$Execution
PSimpleExecutionError@UnavailableActor
lSimpleUnavailableActorErrorLRemovedFromWaitlist,Unsupported�@gear_core_errorssimplePSimpleExecutionError
,RanOutOfGas8MemoryOverflow
0BackendError8UserspacePanicXUnreachableInstructionHStackLimitExceeded,Unsupported�@gear_core_errorssimplelSimpleUnavailableActorError
4ProgramExitedTInitializationFailure
4UninitializedDProgramNotCreated`ReinstrumentationFailure,Unsupported�,gear_commoneventReasonR
!S
%
Runtime!
RSystem%
S
!,gear_commoneventpUserMessageReadRuntimeReason
8MessageReplied8MessageClaimed
%,gear_commoneventlUserMessageReadSystemReason
$OutOfRent) BTreeMapK
IV
-1-,gear_commonevent8DispatchStatus
SuccessFailed
,NotExecuted155I-9OptionT
=
NoneSome=
=,gear_common0gas_providernode$GasNodeIdT
IU
A
NodeI
T,ReservationA
U
A,gprimitives4ReservationId
 [u8; 32]E,gear_commoneventReasonR
IS
M
RuntimeI
RSystemM
S
I,gear_commoneventhMessageWaitedRuntimeReason
(WaitCalled4WaitForCalled
8WaitUpToCalledHWaitUpToCalledFullM,gear_commoneventdMessageWaitedSystemReason
Q,gear_commoneventReasonR
US
Y
RuntimeU
RSystemY
S
U,gear_commoneventdMessageWokenRuntimeReason
(WakeCalledY,gear_commonevent`MessageWokenSystemReason
TProgramGotInitialized8TimeoutHasCome
$OutOfRent],gear_commonevent8CodeChangeKind,BlockNumber

Active
(expiration
LOption<BlockNumber> Inactive
8Reinstrumenteda,gear_commoneventDProgramChangeKind,BlockNumber

Active
(expiration
,BlockNumber Inactive
Paused(TerminatedDExpirationChanged
(expiration
,BlockNumber(ProgramSet
(expiration
,BlockNumberelpallet_gear_staking_rewardspalletEventT
$Deposited
amount
0BalanceOf<T>XDeposited to the pool.$Withdrawn
amount
0BalanceOf<T>
�Transferred from the pool to an external account.Burned
amount
0BalanceOf<T>TBurned from the pool.Minted
amount
0BalanceOf<T>LMinted to the pool.XTargetInflationChanged
valuei
,PerquintilldTarget inflation changed.`IdealStakingRatioChanged
valuei
,PerquintillpIdeal staking ratio changed.|The `Event` enum of this palleti4sp_arithmetic(per_things,Perquintill0
u64mLpallet_gear_voucherpalletEventT
4VoucherIssued
owner
8AccountIdOf<T>�Account id of owner and manager of the voucher.
spender
8AccountIdOf<T>�Account id of user eligible to use the voucher.
(voucher_idi
$VoucherIdLVoucher identifier.`Voucher has been issued.8VoucherRevoked
spender
8AccountIdOf<T>�Account id of the user whose voucher was revoked.
(voucher_idi
$VoucherIdLVoucher identifier.
�Voucher has been revoked by owner.�NOTE: currently means only "refunded".8VoucherUpdated
spender
8AccountIdOf<T>�Account id of user whose voucher was updated.
(voucher_idi
$VoucherIdLVoucher identifier.
$new_owner�

XOption<AccountIdOf<T>>�Optional field defining was the owner changed during update.dVoucher has been updated.<VoucherDeclined
spender
8AccountIdOf<T>�Account id of user who declined its own voucher.
(voucher_idi
$VoucherIdLVoucher identifier.�Voucher has been declined (set to expired state).hPallet Gear Voucher event.qXpallet_gear_eth_bridgepalletEventT
 \AuthoritySetHashChanged4
H256�Grandpa validator's keys set was hashed and set in storage at�first block of the last session in the era.DBridgeInitialized
�Optimistically, single-time called event defining that pallet�got initialized and started processing session changes,�as well as putting initial zeroed queue merkle root.0BridgePaused
Bridge was paused and temporary doesn't process any incoming requests.8BridgeUnpaused
Bridge was unpaused and from now on processes any incoming requests.4MessageQueued
messageu
(EthMessageDEnqueued message.
hash4
H256tHash of the enqueued message.�A new message was queued for bridging.XQueueMerkleRootChanged
 queue_id0
u64DQueue identifier.
root4
H256dMerkle root of the queue.
Merkle root of the queue changed: new messages queued within the block.<QueueOverflowed�Queue has been overflowed and now requires reset.(QueueReset@Queue was reset.9
Related to bridge clearing on initialization of the second block in a new era.|Pallet Gear Eth Bridge's event.u�pallet_gear_eth_bridge_primitives(EthMessage
noncey
U256
source4
H256
,destination}
H160
payload8
Vec<u8>y<primitive_typesU256}
 [u64; 4]}0�Tpallet_grandpa_signerpalletEventT
@RequestScheduled
(request_id
$RequestId
set_id0
SetId8SignatureAdded
(request_id
$RequestId
$authority
8T::AuthorityId
count
u32
|The `Event` enum of this pallet�0frame_systemPhase
8ApplyExtrinsic
u320Finalization
8Initialization�5�0frame_systemXLastRuntimeUpgradeInfo
0spec_version)

Lcodec::Compact<u32>
$spec_name�
dsp_runtime::RuntimeString��0frame_system`CodeUpgradeAuthorizationT
$code_hash4
T::Hash
4check_version 
bool�0frame_systemlimits0BlockWeights
(base_block(
Weight
$max_block(
Weight
$per_class�
�PerDispatchClass<WeightsPerClass>�4frame_support dispatch@PerDispatchClassT
�
normal�
T
,operational�
T
$mandatory�
T�0frame_systemlimits<WeightsPerClass
8base_extrinsic(
Weight
4max_extrinsic�
8Option<Weight>
$max_total�
8Option<Weight>
 reserved�
8Option<Weight>�0frame_systemlimits,BlockLength
max�
TPerDispatchClass<u32>�4frame_support dispatch@PerDispatchClassT

normal
T
,operational
T
$mandatory
T�(sp_weights<RuntimeDbWeight
read0
u64
write0
u64�(sp_version8RuntimeVersion 
$spec_name�
4RuntimeString
$impl_name�
4RuntimeString
Dauthoring_version
u32
0spec_version
u32
0impl_version
u32
apis�
ApisVec
Ltransaction_version
u32
4state_version
u8�CowT
�����q�0frame_systempalletErrorT
$<InvalidSpecName
The name of specification does not match between the current runtimePand the new runtime.hSpecVersionNeedsToIncrease
A
The specification version is not allowed to decrease between the current runtimePand the new runtime.tFailedToExtractRuntimeVersion�Failed to extract the runtime version from the new runtime.	
Either calling `Core_version` or decoding `RuntimeVersion` failed.LNonDefaultComposite�Suicide called when the account has non-default composite data.<NonZeroRefCount5
There is a non-zero reference count preventing the account from being purged.0CallFiltered�The origin filter prevent the call to be dispatched.lMultiBlockMigrationsOngoingU
A multi-block migration is ongoing and prevents the current code from being replaced.DNothingAuthorizedXNo upgrade authorized.0Unauthorized�The submitted code is not authorized.lError for the System pallet�Lbounded_collections@weak_bounded_vec8WeakBoundedVecT
�S�
Vec<T>�-
0���Lbounded_collections,bounded_vec(BoundedVecT
S�
Vec<T>��OptionT
�
NoneSome�
�Dsp_consensus_babedigests$PreDigest
Primary�
@PrimaryPreDigest
8SecondaryPlain�
\SecondaryPlainPreDigest0SecondaryVRF�
TSecondaryVRFPreDigest�Dsp_consensus_babedigests@PrimaryPreDigest
<authority_index
Tsuper::AuthorityIndex
slot1

Slot
4vrf_signature�
0VrfSignature�sp_coresr25519vrf0VrfSignature
(pre_output
0VrfPreOutput
proof]

 VrfProof�Dsp_consensus_babedigests\SecondaryPlainPreDigest
<authority_index
Tsuper::AuthorityIndex
slot1

Slot�Dsp_consensus_babedigestsTSecondaryVRFPreDigest
<authority_index
Tsuper::AuthorityIndex
slot1

Slot
4vrf_signature�
0VrfSignature�Dsp_consensus_babeXBabeEpochConfiguration
c=

((u64, u64)
4allowed_slotsA

0AllowedSlots�Lbounded_collections,bounded_vec(BoundedVecT
�S�
Vec<T>�0��
,pallet_babepalletErrorT
`InvalidEquivocationProof1
An equivocation proof provided as part of an equivocation report is invalid.`InvalidKeyOwnershipProof
1
A key ownership proof provided as part of an equivocation report is invalid.XDuplicateOffenceReport
A given equivocation report is valid but already previously reported.PInvalidConfiguration�Submitted configuration is invalid.�The `Error` enum of this pallet.8pallet_grandpa,StoredStateN

Live0PendingPause
0scheduled_at
N
delay
N
Paused4PendingResume
0scheduled_at
N
delay
N	8pallet_grandpaLStoredPendingChangeN
Limit
0scheduled_at
N
delay
N
@next_authorities

lBoundedAuthorityList<Limit>
forced
$Option<N>
Lbounded_collections@weak_bounded_vec8WeakBoundedVecT
�S�
Vec<T>8pallet_grandpapalletErrorT
,PauseFailed
Attempt to signal GRANDPA pause when the authority set isn't live�(either paused or already pending pause).0ResumeFailed

Attempt to signal GRANDPA resume when the authority set isn't paused�(either live or already pending resume).4ChangePending�Attempt to signal GRANDPA change with one already pending.TooSoon�Cannot signal forced change so soon after last.`InvalidKeyOwnershipProof1
A key ownership proof provided as part of an equivocation report is invalid.`InvalidEquivocationProof1
An equivocation proof provided as part of an equivocation report is invalid.XDuplicateOffenceReport
A given equivocation report is valid but already previously reported.�The `Error` enum of this pallet.Lbounded_collections@weak_bounded_vec8WeakBoundedVecT
S!
Vec<T><pallet_balancestypes,BalanceLockBalance

idq
8LockIdentifier
amount
Balance
reasons
Reasons<pallet_balancestypesReasons
FeeMisc
All!%Lbounded_collections,bounded_vec(BoundedVecT
)S-
Vec<T>)<pallet_balancestypes,ReserveDataDReserveIdentifier
qBalance

idq
DReserveIdentifier
amount
Balance-)1Lbounded_collections,bounded_vec(BoundedVecT
5SA
Vec<T>54frame_supporttraitstokensmisc IdAmountId
9Balance

id9
Id
amount
Balance90vara_runtimeDRuntimeHoldReason
 Preimage=
lpallet_preimage::HoldReason=<pallet_preimagepallet(HoldReason
 PreimageA5ELbounded_collections,bounded_vec(BoundedVecT
ISU
Vec<T>I4frame_supporttraitstokensmisc IdAmountId
MBalance

idM
Id
amount
BalanceM0vara_runtimeLRuntimeFreezeReason
<NominationPoolsQ
�pallet_nomination_pools::FreezeReasonQ\pallet_nomination_poolspallet0FreezeReason
8PoolMinBalanceUIY<pallet_balancespalletErrorTI
08VestingBalance�Vesting balance too high to send value.TLiquidityRestrictions
�Account liquidity restrictions prevent withdrawal.LInsufficientBalancexBalance too low to send value.HExistentialDeposit�Value too low to create account due to existential deposit.4Expendability�Transfer/payment would kill account.\ExistingVestingSchedule�A vesting schedule already exists for this account.,DeadAccount�Beneficiary account must pre-exist.<TooManyReserves�Number of named reserves exceed `MaxReserves`.0TooManyHolds�Number of holds exceed `VariantCountOf<T::RuntimeHoldReason>`.8TooManyFreezes	�Number of freezes exceed `MaxFreezes`.LIssuanceDeactivated


The issuance cannot be modified since it is already deactivated.$DeltaZerodThe delta cannot be zero.�The `Error` enum of this pallet.]4sp_arithmetic,fixed_point$FixedU128
u128ahpallet_transaction_payment Releases
$V1AncientV2
eii�
mq8qsp_corecrypto$KeyTypeIdH
[u8; 4]u8pallet_sessionpalletErrorT
0InvalidProof`Invalid ownership proof.\NoAssociatedValidatorId
�No associated validator ID for account.4DuplicatedKeydRegistered duplicate key.NoKeys�No keys are associated with this account.$NoAccount
Key setting account is not live, so it's impossible to associate keys.tError for the session pallet.y8pallet_utilitypalletErrorT
0TooManyCalls\Too many calls batched.�The `Error` enum of this pallet.}Lbounded_collections@weak_bounded_vec8WeakBoundedVecT
�
S�
Vec<T>��
�Lbounded_collections,bounded_vec(BoundedVecT
�
S�
Vec<T>��
�8pallet_vesting Releases
V0V1
�8pallet_vestingpalletErrorT
(NotVesting�The account given is not vesting.TAtMaxVestingSchedules
%
The account already has `MaxVestingSchedules` count of schedules and thusQ
cannot add another one. Consider merging existing schedules in order to add another.$AmountLow
Amount being transferred is too low to create a vesting schedule.`ScheduleIndexOutOfBounds�An index was out of bounds of the vesting schedules.TInvalidScheduleParams

Failed to create a new schedule because some parameter was invalid.tError for the vesting pallet.�@pallet_bags_listlistNodeTI
id
0T::AccountId
prev�

POption<T::AccountId>
next�

POption<T::AccountId>
$bag_upper0
 T::Score
score0
 T::Score�@pallet_bags_listlistBagTI
head�

POption<T::AccountId>
tail�

POption<T::AccountId>�0�@pallet_bags_listpalletErrorTI
List�
$ListError�A error in the list interface implementation.�The `Error` enum of this pallet.�@pallet_bags_listlist$ListError
$Duplicate(NotHeavier
0NotInSameBag0NodeNotFound�Lbounded_collections@weak_bounded_vec8WeakBoundedVecT
�S�
Vec<T>����@pallet_im_onlinepalletErrorT
(InvalidKey`Non existent public key.LDuplicatedHeartbeat
TDuplicated heartbeat.�The `Error` enum of this pallet.�8pallet_staking4StakingLedgerT
stash
0T::AccountId
total�
0BalanceOf<T>
active�
0BalanceOf<T>
$unlocking�

�BoundedVec<UnlockChunk<BalanceOf<T>>, T::MaxUnlockingChunks>
Xlegacy_claimed_rewards�
�BoundedVec<EraIndex, T::HistoryDepth>�Lbounded_collections,bounded_vec(BoundedVecT
S�

Vec<T>�8pallet_staking,NominationsT
targets�
�BoundedVec<T::AccountId, MaxNominationsOf<T>>
0submitted_in
 EraIndex
(suppressed 
bool�Lbounded_collections,bounded_vec(BoundedVecT
S�

Vec<T>�8pallet_staking4ActiveEraInfo
index
 EraIndex
startM
,Option<u64>�(sp_stakingTPagedExposureMetadataBalance

total�
Balance
own�
Balance
<nominator_count
u32
(page_count
Page��(sp_staking0ExposurePage$AccountId
Balance

(page_total�
Balance
others�
�Vec<IndividualExposure<AccountId, Balance>>�8pallet_staking<EraRewardPoints$AccountId

total
,RewardPoint
(individual�
�BTreeMap<AccountId, RewardPoint>� BTreeMapK
V
�������8pallet_staking8UnappliedSlash$AccountId
Balance

$validator
$AccountId
own
Balance
others�
dVec<(AccountId, Balance)>
$reporters�

8Vec<AccountId>
payout
Balance���8pallet_staking slashing4SlashingSpans
(span_index
$SpanIndex
(last_start
 EraIndex
Hlast_nonzero_slash
 EraIndex
prior�

4Vec<EraIndex>�8pallet_staking slashing(SpanRecordBalance

slashed
Balance
 paid_out
Balance�8pallet_stakingpalletpalletErrorT
|4NotControllerdNot a controller account. NotStash
PNot a stash account.4AlreadyBonded`Stash is already bonded.4AlreadyPairedtController is already paired.0EmptyTargets`Targets cannot be empty.8DuplicateIndex@Duplicate index.DInvalidSlashIndex�Slash record index out of bounds.@InsufficientBondY
Cannot have a validator or nominator role, with value less than the minimum defined by=
governance (see `MinValidatorBond` and `MinNominatorBond`). If unbonding is the
intention, `chill` first to remove one's role as validator/nominator.0NoMoreChunks�Can not schedule more unlock chunks.4NoUnlockChunk	�Can not rebond without unlocking chunks.0FundedTarget
�Attempting to target a stash that still has funds.HInvalidEraToRewardXInvalid era to reward.hInvalidNumberOfNominationsxInvalid number of nominations.HNotSortedAndUnique
�Items are not sorted and unique.8AlreadyClaimed	
Rewards for this era have already been claimed for this validator.,InvalidPage�No nominators exist on this page.TIncorrectHistoryDepth�Incorrect previous history depth input provided.XIncorrectSlashingSpans�Incorrect number of slashing spans provided. BadState9
Internal state has become somehow corrupted and the operation cannot continue.8TooManyTargets�Too many nomination targets supplied.$BadTarget=
A nomination target was supplied that was blocked or otherwise not a validator.@CannotChillOtherU
The user has enough bond and thus cannot be chilled forcefully by an external person.DTooManyNominatorsM
There are too many nominators in the system. Governance needs to adjust the staking�settings to keep things safe for the runtime.DTooManyValidatorsU
There are too many validator candidates in the system. Governance needs to adjust the�staking settings to keep things safe for the runtime.@CommissionTooLow�Commission is too low. Must be at least `MinCommission`.,BoundNotMetXSome bound is not met.PControllerDeprecated

Used when attempting to use deprecated controller account logic.LCannotRestoreLedgerXCannot reset a ledger.lRewardDestinationRestricted�Provided reward destination is not allowed.8NotEnoughFunds�Not enough funds available to withdraw.\VirtualStakerNotAllowed�Operation not allowed for virtual stakers.�The `Error` enum of this pallet.
<pallet_treasury Proposal$AccountId
Balance

 proposer
$AccountId
value
Balance
,beneficiary
$AccountId
bond
BalanceLbounded_collections,bounded_vec(BoundedVecT
S�

Vec<T>	<pallet_treasury,SpendStatus$AssetKind
�0AssetBalance
,Beneficiary
,BlockNumber
$PaymentId
�
(asset_kind�
$AssetKind
amount
0AssetBalance
,beneficiary
,Beneficiary
(valid_from
,BlockNumber
$expire_at
,BlockNumber
status

\PaymentState<PaymentId>
<pallet_treasury0PaymentStateId
�
Pending$Attempted
id�
Id
Failed4sp_arithmetic(per_thingsPermill
u324frame_support PalletIdq
[u8; 8]<pallet_treasurypalletErrorTI
,0InvalidIndex�No proposal, bounty or spend at that index.@TooManyApprovals
�Too many approvals in the queue.XInsufficientPermissionE
The spend origin is valid but the amount it is allowed to spend is lower than theLamount to be spent.LProposalNotApproved|Proposal has not been approved.XFailedToConvertBalanceQ
The balance of the asset kind is not convertible to the balance of the native asset.0SpendExpired�The spend has expired and cannot be claimed.,EarlyPayout�The spend is not yet eligible for payout.@AlreadyAttempted�The payment has already been attempted.,PayoutError�There was some issue with the mechanism of payment.0NotAttempted	�The payout was not yet attempted/claimed.0Inconclusive
�The payment has neither failed nor succeeded yet.xError for the treasury pallet.4!�%`pallet_conviction_votingvoteVotingBalance
$AccountId
,BlockNumber
$PollIndex
 MaxVotes
Casting)
�Casting<Balance, BlockNumber, PollIndex, MaxVotes>(DelegatingA
�Delegating<Balance, AccountId, BlockNumber>
)`pallet_conviction_votingvoteCastingBalance
,BlockNumber
$PollIndex
 MaxVotes
votes-
�BoundedVec<(PollIndex, AccountVote<Balance>), MaxVotes>
,delegations9
PDelegations<Balance>
prior=
|PriorLock<BlockNumber, Balance>-Lbounded_collections,bounded_vec(BoundedVecT
1S5
Vec<T>1�519`pallet_conviction_votingtypes,DelegationsBalance

votes
Balance
capital
Balance=`pallet_conviction_votingvote$PriorLock,BlockNumber
Balance

,BlockNumber
BalanceA`pallet_conviction_votingvote(DelegatingBalance
$AccountId
,BlockNumber

balance
Balance
target
$AccountId
(conviction

(Conviction
,delegations9
PDelegations<Balance>
prior=
|PriorLock<BlockNumber, Balance>ELbounded_collections,bounded_vec(BoundedVecT
ISM
Vec<T>I�MIQ`pallet_conviction_votingpalletErrorTI
0(NotOngoingPPoll is not ongoing. NotVoter
�The given account did not vote on the poll.0NoPermission�The actor has no permission to conduct the action.<NoPermissionYetY
The actor has no permission to conduct the action right now but will do in the future.DAlreadyDelegating�The account is already delegating.4AlreadyVotingU
The account currently has votes attached to it and the operation cannot succeed until�these are removed through `remove_vote`.DInsufficientFunds�Too high a balance was provided that the account cannot afford.4NotDelegating�The account is not currently delegating. Nonsense�Delegation to oneself makes no sense.<MaxVotesReached	�Maximum number of votes reached.,ClassNeeded
9
The class must be supplied since it is not easily determinable from the state. BadClass�The class ID supplied is invalid.�The `Error` enum of this pallet.U@pallet_referendatypes8ReferendumInfo TrackId
�4RuntimeOrigin
�
Moment
Call


Balance
Tally
�$AccountId
<ScheduleAddress
5
OngoingY
�
ReferendumStatus<TrackId, RuntimeOrigin, Moment, Call, Balance, Tally,
AccountId, ScheduleAddress,> Approved
Momenta
�Option<Deposit<AccountId, Balance>>a
�Option<Deposit<AccountId, Balance>>
 Rejected
Momenta
�Option<Deposit<AccountId, Balance>>a
�Option<Deposit<AccountId, Balance>>$Cancelled
Momenta
�Option<Deposit<AccountId, Balance>>a
�Option<Deposit<AccountId, Balance>> TimedOut
Momenta
�Option<Deposit<AccountId, Balance>>a
�Option<Deposit<AccountId, Balance>>Killed
MomentY@pallet_referendatypes@ReferendumStatus TrackId
�4RuntimeOrigin
�
Moment
Call


Balance
Tally
�$AccountId
<ScheduleAddress
5,
track�
TrackId
origin�

4RuntimeOrigin
 proposal


Call
$enactment
PDispatchTime<Moment>
$submitted
Moment
Hsubmission_deposit]
lDeposit<AccountId, Balance>
@decision_deposita
�Option<Deposit<AccountId, Balance>>
 decidinge
xOption<DecidingStatus<Moment>>
tally�
Tally
 in_queue 
bool
alarmm
�Option<(Moment, ScheduleAddress)>]@pallet_referendatypesDeposit$AccountId
Balance

who
$AccountId
amount
BalanceaOptionT
]
NoneSome]
eOptionT
i
NoneSomei
i@pallet_referendatypes8DecidingStatus,BlockNumber

since
,BlockNumber
(confirming
LOption<BlockNumber>mOptionT
q
NoneSomeq
q5uLbounded_collections,bounded_vec(BoundedVecT
yS}
Vec<T>y}y������@pallet_referendatypes$TrackInfoBalance
Moment
$
name�
0&'static str
0max_deciding
u32
@decision_deposit
Balance
8prepare_period
Moment
<decision_period
Moment
8confirm_period
Moment
Pmin_enactment_period
Moment
0min_approval�
Curve
,min_support�
Curve�@pallet_referendatypesCurve
@LinearDecreasing
length�
Perbill
floor�
Perbill
ceil�
PerbillDSteppedDecreasing
begin�
Perbill
end�
Perbill
step�
Perbill
period�
Perbill
(Reciprocal
factor�
 FixedI64
 x_offset�
 FixedI64
 y_offset�
 FixedI64�4sp_arithmetic,fixed_point FixedI64�
i64��@pallet_referendapalletErrorTI
8(NotOngoinghReferendum is not ongoing.(HasDeposit
�Referendum's decision deposit is already paid. BadTrack�The track identifier given was invalid.Full1
There are already a full complement of referenda in progress for this track.(QueueEmpty�The queue of the track is empty.4BadReferendum�The referendum index provided is invalid in this context.,NothingToDo�There was nothing to do in the advancement.NoTrack�No track exists for the proposal origin.(Unfinished

Any deposit cannot be refunded until after the decision is over.0NoPermission	�The deposit refunder is not the depositor.$NoDeposit
�The deposit cannot be refunded since none was made.$BadStatus�The referendum status is invalid for this operation.@PreimageNotExistpThe preimage does not exist.�PreimageStoredWithDifferentLength

The preimage is stored with a different length than the one provided.�The `Error` enum of this pallet.�`pallet_ranked_collective0MemberRecord
rank�
Rank�����Lbounded_collections,bounded_vec(BoundedVecT
S8
Vec<T>�`pallet_ranked_collectivepalletErrorTI
,4AlreadyMemberpAccount is already a member.$NotMember
`Account is not a member.(NotPolling�The given poll index is unknown or has closed.Ongoing�The given poll is still ongoing.4NoneRemaining�There are no further records to be removed.(CorruptionhUnexpected error in state.(RankTooLow�The member's rank is too low to vote.8InvalidWitness�The information provided is incorrect.0NoPermission�The origin is not sufficiently privileged to do the operation.(SameMember	�The new member to exchange is the same as the old member8TooManyMembers
�The max member count for the rank has been reached.�The `Error` enum of this pallet.�@pallet_referendatypes8ReferendumInfo TrackId
�4RuntimeOrigin
�
Moment
Call


Balance
Tally
�$AccountId
<ScheduleAddress
5
Ongoing�
�
ReferendumStatus<TrackId, RuntimeOrigin, Moment, Call, Balance, Tally,
AccountId, ScheduleAddress,> Approved
Momenta
�Option<Deposit<AccountId, Balance>>a
�Option<Deposit<AccountId, Balance>>
 Rejected
Momenta
�Option<Deposit<AccountId, Balance>>a
�Option<Deposit<AccountId, Balance>>$Cancelled
Momenta
�Option<Deposit<AccountId, Balance>>a
�Option<Deposit<AccountId, Balance>> TimedOut
Momenta
�Option<Deposit<AccountId, Balance>>a
�Option<Deposit<AccountId, Balance>>Killed
Moment�@pallet_referendatypes@ReferendumStatus TrackId
�4RuntimeOrigin
�
Moment
Call


Balance
Tally
�$AccountId
<ScheduleAddress
5,
track�
TrackId
origin�

4RuntimeOrigin
 proposal


Call
$enactment
PDispatchTime<Moment>
$submitted
Moment
Hsubmission_deposit]
lDeposit<AccountId, Balance>
@decision_deposita
�Option<Deposit<AccountId, Balance>>
 decidinge
xOption<DecidingStatus<Moment>>
tally�
Tally
 in_queue 
bool
alarmm
�Option<(Moment, ScheduleAddress)>�Lbounded_collections,bounded_vec(BoundedVecT
5S�
Vec<T>�@pallet_referendapalletErrorTI
8(NotOngoinghReferendum is not ongoing.(HasDeposit
�Referendum's decision deposit is already paid. BadTrack�The track identifier given was invalid.Full1
There are already a full complement of referenda in progress for this track.(QueueEmpty�The queue of the track is empty.4BadReferendum�The referendum index provided is invalid in this context.,NothingToDo�There was nothing to do in the advancement.NoTrack�No track exists for the proposal origin.(Unfinished

Any deposit cannot be refunded until after the decision is over.0NoPermission	�The deposit refunder is not the depositor.$NoDeposit
�The deposit cannot be refunded since none was made.$BadStatus�The referendum status is invalid for this operation.@PreimageNotExistpThe preimage does not exist.�PreimageStoredWithDifferentLength

The preimage is stored with a different length than the one provided.�The `Error` enum of this pallet.�@pallet_whitelistpalletErrorT
LUnavailablePreImage�The preimage of the call hash could not be loaded.<UndecodableCall
xThe call could not be decoded.`InvalidCallWeightWitness�The weight of the decoded call was higher than the witness.PCallIsNotWhitelistedtThe call was not whitelisted.XCallAlreadyWhitelisted�The call was already whitelisted; No-Op.�The `Error` enum of this pallet.�Lbounded_collections,bounded_vec(BoundedVecT
�S�
Vec<T>�OptionT
�
NoneSome�
�@pallet_scheduler$ScheduledName
Call


,BlockNumber
4PalletsOrigin
�
$AccountId

 maybe_id�
0Option<Name>
 priority
Hschedule::Priority
call


Call
8maybe_periodic1
�Option<schedule::Period<BlockNumber>>
origin�

4PalletsOrigin���@pallet_scheduler,RetryConfigPeriod

4total_retries
u8
$remaining
u8
period
Period�@pallet_schedulerpalletErrorT
@FailedToScheduledFailed to schedule a call NotFound
|Cannot find the scheduled call.\TargetBlockNumberInPast�Given target block number is in the past.HRescheduleNoChange�Reschedule failed because it does not change scheduled time.Named�Attempt to use a non-named function on a named task.�The `Error` enum of this pallet.�<pallet_preimage@OldRequestStatus$AccountId
Balance

,Unrequested
deposit�
P(AccountId, Balance)
len
u32$Requested
deposit�
pOption<(AccountId, Balance)>
count
u32
len
,Option<u32>
�OptionT
�
NoneSome�
�<pallet_preimage4RequestStatus$AccountId
Ticket
�
,Unrequested
ticket�
L(AccountId, Ticket)
len
u32$Requested
0maybe_ticket�
lOption<(AccountId, Ticket)>
count
u32
$maybe_len
,Option<u32>
�4frame_supporttraitstokens fungibleDHoldConsiderationAFRDFp
(F::Balance���OptionT
�
NoneSome�
�Lbounded_collections,bounded_vec(BoundedVecT
S8
Vec<T>�<pallet_preimagepalletErrorT
 TooBig�Preimage is too large to store on-chain.0AlreadyNoted
�Preimage has already been noted on-chain.4NotAuthorized�The user is not authorized to perform this action. NotNoted�The preimage cannot be removed since it has not yet been noted.$Requested	
A preimage may not be removed when there are outstanding requests.0NotRequested-
The preimage request cannot be removed since no outstanding requests exist.TooManyU
More than `MAX_HASH_UPGRADE_BULK_COUNT` hashes were requested to be upgraded at once.TooFew�Too few hashes were requested to be upgraded (i.e. zero).�The `Error` enum of this pallet.�

<pallet_identitytypes0RegistrationBalance
4MaxJudgements0IdentityInfo
E
(judgements
�BoundedVec<(RegistrarIndex, Judgement<Balance>), MaxJudgements>
deposit
Balance
infoE
0IdentityInfoLbounded_collections,bounded_vec(BoundedVecT
	S

Vec<T>	�
	OptionT
�
NoneSome�
Lbounded_collections,bounded_vec(BoundedVecT
S�

Vec<T>Lbounded_collections,bounded_vec(BoundedVecT
!S)
Vec<T>!OptionT
%
NoneSome%
%<pallet_identitytypes4RegistrarInfoBalance
$AccountId
IdField
0
account
$AccountId
fee
Balance
fields0
IdField)!-<pallet_identitytypesLAuthorityPropertiesSuffix
1
suffix1
Suffix
(allocation
(Allocation1Lbounded_collections,bounded_vec(BoundedVecT
S8
Vec<T>5<pallet_identitypalletErrorT
hHTooManySubAccounts\Too many subs-accounts. NotFound
PAccount isn't found. NotNamedPAccount isn't named.(EmptyIndex0Empty index.(FeeChanged<Fee is changed.(NoIdentityHNo identity found.<StickyJudgementDSticky judgement.8JudgementGiven@Judgement given.@InvalidJudgementHInvalid judgement.0InvalidIndex	TThe index is invalid.4InvalidTarget
XThe target is invalid.DTooManyRegistrars�Maximum amount of registrars reached. Cannot add any more.8AlreadyClaimedpAccount ID is already named.NotSub
pSender is not a sub-account. NotOwned�Sub-account isn't owned by sender.tJudgementForDifferentIdentity�The provided judgement was for a different identity.XJudgementPaymentFailed�Error that occurs when there is an issue paying for judgement.4InvalidSuffix�The provided suffix is too long.PNotUsernameAuthority�The sender does not have permission to issue a username.0NoAllocation�The authority cannot allocate any more usernames.@InvalidSignature�The signature on a username was not valid.DRequiresSignature	
Setting this username requires a signature, but none was provided.<InvalidUsername�The username does not meet the requirements.4UsernameTakenxThe username is already taken.(NoUsername�The requested username does not exist.(NotExpired-
The username cannot be forcefully removed because it can still be accepted.�The `Error` enum of this pallet.9==Lbounded_collections,bounded_vec(BoundedVecT
ASE
Vec<T>A0pallet_proxy<ProxyDefinition$AccountId
$ProxyType
�,BlockNumber

 delegate
$AccountId
(proxy_type�
$ProxyType
delay
,BlockNumberEAIMMLbounded_collections,bounded_vec(BoundedVecT
QSU
Vec<T>Q0pallet_proxy0Announcement$AccountId
Hash
4,BlockNumber

real
$AccountId
$call_hash4
Hash
height
,BlockNumberUQY0pallet_proxypalletErrorT
 TooMany!
There are too many proxies registered or too many announcements pending. NotFound
tProxy registration not found. NotProxy�Sender is not a proxy of the account to be proxied.,Unproxyable!
A call which is incompatible with the proxy type's filter was attempted.$DuplicatelAccount is already a proxy.0NoPermission
Call may not be made by proxy because it may escalate its privileges.,Unannounced�Announcement, if made at all, was made too recently.,NoSelfProxydCannot add self as proxy.�The `Error` enum of this pallet.]a<pallet_multisig Multisig,BlockNumber
Balance
$AccountId
0MaxApprovals
when
XTimepoint<BlockNumber>
deposit
Balance
$depositor
$AccountId
$approvalse
�BoundedVec<AccountId, MaxApprovals>eLbounded_collections,bounded_vec(BoundedVecT
S�

Vec<T>i<pallet_multisigpalletErrorT
8@MinimumThreshold|Threshold must be 2 or greater.<AlreadyApproved
�Call is already approved by this signatory.DNoApprovalsNeeded�Call doesn't need any (more) approvals.DTooFewSignatories�There are too few signatories in the list.HTooManySignatories�There are too many signatories in the list.TSignatoriesOutOfOrder

The signatories were provided out of order; they should be ordered.LSenderInSignatories

The sender was contained in the other signatories; it shouldn't be. NotFound�Multisig operation not found when attempting to cancel. NotOwner-
Only the account that originally created the multisig is able to cancel it.,NoTimepoint	
No timepoint was given, yet the multisig operation is already underway.8WrongTimepoint
-
A different timepoint was given to the multisig operation that is underway.LUnexpectedTimepoint�A timepoint was given, yet no multisig operation is underway.<MaxWeightTooLow�The maximum weight information provided was too low.4AlreadyStored
�The data to be stored is already stored.�The `Error` enum of this pallet.m�pallet_election_provider_multi_phase4ReadySolution$AccountId(MaxWinners
 supportsq
�BoundedSupports<AccountId, MaxWinners>
score�
4ElectionScore
compute�
<ElectionComputeqLbounded_collections,bounded_vec(BoundedVecT
�S�
Vec<T>u�pallet_election_provider_multi_phase4RoundSnapshot$AccountId
0DataProvider
y
voters}
DVec<DataProvider>
targets�

8Vec<AccountId>y0�}y�Lbounded_collections,bounded_vec(BoundedVecT
�S�
Vec<T>������pallet_election_provider_multi_phasesigned@SignedSubmission$AccountId
Balance
 Solution

who
$AccountId
deposit
Balance
0raw_solution

TRawSolution<Solution>
 call_fee
Balance��pallet_election_provider_multi_phasepalletErrorT
<hPreDispatchEarlySubmissiondSubmission was too early.lPreDispatchWrongWinnerCount
�Wrong number of winners presented.dPreDispatchWeakSubmission�Submission was too weak, score-wise.<SignedQueueFullI
The queue was full, and the solution was not better than any of the existing ones.XSignedCannotPayDeposit�The origin failed to pay the deposit.PSignedInvalidWitness�Witness data to dispatchable is invalid.LSignedTooMuchWeight�The signed submission consumes too much weight<OcwCallWrongEra�OCW submitted solution for wrong round\MissingSnapshotMetadata�Snapshot metadata should exist but didn't.XInvalidSubmissionIndex	�`Self::insert_submission` returned an invalid index.8CallNotAllowed
�The call is not allowed at this point.8FallbackFailedLThe fallback failed,BoundNotMetHSome bound not met8TooManyWinners
�Submitted solution has too many winnersdPreDispatchDifferentRound�Submission was prepared for a different round.

Error of the pallet that can be returned in response to dispatches.�(sp_stakingoffence8OffenceDetails Reporter
 Offender
�
 offender�
 Offender
$reporters�

4Vec<Reporter>��8�<pallet_bountiesBounty$AccountId
Balance
,BlockNumber

 proposer
$AccountId
value
Balance
fee
Balance
<curator_deposit
Balance
bond
Balance
status�
�BountyStatus<AccountId, BlockNumber>�<pallet_bounties0BountyStatus$AccountId
,BlockNumber

 Proposed Approved
Funded<CuratorProposed
curator
$AccountIdActive
curator
$AccountId
(update_due
,BlockNumber4PendingPayout
curator
$AccountId
,beneficiary
$AccountId
$unlock_at
,BlockNumber�Lbounded_collections,bounded_vec(BoundedVecT
S8
Vec<T>�<pallet_bountiespalletErrorTI
,pInsufficientProposersBalancexProposer's balance is too low.0InvalidIndex
�No proposal or bounty at that index.0ReasonTooBig�The reason given is just too big.@UnexpectedStatus�The bounty status is unexpected.8RequireCurator\Require bounty curator.0InvalidValueTInvalid bounty value.(InvalidFeeLInvalid bounty fee.4PendingPayoutlA bounty payout is pending.�To cancel the bounty, you must unassign and slash the curator.$PrematureE
The bounties cannot be claimed/closed because it's still in the countdown period.PHasActiveChildBounty	
The bounty cannot be closed because it has active child bounties.4TooManyQueued
�Too many approvals are already queued.�The `Error` enum of this pallet.�Tpallet_child_bounties,ChildBounty$AccountId
Balance
,BlockNumber

4parent_bounty
,BountyIndex
value
Balance
fee
Balance
<curator_deposit
Balance
status�
�ChildBountyStatus<AccountId, BlockNumber>�Tpallet_child_bountiesDChildBountyStatus$AccountId
,BlockNumber

Added<CuratorProposed
curator
$AccountId
Active
curator
$AccountId4PendingPayout
curator
$AccountId
,beneficiary
$AccountId
$unlock_at
,BlockNumber�Tpallet_child_bountiespalletErrorT
TParentBountyNotActive�The parent bounty is not in active state.dInsufficientBountyBalance
�The bounty balance is not enough to add new child-bounty.PTooManyChildBounties

Number of child bounties exceeds limit `MaxActiveChildBountyCount`.�The `Error` enum of this pallet.�\pallet_nomination_pools(PoolMemberT
pool_id
PoolId
points
0BalanceOf<T>
plast_recorded_reward_counter]
@T::RewardCounter
8unbonding_eras�
�BoundedBTreeMap<EraIndex, BalanceOf<T>, T::MaxUnbonding>�Lbounded_collectionsDbounded_btree_map<BoundedBTreeMapK
V
S�
8BTreeMap<K, V>� BTreeMapK
V
}�\pallet_nomination_pools<BondedPoolInnerT
(commission�
4Commission<T>
8member_counter
u32
points
0BalanceOf<T>
roles�
\PoolRoles<T::AccountId>
state

$PoolState�\pallet_nomination_pools(CommissionT
current%
|Option<(Perbill, T::AccountId)>
max�
<Option<Perbill>
,change_rate�
�Option<CommissionChangeRate<BlockNumberFor<T>>>
4throttle_from
dOption<BlockNumberFor<T>>
@claim_permission1
�Option<CommissionClaimPermission<T::AccountId>>�OptionT
�
NoneSome�
�OptionT
-
NoneSome-
�\pallet_nomination_pools$PoolRoles$AccountId

$depositor
$AccountId
root�

DOption<AccountId>
$nominator�

DOption<AccountId>
bouncer�

DOption<AccountId>�\pallet_nomination_pools(RewardPoolT
plast_recorded_reward_counter]
@T::RewardCounter
llast_recorded_total_payouts
0BalanceOf<T>
Ttotal_rewards_claimed
0BalanceOf<T>
`total_commission_pending
0BalanceOf<T>
`total_commission_claimed
0BalanceOf<T>�\pallet_nomination_pools SubPoolsT
no_era�
4UnbondPool<T>
 with_era�


BoundedBTreeMap<EraIndex, UnbondPool<T>, TotalUnbondingPools<T>>�\pallet_nomination_pools(UnbondPoolT
points
0BalanceOf<T>
balance
0BalanceOf<T>�Lbounded_collectionsDbounded_btree_map<BoundedBTreeMapK
V
�S�
8BTreeMap<K, V>� BTreeMapK
V
�������Lbounded_collections,bounded_vec(BoundedVecT
S8
Vec<T>�\pallet_nomination_poolspalletErrorT
�0PoolNotFound�A (bonded) pool id does not exist.HPoolMemberNotFound
lAn account is not a member.HRewardPoolNotFound!
A reward pool does not exist. In all cases this is a system logic error.@SubPoolsNotFoundhA sub pool does not exist.dAccountBelongsToOtherPoolM
An account is already delegating in another pool. An account may only belong to one<pool at a time.8FullyUnbonding=
The member is fully unbonded (and thus cannot access the bonded and reward pool�anymore to, for example, collect rewards).DMaxUnbondingLimit	
The member cannot unbond further chunks due to reaching the limit.DCannotWithdrawAnyM
None of the funds can be withdrawn yet because the bonding duration has not passed.DMinimumBondNotMet)
The amount does not meet the minimum bond to either join or create a pool.U
The depositor can never unbond to a value less than `Pallet::depositor_min_bond`. The]
caller does not have nominating permissions for the pool. Members can never unbond to ahvalue below `MinJoinBond`.0OverflowRisk	!
The transaction could not be executed due to overflow risk for the pool.4NotDestroying
]
A pool must be in [`PoolState::Destroying`] in order for the depositor to unbond or for�other members to be permissionlessly unbonded.0NotNominator�The caller does not have nominating permissions for the pool.TNotKickerOrDestroying=
Either a) the caller cannot make a valid kick or b) the pool is not destroying.NotOpen
pThe pool is not open to join MaxPools�The system is maxed out on pools.8MaxPoolMembers�Too many members in the pool or system.DCanNotChangeState�The pools state cannot be changed.TDoesNotHavePermission�The caller does not have adequate permissions.TMetadataExceedsMaxLen�Metadata exceeds [`Config::MaxMetadataLen`]$Defensive�
8DefensiveError1
Some error occurred that should never happen. This should be reported to the0maintainers.�PartialUnbondNotAllowedPermissionlessly�Partial unbonding now allowed permissionlessly.\MaxCommissionRestricted
The pool's max commission cannot be set higher than the existing value.`CommissionExceedsMaximum�The supplied commission exceeds the max allowed commission.xCommissionExceedsGlobalMaximum�The supplied commission exceeds global maximum commission.dCommissionChangeThrottled	
Not enough blocks have surpassed since the last commission update.xCommissionChangeRateNotAllowed

The submitted changes to commission change rate are not allowed.LNoPendingCommission�There is no pending commission to claim.XNoCommissionCurrentSet�No commission current has been set.,PoolIdInUsedPool id currently in use.4InvalidPoolId�Pool id provided is not correct/usable.LBondExtraRestricted�Bonding extra is restricted to the exact pending reward amount.<NothingToAdjust�No imbalance in the ED deposit for the pool.8NothingToSlash �No slash pending that can be applied to the member.<AlreadyMigrated!
The pool or member delegation has already migrated to delegate stake.,NotMigrated"
The pool or member delegation has not migrated yet to delegate stake.0NotSupported#�This call is not allowed in the current state of the pallet.�The `Error` enum of this pallet.�\pallet_nomination_poolspallet8DefensiveError
hNotEnoughSpaceInUnbondPool0PoolNotFound
HRewardPoolNotFound@SubPoolsNotFoundpBondedStashKilledPrematurelyTDelegationUnsupported<SlashNotApplied
	,pallet_sudopalletErrorT
,RequireSudo�Sender must be the Sudo account.hError for the Sudo pallet.	$gear_corecode0instrumented@InstrumentedCode
bytes8
Vec<u8>
hinstantiated_section_sizes		
`InstantiatedSectionSizes		$gear_corecode0instrumented`InstantiatedSectionSizes
0code_section
u32
0data_section
u32
8global_section
u32
4table_section
u32
<element_section
u32
0type_section
u32
	$gear_corecode metadata0CodeMetadata
Doriginal_code_len
u32
exports	
XBTreeSet<DispatchKind>
0static_pages	
<WasmPagesAmount
$stack_end!	
@Option<WasmPage>
Xinstrumentation_status)	
TInstrumentationStatus	 BTreeSetT
			$gear_coremessage0DispatchKind
InitHandle
ReplySignal			$gear_corepages,PagesAmount
u32!	OptionT
%	
NoneSome%	
%	$gear_corepagesPage
u32)	$gear_corecode metadataTInstrumentationStatus
<NotInstrumented0Instrumented
version
u32
 code_len
u32
TInstrumentationFailed
version
u32-	$numeratedtree4IntervalsTreeT
%	
inner1	
8BTreeMap<T, T>1	 BTreeMapK
%	V
%	5	5	9	9	%	%	=	$gear_coreprogramProgram,BlockNumber

ActiveA	
hActiveProgram<BlockNumber>ExitedE
ActorId
(TerminatedE
ActorIdA	$gear_coreprogram4ActiveProgram,BlockNumber

Pallocations_tree_len
u32
0memory_infixE	
,MemoryInfix
Lgas_reservation_mapI	
DGasReservationMap
code_idA
CodeId
stateY	
0ProgramState
@expiration_block
,BlockNumberE	$gear_coreprogram,MemoryInfix
u32I	 BTreeMapK
AV
M	Q	M	$gear_core,reservationHGasReservationSlot
amount0
u64
start
u32
finish
u32Q	U	U	AM	Y	$gear_coreprogram0ProgramState
4Uninitialized
(message_idI
$MessageId,Initialized
]	EE	a	a	$gear_corepagesPage
u32e	$gear_corememoryPageBufi	
0PageBufInneri	0m	Lpallet_gear_programpalletErrorT
4DuplicateItem<ProgramNotFound
@NotActiveProgramTCannotFindDataForPageLProgramCodeNotFound�The `Error` enum of this pallet.q	,gear_commonstorage,complicateddequeue(LinkedNodeK
IV
u	
next�	
$Option<K>
valueu	
Vu	$gear_coremessagestored8StoredDispatch
kind	
0DispatchKind
messagey	
4StoredMessage
context�	
POption<ContextStore>y	$gear_coremessagestored4StoredMessage
idI
$MessageId
sourceE
ActorId
,destinationE
ActorId
payload�
Payload
value�
Value
details}	
XOption<MessageDetails>}	OptionT
�	
NoneSome�	
�	$gear_coremessagecommon8MessageDetails
Reply
0ReplyDetailsSignal�	
4SignalDetails
�	$gear_coremessagecommon4SignalDetails
toI
$MessageId
code�	
(SignalCode�	@gear_core_errorssimple(SignalCode
$Execution
PSimpleExecutionErrorLRemovedFromWaitlist
�	OptionT
�	
NoneSome�	
�	$gear_coremessagecontext0ContextStore
,initializeda
DBTreeSet<ActorId>
Dreservation_nonce�	
@ReservationNonce
Hsystem_reservationM
,Option<u64>
,local_nonce
u32�	$gear_core,reservation@ReservationNonce0
u64�	OptionT
I
NoneSomeI
�	I�	�	�	�	$gear_coremessageuserDUserStoredMessage
idI
$MessageId
sourceE
ActorId
,destinationE
ActorId
payload�
Payload
value�
Value�	,gear_commonstorage(primitives IntervalT

start
T
finish
T�	EI�	u	�	�	�	�	�	$gear_coremessagestoredTStoredDelayedDispatch
kind	
0DispatchKind
messagey	
4StoredMessage�	Tpallet_gear_messengerpalletErrorT
0DQueueDuplicateKey�Occurs when given key already exists in queue.PQueueElementNotFound
�Occurs when queue's element wasn't found in storage.PQueueHeadShouldBeSet�Occurs when queue's head should contain value,|but it's empty for some reason.\QueueHeadShouldNotBeSet�Occurs when queue's head should be empty,�but it contains value for some reason.LQueueTailHasNextKey�Occurs when queue's tail element contains linkPto the next element.\QueueTailParentNotFound�Occurs when while searching queue's pre-tail,Telement wasn't found.PQueueTailShouldBeSet�Occurs when queue's tail should contain value,|but it's empty for some reason.\QueueTailShouldNotBeSet�Occurs when queue's tail should be empty,�but it contains value for some reason.LMailboxDuplicateKey�Occurs when given value already exists in mailbox.XMailboxElementNotFound	�Occurs when mailbox's element wasn't found in storage.PWaitlistDuplicateKey
�Occurs when given value already exists in waitlist.\WaitlistElementNotFound�Occurs when waitlist's element wasn't found in storage.�The `Error` enum of this pallet.�	�	�	$gear_coretasks4ScheduledTaskRFM
SD
ISUM
 
DRemoveFromMailbox
RFMI
$MessageIdHRemoveFromWaitlistE
ActorIdI
$MessageId
,WakeMessageE
ActorIdI
$MessageId0SendDispatchI
SD<SendUserMessage
(message_idI
$MessageId
(to_mailbox 
SUMPRemoveGasReservationE
ActorIdA
4ReservationId�	Tpallet_gear_schedulerpalletErrorT
4DuplicateTask�Occurs when given task already exists in task pool.0TaskNotFound
�Occurs when task wasn't found in storage.�The `Error` enum of this pallet.�	,gear_common0gas_providernodeGasNode(ExternalId
Id
=Balance
0Funds

 External 
id
(ExternalId
(multiplier�	
tGasMultiplier<Funds, Balance>
value0
Balance
lock�	
DNodeLock<Balance>
8system_reserve0
Balance
refs�	
0ChildrenRefs
 consumed 
bool
deposit 
boolCut
id
(ExternalId
(multiplier�	
tGasMultiplier<Funds, Balance>
value0
Balance
lock�	
DNodeLock<Balance>
 Reserved
id
(ExternalId
(multiplier�	
tGasMultiplier<Funds, Balance>
value0
Balance
lock�	
DNodeLock<Balance>
refs�	
0ChildrenRefs
 consumed 
bool8SpecifiedLocal
parent=
Id
root=
Id
value0
Balance
lock�	
DNodeLock<Balance>
8system_reserve0
Balance
refs�	
0ChildrenRefs
 consumed 
bool@UnspecifiedLocal
parent=
Id
root=
Id
lock�	
DNodeLock<Balance>
8system_reserve0
Balance�	,gear_common4GasMultiplierBalance
Gas
0
,ValuePerGas
Balance,GasPerValue0
Gas
�	,gear_common0gas_providernode NodeLockBalance
0}
�[Balance; cardinality::<LockId>()]�	,gear_common0gas_providernode0ChildrenRefs
$spec_refs
u32
,unspec_refs
u32�	<pallet_gear_gaspalletErrorT
@$ForbiddenDNodeAlreadyExists
LInsufficientBalance0NodeNotFound<NodeWasConsumed0ParentIsLost�Errors stating that gas tree has been invalidatedLParentHasNoChildren\UnexpectedConsumeOutput�Output of `Tree::consume` procedure that wasn't expected.
Outputs of consumption procedure are determined. The error is returned
when unexpected one occurred. That signals, that algorithm works wrong�and expected invariants are not correct.HUnexpectedNodeType�Node type that can't occur if algorithm work well@ValueIsNotCaught	�
Value must have been caught, but was missed or blocked (for more info see `ValueNode::catch_value`).8ValueIsBlocked
�
Value must have been caught or moved upstream, but was blocked (for more info see `ValueNode::catch_value`).DValueIsNotBlocked�
Value must have been blocked, but was either moved or caught (for more info see `ValueNode::catch_value`).@ConsumedWithLock
`GasTree::consume` called on node, which has some balance locked.tConsumedWithSystemReservation

`GasTree::consume` called on node, which has some system reservation.XTotalValueIsOverflowed�`GasTree::create` called with some value amount leading todthe total value overflow.\TotalValueIsUnderflowed
Either `GasTree::consume` or `GasTree::spent` called on a node creating�negative imbalance which leads to the total value drop below 0.�The `Error` enum of this pallet.�	,pallet_gear schedule ScheduleT(
limits�	
Limits
Linstruction_weights�	
TInstructionWeights<T>
<syscall_weights�	
DSyscallWeights<T>
8memory_weights�	
@MemoryWeights<T>
0rent_weights�	
8RentWeights<T>
(db_weights�	
0DbWeights<T>
0task_weights�	
8TaskWeights<T>
Tinstantiation_weights


\InstantiationWeights<T>
\instrumentation_weights

dInstrumentationWeights<T>
\load_allocations_weight(
Weight�	,pallet_gear scheduleLimits4
0stack_height
,Option<u32>
globals
u32
locals
u32
(parameters
u32
0memory_pages�
u16
(table_size
u32
4br_table_size
u32
,subject_len
u32
(call_depth
u32
,payload_len
u32
 code_len
u32
Pdata_segments_amount
u32
@type_section_len
u32�	,pallet_gear scheduleHInstructionWeightsTa

version
u32
 i64const
u32
i64load
u32
i32load
u32
 i64store
u32
 i32store
u32
select
u32
r#if
u32
br
u32
br_if
u32
 br_table
u32
Hbr_table_per_entry
u32
call
u32
4call_indirect
u32
\call_indirect_per_param
u32
8call_per_local
u32
$local_get
u32
$local_set
u32
$local_tee
u32
(global_get
u32
(global_set
u32
8memory_current
u32
i64clz
u32
i32clz
u32
i64ctz
u32
i32ctz
u32
$i64popcnt
u32
$i32popcnt
u32
i64eqz
u32
i32eqz
u32
,i32extend8s
u32
0i32extend16s
u32
,i64extend8s
u32
0i64extend16s
u32
0i64extend32s
u32
4i64extendsi32
u32
4i64extendui32
u32
(i32wrapi64
u32
i64eq
u32
i32eq
u32
i64ne
u32
i32ne
u32
i64lts
u32
i32lts
u32
i64ltu
u32
i32ltu
u32
i64gts
u32
i32gts
u32
i64gtu
u32
i32gtu
u32
i64les
u32
i32les
u32
i64leu
u32
i32leu
u32
i64ges
u32
i32ges
u32
i64geu
u32
i32geu
u32
i64add
u32
i32add
u32
i64sub
u32
i32sub
u32
i64mul
u32
i32mul
u32
i64divs
u32
i32divs
u32
i64divu
u32
i32divu
u32
i64rems
u32
i32rems
u32
i64remu
u32
i32remu
u32
i64and
u32
i32and
u32
i64or
u32
i32or
u32
i64xor
u32
i32xor
u32
i64shl
u32
i32shl
u32
i64shrs
u32
i32shrs
u32
i64shru
u32
i32shru
u32
i64rotl
u32
i32rotl
u32
i64rotr
u32
i32rotr
u32�	,pallet_gear schedule8SyscallWeightsT

alloc(
Weight
free(
Weight
(free_range(
Weight
Lfree_range_per_page(
Weight
8gr_reserve_gas(
Weight
@gr_unreserve_gas(
Weight
Tgr_system_reserve_gas(
Weight
@gr_gas_available(
Weight
4gr_message_id(
Weight
4gr_program_id(
Weight
$gr_source(
Weight
 gr_value(
Weight
Hgr_value_available(
Weight
gr_size(
Weight
gr_read(
Weight
@gr_read_per_byte(
Weight
,gr_env_vars(
Weight
<gr_block_height(
Weight
Hgr_block_timestamp(
Weight
$gr_random(
Weight
@gr_reply_deposit(
Weight
gr_send(
Weight
@gr_send_per_byte(
Weight
0gr_send_wgas(
Weight
Tgr_send_wgas_per_byte(
Weight
0gr_send_init(
Weight
0gr_send_push(
Weight
Tgr_send_push_per_byte(
Weight
8gr_send_commit(
Weight
Lgr_send_commit_wgas(
Weight
Lgr_reservation_send(
Weight
pgr_reservation_send_per_byte(
Weight
hgr_reservation_send_commit(
Weight
<gr_reply_commit(
Weight
Pgr_reply_commit_wgas(
Weight
Pgr_reservation_reply(
Weight
tgr_reservation_reply_per_byte(
Weight
lgr_reservation_reply_commit(
Weight
4gr_reply_push(
Weight
 gr_reply(
Weight
Dgr_reply_per_byte(
Weight
4gr_reply_wgas(
Weight
Xgr_reply_wgas_per_byte(
Weight
Xgr_reply_push_per_byte(
Weight
,gr_reply_to(
Weight
8gr_signal_code(
Weight
8gr_signal_from(
Weight
8gr_reply_input(
Weight
Lgr_reply_input_wgas(
Weight
Lgr_reply_push_input(
Weight
pgr_reply_push_input_per_byte(
Weight
4gr_send_input(
Weight
Hgr_send_input_wgas(
Weight
Hgr_send_push_input(
Weight
lgr_send_push_input_per_byte(
Weight
 gr_debug(
Weight
Dgr_debug_per_byte(
Weight
4gr_reply_code(
Weight
gr_exit(
Weight
 gr_leave(
Weight
gr_wait(
Weight
,gr_wait_for(
Weight
4gr_wait_up_to(
Weight
gr_wake(
Weight
Dgr_create_program(
Weight
�gr_create_program_payload_per_byte(
Weight
|gr_create_program_salt_per_byte(
Weight
Xgr_create_program_wgas(
Weight
�gr_create_program_wgas_payload_per_byte(
Weight
�gr_create_program_wgas_salt_per_byte(
Weight�	,pallet_gear schedule4MemoryWeightsT,
Xlazy_pages_signal_read(
Weight
\lazy_pages_signal_write(
Weight
�lazy_pages_signal_write_after_read(
Weight
dlazy_pages_host_func_read(
Weight
hlazy_pages_host_func_write(
Weight
�lazy_pages_host_func_write_after_read(
Weight
8load_page_data(
Weight
@upload_page_data(
Weight
 mem_grow(
Weight
Dmem_grow_per_page(
Weight
`parachain_read_heuristic(
Weight�	,pallet_gear schedule,RentWeightsT
 waitlist(
Weight
8dispatch_stash(
Weight
,reservation(
Weight
mailbox(
Weight
Dmailbox_threshold(
Weight�	,pallet_gear schedule$DbWeightsT
read(
Weight
4read_per_byte(
Weight
write(
Weight
8write_per_byte(
Weight�	,pallet_gear schedule,TaskWeightsT 
Xremove_gas_reservation(
Weight
psend_user_message_to_mailbox(
Weight
Dsend_user_message(
Weight
4send_dispatch(
Weight
0wake_message(
Weight
Pwake_message_no_wake(
Weight
Premove_from_waitlist(
Weight
Lremove_from_mailbox(
Weight

,pallet_gear schedulePInstantiationWeightsT
Tcode_section_per_byte(
Weight
Tdata_section_per_byte(
Weight
\global_section_per_byte(
Weight
Xtable_section_per_byte(
Weight
`element_section_per_byte(
Weight
Ttype_section_per_byte(
Weight
,pallet_gear scheduleXInstrumentationWeightsT
base(
Weight
 per_byte(
Weight	
$gear_corepercentPercent
u32
,pallet_gearpalletErrorT
@<MessageNotFound�Message wasn't found in the mailbox.LInsufficientBalance
�Not enough balance to execute an action.�
Usually occurs when the gas_limit specified is such that the origin account can't afford the message.<GasLimitTooHighLGas limit too high.q
Occurs when an extrinsic's declared `gas_limit` is greater than a block's maximum gas limit.PProgramAlreadyExists\Program already exists.Q
Occurs if a program with some specific program id already exists in program storage.<InactiveProgramXProgram is terminated.)
Program init failed, so such message destination is no longer unavailable.4NoMessageTreexMessage gas tree is not found.i
When a message claimed from the mailbox has a corrupted or non-extant gas tree associated.DCodeAlreadyExistsPCode already exists.=
Occurs when trying to save to storage a program code that has been saved there.<CodeDoesntExistPCode does not exist.)
Occurs when trying to get a program code from storage, that doesn't exist.0CodeTooLargee
The code supplied to `upload_code` or `upload_program` exceeds the limit specified in theDcurrent schedule.dProgramConstructionFailed	lFailed to create a program.xMessageQueueProcessingDisabled
�Message queue processing is disabled.lResumePeriodLessThanMinimal�Block count doesn't cover MinimalResumePeriod.<ProgramNotFound�Program with the specified id is not found.TGearRunAlreadyInBlock
�Gear::run() already included in current block.LProgramRentDisabled�The program rent logic is disabled.4ActiveProgramHProgram is active.�The `Error` enum of this pallet.
 BTreeSetT
�

lpallet_gear_staking_rewardspalletErrorT
LFailureToRefillPool�Pool not replenished due to error.dFailureToWithdrawFromPool
�Failure to withdraw funds from the rewards pool.�Error for the staking rewards pallet.
i
Lpallet_gear_voucher internal,VoucherInfo$AccountId
,BlockNumber

owner
$AccountId
 programs]
dOption<BTreeSet<ActorId>>
8code_uploading 
bool
expiry
,BlockNumber!
Lpallet_gear_voucherpalletErrorT
,$BadOrigin�The origin is not eligible to execute call.<BalanceTransfer
�Error trying transfer balance to/from voucher account.`InappropriateDestination�Destination program is not in whitelisted set for voucher.DInexistentVoucher
Voucher with given identifier doesn't exist for given spender id.8IrrevocableYet�Voucher still valid and couldn't be revoked.`MaxProgramsLimitExceeded�Try to whitelist more programs than allowed.HUnknownDestination�Failed to query destination of the prepaid call.8VoucherExpired�Voucher has expired and couldn't be used.LDurationOutOfBounds

Voucher issue/prolongation duration out of [min; max] constants.PCodeUploadingEnabled	
Voucher update function tries to cut voucher ability of code upload.TCodeUploadingDisabled
�Voucher is disabled for code uploading, but requested.�The `Error` enum of this pallet.%
@pallet_gear_bankpallet,BankAccountBalance

gas
Balance
value
Balance)
@pallet_gear_bankpalletErrorT
LInsufficientBalancehInsufficient user balance.XInsufficientGasBalance
�Insufficient user's bank account gas balance.`InsufficientValueBalance�Insufficient user's bank account gas balance.\InsufficientBankBalance�Insufficient bank account balance.�**Must be unreachable in Gear main protocol.**LInsufficientDeposit�Deposit of funds that will not keep bank account alive.�**Must be unreachable in Gear main protocol.** Overflow|Overflow during funds transfer.�**Must be unreachable in Gear main protocol.**�The `Error` enum of this pallet.-
Xpallet_gear_eth_bridge internal$QueueInfo
Empty NonEmpty
0highest_root4
H256
Dlatest_nonce_usedy
U256
1
Xpallet_gear_eth_bridgepalletErrorT
TBridgeCleanupRequired�The error happens when bridge queue is temporarily overflowedtand needs cleanup to proceed.dBridgeIsNotYetInitialized
�The error happens when bridge got called before�proper initialization after deployment.8BridgeIsPaused�The error happens when bridge got called when paused.XMaxPayloadSizeExceeded	
The error happens when bridging message sent with too big payload.`InsufficientValueApplied	
The error happens when bridging thorough builtin and message value�is inapplicable to operation or insufficient.DInvalidQueueReset�The error happens when attempted to reset overflowed queue, but�queue isn't overflowed or incorrect finality proof provided.|Pallet Gear Eth Bridge's error.5
Tpallet_grandpa_signerpallet8SigningRequestT
id
$RequestId
payload9

�BoundedVec<u8, T::MaxPayloadLength>
set_id0
SetId
(created_at
DBlockNumberFor<T>
(expires_at
dOption<BlockNumberFor<T>>9
Lbounded_collections,bounded_vec(BoundedVecT
S8
Vec<T>=
A
Tpallet_grandpa_signerpalletErrorT
(<TooManyRequestsHRequestIdExhausted
8UnknownRequest8RequestExpiredDAuthorityNotInSet4AlreadySigned0BadSignature8UnsupportedSet8PayloadTooLongPMaxSignaturesReached	�The `Error` enum of this pallet.E
(I
M
Q
U
Y
]
e
i
m
y
I
lpallet_gear_staking_rewards$extension@StakingBlackListTM
0frame_system(extensionsTcheck_non_zero_senderHCheckNonZeroSenderTQ
0frame_system(extensionsHcheck_spec_version@CheckSpecVersionTU
0frame_system(extensions@check_tx_version8CheckTxVersionTY
0frame_system(extensions4check_genesis0CheckGenesisT]
0frame_system(extensions<check_mortality8CheckMortalityTa

Eraa
(sp_runtimegenericeraEra

 ImmortalMortal1
Mortal2Mortal3Mortal4Mortal5Mortal6Mortal7Mortal8Mortal9	 Mortal10
 Mortal11 Mortal12 Mortal13
 Mortal14 Mortal15 Mortal16 Mortal17 Mortal18 Mortal19 Mortal20 Mortal21 Mortal22 Mortal23 Mortal24 Mortal25 Mortal26 Mortal27 Mortal28 Mortal29 Mortal30 Mortal31 Mortal32  Mortal33! Mortal34" Mortal35# Mortal36$ Mortal37% Mortal38& Mortal39' Mortal40( Mortal41) Mortal42* Mortal43+ Mortal44, Mortal45- Mortal46. Mortal47/ Mortal480 Mortal491 Mortal502 Mortal513 Mortal524 Mortal535 Mortal546 Mortal557 Mortal568 Mortal579 Mortal58: Mortal59; Mortal60< Mortal61= Mortal62> Mortal63? Mortal64@ Mortal65A Mortal66B Mortal67C Mortal68D Mortal69E Mortal70F Mortal71G Mortal72H Mortal73I Mortal74J Mortal75K Mortal76L Mortal77M Mortal78N Mortal79O Mortal80P Mortal81Q Mortal82R Mortal83S Mortal84T Mortal85U Mortal86V Mortal87W Mortal88X Mortal89Y Mortal90Z Mortal91[ Mortal92\ Mortal93] Mortal94^ Mortal95_ Mortal96` Mortal97a Mortal98b Mortal99c$Mortal100d$Mortal101e$Mortal102f$Mortal103g$Mortal104h$Mortal105i$Mortal106j$Mortal107k$Mortal108l$Mortal109m$Mortal110n$Mortal111o$Mortal112p$Mortal113q$Mortal114r$Mortal115s$Mortal116t$Mortal117u$Mortal118v$Mortal119w$Mortal120x$Mortal121y$Mortal122z$Mortal123{$Mortal124|$Mortal125}$Mortal126~$Mortal127$Mortal128�$Mortal129�$Mortal130�$Mortal131�$Mortal132�$Mortal133�$Mortal134�$Mortal135�$Mortal136�$Mortal137�$Mortal138�$Mortal139�$Mortal140�$Mortal141�$Mortal142�$Mortal143�$Mortal144�$Mortal145�$Mortal146�$Mortal147�$Mortal148�$Mortal149�$Mortal150�$Mortal151�$Mortal152�$Mortal153�$Mortal154�$Mortal155�$Mortal156�$Mortal157�$Mortal158�$Mortal159�$Mortal160�$Mortal161�$Mortal162�$Mortal163�$Mortal164�$Mortal165�$Mortal166�$Mortal167�$Mortal168�$Mortal169�$Mortal170�$Mortal171�$Mortal172�$Mortal173�$Mortal174�$Mortal175�$Mortal176�$Mortal177�$Mortal178�$Mortal179�$Mortal180�$Mortal181�$Mortal182�$Mortal183�$Mortal184�$Mortal185�$Mortal186�$Mortal187�$Mortal188�$Mortal189�$Mortal190�$Mortal191�$Mortal192�$Mortal193�$Mortal194�$Mortal195�$Mortal196�$Mortal197�$Mortal198�$Mortal199�$Mortal200�$Mortal201�$Mortal202�$Mortal203�$Mortal204�$Mortal205�$Mortal206�$Mortal207�$Mortal208�$Mortal209�$Mortal210�$Mortal211�$Mortal212�$Mortal213�$Mortal214�$Mortal215�$Mortal216�$Mortal217�$Mortal218�$Mortal219�$Mortal220�$Mortal221�$Mortal222�$Mortal223�$Mortal224�$Mortal225�$Mortal226�$Mortal227�$Mortal228�$Mortal229�$Mortal230�$Mortal231�$Mortal232�$Mortal233�$Mortal234�$Mortal235�$Mortal236�$Mortal237�$Mortal238�$Mortal239�$Mortal240�$Mortal241�$Mortal242�$Mortal243�$Mortal244�$Mortal245�$Mortal246�$Mortal247�$Mortal248�$Mortal249�$Mortal250�$Mortal251�$Mortal252�$Mortal253�$Mortal254�$Mortal255�e
0vara_runtime@CustomCheckNonceT)

 T::Noncei
0frame_system(extensions0check_weight,CheckWeightTm
Lpallet_gear_paymentxCustomChargeTransactionPaymentT
q
u

lChargeTransactionPayment<T>q
0vara_runtimeRuntimeu
hpallet_transaction_payment`ChargeTransactionPaymentT�
0BalanceOf<T>y
tframe_metadata_hash_extensionDCheckMetadataHashT
mode}

Mode}
tframe_metadata_hash_extensionMode
 DisabledEnabled
�
Dsp_consensus_babeDBabeConfiguration
4slot_duration0
u64
0epoch_length0
u64
c=

((u64, u64)
,authorities�
�Vec<(AuthorityId, BabeAuthorityWeight)>
(randomness
(Randomness
4allowed_slotsA

0AllowedSlots�
Dsp_consensus_babeEpoch
,epoch_index0
u64
(start_slot1

Slot
 duration0
u64
,authorities�
�Vec<(AuthorityId, BabeAuthorityWeight)>
(randomness
(Randomness
config�
XBabeEpochConfiguration�
OptionT
�

NoneSome�

�
Dsp_consensus_babe\OpaqueKeyOwnershipProof8
Vec<u8>�
OptionT
�
NoneSome�
�
hpallet_transaction_paymenttypesLRuntimeDispatchInfoBalance
Weight
(
weight(
Weight
class`
4DispatchClass
,partial_fee
Balance�
hpallet_transaction_paymenttypes(FeeDetailsBalance

4inclusion_fee�

tOption<InclusionFee<Balance>>
tip
Balance�
OptionT
�

NoneSome�

�
hpallet_transaction_paymenttypes0InclusionFeeBalance

 base_fee
Balance
len_fee
Balance
Ladjusted_weight_fee
Balance�
lpallet_gear_staking_rewards4InflationInfo
$inflationi
,Perquintill
roii
,Perquintill�
OptionT
�

NoneSome�

�
�pallet_gear_eth_bridge_primitivesProof
root4
H256
proof=
$Vec<H256>
@number_of_leaves0
u64
(leaf_index0
u64
leaf4
H256�
ResultT
�E
�
Ok�Err�
�
OptionT
�
NoneSome�
�
OptionT
8
NoneSome8
�
��
(sp_runtimegenericblockBlockHeader
%
$Extrinsic
�

header%

Header
(extrinsics�

8Vec<Extrinsic>�
(sp_runtimegenericLunchecked_extrinsicHUncheckedExtrinsicAddress
u
Call

$Signature
�Extra
E
8�
�
�
(sp_runtimeXExtrinsicInclusionMode
4AllExtrinsics4OnlyInherents
�
sp_core8OpaqueMetadata8
Vec<u8>�
OptionT
�

NoneSome�

�
ResultT
�E
�

Ok�Err�

�
(sp_runtimePtransaction_validity`TransactionValidityError
Invalid�

HInvalidTransactionUnknown�

HUnknownTransaction
�
(sp_runtimePtransaction_validityHInvalidTransaction
,CallPayment
FutureStale BadProofDAncientBirthBlockDExhaustsResourcesCustom
u80BadMandatoryLMandatoryValidation	$BadSigner
�
(sp_runtimePtransaction_validityHUnknownTransaction
0CannotLookupLNoUnsignedValidator
Custom
u8�
0sp_inherents0InherentData
data�

�BTreeMap<InherentIdentifier, Vec<u8>>�
 BTreeMapK
qV
8�
�
�
�
q8�
0sp_inherentsPCheckInherentsResult
okay 
bool
,fatal_error 
bool
errors�

0InherentData�
(sp_runtimePtransaction_validityDTransactionSource
InBlockLocal
 External
ResultT
E
�

OkErr�

(sp_runtimePtransaction_validity@ValidTransaction
 priority0
LTransactionPriority
 requires

LVec<TransactionTag>
 provides

LVec<TransactionTag>
$longevity0
PTransactionLongevity
$propagate 
bool	OptionT


NoneSome


8q(sp_runtime,OpaqueValue8
Vec<u8>OptionT

NoneSome
ResultT
!E
8
Ok!Err8
!$gear_corerpc$ReplyInfo
payload8
Vec<u8>
value
u128
code	
$ReplyCode%,pallet_gearmanager(HandleKind
Init8
Vec<u8>(InitByHashA
CodeId
HandleE
ActorIdReplyI
$MessageId	
$ReplyCodeSignalI
$MessageId�	
(SignalCode)ResultT
-E
8
Ok-Err8
-$gear_corerpcGasInfo
$min_limit0
u64
 reserved0
u64
burned0
u64
<may_be_returned0
u64
waited 
bool1ResultT
8E
8
Ok8Err8
5ResultT
4E
8
Ok4Err8
90vara_runtime0RuntimeError
�System�
pframe_system::Error<Runtime>Babe

lpallet_babe::Error<Runtime>Grandpa
xpallet_grandpa::Error<Runtime> BalancesY
|pallet_balances::Error<Runtime>Sessionu
xpallet_session::Error<Runtime>Utilityy
xpallet_utility::Error<Runtime>Vesting�
xpallet_vesting::Error<Runtime>
 BagsList�
�pallet_bags_list::Error<Runtime, pallet_bags_list::Instance1> ImOnline�
�pallet_im_online::Error<Runtime>Staking�
xpallet_staking::Error<Runtime>
 Treasury
|pallet_treasury::Error<Runtime>@ConvictionVotingQ
�pallet_conviction_voting::Error<Runtime>$Referenda�
�pallet_referenda::Error<Runtime>PFellowshipCollective�
9
pallet_ranked_collective::Error<Runtime, pallet_ranked_collective::
Instance1>LFellowshipReferenda�
�pallet_referenda::Error<Runtime, pallet_referenda::Instance2>$Whitelist�
�pallet_whitelist::Error<Runtime>$Scheduler�
�pallet_scheduler::Error<Runtime> Preimage�
|pallet_preimage::Error<Runtime> Identity5
|pallet_identity::Error<Runtime>ProxyY
ppallet_proxy::Error<Runtime> Multisigi
|pallet_multisig::Error<Runtime>hElectionProviderMultiPhase�
�pallet_election_provider_multi_phase::Error<Runtime> Bounties�
|pallet_bounties::Error<Runtime>4ChildBounties�
�pallet_child_bounties::Error<Runtime><NominationPools�
�pallet_nomination_pools::Error<Runtime>Sudo
	
lpallet_sudo::Error<Runtime>c,GearProgramm	
�pallet_gear_program::Error<Runtime>d4GearMessenger�	
�pallet_gear_messenger::Error<Runtime>e4GearScheduler�	
�pallet_gear_scheduler::Error<Runtime>fGearGas�	
|pallet_gear_gas::Error<Runtime>gGear

lpallet_gear::Error<Runtime>h8StakingRewards

�pallet_gear_staking_rewards::Error<Runtime>j,GearVoucher!

�pallet_gear_voucher::Error<Runtime>k GearBank)

�pallet_gear_bank::Error<Runtime>l4GearEthBridge1

�pallet_gear_eth_bridge::Error<Runtime>n4GrandpaSignerA

�pallet_grandpa_signer::Error<Runtime>o�System
SystemHAccount

A
�� The full account information for a particular account ID.8ExtrinsicCount� Total extrinsics count for the current block.@InherentsApplied
 � Whether all inherents have been applied.,BlockWeight
$� The current weight for the block.@AllExtrinsicsLenA
 Total length (in bytes) for all extrinsics put together, for the current block.$BlockHash

4�� Map of block numbers to block hashes.4ExtrinsicData

8=
 Extrinsics data for the current block (maps an extrinsic's index to its data).Number
	
 The current block number being processed. Set by `execute_block`.(ParentHash
4�p Hash of the previous block.Digest
<� Digest of the current block, also part of the block header.Events
L� Events deposited for the current block.
 NOTE: The item is unbound and should therefore never be read on chain.� It could otherwise inflate the PoV size of a block.-
 Events have a large in-memory size. Box the events to not go out-of-memory� just in case someone still reads them from within the runtime.(EventCount
� The number of events in the `Events<T>` list.,EventTopics

4�(%
 Mapping between a topic (represented by T::Hash) and a vector of indexes� of events in the `<Events<T>>` list.Q
 All topic vectors have deterministic storage locations depending on the topic. ThisE
 allows light-clients to leverage the changes trie storage tracking mechanism and� in case of changes fetch the list of events of interest.Y
 The value has the type `(BlockNumberFor<T>, EventIndex)` because if we used only justM
 the `EventIndex` then in case if the topic has the same contents on the next block

 no notification will be triggered thus the event might be lost.HLastRuntimeUpgrade�U
 Stores the `spec_version` and `spec_name` of when the last runtime upgrade happened.TUpgradedToU32RefCount
 M
 True if we have upgraded so that `type RefCount` is `u32`. False (default) if not.`UpgradedToTripleRefCount
 ]
 True if we have upgraded so that AccountInfo contains three types of `RefCount`. FalseH (default) if not.8ExecutionPhase�� The execution phase of the block.DAuthorizedUpgrade�� `Some` if a code upgrade has been authorized.
	

X0BlockWeights��
bMl�����������BG�
0ƣ23�Q���Q8
D)5:@
BG�
0����Q���Q�
�����������
�{����������BG�� Block & extrinsics weights: base values and limits.,BlockLength�0(PP� The maximum length of a block (in bytes).8BlockHashCount`	U
 Maximum number of block number to block hash mappings to keep (oldest pruned first). DbWeight�@@x}
��	
 The weight of runtime database operations the runtime can invoke.Version�A0vara-testnet0vara-testnet
�*
L��%�#�hz�J��
��իRpY��
b��
�X��{�p
)�3GoA�
�W����
��C�t��
��w��G��
�j�h�`�7��|���@�:�
���Ҽ���Џ��'��?EL�<r)�
�Ŭ�^������O[�?
7ȻP�����Ȁ7�b#

� Get the chain's in-code version.(SS58Prefix��� The designated SS58 prefix of this chain.9
 This replaces the "ss58Format" property declared in the chain spec. Reason is1
 that the runtime should know about the prefix in order to make use of it asp an identifier of the chain.
�$Timestamp
$TimestampNow
0 � The current time for the current block.$DidUpdate
 � Whether the timestamp has been updated in this block.U
 This value is updated to `true` upon successful submission of a timestamp by a node.E
 It is then checked at the end of each block execution in the `on_finalize` hook.

4MinimumPeriod0 �� The minimum period between blocks.M
 Be aware that this is different to the *expected* period that the block productionI
 apparatus provides. Your chosen consensus system will generally work with this toa
 determine a sensible block time. For example, in the Aura pallet it will be double thisp period on default settings.
(Authorship
(AuthorshipAuthord Author of current block.Babe
BabeD(EpochIndex
0 T Current epoch index.,Authorities
�l Current epoch authorities.,GenesisSlot
1
 � The slot at which the first epoch actually started. This is 0� until the first block of the chain.,CurrentSlot
1
 T Current slot number.(Randomness
�(� The epoch randomness for the *current* epoch., # Security
 This MUST NOT be used for gambling, as it can be influenced by a� malicious validator in the short term. It MAY be used in many
 cryptographic protocols, however, so long as one remembers that this
 (like everything else on-chain) it is public. For example, it can be
 used where a number is needed that cannot have been chosen by an

 adversary, for purposes such as public-coin zero-knowledge proofs.`PendingEpochConfigChange9
a
 Pending epoch configuration change that will be applied when the next epoch is enacted.8NextRandomness
�\ Next epoch randomness.<NextAuthorities
�` Next epoch authorities.0SegmentIndex
$| Randomness under construction.� We make a trade-off between storage accesses and list length.

 We store the under-construction randomness in segments of up to� `UNDER_CONSTRUCTION_SEGMENT_LENGTH`.� Once a segment reaches this length, we begin the next one.	
 We reset all segments and return to `0` at the beginning of every epoch.DUnderConstruction

�
 TWOX-NOTE: `SegmentIndex` is an increasing integer, so this is okay.,Initialized�

 Temporary value (cleared at block finalization) which is `Some`
 if per-block initialization has already been called for current block.LAuthorVrfRandomness
�
 This field should always be populated during block processing unless
 secondary plain slots are enabled (which don't contain a VRF output).I
 It is set in `on_finalize`, before it will contain the value from the last block.(EpochStart
5 ]
 The block numbers when the last and current epoch have started, respectively `N-1` and `N`.I
 NOTE: We track this is in order to annotate the block number when a given pool ofY
 entropy was fixed (i.e. it was known to chain observers). Since epochs are defined inY
 slots, which may be skipped, the block numbers may not line up with the slot numbers. Lateness
� How late the current block is compared to its parent.
 This entry is populated as part of block execution and is cleaned up
 on block finalization. Querying this storage entry outside of block� execution context should always yield zero.,EpochConfig�a
 The configuration for the current epoch. Should never be `None` as it is initialized in$ genesis.<NextEpochConfig�-
 The configuration for the next epoch, `None` if the config will not change� (you can fallback to `EpochConfig` instead in that case).4SkippedEpochs
� )
 A list of the last 100 skipped epochs and the corresponding session indexp when the epoch was skipped.1
 This is only used for validating equivocation proofs. An equivocation proof5
 must contains a key-ownership proof for a given session, therefore we need a9
 way to tie together sessions and epoch indices, i.e. we need to validate that)
 a validator was the owner of a given key on a given session, and what the� active epoch index was during that session.

4EpochDuration0 `	� The amount of time, in slots, that each epoch should last.
 NOTE: Currently it is not possible to change the epoch duration after!
 the chain has started. Attempting to do so will brick block production.DExpectedBlockTime0 �
 The expected average block time at which BABE should be creating
 blocks. Since BABE is probabilistic it is not trivial to figure out
 what the expected average block time should be based on the slot	
 duration and the security parameter `c` (where `1 - c` represents� the probability of a slot being empty).8MaxAuthorities��
� Max number of authorities allowed4MaxNominators� The maximum number of nominators for each validator.

Grandpa
GrandpaState
� State of the current authority set.4PendingChange	� Pending change: (signaled at, scheduled change).(NextForced� next block number where we can force a change.Stalled5� `true` if we are currently stalled.0CurrentSetId
0 ]
 The number of changes (both in terms of keys and underlying economic responsibilities)� in the "set" of Grandpa validators from genesis.0SetIdSession
0(Y
 A mapping from grandpa set ID to the index of the *most recent* session for which itsh members were responsible.E
 This is only used for validating equivocation proofs. An equivocation proof mustM
 contains a key-ownership proof for a given session, therefore we need a way to tieE
 together sessions and GRANDPA set ids, i.e. we need to validate that a validatorA
 was the owner of a given key on a given session, and what the active set ID wasT during that session.� TWOX-NOTE: `SetId` is not under user control.,Authorities

� The current list of authorities.
E

|8MaxAuthorities��
\ Max Authorities in use4MaxNominators� The maximum number of nominators for each validator.XMaxSetIdSessionEntries0 T9
 The maximum number of entries to keep in the set id to session index mapping.1
 Since the `SetIdSession` map is only used for validating equivocations this)
 value should relate to the bonding duration of whatever staking system is5
 being used (if any). If equivocation handling is not enabled then this value4 can be zero.
 Balances
 Balances4TotalIssuance
@� The total units issued in the system.@InactiveIssuance
@	
 The total units of outstanding deactivated balance in the system.Account



�`	
 The Balances pallet example of storing the balance of an account.( # Example4 ```nocompile�  impl pallet_balances::Config for Runtime {    type AccountStore = StorageMapShim<Self::Account<Runtime>, frame_system::Provider<Runtime>, AccountId, Self::AccountData<Balance>>  } ```
 You can also store the balance of an account in the `System` pallet.( # Example4 ```nocompile�  impl pallet_balances::Config for Runtime {t   type AccountStore = System  } ```Q
 But this comes with tradeoffs, storing account balances in the system pallet storesm
 `frame_system` data alongside the account data contrary to storing account balances in the)
 `Balances` pallet, which uses a `StorageMap` to store balances data only.A
 NOTE: This is only used in the case that this pallet is used to store balances.Locks

� Any liquidity locks on some account balances.%
 NOTE: Should only be accessed when setting, changing and freeing a lock.�
 Use of locks is deprecated in favour of freezes. See `https://github.com/paritytech/substrate/pull/12951/` Reserves

%� Named reserves on some account balances.�
 Use of reserves is deprecated in favour of holds. See `https://github.com/paritytech/substrate/pull/12951/`Holds

1l Holds on account balances.Freezes

E� Freeze locks on account balances.
q

�HExistentialDeposit@��� A
 The minimum amount required to keep an account open. MUST BE GREATER THAN ZERO!Y
 If you *really* need it to be zero, you can enable the feature `insecure_zero_ed` fora
 this pallet. However, you do so at your own risk: this will open up a major DoS vector.Y
 In case you have multiple sources of provider references, you may also get unexpected� behaviour if you set this to zero.� Bottom line: Do yourself a favour and make it at least one! MaxLocks2� The maximum number of locks that should exist on an account.� Not strictly enforced, but used for weight estimation.�
 Use of locks is deprecated in favour of freezes. See `https://github.com/paritytech/substrate/pull/12951/`,MaxReserves2

 The maximum number of named reserves that can exist on an account.�
 Use of reserves is deprecated in favour of holds. See `https://github.com/paritytech/substrate/pull/12951/`(MaxFreezes
a
 The maximum number of individual freeze locks that can exist on an account at any time.
YHTransactionPayment
HTransactionPaymentDNextFeeMultiplier
]@d����
8StorageVersion
a
�`OperationalFeeMultiplierTY
 A fee multiplier for `Operational` extrinsics to compute "virtual tip" to boost their, `priority`Q
 This value is multiplied by the `final_fee` to obtain a "virtual tip" that is later� added to a tip component in regular `priority` calculations.M
 It means that a `Normal` transaction can front-run a similarly-sized `Operational`A
 extrinsic (with no tip), by including a tip value greater than the virtual tip.< ```rust,ignore@ // For `Normal`� let priority = priority_calc(tip);T // For `Operational`
 let virtual_tip = (inclusion_fee + tip) * OperationalFeeMultiplier;� let priority = priority_calc(tip + virtual_tip); ```Q
 Note that since we use `final_fee` the multiplier applies also to the regular `tip`]
 sent with the transaction. So, not only does the transaction get a priority bump baseda
 on the `inclusion_fee`, but we also amplify the impact of tips applied to `Operational`8 transactions.Session
Session(Validators
�
| The current set of validators.0CurrentIndex
x Current index of the session.4QueuedChanged
 9
 True if the underlying economic identities or weighting behind the validators� has changed in the queued validator set.(QueuedKeys
e=
 The queued keys for the next session. When the next session begins, these keys� will be used to determine the validator's session keys.HDisabledValidators
�
� Indices of disabled validators.=
 The vec is always kept sorted so that we can find whether a given validator is=
 disabled using binary search. It gets cleared when `on_session_ending` returnsd a new set of identities. NextKeys
�
� The next session keys for a validator. KeyOwner
m	
 The owner of a key. The key is the `KeyTypeId` + the encoded key.
�

�
uUtility
�

�Lbatched_calls_limit�*� The limit on the number of batched calls.
yHAuthorityDiscovery
HAuthorityDiscoveryKeys
}� Keys of the current authority set. NextKeys
}� Keys of the next authority set.	Vesting
VestingVesting
�� Information regarding the vesting of a given account.8StorageVersion
�| Storage version of the pallet.1
 New networks start with latest version, as determined by the genesis build.
�

�DMinVestedTransfer@`��l�� The minimum amount transferred to call `vested_transfer`.LMaxVestingSchedules
�
 BagsList
 BagsList$ListNodes
�� A single node, within some bag.
 Nodes store links forward and back within their respective bags.LCounterForListNodes
�Counter for the related counted storage map ListBags
0�d A bag stored in storage.
 Stores a `Bag` struct, which stores head and tail pointers to itself.
�

�4BagThresholds�	!R��m'v{�,���Ǜ�N��_> ��/��~1�/�
Ď7
-��]
f��
��ٸ
���
a��+"�o(Q���8�W�r<g���~X����ō*z
U*&XC�O$���l�����	f�f�
���O�e�
�+p��`�k��Ȏ�����s�"���
6�"!5�('�C4�+�q�Z1]��h7Ba�4>�!��E�JgNV�X��bwL6�n?��|sPӋ|����\�j;����Cs��Ea�]�
���
�
�K:
���`
��"�
�r���
�E<G�
L�0X��Gu-��x���"�lz��E���x�Ebm�U��O��}����4�$���A�|���������	-H�[){k�*d�
�p/[�̇���/;˺Ȳ[&�l%��d-��T%|W"��/#i���'��#!Y,(����1ʡ�C�7gˆ�>pK2sF�)?mO�7��X��v�c��"��o@K<�}=���
��k-[��B�DZ�<�ʖ�|�l��������a{j
b_�=
�
��c
�ho��
ҝ�j��
�����
���;s5bI)��z����Dž�� <�A@��Q�o��OZ#l�;����i���j�A|#{�w�} ��ܮ+��g�6W��	`p�1�(j'i�m�讜����xƔ�)�x�(���0���Ky3X���@:[Y�)x���l�g��~#�����'�襟�,��&�92���c8NG��M?�!��G�B4g�Oط��Y0���Ǐdde]���p���(��~ �>�K�(�����ؔ�
X�HO� �W��YuW�
���|����T���
�$����?
@�•g
���%� �
 �R����
�+B�
@b��k:`��`d��0�Cg���+�OC#'��8E�%��o��L�����v;�_�/��S̶w�@�C�
P����F��F ���C�����	��-
��BUQK]��w͕�0�Vrj��LϤe]��dpS���h{�
�TN䬴�iy�ٰ(�`����#D��)53(��᫘!-�Į�֪2��u���8ʆ>1�?TVO��Gΐ��|P�_!|\Z��*re3��q�-;,���Z3R��X�M��&��`���P��M���vQHK����������� The list of thresholds separating the various bags.I
 Ids are separated into unsorted bags according to their score. This specifies thea
 thresholds separating the bags. An id's bag is the largest bag for which the id's score� is less than or equal to its upper threshold.e
 When ids are iterated, higher bags are iterated completely before lower bags. This meansY
 that iteration is _semi-sorted_: ids of higher score tend to come before ids of lower-
 score, but peer ids within a particular bag are sorted in insertion order.h # Expressing the constantM
 This constant must be sorted in strictly increasing order. Duplicate items are not, permitted.A
 There is an implied upper limit of `Score::MAX`; that value does not need to be!
 specified within the bag. For any two threshold lists, if one ends with1
 `Score::MAX`, the other one does not, and they are otherwise equal, the two| lists will behave identically.8 # CalculationU
 It is recommended to generate the set of thresholds in a geometric series, such thatA
 there exists some constant ratio such that `threshold[k + 1] == (threshold[k] *� constant_ratio).max(threshold[k] + 1)` for all `k`.Y
 The helpers in the `/utils/frame/generate-bags` module can simplify this calculation., # ExamplesQ
 - If `BagThresholds::get().is_empty()`, then all ids are put into the same bag, and�   iteration is strictly in insertion order.a
 - If `BagThresholds::get().len() == 64`, and the thresholds are determined according to
   the procedure given above, then the constant ratio is equal to 2.e
 - If `BagThresholds::get().len() == 200`, and the thresholds are determined according toY
   the procedure given above, then the constant ratio is approximately equal to 1.248.a
 - If the threshold list begins `[1, 2, 3, ...]`, then an id with score 0 or 1 will fall�   into bag 0, an id with score 2 will fall into bag 1, etc.0 # Migrationa
 In the event that this list ever changes, a copy of the old bags list must be retained.]
 With that `List::migrate` can be called, which will perform the appropriate migration.
� ImOnline
 ImOnline8HeartbeatAfter
,
 The block number after which it's ok to send heartbeats in the current$ session.%
 At the beginning of each session we set this to a value that should fall5
 roughly in the middle of the session duration. The idea is to first wait for
 the validators to produce a block in the current session, so that the� heartbeat later on will not be necessary.9
 This value will only be used as a fallback if we fail to get a proper session-
 progress estimate from `NextSessionRotation`, as those estimates should be

 more accurate then the value we calculate for `HeartbeatAfter`.Keys
�� The current set of keys that may issue a heartbeat.HReceivedHeartbeats
5 5
 For each session index, we keep a mapping of `SessionIndex` and `AuthIndex`.8AuthoredBlocks

�
 For each session index, we keep a mapping of `ValidatorId<T>` to the� number of blocks authored by the given authority.
�

�@UnsignedPriority0 ��������� A configuration for base priority of unsigned transactions.
 This is exposed so that it can be tuned for particular runtime, when� multiple pallets send unsigned transactions.
�Staking
Staking�8ValidatorCount
� The ideal number of active validators.TMinimumValidatorCount
A
 Minimum number of staking participants before emergency conditions are imposed.4Invulnerables
�
Y
 Any validators that may never be slashed or forcibly kicked. It's a Vec since they'reM
 easy to initialize and the performance hit is minimal (we expect no more than four� invulnerables) and restricted to testnets.Bonded


 Map from all locked "stash" accounts to the controller account.� TWOX-NOTE: SAFE since `AccountId` is a secure hash.@MinNominatorBond
@!
 The minimum active bond to become and maintain the role of a nominator.@MinValidatorBond
@!
 The minimum active bond to become and maintain the role of a validator.HMinimumActiveStake
@
 The minimum active nominator stake of the last successful election.4MinCommission
�� The minimum amount of commission that validators can set.� If set to `0`, no limit exists.Ledger
�E
 Map from all (unlocked) "controller" accounts to the info regarding the staking.u
 Note: All the reads and mutations to this storage *MUST* be done through the methods exposed� by [`StakingLedger`] to ensure data and lock consistency.Payee
�� Where the reward payment should be made. Keyed by stash.� TWOX-NOTE: SAFE since `AccountId` is a secure hash.(Validators

�E
 The map from (wannabe) validator stash key to the preferences of that validator.� TWOX-NOTE: SAFE since `AccountId` is a secure hash.PCounterForValidators
�Counter for the related counted storage mapHMaxValidatorsCount1
 The maximum validator count before we stop allowing new validators to join.� When this value is not set, no limits are enforced.(Nominators
�Lu
 The map from nominator stash key to their nomination preferences, namely the validators thatX they wish to support.9
 Note that the keys of this storage map might become non-decodable in case the-
 account's [`NominationsQuota::MaxNominations`] configuration is decreased.� In this rare case, these nominatorse
 are still existent in storage, their key is correct and retrievable (i.e. `contains_key`q
 indicates that they exist), but their value cannot be decoded. Therefore, the non-decodablem
 nominators will effectively not-exist, until they re-submit their preferences such that it

 is within the bounds of the newly set `Config::MaxNominations`.a
 This implies that `::iter_keys().count()` and `::iter().count()` might return differentm
 values for this map. Moreover, the main `::count()` is aligned with the former, namely thel number of keys that exist.m
 Lastly, if any of the nominators become non-decodable, they can be chilled immediately via� [`Call::chill_other`] dispatchable by anyone.� TWOX-NOTE: SAFE since `AccountId` is a secure hash.PCounterForNominators
�Counter for the related counted storage map8VirtualStakers
�� Stakers whose funds are managed by other pallets.u
 This pallet does not apply any locks on them, therefore they are only virtually bonded. Theym
 are expected to be keyless accounts and hence should not be allowed to mutate their ledgerq
 directly via this pallet. Instead, these accounts are managed by other pallets and accessed)
 via low level apis. We keep track of them to do minimal integrity checks.`CounterForVirtualStakers
�Counter for the related counted storage mapHMaxNominatorsCount1
 The maximum nominator count before we stop allowing new validators to join.� When this value is not set, no limits are enforced.(CurrentEra\ The current era index.e
 This is the latest planned era, depending on how the Session pallet queues the validator� set, it might be active or not.$ActiveEra�� The active era information, it holds index and start.Y
 The active era is the era being currently rewarded. Validator set of this era must be� equal to [`SessionInterface::validators`].TErasStartSessionIndex
U
 The session index at which the era start for the last [`Config::HistoryDepth`] eras.a
 Note: This tracks the starting session (i.e. session index when era start being active)� for the eras in `[CurrentEra - HISTORY_DEPTH, CurrentEra]`.,ErasStakers

�� x Exposure of validator at era.a
 This is keyed first by the era index to allow bulk deletion and then the stash account.� Is it removed after [`Config::HistoryDepth`] eras.A
 If stakers hasn't been set or has been removed then empty exposure is returned.)
 Note: Deprecated since v14. Use `EraInfo` instead to work with exposures.LErasStakersOverview
��0� Summary of validator exposure at a given era.q
 This contains the total stake in support of the validator and their own stake. In addition,u
 it can also be used to get the number of nominators backing this validator and the number ofi
 exposure pages they are divided into. The page count is useful to determine the number of� pages of rewards that needs to be claimed.a
 This is keyed first by the era index to allow bulk deletion and then the stash account.� Should only be accessed through `EraInfo`.� Is it removed after [`Config::HistoryDepth`] eras.A
 If stakers hasn't been set or has been removed then empty overview is returned.HErasStakersClipped

��@� Clipped Exposure of validator at era.e
 Note: This is deprecated, should be used as read-only and will be removed in the future.1
 New `Exposure`s are stored in a paged manner in `ErasStakersPaged` instead.Y
 This is similar to [`ErasStakers`] but number of nominators exposed is reduced to the� `T::MaxExposurePageSize` biggest stakers.
 (Note: the field `total` and `own` of the exposure remains unchanged).� This is used to limit the i/o cost for the nominator payout.]
 This is keyed fist by the era index to allow bulk deletion and then the stash account.� It is removed after [`Config::HistoryDepth`] eras.A
 If stakers hasn't been set or has been removed then empty exposure is returned.)
 Note: Deprecated since v14. Use `EraInfo` instead to work with exposures.@ErasStakersPaged
��� Paginated exposure of a validator at given era.q
 This is keyed first by the era index to allow bulk deletion, then stash account and finally� the page. Should only be accessed through `EraInfo`.� This is cleared after [`Config::HistoryDepth`] eras.8ClaimedRewards

��
� History of claimed paged rewards by era and validator.i
 This is keyed by era and validator stash which maps to the set of page indexes which have8 been claimed.� It is removed after [`Config::HistoryDepth`] eras.HErasValidatorPrefs

��
 Similar to `ErasStakers`, this holds the preferences of validators.a
 This is keyed first by the era index to allow bulk deletion and then the stash account.� Is it removed after [`Config::HistoryDepth`] eras.LErasValidatorReward
-
 The total validator era payout for the last [`Config::HistoryDepth`] eras.!
 Eras that haven't finished yet or has been removed doesn't have reward.@ErasRewardPoints

�� Rewards for the last [`Config::HistoryDepth`] eras.%
 If reward hasn't been set or has been removed then 0 reward is returned.8ErasTotalStake

@
 The total amount staked for the last [`Config::HistoryDepth`] eras.
 If total hasn't been set or has been removed then 0 stake is returned. ForceEra
�T Mode of era forcing.@MaxStakedRewards�

 Maximum staked rewards, i.e. the percentage of the era inflation thatl is used for stake rewards.� See [Era payout](./index.html#era-payout).LSlashRewardFraction
�� The percentage of the slash that is distributed to reporters.� The rest of the slashed value is handled by the `Slash`.LCanceledSlashPayout
@
 The amount of currency given to reporters of a slash event which was� canceled by extraordinary circumstances (e.g. governance).@UnappliedSlashes

�� All unapplied slashes that are queued for later.(BondedEras
�%
 A mapping from still-bonded eras to the first session index of that era.� Must contains information for eras for the range:� `[active_era - bounding_duration; active_era]`LValidatorSlashInEra
��E
 All slashing events on validators, mapped by era to the highest slash proportionp and slash value of the era.LNominatorSlashInEra
�a
 All slashing events on nominators, mapped by era to the highest slash value of the era.4SlashingSpans
�� Slashing spans for stash accounts.$SpanSlash

���=
 Records information about the maximum slash of a stash within a slashing span,� as well as how much reward has been paid out.TCurrentPlannedSession
� The last planned session scheduled by the session pallet.q
 This is basically in sync with the call to [`pallet_session::SessionManager::new_session`].HDisabledValidators
�
u
 Indices of validators that have offended in the active era. The offenders are disabled for ai
 whole era. For this reason they are kept here - only staking pallet knows about eras. TheU
 implementor of [`DisablingStrategy`] defines if a validator should be disabled whichm
 implicitly means that the implementor also controls the max number of disabled validators.m
 The vec is always kept sorted so that we can find whether a given validator has previouslyx offended using binary search.8ChillThreshold�
Q
 The threshold for when users can start calling `chill_other` for other validators /Y
 nominators. The threshold is compared to the actual number of validators / nominators)
 (`CountFor*`) in the system compared to the configured max (`Max*Count`).
�

�0HistoryDepthTP� Number of eras to keep in history.� Following information is kept for eras in `[current_era -	
 HistoryDepth, current_era]`: `ErasStakers`, `ErasStakersClipped`,
 `ErasValidatorPrefs`, `ErasValidatorReward`, `ErasRewardPoints`,E
 `ErasTotalStake`, `ErasStartSessionIndex`, `ClaimedRewards`, `ErasStakersPaged`,\ `ErasStakersOverview`.� Must be more than the number of eras delayed by session.� I.e. active era must always be in history. I.e. `active_era >� current_era - history_depth` must be guaranteed.
 If migrating an existing pallet from storage value to config value,� this should be set to same value or greater as in storage.
 Note: `HistoryDepth` is used as the upper bound for the `BoundedVec`-
 item `StakingLedger.legacy_claimed_rewards`. Setting this value lower than� the existing value can lead to inconsistencies in the
 `StakingLedger` and will need to be handled properly in a migration.� The test `reducing_history_depth_abrupt` shows this effect.8SessionsPerErap Number of sessions per era.<BondingDuration� Number of eras that staked funds must remain bonded for.HSlashDeferDuration


 Number of eras that slashes are deferred by, after computation.

 This should be less than the bonding duration. Set to 0 if slashes
 should be applied immediately, without opportunity for intervention.LMaxExposurePageSize
,� The maximum size of each `T::ExposurePage`.)
 An `ExposurePage` is weakly bounded to a maximum of `MaxExposurePageSize`0 nominators.!
 For older non-paged exposure, a reward payout was restricted to the top!
 `MaxExposurePageSize` nominators. This is to limit the i/o cost for theH nominator payout.Y
 Note: `MaxExposurePageSize` is used to bound `ClaimedRewards` and is unsafe to reduce� without handling it in a migration.HMaxUnlockingChunks (
 The maximum number of `unlocking` chunks a [`StakingLedger`] can	
 have. Effectively determines how many unique eras a staker may be8 unbonding in.� Note: `MaxUnlockingChunks` is used as the upper bound for the

 `BoundedVec` item `StakingLedger.unlocking`. Setting this value
 lower than the existing value can lead to inconsistencies in the	
 `StakingLedger` and will need to be handled properly in a runtime
 migration. The test `reducing_max_unlocking_chunks_abrupt` shows4 this effect.
�
 Treasury
 Treasury4ProposalCount
� Number of proposals that have been made.$Proposals

| Proposals that have been made.,Deactivated
@� The amount which has been reported as inactive to Currency.$Approvals
� Proposal indices that have been approved but not yet awarded.(SpendCount
� The count of spends that have been made.Spends
	� Spends that have been approved and being processed.


�,SpendPeriod�p� Period between successive spends.Burn
 Percentage of spare funds (if any) that are burnt per spend period. PalletId py/trsry
 The treasury's pallet id, used for deriving its sovereign account ID.0MaxApprovalsd
 The maximum number of approvals that can wait in the spending queue.M
 NOTE: This parameter is also used within the Bounties Pallet extension if enabled.0PayoutPeriod/

 The period during which an approved treasury spend has to be claimed.
(Historical
(HistoricalHHistoricalSessions
]
 Mapping from historical session indices to session-data root hash and validator count.,StoredRange5� The range of historical sessions we store. [first, last)@ConvictionVoting
@ConvictionVoting$VotingFor

!%�u
 All voting for a particular voter in a particular voting class. We store the balance for the� number of votes that we have recorded.4ClassLocksFor

Ei
 The voting classes which have a non-zero lock requirement and the lock amounts which theym
 require. The actual amount locked on behalf of this pallet should always be the maximum of, this list.
	
� MaxVotes� The maximum number of concurrent votes an account may have.U
 Also used to compute weight, an overly large value can lead to extrinsics with large� weight estimation: see `delegate` for instance.DVoteLockingPeriod�� The minimum period of vote locking.e
 It should be no shorter than enactment period to ensure that in the case of an approval,I
 those successful voters are locked into the consequences that their votes entail.
Q$Referenda
$Referenda<ReferendumCount
1
 The next free referendum index, aka the number of referenda started so far.DReferendumInfoFor
U� Information concerning any given referendum.(TrackQueue

�u]
 The sorted list of referenda ready to be decided but not yet being decided, ordered by| conviction-weighted approvals.A
 This should be empty if `DecidingCount` is less than `TrackInfo::max_deciding`.4DecidingCount

�� The number of referenda being decided currently.(MetadataOf
4
 The metadata is a general information concerning the referendum.I
 The `Hash` refers to the preimage of the `Preimages` provider which can be a JSON� dump or IPFS hash of a JSON file.u
 Consider a garbage collection for a metadata of finished referendums to `unrequest` (remove)D large preimages.

�DSubmissionDeposit@�)�=T5
 The minimum amount to be used as a deposit for a public referendum proposal.$MaxQueuedd� Maximum size of the referendum queue for a single track.DUndecidingTimeout'U
 The number of blocks after submission that a referendum must begin being decided by.� Once this passes, then anyone may cancel the referendum.4AlarmInterval
]
 Quantization level for the referendum wakeup scheduler. A higher number will result in]
 fewer storage reads/writes needed for smaller voters, but also result in delays to theU
 automatic referendum status changes. Explicit servicing instructions are unaffected.Tracks�M<root
�Ά�*�`	'�p�p��>
WC�TC�ʚ;e�
Hwhitelisted_callerd{
�X'���%{W<B9/���
9by
4staking_admin
���h
`	'��C0$e�ʚ;]ox�.��h������$treasurer
O�4�`	'�p��>
WC�TC�ʚ;e�@fellowship_admin
���h
`	'��C0$e�ʚ;]ox�.��h������
4general_admin
���h
`	'���>
WC�TC�Y���)k.kJ�����Preferendum_canceller�{
�`	���C0$e�ʚ;]ox�.��h������Dreferendum_killer�ngCZh`	'��C0$e�ʚ;]ox�.��h������0small_tipper�`��l���I�Ie�ʚ;��*M1kY������(big_tipperd�)�=T����I�Ie�ʚ;iO?5�}�4������ 4small_spender2���kJ5�'@8�p�C0$e�ʚ;]ox�.��h������!8medium_spender2COהj�'�p�p[
�0e�ʚ;a��Ѫ
 �*�����",big_spender2���)��'��pʚ;e�ʚ;A<�
u]4E�e�����(0bridge_admin�Ά�*��' ��ɚ;�q
E�~%e�����)4bridge_pauser��!�
4<@8

�����,��,e������ Information concerning the different referendum tracks.
�PFellowshipCollective
PFellowshipCollective,MemberCount

�i
 The number of members in the collective who have at least the rank according to the index0 of the vec.Members
�� The current members of the collective.$IdToIndex
�a
 The index of each ranks's member into the group of members who have at least that rank.$IndexToId
�]
 The members in the collective by index. All indices in the range `0..MemberCount` wille
 return `Some`, however a member's index is not guaranteed to remain unchanged over time.Voting
��� Votes on a given proposal, if it is ongoing.4VotingCleanup
�
!
�
�LFellowshipReferenda
LFellowshipReferenda<ReferendumCount
1
 The next free referendum index, aka the number of referenda started so far.DReferendumInfoFor
�� Information concerning any given referendum.(TrackQueue

��]
 The sorted list of referenda ready to be decided but not yet being decided, ordered by| conviction-weighted approvals.A
 This should be empty if `DecidingCount` is less than `TrackInfo::max_deciding`.4DecidingCount

�� The number of referenda being decided currently.(MetadataOf
4
 The metadata is a general information concerning the referendum.I
 The `Hash` refers to the preimage of the `Preimages` provider which can be a JSON� dump or IPFS hash of a JSON file.u
 Consider a garbage collection for a metadata of finished referendums to `unrequest` (remove)D large preimages.
%
�DSubmissionDeposit@5
 The minimum amount to be used as a deposit for a public referendum proposal.$MaxQueuedd� Maximum size of the referendum queue for a single track.DUndecidingTimeout�U
 The number of blocks after submission that a referendum must begin being decided by.� Once this passes, then anyone may cancel the referendum.4AlarmInterval
]
 Quantization level for the referendum wakeup scheduler. A higher number will result in]
 fewer storage reads/writes needed for smaller voters, but also result in delays to theU
 automatic referendum status changes. Explicit servicing instructions are unaffected.Tracks��((candidates
���kJ5X�Xʚ;e�ʚ;ʚ;e�
members
�)�=TX�Xʚ;e�ʚ;ʚ;e�,proficients
�)�=TX�Xʚ;e�ʚ;ʚ;e�fellows
�)�=TX�Xʚ;e�ʚ;ʚ;e�8senior fellows
�)�=TX�Xʚ;e�ʚ;ʚ;e�experts
`��l�X�Xʚ;e�ʚ;ʚ;e�8senior experts
`��l�X�Xʚ;e�ʚ;ʚ;e�masters
`��l�X�Xʚ;e�ʚ;ʚ;e�8senior masters
`��l�X�Xʚ;e�ʚ;ʚ;e�	4grand masters
`��l�X�Xʚ;e�ʚ;ʚ;e�� Information concerning the different referendum tracks.
�Origins$Whitelist
$Whitelist<WhitelistedCall
4�
)
�
�$Scheduler
$Scheduler<IncompleteSinceAgenda

�M
 Items to be executed, indexed by the block number that they should be executed on.Retries
5�!
 Retry configurations for items to be executed, indexed by task address.Lookup
5� Lookup from a name to the block number and index of the task.Y
 For v3 -> v4 the previously unbounded identities are Blake2-256 hashed to form the v40 identities.
-
�4MaximumWeight(<@�C���������)
 The maximum weight that may be scheduled per block for any dispatchables.PMaxScheduledPerBlock
 The maximum number of scheduled calls in the queue for a single block. NOTE:Q
 + Dependent pallets' benchmarks might require a higher limit for the setting. Set a� higher limit under `runtime-benchmarks` feature.
� Preimage
 Preimage$StatusFor
4�� The request status of a given hash.@RequestStatusFor
4�� The request status of a given hash.,PreimageFor
�
9
�
� Identity
 Identity(IdentityOf
�i
 Information that is pertinent to identify the entity behind an account. First item is the� registration, second is the account's primary username.� TWOX-NOTE: OK ― `AccountId` is a secure hash.SuperOf
�a
 The super-identity of an alternative "sub" identity together with its name, within thatQ
 context. If the account is not some other account's sub-identity, then just `None`.SubsOf

D� Alternative "sub" identities of this account.
 The first item is the deposit, the second is a vector of the accounts.� TWOX-NOTE: OK ― `AccountId` is a secure hash.(Registrars
M
 The set of registrars. Not expected to get very big as can only be added through a� special origin (likely a council motion).)
 The index into this can be cast to `RegistrarIndex` to get a valid value.LUsernameAuthorities
-� A map of the accounts who are authorized to grant usernames.DAccountOfUsername
�m
 Reverse lookup from `username` to the `AccountId` that has registered it. The value shoulde
 be a key in the `IdentityOf` map, but it may not if the user has cleared their identity.i
 Multiple usernames may map to the same `AccountId`, but `IdentityOf` will only map to oneH primary username.@PendingUsernames
��m
 Usernames that an authority has granted, but that the account controller has not confirmedq
 that they want it. Used primarily in cases where the `AccountId` cannot provide a signature]
 because they are a pure proxy, multisig, etc. In order to confirm it, they should calll [`Call::accept_username`].
 First tuple item is the account and second is the acceptance deadline.
A
� 0BasicDeposit@�)�=T� The amount held on deposit for a registered identity.,ByteDeposit@��y/
 The amount held on deposit per encoded byte for a registered identity.DSubAccountDeposit@�n1�
e
 The amount held on deposit for a registered subaccount. This should account for the facte
 that one storage item's value will increase by the size of an account ID, and there will5
 be another trie item whose value is the size of an account ID plus 32 bytes.8MaxSubAccountsd

 The maximum number of sub-accounts allowed per identified account.4MaxRegistrarsM
 Maximum number of registrars allowed in the system. Needed to bound the complexity| of, e.g., updating judgements.dPendingUsernameExpiration�
 The number of blocks within which a username grant must be accepted.<MaxSuffixLength� The maximum length of a suffix.DMaxUsernameLength a
 The maximum length of a username, including its suffix and any system-added delimiters.
5Proxy
ProxyProxies

9DE
 The set of account proxies. Maps the account which has delegated to the accounts!
 which are being delegated to, together with the amount held on deposit.4Announcements

ID� The announcements made by the proxy (key).
�
�@ProxyDepositBase@h�~�U
 The base amount of currency needed to reserve for creating a proxy.

 This is held for an additional storage item whose value size is%
 `sizeof(Balance)` bytes and whose key size is `sizeof(AccountId)` bytes.HProxyDepositFactor@��
� The amount of currency needed per proxy added.5
 This is held for adding 32 bytes plus an instance of `ProxyType` more into aa
 pre-existing storage value. Thus, when configuring `ProxyDepositFactor` one should take� into account `32 + proxy_type.encode().len()` bytes of data.(MaxProxies � The maximum amount of proxies allowed for a single account.(MaxPending E
 The maximum amount of time-delayed announcements that are allowed to be pending.\AnnouncementDepositBase@h�~�U1
 The base amount of currency needed to reserve for creating an announcement.I
 This is held when a new storage item holding a `Balance` is created (typically 16  bytes).dAnnouncementDepositFactor@ �f=� The amount of currency needed per announcement made.Y
 This is held for adding an `AccountId`, `Hash` and `BlockNumber` (typically 68 bytes)� into a pre-existing storage value.
Y Multisig
 Multisig$Multisigs
]a� The set of open multisig operations.
�
�,DepositBase@h+���Y
 The base amount of currency needed to reserve for creating a multisig execution or to� store a dispatch call for later.

 This is held for an additional storage item whose value size is1
 `4 + sizeof((BlockNumber, Balance, AccountId))` bytes and whose key size is� `32 + sizeof(AccountId)` bytes.4DepositFactor@�9�
U
 The amount of currency needed per unit threshold when creating a multisig execution.%
 This is held for adding 32 bytes more into a pre-existing storage value.8MaxSignatoriesd� The maximum amount of signatories allowed in the multisig.
ihElectionProviderMultiPhase
hElectionProviderMultiPhase(Round

� Internal counter for the number of rounds.U
 This is useful for de-duplication of transactions submitted to the pool, and generall diagnostics of the pallet.M
 This is merely incremented once per every time that an upstream `elect` is called.0CurrentPhase
�< Current phase.8QueuedSolutionm=
 Current best solution, signed or unsigned, queued to be returned upon `elect`.` Always sorted by score. Snapshotup Snapshot data of the round.]
 This is created at the beginning of the signed phase and cleared upon calling `elect`.)
 Note: This storage type must only be mutated through [`SnapshotWrapper`].8DesiredTargets� Desired number of targets to elect for this round.� Only exists when [`Snapshot`] is present.)
 Note: This storage type must only be mutated through [`SnapshotWrapper`].@SnapshotMetadata�� The metadata of the [`RoundSnapshot`]� Only exists when [`Snapshot`] is present.)
 Note: This storage type must only be mutated through [`SnapshotWrapper`].dSignedSubmissionNextIndex
$

 The next index to be assigned to an incoming signed submission.u
 Every accepted submission is assigned a unique index; that index is bound to that particulare
 submission for the duration of the election. On election finalization, the next index is0 reset to 0.i
 We can't just use `SignedSubmissionIndices.len()`, because that's a bounded set; past itsY
 capacity, it will simply saturate. We can't just iterate over `SignedSubmissionsMap`,� because iteration is slow. Instead, we store the value here.\SignedSubmissionIndices
�m
 A sorted, bounded vector of `(score, block_number, index)`, where each `index` points to ax value in `SignedSubmissions`.q
 We never need to process more than a single signed submission at a time. Signed submissionsu
 can be quite large, so we're willing to pay the cost of multiple database accesses to access!
 them one at a time instead of reading and decoding all of them at once.PSignedSubmissionsMap
�t Unchecked, signed solutions.i
 Together with `SubmissionIndices`, this stores a bounded set of `SignedSubmissions` while� allowing us to keep only a single one in memory at a time.i
 Twox note: the key of the map is an auto-incrementing index which users cannot inspect or� affect; we shouldn't need a cryptographically secure hasher.TMinimumUntrustedScore�]
 The minimum score that each 'untrusted' solution must attain in order to be considered( feasible.� Can be set via `set_minimum_untrusted_score`.
	
�8TBetterSignedThreshold�M
 The minimum amount of improvement to the solution score that defines a solution asx "better" in the Signed phase.8OffchainRepeat%� The repeat threshold of the offchain worker.a
 For example, if it is 5, that means that at least 5 blocks will elapse between attempts� to submit the worker's solution.<MinerTxPriority0 �������%
 The priority of the unsigned transaction submitted in the unsigned-phasePSignedMaxSubmissions
� Maximum number of signed submissions that can be queued.U
 It is best to avoid adjusting this during an election, as it impacts downstream datae
 structures. In particular, `SignedSubmissionIndices<T>` is bounded on this value. If you� update this value during an election, you _must_ ensure thatM
 `SignedSubmissionIndices.len()` is less than or equal to the new value. Otherwise,� attempts to submit new solutions may cause a runtime panic.<SignedMaxWeight(<ز�3�Q���Q8� Maximum weight of a signed solution.]
 If [`Config::MinerConfig`] is being implemented to submit signed solutions (outside of=
 this pallet), then [`MinerConfig::solution_weight`] is used to compare against0 this value.@SignedMaxRefunds
 The maximum amount of unchecked solutions to refund the call fee for.@SignedRewardBase@`��l�� Base reward for a signed solutionDSignedDepositByte@��>]
� Per-byte deposit for a signed solution.LSignedDepositWeight@� Per-weight deposit for a signed solution.(MaxWinners�5
 The maximum number of winners that can be elected by this `ElectionProvider`@ implementation.Q
 Note: This must always be greater or equal to `T::DataProvider::desired_targets()`.8MinerMaxLength$8MinerMaxWeight(<ز�3�Q���Q8TMinerMaxVotesPerVoter<MinerMaxWinners�
� Offences
 OffencesReports
4�I
 The primary structure that holds all offence records keyed by report identifiers.XConcurrentReportsIndex

�=)
 A vector of reports of the same kind that happened at the same time slot.
� Bounties
 Bounties,BountyCount
� Number of bounty proposals that have been made. Bounties
�x Bounties that have been made.HBountyDescriptions
�� The description of each bounty.<BountyApprovals
� Bounty indices that have been approved but not yet funded.
�
�$DBountyDepositBase@`��l�� The amount held on deposit for placing a bounty proposal.`BountyDepositPayoutDelay�pY
 The delay period for which a bounty beneficiary need to wait before claim the payout.HBountyUpdatePeriod'l Bounty duration in blocks.`CuratorDepositMultiplier �
 The curator deposit is calculated as a percentage of the curator fee.9
 This deposit has optional upper and lower bounds with `CuratorDepositMax` andT `CuratorDepositMin`.DCuratorDepositMax�
D
���kJ5I
 Maximum amount of funds that should be placed in a deposit for making a proposal.DCuratorDepositMin�
D
`��l�I
 Minimum amount of funds that should be placed in a deposit for making a proposal.HBountyValueMinimum@����p Minimum value for a bounty.HDataDepositPerByte@��>]
a
 The amount held on deposit per byte within the tip report reason or bounty description.LMaximumReasonLength,
� Maximum acceptable reason length.e
 Benchmarks depend on this value, be sure to update weights file when changing this value
�4ChildBounties
4ChildBounties@ChildBountyCount
� Number of total child bounties.LParentChildBounties

� Number of child bounties per parent bounty.� Map of parent bounty index to number of child bounties.4ChildBounties
5�� Child bounties that have been added.\ChildBountyDescriptions
�� The description of each child-bounty.LChildrenCuratorFees

@

 The cumulative child-bounty curator fee for each parent bounty.


�dMaxActiveChildBountyCount
 Maximum number of child bounties that can be added to a parent bounty.\ChildBountyValueMinimum@`��l�� Minimum value for a child-bounty.
�<NominationPools
<NominationPoolsT@TotalValueLocked
@� The sum of funds across all pools.q
 This might be lower but never higher than the sum of `total_balance` of all [`PoolMembers`]Y
 because calling `pool_withdraw_unbonded` might decrease the total stake of the pool's)
 `bonded_account` without adjusting the pallet-internal `UnbondingPool`'s.,MinJoinBond
@� Minimum amount to bond to join a pool.4MinCreateBond
@� Minimum bond required to create a pool.e
 This is the amount that the depositor must put as their initial stake in the pool, as an� indication of "skin in the game".i
 This is the value that will always exist in the staking ledger of the pool bonded account� while all other accounts leave. MaxPoolsi
 Maximum number of nomination pools that can exist. If `None`, then an unbounded number ofD pools can exist.8MaxPoolMembersI
 Maximum number of members that can exist in the system. If `None`, then the count� members are not bound on a system wide basis.TMaxPoolMembersPerPoolA
 Maximum number of members that may belong to pool. If `None`, then the count of� members is not bound on a per pool basis.LGlobalMaxCommission�i
 The maximum commission that can be charged by a pool. Used on commission payouts to bound%
 pool commissions that are > `GlobalMaxCommission`, necessary if a future

 `GlobalMaxCommission` is lower than some current pool commissions.,PoolMembers
�@ Active members.� TWOX-NOTE: SAFE since `AccountId` is a secure hash.TCounterForPoolMembers
�Counter for the related counted storage map,BondedPools
�h Storage for bonded pools.TCounterForBondedPools
�Counter for the related counted storage map,RewardPools
�u
 Reward pools. This is where there rewards for each pool accumulate. When a members payout isY
 claimed, the balance comes out of the reward pool. Keyed by the bonded pools account.TCounterForRewardPools
�Counter for the related counted storage map<SubPoolsStorage
�
 Groups of unbonding pools. Each group of unbonding pools belongs to a)
 bonded pool, hence the name sub-pools. Keyed by the bonded pools account.dCounterForSubPoolsStorage
�Counter for the related counted storage map Metadata

�\ Metadata for the pool.HCounterForMetadata
�Counter for the related counted storage map(LastPoolId
� Ever increasing number of all pools created so far.LReversePoolIdLookup
� A reverse lookup from the pool's account id to its id.u
 This is only used for slashing and on automatic withdraw update. In all other instances, the%
 pool id is used, and the accounts are deterministically derived from it.tCounterForReversePoolIdLookup
�Counter for the related counted storage map@ClaimPermissions

!

 Map from a pool member account to their opted claim permission.

� PalletId py/nopls� The nomination pool's pallet id.HMaxPointsToBalance
0
 The maximum pool points-to-balance ratio that an `open` pool can have.U
 This is important in the event slashing takes place and the pool's points-to-balance| ratio becomes disproportional.e
 Moreover, this relates to the `RewardCounter` type as well, as the arithmetic operationsU
 are a function of number of points, and by setting this value to e.g. 10, you ensuree
 that the total number of points in the system are at most 10 times the total_issuance of� the chain, in the absolute worse case.I
 For a value of 10, the threshold would be a pool points-to-balance ratio of 10:1.1
 Such a scenario would also be the equivalent of the pool being 90% slashed.0MaxUnbonding =
 The maximum number of simultaneous unbonding chunks that can exist per member.
�Sudo
SudoKey� The `AccountId` of the sudo key.
9
�

	c,GearProgram
,GearProgram\InstrumentedCodeStorage
A	LOriginalCodeStorage
A8LCodeMetadataStorage
A
	HAllocationsStorage
E-	8ProgramStorage
E=	,MemoryPages
]	e	
m	d4GearMessenger
4GearMessenger( Dequeued(Dispatches
Iq	PCounterForDispatches
�Counter for the related counted storage mapHeadIMailbox
�	�	<QueueProcessing SentTailI Waitlist
�	�	4DispatchStash
I�	
�	e4GearScheduler
4GearSchedulerdFirstIncompleteTasksBlock TaskPool
�	�@ReserveThreshold

 Amount of blocks for extra delay used to secure from outdated tasks.0WaitlistCost0 d� Cost for storing in waitlist per block.,MailboxCost0 d� Cost for storing in mailbox per block.<ReservationCost0 dx Cost for reservation holding.@DispatchHoldCost0 dx Cost for reservation holding.
�	fGearGas
GearGas4TotalIssuance0 GasNodes
=�	$Allowance
0 �{��4BlockGasLimit0 �{��	
 The maximum amount of gas that can be used within a single block.
�	gGear
Gear<ExecuteInherent
 
Y
 A flag indicating whether the message queue should be processed at the end of a blocka
 If not set, the inherent extrinsic that processes the queue will keep throwing an error� thereby making the block builder exclude it from the block.,BlockNumber
� The current block number being processed.� It shows block number in which queue is processed.)
 May be less than system pallet block number if panic occurred previously.8GearRunInBlock�e
 A guard to prohibit all but the first execution of `pallet_gear::run()` call in a block.9
 Set to `Some(())` if the extrinsic is executed for the first time in a block.M
 All subsequent attempts would fail with `Error::<T>::GearRunAlreadyInBlock` error.!
 Set back to `None` in the `on_finalize()` hook at the end of the block.
=
� Schedule�	�

��
��
  �Pl�y�(�(�$��,�Lsb<������7[#
d
V 
,

�
�
�
����GG�IUK]�=I��a�hG�?K�p�2

�	=S�D^
BW�|��9
h
+y
#K
b
��n�\<2x?�L)�����[H*�EVOF]D��E��D��E�7FޫiE�-HnzE�UD�v�V^
�پ
25�ztN֧|����ˢz��	����j(�0��I��mr�rr��:o��
��E��D�ER�b�'�M
���B���Za��Qq�jE���*W��U��%�*;��_�^���
y:W��
y����(�y�b/Xz�Q
vI���-�
�
�
�
�.��U
��������`›;�	C�tX�`bZn�y@�wi�MD���e7���q%v��2oer�+U
.
�&R]
�<b�:�,
v
h Cost schedule and limits.4OutgoingLimitY
 The maximum amount of messages that can be produced in during all message executions.HOutgoingBytesLimit-
 The maximum amount of bytes in outgoing messages during message execution.TPerformanceMultiplier	
d` Performance multiplier.@MailboxThreshold0 �� The minimal gas amount for message to be inserted in mailbox.5
 This gas will be consuming as rent for storing and message will be available� for reply or claim, once gas ends, message removes.5
 Messages with gas limit less than that minimum will not be added in mailbox,p but will be seen in events.DReservationsLimit0 
� Amount of reservations can exist for 1 program.(RentPoolId�
�
�%�o^����;�ϥ��>ȶ�
��T�Ǽ��� The account id of the rent pool if any.

h,GearPaymenti8StakingRewards
8StakingRewards<TargetInflation
i � Target inflation (at ideal stake)DIdealStakingRatio
i P Ideal staking ratioDNonStakeableShare
i 5
 The current share of issued tokens that cannot be staked (e.g. being vested)a
 This value is guaranteed to remain unchanged for the first year until vesting kicks in.i
 Subsequently, the non-stakeable share should be calculated based on the vesting balances.@FilteredAccounts

i
 List of accounts whose locked balance (due to incomplete vesting) should be excluded fromx the total stakeable quantity.i
 During the 1st year the non-stakeable amount is accounted for as a fixed fraction of TTS.
U
e PalletId py/strwd1
 The staking rewards' pallet id, used for deriving its sovereign account ID.LMillisecondsPerYear0 ��X� Milliseconds per year to calculate inflation.0MinInflationi �o�#h Minimum annual inflation.MaxROIi �i�)$ ROI cap.Falloffi ���
G� Exponential decay (fall-off) parameter.

j,GearVoucher
,GearVoucherIssued0� Storage containing amount of the total vouchers issued.� Used as nonce in voucher creation. Vouchers


� Double map storage containing data of the voucher,� associated with some spender and voucher ids.
Y
m PalletId py/vouch� The pallet id, used for deriving its sovereign account ID.DMaxProgramsAmount � Maximal amount of programs to be specified to interact with.,MinDuration	
 Minimal duration in blocks voucher could be issued/prolonged for.,MaxDuration�$	
 Maximal duration in blocks voucher could be issued/prolonged for.
!
k GearBank
 GearBankBank
%
,BankAddress
�modlpy/gbank,UnusedValue
@LOnFinalizeTransfers
<OnFinalizeValue
@ PalletId py/gbank
 The gear bank's pallet id, used for deriving its sovereign account ID.4GasMultiplier�	DdT Gas price converter.<TreasuryAddress�modlpy/trsryLTreasuryGasFeeShare�
dHTreasuryTxFeeShare�
d
)
l,GearBuiltinm4GearEthBridge
4GearEthBridge0,Initialized
 L Lifecycle storage.%
 Defines if pallet got initialized and focused on common session changes.Paused
 
L Lifecycle storage.
 Defines if pallet is accepting any mutable requests. Governance-ruled.@AuthoritySetHash4D Primary storage.� Keeps hash of queued validator keys for the next era.)
 **Invariant**: Key exists in storage since first block of some era's last

 session, until initialization of the second block of the next era.<QueueMerkleRoot4D Primary storage.� Keeps merkle root of the bridge's queued messages.)
 **Invariant**: Key exists since pallet initialization. If queue is empty,p zeroed hash set in storage.Queue
=D Primary storage.� Keeps bridge's queued messages keccak hashes.QueueId
0 D Primary storage.� Keeps the monotonic identifier of a bridge message queue.(QueuesInfo
0-
@ Helper storage.!
 Keeps queue infos to their ids. For details on info, see [`QueueInfo`].(ClearTimer T Operational storage.
 Defines in how many on_initialize hooks queue, queue merkle root and� grandpa keys hash should be cleared.!
 **Invariant**: set to 2 on_init hooks when new session with authorities!
 set change, then decreasing to zero on each new block hook. When equalst to zero, reset is performed.0MessageNonce
y�T Operational storage.!
 Keeps next message's nonce for bridging. Must be increased on each use.0QueueChanged
 T Operational storage.
 Defines if queue was changed within the block, it's necessary to� update queue merkle root by the end of the block.PQueueOverflowedSinceT Operational storage.	
 Defines since when queue was last pushed to that caused overflow.� Intended to support unlimited queue capacity.0TransportFee
@T Operational storage.
 Defines the amount of fee to be paid for the transport of messages.
y
q PalletId py/gethb

 The bridge' pallet id, used for deriving its sovereign account ID.8BuiltinAddress��l�t��9-:��6=o�島79�zͿ� Account ID of the bridge builtin.,BridgeAdmin�modlpy/gethb0bridge_admin� The AccountId of the bridge admin.0BridgePauser�modlpy/gethb4bridge_pauser� The AccountId of the bridge pauser.8MaxPayloadSize@%
 Constant defining maximal payload size in bytes of message for bridging.4QueueCapacity
 Constant defining maximal amount of messages that are able to be� bridged within the single staking era.
1
n4GrandpaSigner
4GrandpaSigner4NextRequestId
 Requests
5
(Signatures
=
]
8SignatureCount


�
�
A
ou

�E
(@StakingBlackListI
�HCheckNonZeroSenderM
�@CheckSpecVersionQ
8CheckTxVersionU
0CheckGenesisY
48CheckMortality]
4(CheckNoncee
�,CheckWeighti
�`ChargeTransactionPaymentm
�DCheckMetadataHashy
�q
LBabeApi4configuration�
� Return the configuration for BABE.Lcurrent_epoch_start1
� Returns the slot that started the current epoch.4current_epoch�
� Returns information regarding the current epoch.(next_epoch�


 Returns information regarding the next epoch (which was already\ previously announced).pgenerate_key_ownership_proofslot1
0authority_id-
�
,	
 Generates a proof of key ownership for the given authority in the

 current epoch. An example usage of this module is coupled with the
 session historical module to prove that a given authority key is

 tied to a given staking identity during a specific session. Proofs
 of key ownership are necessary for submitting equivocation reports.	
 NOTE: even though the API takes a `slot` as parameter the current	
 implementations ignores this parameter and instead relies on this

 method being called at the correct block height, i.e. any point at� which the epoch for the given slot is live on-chain. Future	
 implementations will instead use indexed data through an offchain� worker, not requiring older states to be available.�submit_report_equivocation_unsigned_extrinsicHequivocation_proof!
<key_owner_proof�
�
 
 Submits an unsigned extrinsic to report an equivocation. The caller� must provide the equivocation proof and a key ownership proof� (should be obtained using `generate_key_ownership_proof`). The
 extrinsic will be unsigned and should only be accepted for local
 authorship (not to be broadcast to the network). This method returns	
 `None` when creation of the extrinsic fails, e.g. if equivocation
 reporting is disabled for the given runtime (i.e. this method is
 hardcoded to return `None`). Only useful in an offchain context.� API necessary for block authorship with BABE.TAuthorityDiscoveryApi,authorities�
 Retrieve authority identifiers of the current and next authority set.t The authority discovery api.Q
 This api is used by the `client/authority-discovery` module to retrieve identifiers� of the current and next authority set.dTransactionPaymentCallApi<query_call_infocall
len�
I
 Query information of a dispatch class, weight, and fee of a given encoded `Call`.Xquery_call_fee_detailscall
len�
� Query fee details of a given encoded `Call`.Lquery_weight_to_feeweight(

 Query the output of the current `WeightToFee` given some input.Lquery_length_to_feelength

 Query the output of the current `LengthToFee` given some input.HNominationPoolsApi$<pending_rewardswho5
 Returns the pending rewards for the member that the AccountId was given for.Dpoints_to_balancepool_idpoints� Returns the equivalent balance of `points` for a given pool.Dbalance_to_pointspool_id$new_funds� Returns the equivalent points of `new_funds` for a given pool.Hpool_pending_slashpool_id� Returns the pending slash for a given pool.Pmember_pending_slashmember� Returns the pending slash for a given pool member.tpool_needs_delegate_migrationpool_id  � Returns true if the pool with `pool_id` needs migration.I
 This can happen when the `pallet-nomination-pools` has switched to using strategyA
 [`DelegateStake`](pallet_nomination_pools::adapter::DelegateStake) but the pool� still has funds that were staked using the older strategy
 [TransferStake](pallet_nomination_pools::adapter::TransferStake). Use�
 [`migrate_pool_to_delegate_stake`](pallet_nomination_pools::Call::migrate_pool_to_delegate_stake)T to migrate the pool.|member_needs_delegate_migrationmember )
 Returns true if the delegated funds of the pool `member` needs migration.� Once a pool has successfully migrated to the strategyU
 [`DelegateStake`](pallet_nomination_pools::adapter::DelegateStake), the funds of the
 member can be migrated from pool account to the member's account. Use)
 [`migrate_delegation`](pallet_nomination_pools::Call::migrate_delegation)� to migrate the funds of the pool member.Pmember_total_balancewhoe
 Returns the total contribution of a pool member including any balance that is unbonding.0pool_balancepool_id� Total balance contributed to the pool.� Runtime api for accessing information about nomination pools.(StakingApiDnominations_quotabalance
 Returns the nominations quota for a nominator with a given balance.\eras_stakers_page_counteraaccount9
 Returns the page count of exposures for a validator `account` in a given era.<pending_rewardseraaccount =
 Returns true if validator `account` has pages to be claimed for the given era.TGearStakingRewardsApi8inflation_info�
� Calculate token economics related data.8GearBuiltinApi8query_actor_id(builtin_id04� Calculate `ActorId` (a.k.a. actor id) for a given builtin id.@GearEthBridgeApi0merkle_proofhash4�

 Generate merkle inclusion proof of the message hash in bridge queue.8GenesisBuilder,build_statejson8�
$e
 Build `RuntimeGenesisConfig` from a JSON blob not using any defaults and store it in the$ storage.�
 In the case of a FRAME-based runtime, this function deserializes the full `RuntimeGenesisConfig` from the given JSON blob andY
 puts it into the storage. If the provided JSON blob is incorrect or incomplete or the� deserialization fails, an error is returned.]
 Please note that provided JSON blob must contain all `RuntimeGenesisConfig` fields, no\ defaults will be used.(get_presetid�
�
8a
 Returns a JSON blob representation of the built-in `RuntimeGenesisConfig` identified by `id`.=
 If `id` is `None` the function returns JSON blob representation of the defaultI
 `RuntimeGenesisConfig` struct of the runtime. Implementation must provide default` `RuntimeGenesisConfig`.!
 Otherwise function returns a JSON representation of the built-in, namedQ
 `RuntimeGenesisConfig` preset identified by `id`, or `None` if such preset does nota
 exist. Returned `Vec<u8>` contains bytes of JSON blob (patch) which comprises a list ofM
 (potentially nested) key-value pairs that are intended for customizing the defaulte
 runtime genesis config. The patch shall be merged (rfc7386) with the JSON representationa
 of the default `RuntimeGenesisConfig` to create a comprehensive genesis config that can� be used in `build_state` method.0preset_names�
Q
 Returns a list of identifiers for available builtin `RuntimeGenesisConfig` presets.a
 The presets from the list can be queried with [`GenesisBuilder::get_preset`] method. If

 no named presets are provided by the runtime the list is empty.� API to interact with RuntimeGenesisConfig for the runtimeCoreversion�� Returns the version of the runtime.4execute_blockblock�
�d Execute the given block.@initialize_blockheader%
�
A
 Initialize a block with the given header and return the runtime executive mode.!
 The `Core` runtime api that every Substrate runtime needs to implement. Metadata metadata�
� Returns the metadata of a runtime.Lmetadata_at_versionversion�
� Returns the metadata at a given version.
 If the given `version` isn't supported, this will return `None`.u
 Use [`Self::metadata_versions`] to find out about supported metadata version of the runtime.Dmetadata_versions�
� Returns the supported metadata versions.� This can be used to call `metadata_at_version`.

 The `Metadata` api trait that returns metadata for the runtime.0BlockBuilder<apply_extrinsic$extrinsic�
�
l Apply the given extrinsic.9
 Returns an inclusion outcome which specifies if this extrinsic is included inL this block or not.8finalize_block%
h Finish the current block.Linherent_extrinsics inherent�
�
=
 Generate inherent extrinsics. The inherent data will vary from chain to chain.<check_inherentsblock�
data�
�
U
 Check that the inherents are valid. The inherent data will vary from chain to chain.q
 The `BlockBuilder` api trait that provides the required functionality for building a block.XTaggedTransactionQueuePvalidate_transactionsource�
tx�
(block_hash4
$h Validate the transaction.e
 This method is invoked by the transaction pool to learn details about given transaction.E
 The implementation should make sure to verify the correctness of the transactionM
 against current state. The given `block_hash` corresponds to the hash of the block| that is used as current state.E
 Note that this call may be performed by the pool multiple times and transactions� might be verified in any possible order.M
 The `TaggedTransactionQueue` api trait for interfering with the transaction queue.DOffchainWorkerApi<offchain_workerheader%
�� Starts the off-chain task for given block header.d The offchain worker api.,SessionKeysTgenerate_session_keysseed�
8
 Generate a set of session keys with optionally using the given seed.	
 The keys should be stored within the keystore exposed via runtime< externalities.� The seed needs to be a valid `utf8` string.� Returns the concatenated SCALE encoded public keys.Ldecode_session_keysencoded8	� Decode the given public session keys.� Returns the list of public raw public keys + key type.h Session keys runtime api.(GrandpaApiLgrandpa_authorities�=
 Get the current GRANDPA authorities and weights. This should not change except
 for when changes are scheduled and the corresponding delay has passed.5
 When called at block B, it will return the set of authorities that should be=
 used to finalize descendants of this block (B+1, B+2, ...). The block B itself� is finalized by the authorities from block B-1.�submit_report_equivocation_unsigned_extrinsicHequivocation_proofI
<key_owner_proof�
 
 Submits an unsigned extrinsic to report an equivocation. The caller� must provide the equivocation proof and a key ownership proof� (should be obtained using `generate_key_ownership_proof`). The
 extrinsic will be unsigned and should only be accepted for local
 authorship (not to be broadcast to the network). This method returns	
 `None` when creation of the extrinsic fails, e.g. if equivocation
 reporting is disabled for the given runtime (i.e. this method is
 hardcoded to return `None`). Only useful in an offchain context.pgenerate_key_ownership_proofset_id00authority_id�,	
 Generates a proof of key ownership for the given authority in the� given set. An example usage of this module is coupled with the
 session historical module to prove that a given authority key is

 tied to a given staking identity during a specific session. Proofs
 of key ownership are necessary for submitting equivocation reports.
 NOTE: even though the API takes a `set_id` as parameter the current� implementations ignore this parameter and instead rely on this

 method being called at the correct block height, i.e. any point at
 which the given set id is live on-chain. Future implementations will

 instead use indexed data through an offchain worker, not requiringx older states to be available.8current_set_id0� Get current GRANDPA authority set id.$

 APIs for integrating the GRANDPA finality gadget into runtimes.� This should be implemented on the runtime side.
 This is primarily used for negotiating authority-set changes for the

 gadget. GRANDPA uses a signaling model of changing authority sets:1
 changes should be signaled with a delay of N blocks, and then automatically� applied in the runtime after those N blocks have passed.� The consensus protocol will coordinate the handoff externally.<AccountNonceApi4account_nonceaccount� Get current account nonce of given `AccountId`.� The API to query account nonce.TTransactionPaymentApi(query_infouxt�
len�
Dquery_fee_detailsuxt�
len�
Lquery_weight_to_feeweight(Lquery_length_to_feelengthGearApihcalculate_reply_for_handleorigin4,destination4payload8$gas_limit0valuePallowance_multiplier0Hcalculate_gas_infosource4kind%payload8valueHallow_other_panics ,initial_gasMPallowance_multiplierM)Hgear_run_extrinsicmax_gasM�

 Generate inherent-like extrinsic that runs message queue processing.(read_state(program_id4payload8Pallowance_multiplierM1Tread_state_using_wasm(program_id4payload8fn_name8wasm8 argument�
Pallowance_multiplierM14read_metahash(program_id4Pallowance_multiplierM5
T9