metaE sp_corecrypto,AccountId32 [u8; 32]  0frame_system,AccountInfoIndex,AccountDatanonceIndex$consumers RefCount$providers RefCount,sufficients RefCountdata,AccountData044(sp_runtimegenericdigest(DigestItem(PreRuntime8DConsensusEngineId(Vec$Consensus8DConsensusEngineId(VecSeal8DConsensusEngineId(VecOther(VecdRuntimeEnvironmentUpdated8<@@0frame_system,EventRecordEDT$ phase PhaseeventDEtopics VecDDspiritnet_runtimeEvent\SystemHpframe_system::EventIndiceshxpallet_indices::Event Balancesl|pallet_balances::Event@ParachainStakingtparachain_staking::EventSession|Tpallet_session::Event$Democracypallet_democracy::EventCouncilpallet_collective::EventHTechnicalCommitteepallet_collective::Event LTechnicalMembershippallet_membership::Event" Treasury|pallet_treasury::Event#UtilityTpallet_utility::Event(Vestingxpallet_vesting::Event)$Schedulerpallet_scheduler::Event*Proxyppallet_proxy::Event+ Preimage|pallet_preimage::Event,(KiltLaunchlkilt_launch::Event<CtypeTctype::Event=,Attestationlattestation::Event>(Delegationhdelegation::Event? DidLdid::Event@$DidLookuppallet_did_lookup::EventC$Web3Namespallet_web3_names::EventDPH 0frame_systempalletEventT@ExtrinsicSuccess4dispatch_infoL0DispatchInfoAn extrinsic completed successfully.A new account has joined the set of collator candidates.\[account, amount staked by the new candidate\]HCollatorStakedMore 0T::AccountId0BalanceOf0BalanceOfA collator candidate has increased the amount of funds at stake.\[collator's account, previous stake, new stake\]HCollatorStakedLess 0T::AccountId0BalanceOf0BalanceOfA collator candidate has decreased the amount of funds at stake.\[collator's account, previous stake, new stake\]TCollatorScheduledExit 0SessionIndex0T::AccountId0SessionIndexA collator candidate has started the process to leave the set ofcandidates. \[round number, collator's account, round number whenthe collator will be effectively removed from the set of0candidates\]PCollatorCanceledExit0T::AccountId A collator candidate has canceled the process to leave the set ofcandidates and was added back to the candidate pool. \[collator's$account\]4CandidateLeft0T::AccountId0BalanceOfAn account has left the set of collator candidates.\[account, amount of funds un-staked\] An account was forcedly removed from the set of collatorcandidates. \[account, amount of funds un-staked\]`MaxCandidateStakeChanged0BalanceOf The maximum candidate stake has been changed.H\[new max amount\]LDelegatorStakedMore0T::AccountId0T::AccountId0BalanceOf0BalanceOf A delegator has increased the amount of funds at stake for acollator. \[delegator's account, collator's account, previousdelegation stake, new delegation stake\]LDelegatorStakedLess0T::AccountId0T::AccountId0BalanceOf0BalanceOf A delegator has decreased the amount of funds at stake for acollator. \[delegator's account, collator's account, previousdelegation stake, new delegation stake\]4DelegatorLeft0T::AccountId0BalanceOf An account has left the set of delegators.\[account, amount of funds un-staked\](Delegation0T::AccountId0BalanceOf0T::AccountId0BalanceOf An account has delegated a new collator candidate.\[account, amount of funds staked, total amount of delegators' fundsstaked for the collator candidate\]HDelegationReplaced0T::AccountId0BalanceOf0T::AccountId0BalanceOf0T::AccountId0BalanceOf A new delegation has replaced an existing one in the set of ongoingdelegations for a collator candidate. \[new delegator's account, amount of funds staked in the new delegation, replaced delegator's account, amount of funds staked in the replace delegation, collatorcandidate's account, new total amount of delegators' funds stakedpfor the collator candidate\]TDelegatorLeftCollator0T::AccountId0T::AccountId0BalanceOf0BalanceOf An account has stopped delegating a collator candidate. \[account, collator candidate's account, old amount of delegators'funds staked, new amount of delegators' funds staked\] Rewarded0T::AccountId0BalanceOfA collator or a delegator has received a reward.t\[account, amount of reward\]DRoundInflationSetx,Perquintillx,Perquintillx,Perquintillx,Perquintill Inflation configuration for future validation rounds has changed. \[maximum collator's staking rate, maximum collator's reward rate, maximum delegator's staking rate, maximum delegator's reward rate\]`MaxSelectedCandidatesSet u32 u32The maximum number of collator candidates selected in futurevalidation rounds has changed. \[old value, new value\]DBlocksPerRoundSet0SessionIndex8T::BlockNumber8T::BlockNumber8T::BlockNumber The length in blocks for future validation rounds has changed.\[round number, first block in the current round, old value, newvalue\] The [event](https://docs.substrate.io/v3/runtime/events-and-errors) emitted by this pallet. x 4sp_arithmetic(per_things,Perquintill u64| 8pallet_sessionpalletEvent(NewSession4session_index0SessionIndex9New session has happened. Note that the argument is the session index, not theblock number as the type might suggest. The [event](https://docs.substrate.io/v3/runtime/events-and-errors) emitted by this pallet. @pallet_democracypalletEventTL Proposed8proposal_index$PropIndexdeposit0BalanceOfA motion has been proposed by a public account.Tabled 8proposal_index$PropIndexdeposit0BalanceOf(depositorsDVecA public proposal has been tabled for referendum vote.8ExternalTabledAn external proposal has been tabled.Started$ref_index A proposal's preimage was noted, and the deposit taken.0PreimageUsed 4proposal_hash$T::Hash provider0T::AccountIddeposit0BalanceOf A proposal preimage was removed and used (the deposit was returned).reaper0T::AccountId)A registered preimage was removed and the deposit collected by the reaper.,Blacklisted4proposal_hash$T::HashA proposal_hash has been blacklisted permanently.Voted voter0T::AccountId$ref_index>An account has voted in a referendum Seconded seconder0T::AccountId(prop_index$PropIndexAn account has secconded a proposal The [event](https://docs.substrate.io/v3/runtime/events-and-errors) emitted by this pallet.  @pallet_democracy8vote_threshold4VoteThreshold PSuperMajorityApprovePSuperMajorityAgainst8SimpleMajorityResultTEXOk ErrX @pallet_democracyvote,AccountVoteBalance StandardvoteVotebalanceBalanceSplit ayeBalance nayBalance @pallet_democracyvoteVote Dpallet_collectivepalletEventTI Proposedaccount0T::AccountId8proposal_index4ProposalIndex4proposal_hash$T::Hash$threshold,MemberCountIA motion (given hash) has been proposed (by given account) with a threshold (given<`MemberCount`).Votedaccount0T::AccountId4proposal_hash$T::Hashvotedbool yes,MemberCountno,MemberCountA motion (given hash) has been voted on by given account, leavinga tally (yes votes and no votes given respectively as `MemberCount`). Approved4proposal_hash$T::HashA motion was approved by the required threshold.,Disapproved4proposal_hash$T::HashA motion was not approved by the required threshold. Executed4proposal_hash$T::Hashresult8DispatchResult!A motion was executed; result will be `Ok` if it returned without error.8MemberExecuted4proposal_hash$T::Hashresult8DispatchResultIA single member did some action; result will be `Ok` if it returned without error.Closed 4proposal_hash$T::Hash yes,MemberCountno,MemberCountUA proposal was closed because its threshold was reached or after its duration was up. The [event](https://docs.substrate.io/v3/runtime/events-and-errors) emitted by this pallet.  Dpallet_collectivepalletEventTI Proposedaccount0T::AccountId8proposal_index4ProposalIndex4proposal_hash$T::Hash$threshold,MemberCountIA motion (given hash) has been proposed (by given account) with a threshold (given<`MemberCount`).Votedaccount0T::AccountId4proposal_hash$T::Hashvotedbool yes,MemberCountno,MemberCountA motion (given hash) has been voted on by given account, leavinga tally (yes votes and no votes given respectively as `MemberCount`). Approved4proposal_hash$T::HashA motion was approved by the required threshold.,Disapproved4proposal_hash$T::HashA motion was not approved by the required threshold. Executed4proposal_hash$T::Hashresult8DispatchResult!A motion was executed; result will be `Ok` if it returned without error.8MemberExecuted4proposal_hash$T::Hashresult8DispatchResultIA single member did some action; result will be `Ok` if it returned without error.Closed 4proposal_hash$T::Hash yes,MemberCountno,MemberCountUA proposal was closed because its threshold was reached or after its duration was up. The [event](https://docs.substrate.io/v3/runtime/events-and-errors) emitted by this pallet. Dpallet_membershippalletEventTI,MemberAddedThe given member was added; see the transaction for who.4MemberRemovedThe given member was removed; see the transaction for who.8MembersSwappedTwo members were swapped; see the transaction for who.0MembersResetThe membership was reset; see the transaction for who the new set is.(KeyChangedOne of the members' keys changed.DummylPhantom member, never used. The [event](https://docs.substrate.io/v3/runtime/events-and-errors) emitted by this pallet. We have ended a spend period and will now allocate funds.Awarded 8proposal_index4ProposalIndexawardaccount0T::AccountId|Some funds have been allocated. Rejected8proposal_index4ProposalIndexslashedA proposal was rejected; funds were slashed.Burnt,burnt_fundsSome of our funds have been burnt. Rollover@rollover_balance-Spending has finished; this is the amount that rolls over until next spend.Depositvalue|Some funds have been deposited. The [event](https://docs.substrate.io/v3/runtime/events-and-errors) emitted by this pallet. 8pallet_utilitypalletEvent@BatchInterruptedindex u32errorX4DispatchErrorUBatch of dispatches did not complete fully. Index of first failing dispatch given, asHwell as the error.8BatchCompletedBatch of dispatches completed fully with no error.4ItemCompletedA single item within a Batch of dispatches has completed with no error.0DispatchedAsresult8DispatchResultXA call was dispatched. The [event](https://docs.substrate.io/v3/runtime/events-and-errors) emitted by this pallet. 8pallet_vestingpalletEventT8VestingUpdatedaccount0T::AccountId unvested0BalanceOfQThe 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).@VestingCompletedaccount0T::AccountIdAn \[account\] has become fully vested. The [event](https://docs.substrate.io/v3/runtime/events-and-errors) emitted by this pallet. @pallet_schedulerpalletEventT$Scheduledwhen8T::BlockNumberindex u32PScheduled some task. Canceledwhen8T::BlockNumberindex u32LCanceled some task.(Dispatched tasklTaskAddressid>result8DispatchResultTDispatched some task.@CallLookupFailed tasklTaskAddressid>error,LookupError)The call for the provided hash was not found so the task has been aborted.0Events type.OptionT(NoneSome(4frame_supporttraits schedule,LookupErrorUnknown$BadFormat 0pallet_proxypalletEventT4ProxyExecutedresult8DispatchResultA proxy was executed correctly, with the given.@AnonymousCreated$anonymous0T::AccountId who0T::AccountId(proxy_type0T::ProxyTypePdisambiguation_index u16Anonymous account has been created by new proxy with givendisambiguation index and proxy type.$Announced real0T::AccountIdproxy0T::AccountId$call_hash$4CallHashOfAn announcement was placed to make a call in the future.(ProxyAdded$delegator0T::AccountId$delegatee0T::AccountId(proxy_type0T::ProxyTypedelay8T::BlockNumberHA proxy was added. The [event](https://docs.substrate.io/v3/runtime/events-and-errors) emitted by this pallet. Dspiritnet_runtime$ProxyType Any,NonTransfer(Governance@ParachainStaking,CancelProxyHNonDepositClaiming 0BalanceOfVesting has been added to an account. \[who, per_block, total\] The [event](https://docs.substrate.io/v3/runtime/events-and-errors) emitted by this pallet. ctypepalletEventT0CTypeCreatedDCtypeCreatorOf$8CtypeHashOftA new CType has been created.\[creator identifier, CType hash\] The [event](https://docs.substrate.io/v3/runtime/events-and-errors) emitted by this pallet. ,attestationpalletEventTHAttestationCreated4AttesterOf$8ClaimHashOf$8CtypeHashOftOption>A new attestation has been created.\[attester ID, claim hash, CType hash, (optional) delegation ID\]HAttestationRevoked4AttesterOf$8ClaimHashOfAn attestation has been revoked.h\[account id, claim hash\]HAttestationRemoved4AttesterOf$8ClaimHashOfAn attestation has been removed.h\[account id, claim hash\]@DepositReclaimed8AccountIdOf$8ClaimHashOfThe deposit owner reclaimed a deposit by removing an attestation.h\[account id, claim hash\] The [event](https://docs.substrate.io/v3/runtime/events-and-errors) emitted by this pallet. OptionT$NoneSome$ (delegationpalletEventT@HierarchyCreated @DelegatorIdOf$TDelegationNodeIdOf$8CtypeHashOfA new hierarchy has been created.\[creator ID, root node ID, CTYPE hash\]@HierarchyRevoked@DelegatorIdOf$TDelegationNodeIdOftA hierarchy has been revoked.p\[revoker ID, root node ID\]@HierarchyRemoved@DelegatorIdOf$TDelegationNodeIdOfA hierarchy has been removed from the storage on chain.p\[remover ID, root node ID\]DDelegationCreated@DelegatorIdOf$TDelegationNodeIdOf$TDelegationNodeIdOf$TDelegationNodeIdOf@DelegatorIdOf,Permissions A new delegation has been created.\[creator ID, root node ID, delegation node ID, parent node ID,hdelegate ID, permissions\]DDelegationRevoked@DelegatorIdOf$TDelegationNodeIdOfxA delegation has been revoked.\[revoker ID, delegation node ID\]DDelegationRemoved8AccountIdOf$TDelegationNodeIdOfxA delegation has been removed.\[remover ID, delegation node ID\]@DepositReclaimed8AccountIdOf$TDelegationNodeIdOfThe deposit owner reclaimed a deposit by removing a delegationsubtree. \[revoker ID, delegation node ID\] The [event](https://docs.substrate.io/v3/runtime/events-and-errors) emitted by this pallet. (delegationPdelegation_hierarchy,Permissionsbits u32 didpalletEventT(DidCreated8AccountIdOfHDidIdentifierOflA new DID has been created.\[transaction signer, DID identifier\](DidUpdatedHDidIdentifierOf\A DID has been updated.H\[DID identifier\](DidDeletedHDidIdentifierOf\A DID has been deleted.H\[DID identifier\]DDidCallDispatchedHDidIdentifierOf8DispatchResultA DID-authorised call has been executed.|\[DID caller, dispatch result\] The [event](https://docs.substrate.io/v3/runtime/events-and-errors) emitted by this pallet. Dpallet_did_lookuppalletEventTXAssociationEstablished8AccountIdOfHDidIdentifierOfA new association between a DID and an account ID was created.HAssociationRemoved8AccountIdOfHDidIdentifierOfAn association between a DID and an account ID was removed. The [event](https://docs.substrate.io/v3/runtime/events-and-errors) emitted by this pallet. Dpallet_web3_namespalletEventTname4Web3NameOfpA new name has been claimed.@Web3NameReleasedownerHWeb3NameOwnerOfname4Web3NameOfdA name has been released.8Web3NameBannedname4Web3NameOf\A name has been banned.@Web3NameUnbannedname4Web3NameOfdA name has been unbanned. The [event](https://docs.substrate.io/v3/runtime/events-and-errors) emitted by this pallet. Dpallet_web3_names$web3_name4AsciiWeb3Name T$MinLength$MaxLengthdBoundedVec4frame_supportstorage,bounded_vec(BoundedVecTS(Vec |cumulus_pallet_parachain_systempalletEventT`ValidationFunctionStoredThe validation function has been scheduled to apply.dValidationFunctionAppliedTRelayChainBlockNumberEThe validation function was applied as of the contained relay chain block number.lValidationFunctionDiscardedThe relay-chain aborted the upgrade process.DUpgradeAuthorized$T::Hash|An upgrade has been authorized.`DownwardMessagesReceived u32Some downward messages have been received and will be processed.,\[ count \]dDownwardMessagesProcessedWeight$Drelay_chain::HashDownward messages were processed using the given weight.\[ weight_used, result_mqc_head \] The [event](https://docs.substrate.io/v3/runtime/events-and-errors) emitted by this pallet. 0frame_systemPhase 8ApplyExtrinsic u320Finalization8Initialization $0frame_systemXLastRuntimeUpgradeInfo0spec_versionLcodec::Compact$spec_namedsp_runtime::RuntimeString! 0frame_systempalletCallT$(fill_blockratio%PerbillA dispatch that will fill the block weight up to the given ratio.remarkremark(VechMake some on-chain remark.(# - `O(1)`,# 8set_heap_pagespages u64Set the number of pages in the WebAssembly environment's heap. set_codecode(Vec0dSet the new runtime code.(# 1- `O(C + S)` where `C` length of `code` and `S` complexity of `can_set_code`E- 1 call to `can_set_code`: `O(S)` (calls `sp_io::misc::runtime_version` which is4 expensive).- 1 storage write (codec `O(C)`).@- 1 digest item.(- 1 event.MThe weight of this function is dependent on the runtime, but generally this is veryexpensive. We will treat this as a full block.,# \set_code_without_checkscode(Vec$Set the new runtime code without doing any checks of the given `code`.(# - `O(C)` where `C` length of `code`- 1 storage write (codec `O(C)`).@- 1 digest item.(- 1 event.UThe weight of this function is dependent on the runtime. We will treat this as a fullHblock. # ,set_storageitems)4VechSet some items of storage.0kill_storagekeys1 VectKill some items from storage.,kill_prefixprefix( Keysubkeys u32Kill 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_eventremark(VecMake some on-chain remark and emit event.%Contains one variant per dispatchable that can be called by an extrinsic.% 4sp_arithmetic(per_thingsPerbill u32)--((1(5 0frame_systemlimits0BlockWeights (base_blockWeight$max_blockWeight$per_class9PerDispatchClass9 4frame_supportweights@PerDispatchClassT= normal=T,operational=T$mandatory=T= 0frame_systemlimits$max_totalA8Option reservedA8OptionAOptionTNoneSomeE 0frame_systemlimits,BlockLength maxITPerDispatchClassI 4frame_supportweights@PerDispatchClassT normalT,operationalT$mandatoryTM 4frame_supportweightsm @pallet_timestamppalletCallT set nowq$T::Moment@TSet the current time.UThis call should be invoked exactly once per block. It will panic at the finalizationphase, if this call hasn't been invoked by that time.AThe timestamp should be greater than the previous one by the amount specified by@`MinimumPeriod`.The dispatch origin for this call must be `Inherent`.(# 1- `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`)a- 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 one variant per dispatchable that can be called by an extrinsic.qu y 8pallet_indicespalletCallTclaimindex$- `O(1)`.- One storage mutation (codec `O(1)`).`- One reserve operation.0- One event.L-------------------- DB Weight: 1 Read/Write (Accounts),# transfer new0T::AccountIdindex$- `O(1)`.- One storage mutation (codec `O(1)`).d- One transfer operation.0- One event.L-------------------0- DB Weight: - Reads: Indices Accounts, System Account (recipient) - Writes: Indices Accounts, System Account (recipient),# freeindex$- `O(1)`.- One storage mutation (codec `O(1)`).`- One reserve operation.0- One event.L-------------------- DB Weight: 1 Read/Write (Accounts),# 8force_transfer  new0T::AccountIdindex$- `O(1)`.- One storage mutation (codec `O(1)`).x- Up to one reserve operation.0- One event.L-------------------0- DB Weight: - Reads: Indices Accounts, System Account (original owner) - Writes: Indices Accounts, System Account (original owner),# freezeindex$- `O(1)`.- One storage mutation (codec `O(1)`).p- Up to one slash operation.0- One event.L-------------------- DB Weight: 1 Read/Write (Accounts),# %Contains one variant per dispatchable that can be called by an extrinsic.} 8pallet_indicespalletErrorT,NotAssignedThe index was not already assigned. NotOwnerThe index is assigned to another account.InUsepThe index was not available.,NotTransferThe source and destination accounts are identical.$PermanentThe index is permanent and may not be freed/changed. Custom [dispatch errors](https://docs.substrate.io/v3/runtime/events-and-errors) of this pallet. 4frame_supportstorage@weak_bounded_vec8WeakBoundedVecTSVec::Sourcevalue(T::BalancedTransfer some liquid free balance to another account.`transfer` will set the `FreeBalance` of the sender and receiver.If the sender's account is below the existential deposit as a resultof the transfer, the account will be reaped.The dispatch origin for this call must be `Signed` by the transactor.(# a- Dependent on arguments but not critical, given proper implementations for input config types. See related functions below.1- It contains a limited number of reads and writes internally and no complex8 computation.HRelated functions:M - `ensure_can_withdraw` is always called internally but has a bounded complexity.) - Transferring balances to accounts that did not exist before will cause `T::OnNewAccount::on_new_account` to be called.] - Removing enough funds from an account will trigger `T::DustRemoval::on_unbalanced`.] - `transfer_keep_alive` works the same way as `transfer`, but has an additional check that the transfer will not kill the origin account.---------------------------------- Origin account is already in memory, so no DB operations for them.,# ,set_balance  who::Source new_free(T::Balance0new_reserved(T::Balance Set the balances of a given account.This will alter `FreeBalance` and `ReservedBalance` in storage. it will1also alter the total issuance of the system (`TotalIssuance`) appropriately.If the new free or reserved balance is below the existential deposit,it will reset the account nonce (`frame_system::AccountNonce`).The dispatch origin for this call is `root`.8force_transfer source::Sourcedest::Sourcevalue(T::BalanceMExactly as `transfer`, except the origin must be root and the source account may be(specified.(# M- Same as transfer, but additional read and write because the source account is not| assumed to be in the overlay.,# Ltransfer_keep_alivedest::Sourcevalue(T::BalanceMSame as the [`transfer`] call, but with a check that the transfer will not kill the::Source(keep_aliveboolDTransfer the entire transferable balance from the caller account.YNOTE: This function only attempts to transfer _transferable_ balances. This means thataany 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,Eyou 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). # 9- O(1). Just like transfer, but reading the user's transferable balance first.0 #::Sourceamount(T::Balance Unreserve some balance from a user by force.lCan only be called by ROOT.%Contains one variant per dispatchable that can be called by an extrinsic. (sp_runtime0multiaddress0MultiAddress$AccountId0AccountIndexId$AccountIdIndex0AccountIndex Raw(Vec$Address32 [u8; 32]$Address20 [u8; 20] OptionTNoneSome Dpallet_authorshippalletCallT(set_uncles(new_uncles8Vec`Provide a set of uncles.%Contains one variant per dispatchable that can be called by an extrinsic.(sp_runtimegenericheaderHeaderNumberHash,parent_hash$0Hash::OutputnumberqNumber(state_root$0Hash::Output, MaxCollatorsPerDelegator>totalBalance Dparachain_staking set(OrderedSetTS@BoundedVec Dparachain_stakingtypesStake$AccountIdBalanceowner$AccountIdamountBalance4frame_supportstorage,bounded_vec(BoundedVecTSVec Dparachain_stakingtypes$Candidate $AccountIdBalancedMaxDelegatorsPerCandidateid$AccountIdstakeBalance(delegators OrderedSet, MaxDelegatorsPerCandidate>totalBalancestatus 4frame_supportstorage,bounded_vec(BoundedVecTSVec Dparachain_stakingtypes4frame_supportstorage,bounded_vec(BoundedVecTSVec! Dparachain_staking$inflation4InflationInfo collator%,StakingInfo$delegator%,StakingInfo% Dparachain_staking$inflation,StakingInfo max_ratex,Perquintill,reward_rate)(RewardRate) Dparachain_staking$inflation(RewardRateannualx,Perquintill$per_blockx,Perquintill-4frame_supportstorageDbounded_btree_map1 BTreeMapKV5599= Dparachain_stakingpalletCallTL>::should_end_session.The dispatch origin must be Root.(# 0Weight: O(1)d- Reads: [Origin Account]\- Writes: ForceNewRound,# 4set_inflationpcollator_max_rate_percentagex,Perquintillcollator_annual_reward_rate_percentagex,Perquintilltdelegator_max_rate_percentagex,Perquintilldelegator_annual_reward_rate_percentagex,PerquintillDSet the annual inflation rate to derive per-round inflation.The inflation details are considered valid if the annual reward rateis approximately the per-block reward rate multiplied by theestimated* total number of blocks per year.The estimated average block time is twelve seconds.The dispatch origin must be Root.hEmits `RoundInflationSet`.(# 0Weight: O(1)d- Reads: [Origin Account]d- Writes: InflationConfig,# lset_max_selected_candidates new u32d Set the maximum number of collator candidates that can be selectedat the beginning of each validation round.Changes are not applied until the start of the next round. The new value must be higher than the minimum allowed as set in the\pallet's configuration.The dispatch origin must be Root.Emits `MaxSelectedCandidatesSet`.(# - The transaction's complexity is mainly dependent on updating the  `SelectedCandidates` storage in `select_top_candidates` which in return depends on the number of `MaxSelectedCandidates` (N).- For each N, we read `CandidatePool` from the storage.$---------Weight: O(N + D) where N is `MaxSelectedCandidates` bounded by`MaxTopCandidates` and D is the number of delegators of acandidate bounded by `MaxDelegatorsPerCollator`.- Reads: MaxSelectedCandidates, TopCandidates, N * CandidatePool|- Writes: MaxSelectedCandidates,# Pset_blocks_per_round new8T::BlockNumberDSet the number of blocks each validation round lasts. If the new value is less than the length of the current round, thesystem will immediately move to the next round in the next block. The new value must be higher than the minimum allowed as set in the\pallet's configuration.The dispatch origin must be Root.hEmits `BlocksPerRoundSet`.(# 0Weight: O(1)- Reads: [Origin Account], Round<- Writes: Round,# \set_max_candidate_stake new0BalanceOf0Set the maximal amount a collator can stake. Existing stakes are not changed.The dispatch origin must be Root.Emits `MaxCandidateStakeChanged`.(# 0Weight: O(1)- Reads: [Origin Account], MaxCollatorCandidateStake<- Writes: Round,# Xforce_remove_candidate collator::SourcehForcedly removes a collator candidate from the TopCandidates andclears all associated storage for the candidate and their,delegators.Prepares unstaking of the candidates and their delegators stakewhich can be unlocked via `unlock_unstaked` after waiting atleast `StakeDuration` many blocks.dEmits `CandidateRemoved`.(# - The transaction's complexity is mainly dependent on updating the  `SelectedCandidates` storage in `select_top_candidates` which in return depends on the number of `MaxSelectedCandidates` (N).- For each N, we read `CandidatePool` from the storage.$---------Weight: O(N + D) where N is `MaxSelectedCandidates` bounded by`MaxTopCandidates` and D is the number of delegators of thecollator candidate bounded by `MaxDelegatorsPerCollator`.- Reads: MaxCollatorCandidateStake, 2 * N * CandidatePool, TopCandidates, BlockNumber, D * DelegatorState, D * Unstaking- Writes: MaxCollatorCandidateStake, N * CandidatePool, D * DelegatorState, (D + 1) * Unstaking- Kills: CandidatePool, DelegatorState for all delegators which onlyp delegated to the candidate,# lJoin the set of collator candidates.In the next blocks, if the collator candidate has enough fundsstaked to be included in any of the top `MaxSelectedCandidates` positions, it will be included in the set of potential authors thatwill be selected by the stake-weighted random selection function.The staked funds of the new collator candidate are added to thehtotal stake of the system.The total amount of funds staked must be within the allowed range asset in the pallet's configuration.The dispatch origin must not be already part of the collatorcandidates nor of the delegators set.Emits `JoinedCollatorCandidates`.(# Weight: O(N + D) where N is `MaxSelectedCandidates` bounded by`MaxTopCandidates` and D is the number of delegators for thiscandidate bounded by `MaxDelegatorsPerCollator`.- Reads: [Origin Account], DelegatorState, MaxCollatorCandidateStake, Locks, TotalCollatorStake, TopCandidates, MaxSelectedCandidates, CandidatePool, - Writes: Locks, TotalCollatorStake, CandidatePool, TopCandidates,,# Tinit_leave_candidatesRequest to leave the set of collator candidates.On success, the account is immediately removed from the candidatepool to prevent selection as a collator in future validation rounds,but unstaking of the funds is executed with a delay of\`StakeDuration` blocks.The exit request can be reversed by callingh`cancel_leave_candidates`.This operation affects the pallet's total stake amount. It isupdated even though the funds of the candidate who signaled to leaveare still locked for `ExitDelay` + `StakeDuration` more blocks.NOTE: Upon starting a new session_i in `new_session`, the currenttop candidates are selected to be block authors for session_i+1. Anychanges to the top candidates afterwards do not effect the set of`authors for session_i+1.Thus, we have to make sure none of these collators canleave before session_i+1 ends by delaying theirexit for `ExitDelay` many blocks.xEmits `CollatorScheduledExit`.(# - The transaction's complexity is mainly dependent on updating the  `SelectedCandidates` storage in `select_top_candidates` which in return depends on the number of `MaxSelectedCandidates` (N).- For each N, we read `CandidatePool` from the storage.$---------Weight: O(N + D) where N is `MaxSelectedCandidates` bounded by`MaxTopCandidates` and D is the number of delegators for thiscandidate bounded by `MaxDelegatorsPerCollator`. - Reads: [Origin Account], TopCandidates, (N + 1) * CandidatePool,P TotalCollatorStake- Writes: CandidatePool, TopCandidates, TotalCollatorStake,# `execute_leave_candidates collator::Source`Execute the network exit of a candidate who requested to leave atleast `ExitQueueDelay` rounds ago. Prepares unstaking of thecandidates and their delegators stake which can be unlocked via`unlock_unstaked` after waiting at least `StakeDuration` manyblocks.Requires the candidate to previously have called``init_leave_candidates`.The exit request can be reversed by callingh`cancel_leave_candidates`.TEmits `CollatorLeft`.(# Weight: O(N + D + U) where where N is `MaxSelectedCandidates`bounded by `MaxTopCandidates`, D is the number of delegators forthis candidate bounded by `MaxDelegatorsPerCollator` and U is thenumber of locked unstaking requests bounded by `MaxUnstakeRequests`.- Reads: CandidatePool, Round, D * DelegatorState, Dx * BlockNumber, D * Unstaking- Writes: D * Unstaking, D * DelegatorState, Total- Kills: CandidatePool, DelegatorState,# \cancel_leave_candidates DRevert the previously requested exit of the network of a collator candidate. On success, adds back the candidate to the TopCandidateshand updates the collators.Requires the candidate to previously have called``init_leave_candidates`.tEmits `CollatorCanceledExit`.(# Weight: O(N + D) where N is `MaxSelectedCandidates` bounded by`MaxTopCandidates` and D is the number of delegators for thiscandidate bounded by `MaxDelegatorsPerCollator`.- Reads: [Origin Account], TotalCollatorStake, TopCandidates,< CandidatePool- Writes: TotalCollatorStake, CandidatePool, TopCandidates,# Pcandidate_stake_moremore0BalanceOf XStake more funds for a collator candidate.If not in the set of candidates, staking enough funds allows theaccount to be added to it. The larger amount of funds, the higherchances to be selected as the author of the next block.This operation affects the pallet's total stake amount.The resulting total amount of funds staked must be within theallowed range as set in the pallet's configuration.lEmits `CollatorStakedMore`.(# Weight: O(N + D + U) where where N is `MaxSelectedCandidates`bounded by `MaxTopCandidates`, D is the number of delegators forthis candidate bounded by `MaxDelegatorsPerCollator` and U is thenumber of locked unstaking requests bounded by `MaxUnstakeRequests`.- Reads: [Origin Account], Locks, TotalCollatorStake, MaxCollatorCandidateStake, TopCandidates, CandidatePool- Writes: Locks, TotalCollatorStake, CandidatePool, TopCandidates,# Pcandidate_stake_lessless0BalanceOf `Stake less funds for a collator candidate.If the new amount of staked fund is not large enough, the accountcould be removed from the set of collator candidates and not beconsidered for authoring the next blocks.This operation affects the pallet's total stake amount. The unstaked funds are not released immediately to the account, butthey will be available after `StakeDuration` blocks.The resulting total amount of funds staked must be within theallowed range as set in the pallet's configuration.lEmits `CollatorStakedLess`.(# Weight: O(N + D) where N is `MaxSelectedCandidates` bounded by`MaxTopCandidates` and D is the number of delegators for thiscandidate bounded by `MaxDelegatorsPerCollator`.- Reads: [Origin Account], Unstaking, TopCandidates, MaxSelectedCandidates, CandidatePool- Writes: Unstaking, CandidatePool, TotalCollatorStake,# ::Sourceamount0BalanceOf Join the set of delegators by delegating to a collator candidate.The account that wants to delegate cannot be part of the collator\candidates set as well.The caller must _not_ have delegated before. Otherwise,`delegate_another_candidate` should be called.The amount staked must be larger than the minimum required to becomea delegator as set in the pallet's configuration. As only `MaxDelegatorsPerCollator` are allowed to delegate a givencollator, the amount staked must be larger than the lowest one inthe current set of delegator for the operation to be meaningful. The collator's total stake as well as the pallet's total stake areXincreased accordingly.LEmits `Delegation`.Emits `DelegationReplaced` if the candidate has`MaxDelegatorsPerCollator` many delegations but this delegatorstaked more than one of the other delegators of this candidate.(# Weight: O(N + D) where N is `MaxSelectedCandidates` bounded by`MaxTopCandidates` and D is the number of delegators for thiscandidate bounded by `MaxDelegatorsPerCollator`.- Reads: [Origin Account], DelegatorState, TopCandidates, MaxSelectedCandidates, CandidatePool, LastDelegation, Round - Writes: Locks, CandidatePool, DelegatorState, TotalCollatorStake,@ LastDelegation,# hdelegate_another_candidate collator::Sourceamount0BalanceOf Delegate another collator's candidate by staking some funds andincreasing the pallet's as well as the collator's total stake.The account that wants to delegate cannot be part of the collator\candidates set as well.The caller _must_ have delegated before. Otherwise,`join_delegators` should be called.If the delegator has already delegated the maximum number ofcollator candidates, this operation will fail.The amount staked must be larger than the minimum required to becomea delegator as set in the pallet's configuration. As only `MaxDelegatorsPerCollator` are allowed to delegate a givencollator, the amount staked must be larger than the lowest one inthe current set of delegator for the operation to be meaningful. The collator's total stake as well as the pallet's total stake areXincreased accordingly.NOTE: This transaction is expected to throw until we increase`MaxCollatorsPerDelegator` by at least one, since it is currently,set to one.LEmits `Delegation`.Emits `DelegationReplaced` if the candidate has`MaxDelegatorsPerCollator` many delegations but this delegatorstaked more than one of the other delegators of this candidate.(# Weight: O(N + D) where N is `MaxSelectedCandidates` bounded by`MaxTopCandidates` and D is the number of delegators for thiscandidate bounded by `MaxDelegatorsPerCollator`.- Reads: [Origin Account], DelegatorState, TopCandidates, MaxSelectedCandidates, CandidatePool, LastDelegation, Round - Writes: Locks, CandidatePool, DelegatorState, TotalCollatorStake,@ LastDelegation,# @leave_delegatorsX Leave the set of delegators and, by implication, revoke all ongoing0delegations.All staked funds are not unlocked immediately, but they are added tothe queue of pending unstaking, and will effectively be released after `StakeDuration` blocks from the moment the delegator leaves. This operation reduces the total stake of the pallet as well as the stakes of all collators that were delegated, potentially affectingtheir chances to be included in the set of candidates in the nextrounds.XEmits `DelegatorLeft`.(# Weight: O(C) where C is the number of delegations for this delegatorwhich is bounded by by `MaxCollatorsPerDelegator`. - Reads: [Origin Account], DelegatorState, BlockNumber, Unstaking, TopCandidates, MaxSelectedCandidates, C * CandidatePool,- Writes: Unstaking, CandidatePool, TotalCollatorStake,\- Kills: DelegatorState,# Drevoke_delegation collator::Source\Terminates an ongoing delegation for a given collator candidate.The staked funds are not unlocked immediately, but they are added tothe queue of pending unstaking, and will effectively be releasedafter `StakeDuration` blocks from the moment the delegation is,terminated. This operation reduces the total stake of the pallet as well as the stakes of the collator involved, potentially affecting its chancesto be included in the set of candidates in the next rounds.XEmits `DelegatorLeft`.(# Weight: O(C) where C is the number of delegations for this delegatorwhich is bounded by by `MaxCollatorsPerDelegator`. - Reads: [Origin Account], DelegatorState, BlockNumber, Unstaking, Locks, TopCandidates, CandidatePool, MaxSelectedCandidates- Writes: Unstaking, Locks, DelegatorState, CandidatePool,P TotalCollatorStake- Kills: DelegatorState if the delegator has not delegated toH another collator,# Pdelegator_stake_more$candidate::Sourcemore0BalanceOfDIncrease the stake for delegating a collator candidate.If not in the set of candidates, staking enough funds allows thecollator candidate to be added to it.pEmits `DelegatorStakedMore`.(# Weight: O(N) + O(D) where N is `MaxSelectedCandidates` boundedby `MaxTopCandidates` and D the number of total delegators forthis collator bounded by `MaxCollatorsPerDelegator`.bounded by `MaxUnstakeRequests`. - Reads: [Origin Account], DelegatorState, BlockNumber, Unstaking, Locks, TopCandidates, CandidatePool, MaxSelectedCandidates- Writes: Unstaking, Locks, DelegatorState, CandidatePool,P TotalCollatorStake,# Pdelegator_stake_less$candidate::Sourceless0BalanceOf`Reduce the stake for delegating a collator candidate. If the new amount of staked fund is not large enough, the collatorcould be removed from the set of collator candidates and not beconsidered for authoring the next blocks. The unstaked funds are not release immediately to the account, butthey will be available after `StakeDuration` blocks.The remaining staked funds must still be larger than the minimumrequired by this pallet to maintain the status of delegator.The resulting total amount of funds staked must be within theallowed range as set in the pallet's configuration.pEmits `DelegatorStakedLess`.(# 0Weight: O(1) - Reads: [Origin Account], DelegatorState, BlockNumber, Unstaking, TopCandidates, CandidatePool, MaxSelectedCandidates- Writes: Unstaking, DelegatorState, CandidatePool,P TotalCollatorStake,# ::Source(Unlock all previously staked funds that are now available forunlocking by the origin account after `StakeDuration` blocks have elapsed.Weight: O(U) where U is the number of locked unstaking requestsbounded by `MaxUnstakeRequests`.- Reads: [Origin Account], Unstaking, Locksh- Writes: Unstaking, Locks- Kills: Unstaking & Locks if no balance is locked anymore,# %Contains one variant per dispatchable that can be called by an extrinsic.A Dparachain_stakingpalletErrorTxDDelegatorNotFoundThe account is not part of the delegators set.DCandidateNotFoundThe account is not part of the collator candidates set.::PublicQDsp_consensus_aurasr25519,app_sr25519PublicU8Sets 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.(# - Complexity: `O(1)`. Actual cost depends on the number of length of `T::Keys::key_ids()` which is fixed.- DbReads: `origin account`, `T::ValidatorIdOf`, `NextKeys`- DbWrites: `origin account`, `NextKeys`- DbReads per key id: `KeyOwner`- DbWrites per key id: `KeyOwner`,# (purge_keys@Removes any session key(s) of the function caller.This doesn't take effect until the next session.UThe 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 usuallyQmeans being a controller account) or directly convertible into a validator ID (whichusually means being a stash account).(# a- Complexity: `O(1)` in number of key types. Actual cost depends on the number of length of `T::Keys::key_ids()` which is fixed.- DbReads: `T::ValidatorIdOf`, `NextKeys`, `origin account`- DbWrites: `NextKeys`, `origin account`- DbWrites per key id: `KeyOwner`,# %Contains one variant per dispatchable that can be called by an extrinsic.i 8pallet_sessionpalletErrorT0InvalidProof`Invalid ownership proof.\NoAssociatedValidatorIdNo associated validator ID for account.4DuplicatedKeydRegistered duplicate key.NoKeysNo keys are associated with this account.$NoAccountKey setting account is not live, so it's impossible to associate keys.tError for the session pallet.m4frame_supportstorage@weak_bounded_vec8WeakBoundedVecTQSqVecqQuHsp_consensus_slotsSlot u64y \cumulus_pallet_aura_extpalletCallT%Contains one variant per dispatchable that can be called by an extrinsic.} $@pallet_democracy8PreimageStatus $AccountIdBalance,BlockNumberMissing,BlockNumber$Availabledata(Vec provider$AccountIddepositBalancesince,BlockNumberexpiryALOption @pallet_democracytypes8ReferendumInfo ,BlockNumberHash$BalanceOngoingReferendumStatus Finished approvedbool end,BlockNumber @pallet_democracytypes@ReferendumStatus ,BlockNumberHash$Balance end,BlockNumber4proposal_hash$Hash$threshold4VoteThresholddelay,BlockNumbertally8Tally @pallet_democracytypesTallyBalance ayesBalancenaysBalanceturnoutBalance @pallet_democracyvoteVoting Balance$AccountId,BlockNumberDirect votesVec<(ReferendumIndex, AccountVote)>,delegationsPDelegationsprior|PriorLock(DelegatingbalanceBalancetarget$AccountId(conviction(Conviction,delegationsPDelegationsprior|PriorLock @pallet_democracytypes,DelegationsBalancevotesBalancecapitalBalance @pallet_democracyvote$PriorLock,BlockNumberBalance,BlockNumberBalance @pallet_democracy(conviction(ConvictionNone Locked1x Locked2x Locked3x Locked4x Locked5x Locked6x$@pallet_democracy ReleasesV1 @pallet_democracypalletCallTdpropose4proposal_hash$T::Hashvalue0BalanceOf,Propose a sensitive action to be taken.The dispatch origin of this call must be _Signed_ and the sender musthave funds to cover the deposit.- `proposal_hash`: The hash of the proposal preimage.- `value`: The amount of deposit (must be at least `MinimumDeposit`).DEmits `Proposed`.8Weight: `O(p)`second proposal$PropIndexLseconds_upper_bound u32(Signals agreement with a particular proposal.The dispatch origin of this call must be _Signed_ and the sendermust have funds to cover the deposit, equal to the original deposit.- `proposal`: The index of the proposal to second.A- `seconds_upper_bound`: an upper bound on the current number of seconds on this% proposal. Extrinsic is weighted according to this value with no refund.Weight: `O(S)` where S is the number of seconds a proposal already has.vote$ref_index>$1Vote in a referendum. 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_.- `ref_index`: The index of the referendum to vote for.- `vote`: The vote configuration.-Weight: `O(R)` where R is the number of referendums the voter has voted on.@emergency_cancel$ref_index P9Delegate the voting power (with some given conviction) of the sending account.UThe balance delegated is locked for as long as it's delegated, and thereafter for thetime 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; orY - have no voting activity (if there is, then it will need to be removed/consolidated through `reap_vote` or `unvote`).E- `to`: The account whose voting the `target` account's voting power will follow.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 referendums the voter delegating to has voted on. Weight is charged as if maximum votes.(undelegate 0Undelegate the voting power of the sending account.]Tokens may be unlocked following once an amount of time consistent with the lock periodof the conviction with which the delegation was issued.EThe dispatch origin of this call must be _Signed_ and the signing account must beTcurrently delegating.PEmits `Undelegated`.=Weight: `O(R)` where R is the number of referendums the voter delegating to has voted on. Weight is charged as if maximum votes.Xclear_public_proposals pClears all public proposals.The dispatch origin of this call must be _Root_.(]Register the preimage for an upcoming proposal. This doesn't require the proposal to be!in the dispatch queue but does require a deposit, returned once enacted.The dispatch origin of this call must be _Signed_.- `encoded_proposal`: The preimage of a proposal.XEmits `PreimageNoted`.MWeight: `O(E)` with E size of `encoded_proposal` (protected by a required deposit).dnote_preimage_operational@encoded_proposal(Vec Same as `note_preimage` but origin is `OperationalPreimageOrigin`.Xnote_imminent_preimage@encoded_proposal(Vec0ARegister the preimage for an upcoming proposal. This requires the proposal to be=in the dispatch queue. No deposit is needed. When this call is successful, i.e.5the preimage has not been uploaded before and matches some imminent proposal,-Same as `note_imminent_preimage` but origin is `OperationalPreimageOrigin`.4reap_preimage4proposal_hash$T::Hash`proposal_len_upper_bound u32::decode_len()`%Contains one variant per dispatchable that can be called by an extrinsic.OptionTNoneSome @pallet_democracypalletErrorTp ValueLow4Value too lowDspiritnet_runtimeCallhSystem!self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch ::CallableCallFor$Timestampmself::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch ::CallableCallForIndicesyself::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch ::CallableCallFor Balancesself::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch ::CallableCallFor(Authorshipself::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch ::CallableCallFor@ParachainStaking=self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch ::CallableCallForSessioneself::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch ::CallableCallForAuraExtyself::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch ::CallableCallFor$Democracyself::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch ::CallableCallForCouncilself::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch ::CallableCallForHTechnicalCommitteeself::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch ::CallableCallFor LTechnicalMembershipself::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch ::CallableCallFor" Treasuryself::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch ::CallableCallFor#Utilityself::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch ::CallableCallFor(Vestingself::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch ::CallableCallFor)$Scheduler self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch ::CallableCallFor*Proxyself::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch ::CallableCallFor+ Preimageself::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch ::CallableCallFor,(KiltLaunch!self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch ::CallableCallFor<Ctype)self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch ::CallableCallFor=,Attestation-self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch ::CallableCallFor>(Delegation1self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch ::CallableCallFor? DidMself::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch ::CallableCallFor@$DidLookupself::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch ::CallableCallForC$Web3Namesself::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch ::CallableCallForDP Dpallet_collectivepalletCallTI,set_members ,new_membersDVecprimePOption$old_count,MemberCountSet the collective's membership.E- `new_members`: The new member list. Be nice to the chain and provide it sorted.- `prime`: The prime member whose vote sets the default.Y- `old_count`: The upper bound for the previous number of members in storage. Used forP weight estimation.TRequires root origin.QNOTE: Does not enforce the expected `MaxMembers` limit on the amount of members, but! the weight estimations rely on it to estimate dispatchable weight.(# WARNING:YThe `pallet-collective` can also be managed by logic outside of the pallet through theimplementation of the trait [`ChangeMembers`].UAny call to `set_members` must be careful that the member set doesn't get out of syncwith other logic managing the member set.(# $## WeightP- `O(MP + N)` where: - `M` old-members-count (code- and governance-bounded) - `N` new-members-count (code- and governance-bounded) - `P` proposals-count (code-bounded)- DB:Q - 1 storage mutation (codec `O(M)` read, `O(N)` write) for reading and writing the, members - 1 storage read (codec `O(P)`) for reading the proposalsE - `P` storage mutations (codec `O(M)`) for updating the votes for each proposal] - 1 storage write (codec `O(1)`) for deleting the old `prime` and setting the new one,# execute proposal|Box<>::Proposal>0length_bound u32,Dispatch a proposal from a member using the `Member` origin.Origin must be a member of the collective.(# $## WeightU- `O(M + P)` where `M` members-count (code-bounded) and `P` complexity of dispatching0 `proposal`- DB: 1 read (codec `O(M)`) + DB access of `proposal`$- 1 event,# propose $threshold,MemberCount proposal|Box<>::Proposal>0length_bound u32lAdd a new proposal to either be voted on or executed directly.Requires the sender to be member.A`threshold` determines whether `proposal` is executed directly (`threshold < 2`)Tor put up for voting.(# $## Weight- `O(B + M + P1)` or `O(B + M + P2)` where: - `B` is `proposal` size in bytes (length-fee-bounded) - `M` is members-count (code- and governance-bounded) - branching is influenced by `threshold` where: - `P1` is proposal execution complexity (`threshold < 2`) - `P2` is proposals-count (code-bounded) (`threshold >= 2`)- DB: - 1 storage read `is_member` (codec `O(M)`) - 1 storage read `ProposalOf::contains_key` (codec `O(1)`) - DB accesses influenced by `threshold`:  - EITHER storage accesses done by `proposal` (`threshold < 2`) - OR proposal insertion (`threshold <= 2`) - 1 storage mutation `Proposals` (codec `O(P2)`) - 1 storage mutation `ProposalCount` (codec `O(1)`) - 1 storage write `ProposalOf` (codec `O(B)`) - 1 storage write `Voting` (codec `O(M)`), - 1 event,# vote  proposal$T::Hashindex4ProposalIndexapprovebool$## Weight - `O(M)` where `M` is members-count (code- and governance-bounded)- DB: - 1 storage read `Members` (codec `O(M)`) - 1 storage mutation `Voting` (codec `O(M)`)$- 1 event,# close4proposal_hash$T::Hashindex4ProposalIndexTproposal_weight_boundqWeight0length_bound u32MClose a vote that is either approved, disapproved or whose voting period has ended.UMay be called by any signed account in order to finish voting and close the proposal.IIf called before the end of the voting period it will only close the vote if it ishas enough votes to be approved or disapproved.IIf called after the end of the voting period abstentions are counted as rejections%unless there is a prime member set and the prime member cast an approval.aIf the close operation completes successfully with disapproval, the transaction fee will]be waived. Otherwise execution of the approved operation will be charged to the caller.a+ `proposal_weight_bound`: The maximum amount of weight consumed by executing the closed$proposal.a+ `length_bound`: The upper bound for the length of the proposal in storage. Checked via5`storage::read` so it is `size_of::() == 4` larger than the pure length.(# $## Weightt- `O(B + M + P1 + P2)` where: - `B` is `proposal` size in bytes (length-fee-bounded) - `M` is members-count (code- and governance-bounded) - `P1` is the complexity of `proposal` preimage. - `P2` is proposal-count (code-bounded)- DB:  - 2 storage reads (`Members`: codec `O(M)`, `Prime`: codec `O(1)`)Y - 3 mutations (`Voting`: codec `O(M)`, `ProposalOf`: codec `O(B)`, `Proposals`: codec, `O(P2)`) - any mutations done while executing `proposal` (`P1`)@- up to 3 events,# Ldisapprove_proposal4proposal_hash$T::Hash8YDisapprove a proposal, close, and remove it from the system, regardless of its currentstate.Must be called by the Root origin.,Parameters:* `proposal_hash`: The hash of the proposal that should be disapproved.(# Complexity: O(P) where P is the number of max proposals(DB Weight:H* Reads: Proposals* Writes: Voting, Proposals, ProposalOf,# %Contains one variant per dispatchable that can be called by an extrinsic. Dpallet_collectivepalletCallTI,set_members ,new_membersDVecprimePOption$old_count,MemberCountSet the collective's membership.E- `new_members`: The new member list. Be nice to the chain and provide it sorted.- `prime`: The prime member whose vote sets the default.Y- `old_count`: The upper bound for the previous number of members in storage. Used forP weight estimation.TRequires root origin.QNOTE: Does not enforce the expected `MaxMembers` limit on the amount of members, but! the weight estimations rely on it to estimate dispatchable weight.(# WARNING:YThe `pallet-collective` can also be managed by logic outside of the pallet through theimplementation of the trait [`ChangeMembers`].UAny call to `set_members` must be careful that the member set doesn't get out of syncwith other logic managing the member set.(# $## WeightP- `O(MP + N)` where: - `M` old-members-count (code- and governance-bounded) - `N` new-members-count (code- and governance-bounded) - `P` proposals-count (code-bounded)- DB:Q - 1 storage mutation (codec `O(M)` read, `O(N)` write) for reading and writing the, members - 1 storage read (codec `O(P)`) for reading the proposalsE - `P` storage mutations (codec `O(M)`) for updating the votes for each proposal] - 1 storage write (codec `O(1)`) for deleting the old `prime` and setting the new one,# execute proposal|Box<>::Proposal>0length_bound u32,Dispatch a proposal from a member using the `Member` origin.Origin must be a member of the collective.(# $## WeightU- `O(M + P)` where `M` members-count (code-bounded) and `P` complexity of dispatching0 `proposal`- DB: 1 read (codec `O(M)`) + DB access of `proposal`$- 1 event,# propose $threshold,MemberCount proposal|Box<>::Proposal>0length_bound u32lAdd a new proposal to either be voted on or executed directly.Requires the sender to be member.A`threshold` determines whether `proposal` is executed directly (`threshold < 2`)Tor put up for voting.(# $## Weight- `O(B + M + P1)` or `O(B + M + P2)` where: - `B` is `proposal` size in bytes (length-fee-bounded) - `M` is members-count (code- and governance-bounded) - branching is influenced by `threshold` where: - `P1` is proposal execution complexity (`threshold < 2`) - `P2` is proposals-count (code-bounded) (`threshold >= 2`)- DB: - 1 storage read `is_member` (codec `O(M)`) - 1 storage read `ProposalOf::contains_key` (codec `O(1)`) - DB accesses influenced by `threshold`:  - EITHER storage accesses done by `proposal` (`threshold < 2`) - OR proposal insertion (`threshold <= 2`) - 1 storage mutation `Proposals` (codec `O(P2)`) - 1 storage mutation `ProposalCount` (codec `O(1)`) - 1 storage write `ProposalOf` (codec `O(B)`) - 1 storage write `Voting` (codec `O(M)`), - 1 event,# vote  proposal$T::Hashindex4ProposalIndexapprovebool$## Weight - `O(M)` where `M` is members-count (code- and governance-bounded)- DB: - 1 storage read `Members` (codec `O(M)`) - 1 storage mutation `Voting` (codec `O(M)`)$- 1 event,# close4proposal_hash$T::Hashindex4ProposalIndexTproposal_weight_boundqWeight0length_bound u32MClose a vote that is either approved, disapproved or whose voting period has ended.UMay be called by any signed account in order to finish voting and close the proposal.IIf called before the end of the voting period it will only close the vote if it ishas enough votes to be approved or disapproved.IIf called after the end of the voting period abstentions are counted as rejections%unless there is a prime member set and the prime member cast an approval.aIf the close operation completes successfully with disapproval, the transaction fee will]be waived. Otherwise execution of the approved operation will be charged to the caller.a+ `proposal_weight_bound`: The maximum amount of weight consumed by executing the closed$proposal.a+ `length_bound`: The upper bound for the length of the proposal in storage. Checked via5`storage::read` so it is `size_of::() == 4` larger than the pure length.(# $## Weightt- `O(B + M + P1 + P2)` where: - `B` is `proposal` size in bytes (length-fee-bounded) - `M` is members-count (code- and governance-bounded) - `P1` is the complexity of `proposal` preimage. - `P2` is proposal-count (code-bounded)- DB:  - 2 storage reads (`Members`: codec `O(M)`, `Prime`: codec `O(1)`)Y - 3 mutations (`Voting`: codec `O(M)`, `ProposalOf`: codec `O(B)`, `Proposals`: codec, `O(P2)`) - any mutations done while executing `proposal` (`P1`)@- up to 3 events,# Ldisapprove_proposal4proposal_hash$T::Hash8YDisapprove a proposal, close, and remove it from the system, regardless of its currentstate.Must be called by the Root origin.,Parameters:* `proposal_hash`: The hash of the proposal that should be disapproved.(# Complexity: O(P) where P is the number of max proposals(DB Weight:H* Reads: Proposals* Writes: Voting, Proposals, ProposalOf,# %Contains one variant per dispatchable that can be called by an extrinsic. Dpallet_membershippalletCallTI(add_member who0T::AccountId xAdd a member `who` to the set.May only be called from `T::AddOrigin`.4remove_member who0T::AccountId Remove a member `who` from the set.May only be called from `T::RemoveOrigin`.,swap_memberremove0T::AccountId add0T::AccountIdSwap out one member `remove` for another `add`.May only be called from `T::SwapOrigin`. Prime membership is *not* passed from `remove` to `add`, if extant.4reset_membersmembersDVecUChange the membership to a new set, disregarding the existing membership. Be nice andhpass `members` pre-sorted.May only be called from `T::ResetOrigin`.(change_key new0T::AccountIdSwap out the sending member for some other key `new`.May only be called from `Signed` origin of a current member.Prime membership is passed from the origin account to `new`, if extant.$set_prime who0T::AccountId Set the prime member. Must be a current member.May only be called from `T::PrimeOrigin`.,clear_prime Remove the prime member if it exists.May only be called from `T::PrimeOrigin`.%Contains one variant per dispatchable that can be called by an extrinsic. ,beneficiary::Source$)Put forward a suggestion for spending. A deposit proportional to the value1is reserved and slashed if the proposal is rejected. It is returned once thePproposal is awarded.(# H- Complexity: O(1)- DbReads: `ProposalCount`, `origin account`- DbWrites: `ProposalCount`, `Proposals`, `origin account`,# H- Complexity: O(1)- DbReads: `Proposals`, `rejected proposer account`- DbWrites: `Proposals`, `rejected proposer account`,# @approve_proposal,proposal_id4ProposalIndex(YApprove a proposal. At a later time, the proposal will be allocated to the beneficiaryand the original deposit will be returned.May only be called from `T::ApproveOrigin`.(# L- Complexity: O(1).- DbReads: `Proposals`, `Approvals`X- DbWrite: `Approvals`,# %Contains one variant per dispatchable that can be called by an extrinsic. 8pallet_utilitypalletCallTbatchcalls`Vec<::Call>L|Send a batch of dispatch calls.xMay be called from any origin.]- `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).]If origin is root then call are dispatch without checking origin filter. (This includesbypassing `frame_system::Config::BaseCallFilter`).(# - Complexity: O(C) where C is the number of calls to be batched.,# UThis will return `Ok` in all circumstances. To determine the success of the batch, an1event is deposited. If a call failed and the batch was interrupted, then theU`BatchInterrupted` event is deposited, along with the number of successful calls madeMand the error of the failed call. If all were successful, then the `BatchCompleted`Levent is deposited.4as_derivativeindex u16call`Box<::Call>4Send a call through an indexed pseudonym of the sender.UFilter from origin are passed along. The call will be dispatched with an origin whichuse the same filter as the origin of this call.ENOTE: If you need to ensure that any account-based filtering is not honored (i.e.abecause you expect `proxy` to have been used prior in the call stack and you do not wantQthe 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_allcalls`Vec<::Call>8Send a batch of dispatch calls and atomically execute them.!The whole transaction will rollback and fail if any of the calls failed.xMay be called from any origin.]- `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).]If origin is root then call are dispatch without checking origin filter. (This includesbypassing `frame_system::Config::BaseCallFilter`).(# - Complexity: O(C) where C is the number of calls to be batched.,# ,dispatch_as$as_originTBoxcall`Box<::Call>(Dispatches a function call with a provided origin.The dispatch origin for this call must be _Root_.(# - O(1).`- Limited storage reads.\- One DB write (event).- Weight of derivative `call` execution + T::WeightInfo::dispatch_as().,# %Contains one variant per dispatchable that can be called by an extrinsic.Dspiritnet_runtime0OriginCallersystemtframe_system::OriginCouncilpallet_collective::OriginHTechnicalCommitteepallet_collective::Origin DidPdid::Origin@Voidself::sp_api_hidden_includes_construct_runtime::hidden_include::Void 4frame_support dispatch$RawOrigin$AccountId RootSigned$AccountIdNoneDpallet_collective$RawOrigin$AccountIdI Members,MemberCount,MemberCountMember$AccountId _PhantomDpallet_collective$RawOrigin$AccountIdI Members,MemberCount,MemberCountMember$AccountId _Phantom didorigin0DidRawOrigin4DidIdentifier$AccountIdid4DidIdentifier$submitter$AccountIdsp_coreVoid 8pallet_vestingpalletCallTvest4Unlock 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`.(# $- `O(1)`.t- DbWeight: 2 Reads, 2 Writes - Reads: Vesting Storage, Balances Locks, [Sender Account] - Writes: Vesting Storage, Balances Locks, [Sender Account],# (vest_othertarget::Source$- `O(1)`.t- DbWeight: 3 Reads, 3 Writes - Reads: Vesting Storage, Balances Locks, Target Account - Writes: Vesting Storage, Balances Locks, Target Account,# ::Source scheduleVestingInfo, T::BlockNumber>DdCreate 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.(# $- `O(1)`.t- DbWeight: 3 Reads, 3 Writes9 - Reads: Vesting Storage, Balances Locks, Target Account, [Sender Account]= - Writes: Vesting Storage, Balances Locks, Target Account, [Sender Account],# Tforce_vested_transfer source::Sourcetarget::Source scheduleVestingInfo, T::BlockNumber>H`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.(# $- `O(1)`.t- DbWeight: 4 Reads, 4 Writes1 - Reads: Vesting Storage, Balances Locks, Target Account, Source Account5 - Writes: Vesting Storage, Balances Locks, Target Account, Source Account,# > priorityHschedule::PrioritycallPBox>pAnonymously schedule a task.cancelwhen8T::BlockNumberindex u32Cancel an anonymously scheduled task.8schedule_namedid(Vecwhen8T::BlockNumber8maybe_periodic Option> priorityHschedule::PrioritycallPBox>XSchedule a named task.0cancel_namedid(VecxCancel a named scheduled task.8schedule_afterafter8T::BlockNumber8maybe_periodic Option> priorityHschedule::PrioritycallPBox>Anonymously schedule a task after a delay.(# TSame as [`schedule`].,# Pschedule_named_afterid(Vecafter8T::BlockNumber8maybe_periodic Option> priorityHschedule::PrioritycallPBox>Schedule a named task after a delay.(# Same as [`schedule_named`](Self::schedule_named).,# %Contains one variant per dispatchable that can be called by an extrinsic. OptionTNoneSome4frame_supporttraits schedule,MaybeHashedTHash$ValueTHash$Hash 0pallet_proxypalletCallT(proxy real0T::AccountId@force_proxy_typePOptioncall`Box<::Call>Weight is a function of the number of proxies the user has (P).,# $add_proxy  delegate0T::AccountId(proxy_type0T::ProxyTypedelay8T::BlockNumber4ERegister 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.(# Weight is a function of the number of proxies the user has (P).,# 0remove_proxy  delegate0T::AccountId(proxy_type0T::ProxyTypedelay8T::BlockNumber,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.(# Weight is a function of the number of proxies the user has (P).,# 8remove_proxies(Unregister all proxy accounts for the sender.The dispatch origin for this call must be _Signed_.UWARNING: This may be called on accounts created by `anonymous`, however if done, thenYthe unreserved fees will be inaccessible. **All access to this account will be lost.**(# Weight is a function of the number of proxies the user has (P).,# $anonymous (proxy_type0T::ProxyTypedelay8T::BlockNumberindex u16\9Spawn a fresh new account that is guaranteed to be otherwise inaccessible, andinitialize 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 theMnew 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.QFails with `Duplicate` if this has already been called in this transaction, from thesame sender, with the same parameters.Fails if there are insufficient funds to pay for deposit.(# Weight is a function of the number of proxies the user has (P).,# TODO: Might be over counting 1 read8kill_anonymousspawner0T::AccountId(proxy_type0T::ProxyTypeindex u16heightq8T::BlockNumber$ext_index u32PRemoves a previously spawned anonymous proxy.IWARNING: **All access to this account will be lost.** Any funds held in it will be4inaccessible.YRequires a `Signed` origin, and the sender account must have been created by a call to`anonymous` with corresponding parameters.M- `spawner`: The account that originally called `anonymous` to create this account.M- `index`: The disambiguation index originally passed to `anonymous`. Probably `0`.- `proxy_type`: The proxy type originally passed to `anonymous`.=- `height`: The height of the chain when the call to `anonymous` was processed.I- `ext_index`: The extrinsic index in which the call to `anonymous` was processed.IFails with `NoPermission` in case the caller is not a previously created anonymousaccount whose `anonymous` call has corresponding parameters.(# Weight is a function of the number of proxies the user has (P).,# announcereal0T::AccountId$call_hash$4CallHashOfTPublish 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.(# `Weight is a function of:- A: the number of announcements made.- P: the number of proxies the user has.,# Lremove_announcementreal0T::AccountId$call_hash$4CallHashOf@pRemove a given announcement.YMay 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.(# `Weight is a function of:- A: the number of announcements made.- P: the number of proxies the user has.,# Lreject_announcement delegate0T::AccountId$call_hash$4CallHashOf@Remove the given announcement of a delegate.aMay 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.(# `Weight is a function of:- A: the number of announcements made.- P: the number of proxies the user has.,# call`Box<::Call> DMDispatch 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.(# `Weight is a function of:- A: the number of announcements made.- P: the number of proxies the user has.,# %Contains one variant per dispatchable that can be called by an extrinsic.OptionTNoneSome tRegister a preimage on-chain.UIf the preimage was previously requested, no fees or deposits are taken for providingUthe preimage. Otherwise, a deposit is taken proportional to the size of the preimage.- The transaction's complexity is proportional to the size of storage entries in `UnlockingAt` (N) which is practically uncapped but in theory it should be `MaxClaims` at most.$---------Weight: O(N) where N is the number of accounts for which the lockwill be removed for the given block.- Reads: UnlockingAt, [Origin Account] - Kills: UnlockingAt (if N > 0), Locks (if N > 0), BalanceLocks (if N > 0),# \change_transfer_account@transfer_account::Source$Forcedly change the transfer account to the specified account.The dispatch origin must be Root.(# 0Weight: O(1)d- Reads: [Origin Account]d- Writes: TransferAccount,# \migrate_genesis_accountsource::Sourcetarget::SourceTransfer tokens and vesting information or the KILT balance lockfrom an unowned source address to an account owned by the target.If vesting info or a KILT balance lock has been set up for thesource account in the genesis block via `GenesisBuild`, then the corresponding locked/vested information and balance is migrated automatically. Please note that even though this extrinsic supportsmigrating both the KILT balance lock as well as vesting in one call, all source accounts should only contain either a KILT balance lock,or vesting.Additionally, for vesting we already unlock the usable balance until the current block. This should enable the userto pay the transaction fees for the next call of `vest` which isalways required to be explicitly called in order to unlock (more)Tbalance from vesting.NOTE: Setting the KILT balance lock actually only occurs in this call (and not when building the genesis block in `GenesisBuild`) toavoid overhead from handling locks when migrating. We can do so because all target accounts are not owned by anyone and thus thesecannot sign and/or call any extrinsics.The dispatch origin must be TransferAccount.Emits either `AddedVesting` or `AddedKiltLock`.(# 0Weight: O(1)- Reads: [Origin Account], TransferAccount, Locks, Balance, Vesting,8 BalanceLocks- Writes: Locks, Balance, UnownedAccount, Vesting (if source is vesting), BalanceLocks (if source is locking), UnlockingAt (ifP source is locking)- Kills (for source): Locks, Balance, UnownedAccount, Vesting (if source is vesting), BalanceLocks (if source is locking),# migrate_multiple_genesis_accountssources%Vec<::Source>target::Source`Transfer all balances, vesting information and KILT balance locksfrom multiple source addresses to the same target address. See `migrate_genesis_account` for details as we run the same logic`for each source address.The dispatch origin must be TransferAccount. Emits N events which are either `AddedVesting` or `AddedKiltLock`.(# - The transaction's complexity is proportional to the size of `sources` (N) which is capped at CompactAssignments::LIMIT4 (MaxClaims)$---------Weight: O(N) where N is the number of source addresses. - Reads: [Origin Account], TransferAccount, UnownedAccount, Locks, Balance, Vesting, BalanceLocks- Writes: Locks, Balance, Vesting (if any source is vesting), BalanceLocks (if aby source is locking), UnlockingAt (if anyP source is locking) - Kills (for sources): Locks, Balance, UnownedAccount, Vesting (if any source is vesting), BalanceLocks (if any source is locking),# ::Sourceamount::BalanceLTransfer KILT locked tokens to another account similar to`pallet_vesting::vested_transfer`.Expects the source to have a KILT balance lock and at least thespecified amount available as balance locked with LockIdD`KILT_LAUNCH_ID`.Calls `migrate_kilt_balance_lock` internally.Emits `LockedTransfer` and if target does not have KILT balancelockup prior to transfer `AddedKiltLock`.(# 0Weight: O(1)- Reads: [Origin Account], Locks, Balance, BalanceLocks, UnlockingAt- Writes: Locks, Balance, BalanceLocks, UnlockingAt- Kills (if source transfers all locked balance): Locks,l BalanceLocks, UnlockingAt,# %Contains one variant per dispatchable that can be called by an extrinsic.%) ctypepalletCallT addctype(Vec0 Create a new CType from the given unique CType hash and associatesPit with its creator.A CType with the same hash must not be stored on chain.TEmits `CTypeCreated`.(# 0Weight: O(1)`- Reads: Ctypes, Balanced- Writes: Ctypes, Balance,# %Contains one variant per dispatchable that can be called by an extrinsic.- ,attestationpalletCallT add (claim_hash$8ClaimHashOf(ctype_hash$8CtypeHashOf4delegation_idtOption>TdCreate a new attestation.The attester can optionally provide a reference to an existing delegation that will be saved along with the attestation itself inthe form of an attested delegation.The referenced CType hash must already be present on chain. If an optional delegation id is provided, the dispatch origin mustbe the owner of the delegation. Otherwise, it could be anyT`DelegationEntityId`.lEmits `AttestationCreated`.(# 0Weight: O(1)- Reads: [Origin Account], Ctype, Attestations- Reads if delegation id is provided: Delegations, Roots,\ DelegatedAttestations- Writes: Attestations, (DelegatedAttestations),# revoke(claim_hash$8ClaimHashOfDmax_parent_checks u32D|Revoke an existing attestation.The revoker must be either the creator of the attestation being revoked or an entity that in the delegation tree is an ancestor of the attester, i.e., it was either the delegator of the attester orPan ancestor thereof.lEmits `AttestationRevoked`.(# Weight: O(P) where P is the number of steps required to verify that the dispatch Origin controls the delegation entitled to revoke theattestation. It is bounded by `max_parent_checks`.- Reads: [Origin Account], Attestations, delegation::Roots- Reads per delegation step P: delegation::Delegations- Writes: Attestations, DelegatedAttestations,# remove(claim_hash$8ClaimHashOfDmax_parent_checks u32DXRemove an attestation.The origin must be either the creator of the attestation or an entity which is an ancestor of the attester in the delegation tree,i.e., it was either the delegator of the attester or an ancestor thereof.lEmits `AttestationRemoved`.(# Weight: O(P) where P is the number of steps required to verify that the dispatch Origin controls the delegation entitled to revoke theattestation. It is bounded by `max_parent_checks`.- Reads: [Origin Account], Attestations, delegation::Roots- Reads per delegation step P: delegation::Delegations- Writes: Attestations, DelegatedAttestations,# $Reclaim a storage deposit by removing an attestationdEmits `DepositReclaimed`.(# 0Weight: O(1)- Reads: [Origin Account], Attestations, DelegatedAttestations- Writes: Attestations, DelegatedAttestations,# %Contains one variant per dispatchable that can be called by an extrinsic.1 (delegationpalletCallT@create_hierarchy0root_node_id$TDelegationNodeIdOf(ctype_hash$8CtypeHashOfdCreate a new delegation root associated with a given CType hash.The new root will allow a new trust hierarchy to be created byadding children delegations to the root. There must be no delegation with the same ID stored on chain, whilethere must be already a CType with the given hash stored in the4CType pallet.The dispatch origin must be split into * a submitter of type `AccountId` who is responsible for paying theT transaction fee and * a DID subject of type `DelegationEntityId` who creates, owns andp can revoke the delegation. Requires the sender of the transaction to have a reservable balanceof at least `Deposit` many tokens.PEmits `RootCreated`.(# 0Weight: O(1)- Reads: [Origin Account], Roots, CTypes<- Writes: Roots,# 8add_delegation4delegation_id$TDelegationNodeIdOf$parent_id$TDelegationNodeIdOf delegate@DelegatorIdOf,permissions,PermissionsHdelegate_signature5hDelegateSignatureTypeOftCreate a new delegation node.The new delegation node represents a new trust hierarchy that considers the new node as its root. The owner of this node has fullcontrol over any of its direct and indirect descendants.For the creation to succeed, the delegatee must provide a validsignature over the (blake256) hash of the creation operation detailswhich include (in order) delegation id, root node id, parent id, andppermissions of the new node.There must be no delegation with the same id stored on chain.Furthermore, the referenced root and parent nodes must already bepresent on chain and contain the valid permissions and revocationlstatus (i.e., not revoked).The dispatch origin must be split into * a submitter of type `AccountId` who is responsible for paying theT transaction fee and * a DID subject of type `DelegationEntityId` who creates, owns andp can revoke the delegation. Requires the sender of the transaction to have a reservable balanceof at least `Deposit` many tokens.hEmits `DelegationCreated`.(# 0Weight: O(1)- Reads: [Origin Account], Roots, DelegationsT- Writes: Delegations,# Drevoke_delegation 4delegation_id$TDelegationNodeIdOfDmax_parent_checks u32Weight: O(C) where C is the number of children of the delegationnode which is bounded by `max_children`.- Reads: [Origin Account], Roots, C * Delegations, C * Children.- Writes: Roots, C * Delegations,# Dremove_delegation4delegation_id$TDelegationNodeIdOf0max_removals u32pRemove a delegation node (potentially a root node) and all its$children.Returns the delegation deposit to the deposit owner for eachremoved DelegationNode by unreserving it. Removing a delegation node results in the trust hierarchy startingfrom the given node being removed. Nevertheless, removal starts from the leave nodes upwards, so if the operation ends prematurelybecause it runs out of gas, the delegation state would be consistentas no child would "survive" its parent. As a consequence, if the given node is removed, the trust hierarchy with the node as root isdto be considered removed.The dispatch origin must be split into * a submitter of type `AccountId` who is responsible for paying theT transaction fee and * a DID subject of type `DelegationEntityId` who creates, owns andp can revoke the delegation.xEmits C * `DelegationRemoved`.(# Weight: O(C) where C is the number of children of the delegationnode which is bounded by `max_children`.- Reads: [Origin Account], Roots, C * Delegations, C * Children.- Writes: Roots, 2 * C * Delegations,# 0max_removals u32`Reclaim the deposit for a delegation node (potentially a rootnode), removing the node and all its children.Returns the delegation deposit to the deposit owner for eachremoved DelegationNode by unreserving it. Removing a delegation node results in the trust hierarchy startingfrom the given node being removed. Nevertheless, removal starts from the leave nodes upwards, so if the operation ends prematurelybecause it runs out of gas, the delegation state would be consistentas no child would "survive" its parent. As a consequence, if the given node is removed, the trust hierarchy with the node as root isdto be considered removed. The dispatch origin must be signed by the delegation deposit owner.L`DepositReclaimed`.(# Weight: O(C) where C is the number of children of the delegationnode which is bounded by `max_removals`.- Reads: [Origin Account], Roots, C * Delegations, C * Children.- Writes: Roots, 2 * C * Delegations,# %Contains one variant per dispatchable that can be called by an extrinsic.5 did,did_details0DidSignature Ed255199Hed25519::SignatureSr25519AHsr25519::SignatureEcdsaE@ecdsa::Signature9 sp_coreed25519$Signature= [u8; 64]=@A sp_coresr25519$Signature= [u8; 64]E sp_coreecdsa$SignatureI [u8; 65]IAM didpalletCallT4createdetailsQhBox>$signature50DidSignature|Store a new DID on chain, after verifying that the creationoperation has been signed by the KILT account associated with theidentifier of the DID being created and that a DID with the sameidentifier has not previously existed on (and then deleted from) thechain. There must be no DID information stored on chain under the same DID,identifier.The new keys added with this operation are stored under the DIDidentifier along with the block number in which the operation was$executed.The dispatch origin can be any KILT account with enough funds to execute the extrinsic and it does not have to be tied in any way tothe KILT account identifying the DID subject.LEmits `DidCreated`.(# - The transaction's complexity is mainly dependent on the number of new key agreement keys and the number of new service endpointsp included in the operation.$---------Weight: O(K) + O(N) where K is the number of new key agreement keys bounded by `MaxNewKeyAgreementKeys`, while N is the number ofnew service endpoints bounded by `MaxNumberOfServicesPerDid`.- Reads: [Origin Account], Did, DidBlacklist- Writes: Did (with K new key agreement keys), ServiceEndpoints (with N new service endpoints), DidEndpointsCount,# Xset_authentication_keynew_keyiHDidVerificationKey@Update the DID authentication key.The old key is deleted from the set of public keys if it is not used in any other part of the DID. The new key is added to theLset of public keys.The dispatch origin must be a DID origin proxied via thep`submit_did_call` extrinsic.LEmits `DidUpdated`.(# 0Weight: O(1)x- Reads: [Origin Account], Did4- Writes: Did,# Hset_delegation_keynew_keyiHDidVerificationKey@Set or update the DID delegation key. If an old key existed, it is deleted from the set of public keys ifit is not used in any other part of the DID. The new key is added to\the set of public keys.The dispatch origin must be a DID origin proxied via thep`submit_did_call` extrinsic.LEmits `DidUpdated`.(# 0Weight: O(1)x- Reads: [Origin Account], Did4- Writes: Did,# Tremove_delegation_key0Weight: O(1)x- Reads: [Origin Account], Did4- Writes: Did,# Lset_attestation_keynew_keyiHDidVerificationKey@Set or update the DID attestation key. If an old key existed, it is deleted from the set of public keys ifit is not used in any other part of the DID. The new key is added to\the set of public keys.The dispatch origin must be a DID origin proxied via thep`submit_did_call` extrinsic.LEmits `DidUpdated`.(# 0Weight: O(1)x- Reads: [Origin Account], Did4- Writes: Did,# Xremove_attestation_key<|Remove the DID attestation key.The old key is deleted from the set of public keys ifit is not used in any other part of the DID.The dispatch origin must be a DID origin proxied via thep`submit_did_call` extrinsic.LEmits `DidUpdated`.(# 0Weight: O(1)x- Reads: [Origin Account], Did4- Writes: Did,# Tadd_key_agreement_keynew_keyY@DidEncryptionKey8Add a single new key agreement key to the DID.The new key is added to the set of public keys.The dispatch origin must be a DID origin proxied via thep`submit_did_call` extrinsic.LEmits `DidUpdated`.(# 0Weight: O(1)x- Reads: [Origin Account], Did4- Writes: Did,# `remove_key_agreement_keykey_id$(KeyIdOf4Remove a DID key agreement key from both its set of key agreementkeys and as well as its public keys.The dispatch origin must be a DID origin proxied via thep`submit_did_call` extrinsic.LEmits `DidUpdated`.(# 0Weight: O(1)x- Reads: [Origin Account], Did4- Writes: Did,# Padd_service_endpoint@service_endpoint}8DidEndpoint0Add a new service endpoint under the given DID.The dispatch origin must be a DID origin proxied via thep`submit_did_call` extrinsic.LEmits `DidUpdated`.(# 0Weight: O(1) - Reads: [Origin Account], Did, ServiceEndpoints, DidEndpointsCount- Writes: Did, ServiceEndpoints, DidEndpointsCount,# \remove_service_endpoint(service_idPServiceEndpointId 0Remove the service with the provided ID from the DID.The dispatch origin must be a DID origin proxied via thep`submit_did_call` extrinsic.LEmits `DidUpdated`.(# 0Weight: O(1)- Reads: [Origin Account], ServiceEndpoints, DidEndpointsCount- Writes: Did, ServiceEndpoints, DidEndpointsCount,# deleteLendpoints_to_remove u32 ` Delete a DID from the chain and all information associated with it,after verifying that the delete operation has been signed by the DIDsubject using the authentication key currently stored on chain.The referenced DID identifier must be present on chain before thexdelete operation is evaluated.After it is deleted, a DID with the same identifier cannot beXre-created ever again.As the result of the deletion, all traces of the DID are removedfrom the storage, which results in the invalidation of allattestations issued by the DID subject.The dispatch origin must be a DID origin proxied via thep`submit_did_call` extrinsic.LEmits `DidDeleted`.(# 0Weight: O(1)x- Reads: [Origin Account], Did- Kills: Did entry associated to the DID identifier,# Lendpoints_to_remove u32 TReclaim a deposit for a DID. This will delete the DID and all information associated with it, after verifying that the caller isdthe owner of the deposit.The referenced DID identifier must be present on chain before thexdelete operation is evaluated.After it is deleted, a DID with the same identifier cannot beXre-created ever again.As the result of the deletion, all traces of the DID are removedfrom the storage, which results in the invalidation of allattestations issued by the DID subject.LEmits `DidDeleted`.(# 0Weight: O(1)x- Reads: [Origin Account], Did- Kills: Did entry associated to the DID identifier,# >$signature50DidSignature Proxy a dispatchable call of another runtime extrinsic thatXsupports a DID origin.The referenced DID identifier must be present on chain before the`operation is dispatched.A call submitted through this extrinsic must be signed with the right DID key, depending on the call. This information is provided by the `DidAuthorizedCallOperation` parameter, which specifies the DID subject acting as the origin of the call, the DID's tx counter(nonce), the dispatchable to call in case signature verificationsucceeds, the type of DID key to use to verify the operationsignature, and the block number the operation was targeting forinclusion, when it was created and signed.In case the signature is incorrect, the nonce is not valid, therequired key is not present for the specified DID, or the blockspecified is too old the verification fails and the call is notdispatched. Otherwise, the call is properly dispatched with a`DidOrigin` origin indicating the DID subject.A successful dispatch operation results in the tx counter associatedwith the given DID to be incremented, to mitigate replay attacks.The dispatch origin can be any KILT account with enough funds to execute the extrinsic and it does not have to be tied in any way tothe KILT account identifying the DID subject.hEmits `DidCallDispatched`.(# Weight: O(1) + weight of the dispatched callx- Reads: [Origin Account], Did4- Writes: Did,# %Contains one variant per dispatchable that can be called by an extrinsic.Q did,did_detailsHDidCreationDetailsT didHDidIdentifierOf$submitter8AccountIdOfXnew_key_agreement_keysUlDidNewKeyAgreementKeySetLnew_attestation_keyehOptionHnew_delegation_keyehOptionLnew_service_detailsyLVec>U4frame_supportstorageDbounded_btree_setY did,did_details@DidEncryptionKeyX25519 [u8; 32]] BTreeSetTYaaYeOptionTiNoneSomeii did,did_detailsHDidVerificationKey Ed25519m4service_typestServiceEndpointTypeEntriesurlspServiceEndpointUrlEntries4frame_supportstorage,bounded_vec(BoundedVecTS(Vec4frame_supportstorage,bounded_vec(BoundedVecTSVec4frame_supportstorage,bounded_vec(BoundedVecTS(Vec4frame_supportstorage,bounded_vec(BoundedVecTSVec4frame_supportstorage,bounded_vec(BoundedVecTS(Vec did,did_detailshDidAuthorizedCallOperationT didHDidIdentifierOf(tx_counter u64call@DidCallableOf0block_number@BlockNumberOf$submitter8AccountIdOf Dpallet_did_lookuppalletCallTDassociate_account account8AccountIdOf(expiration::BlockNumberproof8SignatureOfDAssociate the given account to the DID that authorized this call.The account has to sign the DID and a blocknumber after which thesignature expires in order to authorize the association.The signature will be checked against the scale encoded tuple of the method specific id of the did identifier and the block number afterwhich the signature should be regarded invalid.Emits `AssociationEstablished` and, optionally, `AssociationRemoved`if there was a previous association for the account.(# 0Weight: O(1)- Reads: ConnectedDids + ConnectedAccounts + DID Origin Check- Writes: ConnectedDids + ConnectedAccounts,# @associate_sender,Associate the sender of the call to the DID that authorized thiscall.Emits `AssociationEstablished` and, optionally, `AssociationRemoved`if there was a previous association for the account.(# 0Weight: O(1)- Reads: ConnectedDids + ConnectedAccounts + DID Origin Check- Writes: ConnectedDids + ConnectedAccounts,# dremove_sender_association(Remove the association of the sender account. This call doesn't require the authorization of the DID, but requires a signed origin.lEmits `AssociationRemoved`.(# 0Weight: O(1)- Reads: ConnectedDids + ConnectedAccounts + DID Origin Check- Writes: ConnectedDids + ConnectedAccounts,# hremove_account_associationaccount8AccountIdOf,Remove the association of the provided account ID. This call doesn't require the authorization of the account ID, but the associated DIDneeds to match the DID that authorized this call.lEmits `AssociationRemoved`.(# 0Weight: O(1)- Reads: ConnectedDids + ConnectedAccounts + DID Origin Check- Writes: ConnectedDids + ConnectedAccounts,# , Remove the association of the provided account. This call can onlybe called from the deposit owner. The reserved deposit will befreed.lEmits `AssociationRemoved`.(# 0Weight: O(1)X- Reads: ConnectedDids\- Writes: ConnectedDids,# %Contains one variant per dispatchable that can be called by an extrinsic.(sp_runtime8MultiSignature Ed255199Hed25519::SignatureSr25519AHsr25519::SignatureEcdsaE@ecdsa::Signature Dpallet_web3_namespalletCallTclaimname@Web3NameInput0Weight: O(1) - Reads: Names, Owner, Banned storage entries + available currencyX check + origin check- Writes: Names, Owner storage entries + currency deposit reserve,# @release_by_owner0Release the provided name from its owner.The origin must be the owner of the specified name.Emits `Web3NameReleased` if the operation is carried out4successfully.(# 0Weight: O(1)- Reads: Names storage entry + origin check- Writes: Names, Owner storage entries + currency deposit release,# 0Release the provided name from its owner.The origin must be the account that paid for the name's deposit.Emits `Web3NameReleased` if the operation is carried out4successfully.(# 0Weight: O(1)- Reads: Owner storage entry + origin check- Writes: Names, Owner storage entries + currency deposit release,# banname@Web3NameInput@,Ban a name.A banned name cannot be claimed by anyone. The name's depositis returned to the original payer.The origin must be the ban origin.Emits `Web3NameBanned` if the operation is carried out4successfully.(# 0Weight: O(1)- Reads: Banned, Owner, Names storage entries + origin check- Writes: Names, Owner, Banned storage entries + currency deposit$ release,# unbanname@Web3NameInput84Unban a name.pMake a name claimable again.The origin must be the ban origin.Emits `Web3NameUnbanned` if the operation is carried out4successfully.(# 0Weight: O(1)- Reads: Banned storage entry + origin check- Writes: Banned storage entry deposit release,# %Contains one variant per dispatchable that can be called by an extrinsic. |cumulus_pallet_parachain_systempalletCallTLset_validation_datadataTParachainInherentData$Set the current validation data.AThis should be invoked exactly once per block. It will panic at the finalizationphase if the call was not invoked.The dispatch origin for this call must be `Inherent`!As a side effect, this function upgrades the current validation functionif the appropriate time has come.`sudo_send_upward_messagemessage(4UpwardMessageDauthorize_upgrade$code_hash$T::Hash`enact_authorized_upgradecode(Vec%Contains one variant per dispatchable that can be called by an extrinsic.cumulus_primitives_parachain_inherentTParachainInherentDataLhorizontal_messagesBTreeMap> Lpolkadot_primitivesv1\PersistedValidationDataH$N,parent_head HeadDataLrelay_parent_numberNdrelay_parent_storage_root$H0max_pov_size u32 Hpolkadot_parachain(primitives HeadData(Vec sp_trie4storage_proof0StorageProof(trie_nodes10Vec>`polkadot_core_primitivesXInboundDownwardMessage,BlockNumbersent_at,BlockNumber msg(Dpallet_collectiveVotes$AccountId,BlockNumberindex4ProposalIndex$threshold,MemberCountayes8Vecnays8Vec end,BlockNumber Dpallet_collectivepalletErrorTI($NotMember\Account is not a memberDDuplicateProposal|Duplicate proposals not allowed Dpallet_collectivepalletErrorTI($NotMember\Account is not a memberDDuplicateProposal|Duplicate proposals not allowed 4sp_arithmetic(per_thingsPermill u32OptionTNoneSome4frame_support PalletIda[u8; 8]  8pallet_vesting ReleasesV0V1 8pallet_vestingpalletErrorT(NotVestingThe account given is not vesting.TAtMaxVestingSchedules%The account already has `MaxVestingSchedules` count of schedules and thusQcannot add another one. Consider merging existing schedules in order to add another.$AmountLowAmount being transferred is too low to create a vesting schedule.`ScheduleIndexOutOfBoundsAn 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.!%%OptionT)NoneSome))@pallet_scheduler,ScheduledV3Call,BlockNumber4PalletsOrigin$AccountId maybe_id> priorityHschedule::PrioritycallCall8maybe_periodic Option>origin4PalletsOrigin- @pallet_schedulerpalletErrorT@FailedToScheduledFailed to schedule a call NotFound|Cannot find the scheduled call.\TargetBlockNumberInPastGiven target block number is in the past.HRescheduleNoChangeReschedule failed because it does not change scheduled time. Custom [dispatch errors](https://docs.substrate.io/v3/runtime/events-and-errors) of this pallet. 1554frame_supportstorage,bounded_vec(BoundedVecT9S=Vec90pallet_proxyI0pallet_proxy0Announcement $AccountIdHash$,BlockNumber real$AccountId$call_hash$Hashheight,BlockNumberMIQ 0pallet_proxypalletErrorT TooMany!There are too many proxies registered or too many announcements pending. NotFoundtProxy registration not found. NotProxySender 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.0NoPermissionCall may not be made by proxy because it may escalate its privileges.,UnannouncedAnnouncement, if made at all, was made too recently.,NoSelfProxydCannot add self as proxy. Custom [dispatch errors](https://docs.substrate.io/v3/runtime/events-and-errors) of this pallet. U$Requested u32YOptionT]NoneSome]]a4frame_supportstorage,bounded_vec(BoundedVecTS(Vece m ,kilt_launchpallet4LockedBalanceTblock::BlockNumberamount::Balanceq ,kilt_launchpalletErrorT0LBalanceLockNotFoundThe source address does not have KILT balance lock which is|required for `locked_transfer`.`ConflictingLockingBlocksThe source and destination address have limits for their custom KILTbalance lock and thus cannot be merged. Should never be thrown.`ConflictingVestingStarts The source and destination address differ in their vesting startingblocks and thus cannot be merged. Should never be thrown.DMaxClaimsExceededWhen migrating multiple accounts to the same target, the size of thelist of source addresses should never exceed `MaxClaims`.4ExpectedLocksThe source address does not have any balance lock at all which is|required for `locked_transfer`.LInsufficientBalanceThe source address has less balance available than the locked amountwhich should be transferred in `locked_transfer`.dInsufficientLockedBalanceThe source address has less locked balance than the amount whichshould be transferred in `locked_transfer`.DNotUnownedAccountThe source address is not a valid address which was set up as anunowned account in the genesis build.XMultipleVestingSchemesThe source address has more than one vesting scheme which shouldponly be a theoretical issue. attester4AttesterOf4delegation_idtOption>revokedbooldeposit}Deposit, BalanceOf>} 0kilt_supportdepositDepositAccountBalanceownerAccountamountBalance4frame_supportstorage,bounded_vec(BoundedVecT$S Vec ,attestationpalletErrorT$parenttOption> childrenBoundedBTreeSet, T::MaxChildren>detailsPDelegationDetailsdeposit}Deposit, BalanceOf>4frame_supportstorageDbounded_btree_set BTreeSetT$  (delegationPdelegation_hierarchyDDelegationDetailsT owner@DelegatorIdOfrevokedbool,permissions,Permissions (delegationPdelegation_hierarchyhDelegationHierarchyDetailsT(ctype_hash$8CtypeHashOf (delegationpalletErrorTT\DelegationAlreadyExistsThere is already a delegation node with the same ID stored on chain.`InvalidDelegateSignatureThe delegate's signature for the delegation creation operation is invalid.HDelegationNotFoundNo delegation with the given ID stored on chain.@DelegateNotFoundNo delegate with the given ID stored on chain.XHierarchyAlreadyExistsThere is already a hierarchy with the same ID stored on chain.DHierarchyNotFoundNo hierarchy with the given ID stored on chain.TMaxSearchDepthReached Max number of nodes checked without verifying the given condition.hNotOwnerOfParentDelegationThe delegation creator is not allowed to write the delegationbecause they are not the owner of the delegation parent node.tNotOwnerOfDelegationHierarchyThe delegation creator is not allowed to write the delegationbecause they are not the owner of the delegation root node.`ParentDelegationNotFound No parent delegation with the given ID stored on chain.\ParentDelegationRevoked The parent delegation has previously been revoked.XUnauthorizedRevocation The delegation revoker is not allowed to revoke the delegation.LUnauthorizedRemoval The call origin is not authorized to remove the delegation.XUnauthorizedDelegation The delegation creator is not allowed to create the delegation.`ExceededRevocationBounds Max number of revocations for delegation nodes has been reached for8the operation.TExceededRemovalBoundsMax number of removals for delegation nodes has been reached for the(operation.XMaxRevocationsTooLargeThe max number of revocation exceeds the limit for the pallet.LMaxRemovalsTooLargeThe max number of removals exceeds the limit for the pallet.\MaxParentChecksTooLargeThe max number of parent checks exceeds the limit for the pallet.4InternalErrorAn error that is not supposed to take place, yet it happened.LMaxChildrenExceededThe max number of all children has been reached for thexcorresponding delegation node. Custom [dispatch errors](https://docs.substrate.io/v3/runtime/events-and-errors) of this pallet.  did,did_details(DidDetailsTHauthentication_key$(KeyIdOfHkey_agreement_keys`DidKeyAgreementKeySet8delegation_keyHOption>>,public_keysHDidPublicKeyMap, BalanceOf>4frame_supportstorageDbounded_btree_set4frame_supportstorageDbounded_btree_map did,did_detailsLDidPublicKeyDetailsT key0DidPublicKey0block_number@BlockNumberOf did,did_details0DidPublicKeyTPublicVerificationKeyiHDidVerificationKeyLPublicEncryptionKeyY@DidEncryptionKey BTreeMapK$V$ didpalletErrorTlXInvalidSignatureFormatThe DID operation signature is not in the format the verification0key expects.@InvalidSignatureThe DID operation signature is invalid for the payload and thehverification key provided.DDidAlreadyPresentThe DID with the given identifier is already present on chain.4DidNotPresentNo DID with the given identifier is present on chain.dVerificationKeyNotPresent One or more verification keys referenced are not stored in the setTof verification keys.0InvalidNonce The DID operation nonce is not equal to the current DID nonce + 1.|UnsupportedDidAuthorizationCallThe called extrinsic does not support DID authorisation.lInvalidDidAuthorizationCallThe call had parameters that conflicted with each other@or were invalid.MaxKeyAgreementKeysLimitExceeded A number of new key agreement keys greater than the maximum allowedHhas been provided.lMaxPublicKeysPerDidExceeded The maximum number of public keys for this DID key identifier has4been reached.MaxTotalKeyAgreementKeysExceeded The maximum number of key agreements has been reached for the DID subject.0BadDidOrigin The DID call was submitted by the wrong accountHTransactionExpired  The block number provided in a DID-authorized operation is invalid.DDidAlreadyDeleted The DID has already been previously deleted.DNotOwnerOfDepositOnly the owner of the deposit can reclaim its reserved balance. Dpallet_did_lookuppalletErrorTLAssociationNotFound|The association does not exist.4NotAuthorizedThe origin was not allowed to manage the association between the DIDLand the account ID.4OutdatedProofThe supplied proof of ownership was outdated.DInsufficientFundsThe account has insufficient funds and can't pay the fees or reserve0the deposit. Custom [dispatch errors](https://docs.substrate.io/v3/runtime/events-and-errors) of this pallet.  Dpallet_web3_names$web3_nameDWeb3NameOwnership OwnerDeposit},BlockNumber ownerOwner(claimed_at,BlockNumberdeposit}Deposit Dpallet_web3_namespalletErrorT0DInsufficientFunds The tx submitter does not have enough funds to pay for the deposit.XWeb3NameAlreadyClaimedThe specified name has already been previously claimed.@Web3NameNotFoundThe specified name does not exist.HOwnerAlreadyExistsThe specified owner already owns a name.4OwnerNotFoundThe specified owner does not own any names.8Web3NameBannedThe specified name has been banned and cannot be interactedwith.DWeb3NameNotBannedThe specified name is not currently banned.TWeb3NameAlreadyBannedThe specified name has already been previously banned.4NotAuthorizedThe actor cannot performed the specified operation.@Web3NameTooShort A name that is too short is being claimed. Lpolkadot_primitivesv1LAbridgedHrmpChannel0max_capacity u328max_total_size u32@max_message_size u32$msg_count u32(total_size u32 mqc_head0Option Lpolkadot_primitivesv1dAbridgedHostConfiguration$4max_code_size u32Hmax_head_data_size u32Xmax_upward_queue_count u32Tmax_upward_queue_size u32\max_upward_message_size u32max_upward_message_num_per_candidate u32hrmp_max_message_num_per_candidate u32lvalidation_upgrade_cooldown,BlockNumber`validation_upgrade_delay,BlockNumbercumulus_primitives_parachain_inherentDMessageQueueChain$$RelayHash BTreeMapKV   `polkadot_core_primitivesLOutboundHrmpMessageId$recipientIddata(Psp_std::vec::Vec |cumulus_pallet_parachain_systempalletErrorT LOverlappingUpgradesAttempt to upgrade validation function while existing upgrade pendingPProhibitedByPolkadotIPolkadot currently prohibits this parachain from upgrading its validation functionTooBigEThe supplied validation function has compiled into a blob larger than Polkadot is8willing to runhValidationDataNotAvailableThe inherent which supplies the validation data did not run this blocktHostConfigurationNotAvailable%The inherent which supplies the host configuration did not run this block0NotScheduledNo validation function upgrade is currently scheduled.DNothingAuthorizedNo code upgrade has been authorized.0UnauthorizedThe given code upgrade has not been authorized. Custom [dispatch errors](https://docs.substrate.io/v3/runtime/events-and-errors) of this pallet. (sp_runtimegenericLunchecked_extrinsicHUncheckedExtrinsicAddressCall$SignatureExtra(!%)-59=!0frame_system(extensionsHcheck_spec_version@CheckSpecVersionT%0frame_system(extensions@check_tx_version8CheckTxVersionT)0frame_system(extensions4check_genesis0CheckGenesisT-0frame_system(extensions 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$Mortal25550frame_system(extensions,check_nonce(CheckNonceTq T::Index90frame_system(extensions0check_weight,CheckWeightT=hpallet_transaction_payment`ChargeTransactionPaymentT0BalanceOfADspiritnet_runtimeRuntime|SystemSystem@Account Q The full account information for a particular account ID.8ExtrinsicCount Total extrinsics count for the current block.,BlockWeight ` The current weight for the block.@AllExtrinsicsLenA Total length (in bytes) for all extrinsics put together, for the current block.$BlockHash$ Map of block numbers to block hashes.4ExtrinsicData(= 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$p Hash of the previous block.Digest, Digest of the current block, also part of the block header.Events< Events deposited for the current block.Y NOTE: This storage item is explicitly unbounded since it is never intended to be readd from within the runtime.(EventCount The number of events in the `Events` list.,EventTopics$(% Mapping between a topic (represented by T::Hash) and a vector of indexes of events in the `>` 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.M The value has the type `(T::BlockNumber, 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.HLastRuntimeUpgradeU Stores the `spec_version` and `spec_name` of when the last runtime upgrade happened.TUpgradedToU32RefCountM 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.!H0BlockWeights5*Rjt@YsKOW@YshRjt@Ys Block & extrinsics weights: base values and limits.,BlockLengthE0<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). DbWeightM@@x}  The weight of runtime database operations the runtime can invoke.VersionQ8kilt-spiritnet8kilt-spiritnet|)(jh`7|O[?7ȻP@:ҼЏ'?EL<r)q\2bo=ib Get the chain's current version.(SS58Prefix& The designated SS85 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.e`RandomnessCollectiveFlip`RandomnessCollectiveFlip8RandomMateriali a Series of block headers from the last 81 blocks that acts as random seed material. Thisa is arranged as a ring buffer with `block_number % 81` being the index into the `Vec` ofD the oldest hash.$Timestamp$Timestamp Now  Current time for the current block.$DidUpdate Did the timestamp get updated in this block?m4MinimumPeriod pM The minimum period between blocks. Beware that this is different to the *expected*] period that the block production apparatus provides. Your chosen consensus system will] generally work with this to determine a sensible block time. e.g. For Aura, it will be double this period on default settings.IndicesIndices Accountsu The lookup from index to account.yhDeposit@|(5 The deposit needed for reserving an index.} Balances Balances4TotalIssuance@ The total units issued 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, frame_system::Provider, AccountId, Self::AccountData> } ``` 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. Reserves Named reserves on some account balances.8StorageVersion | Storage version of the pallet. This is set to v2.0.0 for new networks.l HExistentialDeposit@rN  The minimum amount required to keep an account open. MaxLocks2 The maximum number of locks that should exist on an account. Not strictly enforced, but used for weight estimation.,MaxReserves2  The maximum number of named reserves that can exist on an account.HTransactionPaymentHTransactionPaymentDNextFeeMultiplier@d 8StorageVersion HTransactionByteFee@ʚ;  The fee to be paid for making a transaction; the per-byte portion.`OperationalFeeMultiplierTY A fee mulitplier for `Operational` extrinsics to compute "virtual tip" to boost their, `priority`M This value is multipled 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.,WeightToFee\{8v.  The polynomial that is applied in order to derive fee from weight.(Authorship(Authorship Uncles UnclesAuthord Author of current block.0DidSetUncles Whether uncles were already set in this block.@UncleGenerations The number of blocks back we should accept uncles. This means that we will deal with uncle-parents that are `UncleGenerations + 1` before `now`.@ParachainStaking@ParachainStaking4TMaxSelectedCandidates  The maximum number of collator candidates selected at each round.RoundP Current round number and next round scheduled transition.8LastDelegation   Delegation information for the latest session in which a delegator, delegated. It maps from an account to the number of delegations in the last session in which they (re-)delegated.8DelegatorState Delegation staking information. It maps from an account to its delegation details.4CandidatePool The staking information for a candidate. It maps from an account to its information. Moreover, it counts the number of candidates.\CounterForCandidatePoolCounter for the related counted storage mapHTotalCollatorStake Total funds locked to back the currently selected collators. The sum of all collator and their delegator stakes.! Note: There are more funds locked by this pallet, since the backing for  non collating candidates is not included in [TotalCollatorStake].4TopCandidates( The collator candidates with the highest amount of stake. Each time the stake of a collator is increased, it is checked whether this pushes another candidate out of the list. When the stake is! reduced however, it is not checked if another candidate has more stake, since this would require iterating over the entire [CandidatePool]. There must always be more candidates than [MaxSelectedCandidates] so  that a collator can drop out of the collator set by reducing their stake.(Delegation(Delegation,"  The amount of balance that will be taken for each DID as a deposit to incentivise fair use of the on chain storage. The deposit can be reclaimed when the DID is deleted. Fee@ =y-  The amount of balance that will be taken for each DID as a fee to  incentivise fair use of the on chain storage. The fee will not get refunded when the DID is deleted.LMaxPublicKeysPerDid  Maximum number of total public keys which can be stored per DID key identifier. This includes the ones currently used for authentication, key agreement, attestation, and delegation.XMaxNewKeyAgreementKeys  Maximum number of key agreement keys that can be added in a creation, operation.`MaxTotalKeyAgreementKeys Maximum number of total key agreement keys that can be stored for a4 DID subject. Should be greater than `MaxNewKeyAgreementKeys`.LMaxBlocksTxValidity , The maximum number of blocks a DID-authorized operation is considered valid after its creation.dMaxNumberOfServicesPerDid The maximum number of services that can be stored under a DID.HMaxServiceIdLength2 The maximum length of a service ID.PMaxServiceTypeLength2 The maximum length of a service type description.hMaxNumberOfTypesPerService  The maximum number of a types description for a service endpoint.LMaxServiceUrlLength The maximum length of a service URL.dMaxNumberOfUrlsPerService The maximum number of a URLs for a service endpoint.@$InflationLInitialPeriodLength H  The length of the initial period in which the constant reward is minted. Once the current block exceeds this, rewards are no further issued.LInitialPeriodReward@69 The amount of newly issued tokens per block during the initial period.B$DidLookup$DidLookup4ConnectedDids Mapping from account identifiers to DIDs.DConnectedAccounts Mapping from (DID + account identifier) -> ().  The empty tuple is used as a sentinel value to simply indicate the presence of a given tuple in the map.Deposit@֑6  The amount of balance that will be taken for each DID as a deposit to incentivise fair use of the on chain storage. The deposit can be reclaimed when the DID is deleted.C$Web3Names$Web3Names Owner Map of name -> ownership details.NamesX Map of owner -> name.Banned L Map of name -> (). If a name key is present, the name is currently banned. Deposit@P]k The amount of KILT to deposit to claim a name.4MinNameLength The min encoded length of a name.4MaxNameLength  The max encoded length of a name.D