quantus-cli 2.1.1

metaQ(sp_runtime0multiaddress0MultiAddress$AccountId
0AccountIndex

Id
$AccountIdIndex
0AccountIndex
Raw
Vec<u8>$Address32
 [u8; 32]$Address20
 [u8; 20]sp_corecrypto,AccountId32
 [u8; 32]  <quantus_runtime,RuntimeCall
4System$
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<System, Runtime>$Timestamp@
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Timestamp, Runtime>
 BalancesH
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Balances, Runtime> Preimage`
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Preimage, Runtime>Utilityh
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Utility, Runtime>	LReversibleTransfers�
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<ReversibleTransfers, Runtime>8TechCollective�
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<TechCollective, Runtime>
4TechReferenda�
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<TechReferenda, Runtime>8TreasuryPallet�
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<TreasuryPallet, Runtime> Recovery�
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Recovery, Runtime> Multisig�
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Multisig, Runtime> Wormhole�
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Wormhole, Runtime>Vesting�
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Vesting, Runtime>$0frame_systempalletCallT
,remark
remark
Vec<u8>hMake some on-chain remark.�Can be executed by every `origin`.8set_heap_pages
pages(
u64
�Set the number of pages in the WebAssembly environment's heap. set_code
code
Vec<u8>dSet the new runtime code.\set_code_without_checks
code
Vec<u8>
Set the new runtime code without doing any checks of the given `code`.Q
Note that runtime upgrades will not run if this is called with a not-increasing spec version!,set_storage
items,
4Vec<KeyValue>hSet some items of storage.0kill_storage
keys4
 Vec<Key>tKill some items from storage.,kill_prefix
prefix
Key
subkeys8
u32
Kill all storage items with a key that starts with the given prefix.9
**NOTE:** We rely on the Root origin to provide us the number of subkeys under=
the prefix we are removing to accurately calculate the weight of this function.Dremark_with_event
remark
Vec<u8>�Make some on-chain remark and emit event.Dauthorize_upgrade
$code_hash<
T::Hash	a
Authorize an upgrade to a given `code_hash` for the runtime. The runtime can be suppliedlater.|This call requires Root origin.�authorize_upgrade_without_checks
$code_hash<
T::Hash
 a
Authorize an upgrade to a given `code_hash` for the runtime. The runtime can be suppliedlater.]
WARNING: This authorizes an upgrade that will take place without any safety checks, forY
example that the spec name remains the same and that the version number increases. Not�recommended for normal use. Use `authorize_upgrade` instead.|This call requires Root origin.`apply_authorized_upgrade
code
Vec<u8>$U
Provide the preimage (runtime binary) `code` for an upgrade that has been authorized.I
If the authorization required a version check, this call will ensure the spec name�remains unchanged and that the spec version has increased.Y
Depending on the runtime's `OnSetCode` configuration, this function may directly apply
the new `code` in the same block or attempt to schedule the upgrade.`All origins are allowed.

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

Contains a variant per dispatchable extrinsic that this pallet has.D(H<pallet_balancespalletCallTI
$Ptransfer_allow_death
dest
PAccountIdLookupOf<T>
valueL
(T::Balance�Transfer some liquid free balance to another account.5
`transfer_allow_death` will set the `FreeBalance` of the sender and receiver.
If the sender's account is below the existential deposit as a result�of the transfer, the account will be reaped.
The dispatch origin for this call must be `Signed` by the transactor.8force_transfer
source
PAccountIdLookupOf<T>
dest
PAccountIdLookupOf<T>
valueL
(T::Balancea
Exactly as `transfer_allow_death`, except the origin must be root and the source accountDmay be specified.Ltransfer_keep_alive
dest
PAccountIdLookupOf<T>
valueL
(T::BalanceY
Same as the [`transfer_allow_death`] call, but with a check that the transfer will not`kill the origin account.�99% of the time you want [`transfer_allow_death`] instead.�[`transfer_allow_death`]: struct.Pallet.html#method.transfer0transfer_all
dest
PAccountIdLookupOf<T>
(keep_aliveT
bool<
Transfer the entire transferable balance from the caller account.Y
NOTE: This function only attempts to transfer _transferable_ balances. This means thata
any locked, reserved, or existential deposits (when `keep_alive` is `true`), will not be]
transferred by this function. To ensure that this function results in a killed account,E
you might need to prepare the account by removing any reference counters, storage@deposits, etc...�The dispatch origin of this call must be Signed.�- `dest`: The recipient of the transfer.Y
- `keep_alive`: A boolean to determine if the `transfer_all` operation should send allM
  of the funds the account has, causing the sender account to be killed (false), orY
  transfer everything except at least the existential deposit, which will guarantee to�  keep the sender account alive (true).<force_unreserve
who
PAccountIdLookupOf<T>
amountP
(T::Balance�Unreserve some balance from a user by force.lCan only be called by ROOT.@upgrade_accounts
whoX
DVec<T::AccountId> pUpgrade a specified account.t- `origin`: Must be `Signed`.�- `who`: The account to be upgraded.U
This will waive the transaction fee if at least all but 10% of the accounts needed toA
be upgraded. (We let some not have to be upgraded just in order to allow for theXpossibility of churn).Dforce_set_balance
who
PAccountIdLookupOf<T>
 new_freeL
(T::Balance�Set the regular balance of a given account.�The dispatch origin for this call is `root`.lforce_adjust_total_issuance
$direction\
LAdjustmentDirection
deltaL
(T::Balance	�Adjust the total issuance in a saturating way.�Can only be called by root and always needs a positive `delta`.$# Exampleburn
valueL
(T::Balance
(keep_aliveT
bool
�Burn the specified liquid free balance from the origin account.%
If the origin's account ends up below the existential deposit as a result	
of the burn and `keep_alive` is false, the account will be reaped.Q
Unlike sending funds to a _burn_ address, which merely makes the funds inaccessible,!
this `burn` operation will reduce total issuance by the amount _burned_.

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

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

Contains a variant per dispatchable extrinsic that this pallet has.d<h8pallet_utilitypalletCallT
 batch
callsl
|Vec<<T as Config>::RuntimeCall>H|Send a batch of dispatch calls.�May be called from any origin except `None`.]
- `calls`: The calls to be dispatched from the same origin. The number of call must not9
  exceed the constant: `batched_calls_limit` (available in constant metadata).U
If origin is root then the calls are dispatched without checking origin filter. (This�includes bypassing `frame_system::Config::BaseCallFilter`).4## Complexity�- O(C) where C is the number of calls to be batched.U
This will return `Ok` in all circumstances. To determine the success of the batch, an1
event is deposited. If a call failed and the batch was interrupted, then theU
`BatchInterrupted` event is deposited, along with the number of successful calls madeM
and the error of the failed call. If all were successful, then the `BatchCompleted`Levent is deposited.4as_derivative
indexp
u16
call 
|Box<<T as Config>::RuntimeCall>
4�Send a call through an indexed pseudonym of the sender.U
Filter from origin are passed along. The call will be dispatched with an origin which�use the same filter as the origin of this call.E
NOTE: If you need to ensure that any account-based filtering is not honored (i.e.a
because you expect `proxy` to have been used prior in the call stack and you do not wantQ
the call restrictions to apply to any sub-accounts), then use `as_multi_threshold_1`|in the Multisig pallet instead.�NOTE: Prior to version *12, this was called `as_limited_sub`.�The dispatch origin for this call must be _Signed_.$batch_all
callsl
|Vec<<T as Config>::RuntimeCall>4�Send a batch of dispatch calls and atomically execute them.!
The whole transaction will rollback and fail if any of the calls failed.�May be called from any origin except `None`.]
- `calls`: The calls to be dispatched from the same origin. The number of call must not9
  exceed the constant: `batched_calls_limit` (available in constant metadata).U
If origin is root then the calls are dispatched without checking origin filter. (This�includes bypassing `frame_system::Config::BaseCallFilter`).4## Complexity�- O(C) where C is the number of calls to be batched.,dispatch_as
$as_origint
TBox<T::PalletsOrigin>
call 
|Box<<T as Config>::RuntimeCall>�Dispatches a function call with a provided origin.�The dispatch origin for this call must be _Root_.4## Complexity- O(1).,force_batch
callsl
|Vec<<T as Config>::RuntimeCall>4|Send a batch of dispatch calls.�Unlike `batch`, it allows errors and won't interrupt.�May be called from any origin except `None`.]
- `calls`: The calls to be dispatched from the same origin. The number of call must not9
  exceed the constant: `batched_calls_limit` (available in constant metadata).M
If origin is root then the calls are dispatch without checking origin filter. (This�includes bypassing `frame_system::Config::BaseCallFilter`).4## Complexity�- O(C) where C is the number of calls to be batched.,with_weight
call 
|Box<<T as Config>::RuntimeCall>
weight|
Weight�Dispatch a function call with a specified weight.-
This function does not check the weight of the call, and instead allows the�Root origin to specify the weight of the call.�The dispatch origin for this call must be _Root_.if_else
main 
|Box<<T as Config>::RuntimeCall>
 fallback 
|Box<<T as Config>::RuntimeCall>\
Dispatch a fallback call in the event the main call fails to execute.�May be called from any origin except `None`.�This function first attempts to dispatch the `main` call.�If the `main` call fails, the `fallback` is attemted.
if the fallback is successfully dispatched, the weights of both calls%
are accumulated and an event containing the main call error is deposited.�In the event of a fallback failure the whole call failshwith the weights returned.A
- `main`: The main call to be dispatched. This is the primary action to execute.=
- `fallback`: The fallback call to be dispatched in case the `main` call fails.D## Dispatch LogicA
- If the origin is `root`, both the main and fallback calls are executed withoutx  applying any origin filters.I
- If the origin is not `root`, the origin filter is applied to both the `main` andL  `fallback` calls.,## Use CaseY
- Some use cases might involve submitting a `batch` type call in either main, fallback(  or both.Pdispatch_as_fallible
$as_origint
TBox<T::PalletsOrigin>
call 
|Box<<T as Config>::RuntimeCall>�Dispatches a function call with a provided origin.Q
Almost the same as [`Pallet::dispatch_as`] but forwards any error of the inner call.�The dispatch origin for this call must be _Root_.

Contains a variant per dispatchable extrinsic that this pallet has.l pt<quantus_runtime0OriginCaller
systemx
tframe_system::Origin<Runtime>x4frame_support dispatch$RawOrigin$AccountId

RootSigned
$AccountId
None(Authorized|(sp_weights$weight_v2Weight
 ref_timeD
u64
(proof_sizeD
u64�lpallet_reversible_transferspalletCallT
Dset_high_security
delay�
lBlockNumberOrTimestampOf<T>
 guardian
0T::AccountId��Enable high-security for the calling account with a specifiedPreversibility delay.

Once an account is set as high security it can only make reversible�transfers. It is not allowed any other calls.�# Warning: Permanent and Irreversible5
**Enabling high security mode is a one-way operation that cannot be undone.**A
Once this function is called successfully, the account is permanently restricted�to only the following operations:A
- [`schedule_transfer`](Self::schedule_transfer) - Schedule delayed native token,  transfers�- [`cancel`](Self::cancel) - Cancel pending transfersU
- [`recover_funds`](Self::recover_funds) - Guardian-initiated emergency fund recovery5
There is no mechanism to disable high security mode or restore normal accountE
functionality. This design is intentional to provide maximum security guarantees:I
an attacker who gains access to the account cannot simply disable the protections.9
This permanence also ensures that any funds subsequently sent to a compromised=
account (e.g., from pending payments, contracts, or accidental deposits) remain�protected and can be recovered by the guardian via5
[`recover_funds`](Self::recover_funds). The guardian can call `recover_funds`Trepeatedly as needed.A
Users who no longer wish to use high-security features can simply transfer theirI
funds to a different account using [`schedule_transfer`](Self::schedule_transfer).0# ParametersU
- `delay`: The reversibility time for any transfer made by the high-security account.Y
- `guardian`: The guardian account that can cancel pending transfers and recover funds�  from this high-security account.cancel
tx_id<
T::Hash


Cancel a pending reversible transaction scheduled by the caller.�- `tx_id`: The unique identifier of the transaction to cancel.@execute_transfer
tx_id<
T::Hash@1
Executes a previously scheduled transfer after the delay period has elapsed.
This extrinsic is called automatically by the Scheduler pallet when the9
delay period expires. It must be signed by this pallet's account (not a user).�The pallet account is set as the origin when scheduling via
[`do_schedule_transfer_inner`](Self::do_schedule_transfer_inner).0# Parameters
- `tx_id`: The unique identifier of the pending transfer to execute. # Errors]
- [`InvalidSchedulerOrigin`](Error::InvalidSchedulerOrigin): Called by an account othert  than this pallet's account.Q
- [`PendingTxNotFound`](Error::PendingTxNotFound): No pending transfer with this ID.Dschedule_transfer
dest
�<<T as frame_system::Config>::Lookup as StaticLookup>::Source
amountP
0BalanceOf<T>�Schedule a transaction for delayed execution.pschedule_transfer_with_delay
dest
�<<T as frame_system::Config>::Lookup as StaticLookup>::Source
amountP
0BalanceOf<T>
delay�
lBlockNumberOrTimestampOf<T>-
Schedule a transaction for delayed execution with a custom, one-time delay.
This can only be used by accounts that have *not* set up a persistent�reversibility configuration with `set_high_security`.A
- `delay`: The time (in blocks or milliseconds) before the transaction executes.4recover_funds
account
0T::AccountId�
Allows the guardian to recover all funds from a high-security account�by transferring the entire balance to themselves.Q
This is an emergency function for when the high-security account may be compromised.5
It cancels all pending transfers first (applying volume fees), then transfers�the remaining free balance to the guardian.x# Cancel vs recovery authority9
Per-transfer `cancel` freezes authority in `pending.guardian` at schedule time9
(so a later `set_high_security` cannot rewrite cancel rights on pre-enrollmentA
one-time transfers). `recover_funds` does **not** use that freeze: it authorizes9
against the *live* high-security guardian and seizes every pending hold on the-
account (volume fee applied). That asymmetry is intentional — recovery is�seize-the-account, not a batch of frozen cancel policies.L# Repeated RecoveryE
This function can be called multiple times on the same account. The high-securityU
status and guardian relationship are intentionally preserved after recovery, ensuringI
that any funds subsequently deposited to the account (e.g., from pending payments,
contracts, or accidental deposits) remain protected and recoverable.@# Error HandlingI
If releasing held funds fails for any transfer, that transfer is skipped (metadataA
preserved for manual retry via `cancel`) and a `TransferRecoveryFailed` event is�emitted. Other transfers continue to be processed.5
The closing free-balance sweep to the guardian is likewise best-effort: if it=
fails (e.g. the guardian cannot receive the funds), the call still succeeds and9
all cancellations performed above remain in effect — they must not be rolled=
back, or the pending transfers would be re-armed and execute at their scheduled=
time. A `RecoverySweepFailed` event is emitted instead of `FundsRecovered`, and�the guardian can call `recover_funds` again to retry the sweep.

Contains a variant per dispatchable extrinsic that this pallet has.�0qp_schedulerXBlockNumberOrTimestamp,BlockNumber
8Moment
(
,BlockNumber8
,BlockNumber$Timestamp(
Moment
�`pallet_ranked_collectivepalletCallTI
(add_member
who
PAccountIdLookupOf<T>\Introduce a new member.�- `origin`: Must be the `AddOrigin`.�- `who`: Account of non-member which will become a member.8Weight: `O(1)`8promote_member
who
PAccountIdLookupOf<T>
�Increment the rank of an existing member by one.�- `origin`: Must be the `PromoteOrigin`.�- `who`: Account of existing member.8Weight: `O(1)`4demote_member
who
PAccountIdLookupOf<T>]
Decrement the rank of an existing member by one. If the member is already at rank zero,|then they are removed entirely.�- `origin`: Must be the `DemoteOrigin`.�- `who`: Account of existing member of rank greater than zero.	
Weight: `O(1)`, less if the member's index is highest in its rank.4remove_member
who
PAccountIdLookupOf<T>
 min_rankp
RanklRemove the member entirely.�- `origin`: Must be the `RemoveOrigin`.�- `who`: Account of existing member of rank greater than zero.�- `min_rank`: The rank of the member or greater.XWeight: `O(min_rank)`.vote
poll8
DPollIndexOf<T, I>
ayeT
bool,�Add an aye or nay vote for the sender to the given proposal.�- `origin`: Must be `Signed` by a member account.�- `poll`: Index of a poll which is ongoing.)
- `aye`: `true` if the vote is to approve the proposal, `false` otherwise.E
Transaction fees are be waived if the member is voting on any particular proposalQ
for the first time and the call is successful. Subsequent vote changes will charge afee.5
Weight: `O(1)`, less if there was no previous vote on the poll by the member.0cleanup_poll
(poll_index8
DPollIndexOf<T, I>
max8
u32(�Remove votes from the given poll. It must have ended.�- `origin`: Must be `Signed` by any account.I
- `poll_index`: Index of a poll which is completed and for which votes continue to   exist.�- `max`: Maximum number of vote items from remove in this call.�Transaction fees are waived if the operation is successful.
Weight `O(max)` (less if there are fewer items to remove than `max`).<exchange_member
who
PAccountIdLookupOf<T>
new_who
PAccountIdLookupOf<T>
Exchanges a member with a new account and the same existing rank.�- `origin`: Must be the `ExchangeOrigin`.9
- `who`: Account of existing member of rank greater than zero to be exchanged.Y
- `new_who`: New Account of existing member of rank greater than zero to exchanged to.

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

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

Contains a variant per dispatchable extrinsic that this pallet has.�4frame_supporttraits$preimagesBoundedT
 H
�
Legacy
hash<
$H::OutputInline�
4BoundedInline
Lookup
hash<
$H::Output
len8
u32�(sp_runtimetraits,BlakeTwo256�Lbounded_collections,bounded_vec(BoundedVecT
S
Vec<T>�4frame_supporttraits schedule0DispatchTime,BlockNumber
8
At8
,BlockNumberAfter8
,BlockNumber
�OptionT
<
NoneSome<
�<pallet_treasurypalletCallT
Pset_treasury_account
account
0T::AccountIdY
Set the treasury account. Root only. Zero address is rejected (funds would be locked).Q
**Important**: This only changes where *future* mining rewards are sent. Any balanceE
that has already accumulated in the current treasury account is NOT automaticallyM
migrated to the new account. If you need to move existing funds, perform a separate1
balance transfer (e.g., via governance proposal) after updating the account.Pset_treasury_portion
portion�
Permill
�Set the treasury portion (Permill, 0–100%). Root only.

Contains a variant per dispatchable extrinsic that this pallet has.�4sp_arithmetic(per_thingsPermill8
u32�<pallet_recoverypalletCallT
(0as_recovered
account
PAccountIdLookupOf<T>
call 
|Box<<T as Config>::RuntimeCall> �Send a call through a recovered account.
The dispatch origin for this call must be _Signed_ and registered to�be able to make calls on behalf of the recovered account.,Parameters:!
- `account`: The recovered account you want to make a call on-behalf-of.�- `call`: The call you want to make with the recovered account.4set_recovered
lost
PAccountIdLookupOf<T>
rescuer
PAccountIdLookupOf<T>
 

Allow ROOT to bypass the recovery process and set a rescuer accountpfor a lost account directly.�The dispatch origin for this call must be _ROOT_.,Parameters:�- `lost`: The "lost account" to be recovered.
- `rescuer`: The "rescuer account" which can call as the lost account.<create_recovery
friendsX
DVec<T::AccountId>
$thresholdp
u16
0delay_period8
pBlockNumberFromProviderOf<T>@Y
Create a recovery configuration for your account. This makes your account recoverable.-
Payment: `ConfigDepositBase` + `FriendDepositFactor` * #_of_friends balanceE
will be reserved for storing the recovery configuration. This deposit is returned�in full when the user calls `remove_recovery`.�The dispatch origin for this call must be _Signed_.,Parameters:I
- `friends`: A list of friends you trust to vouch for recovery attempts. Should be�  ordered and contain no duplicate values.Y
- `threshold`: The number of friends that must vouch for a recovery attempt before theU
  account can be recovered. Should be less than or equal to the length of the list of(  friends.M
- `delay_period`: The number of blocks after a recovery attempt is initialized that�  needs to pass before the account can be recovered.Dinitiate_recovery
account
PAccountIdLookupOf<T>,�Initiate the process for recovering a recoverable account.
Payment: `RecoveryDeposit` balance will be reserved for initiating the!
recovery process. This deposit will always be repatriated to the account�trying to be recovered. See `close_recovery`.�The dispatch origin for this call must be _Signed_.,Parameters:A
- `account`: The lost account that you want to recover. This account needs to be�  recoverable (i.e. have a recovery configuration).8vouch_recovery
lost
PAccountIdLookupOf<T>
rescuer
PAccountIdLookupOf<T>0%
Allow a "friend" of a recoverable account to vouch for an active recoverydprocess for that account.%
The dispatch origin for this call must be _Signed_ and must be a "friend"pfor the recoverable account.,Parameters:�- `lost`: The lost account that you want to recover.Y
- `rescuer`: The account trying to rescue the lost account that you want to vouch for.!
The combination of these two parameters must point to an active recovery process.8claim_recovery
account
PAccountIdLookupOf<T>$�Allow a successful rescuer to claim their recovered account.)
The dispatch origin for this call must be _Signed_ and must be a "rescuer"
who has successfully completed the account recovery process: collected-
`threshold` or more vouches, waited `delay_period` blocks since initiation.,Parameters:]
- `account`: The lost account that you want to claim has been successfully recovered by  you.8close_recovery
rescuer
PAccountIdLookupOf<T>,
As the controller of a recoverable account, close an active recoverydprocess for your account.
Payment: By calling this function, the recoverable account will receive�the recovery deposit `RecoveryDeposit` placed by the rescuer.

The dispatch origin for this call must be _Signed_ and must be a�recoverable account with an active recovery process for it.,Parameters:

- `rescuer`: The account trying to rescue this recoverable account.<remove_recovery,Y
Remove the recovery process for your account. Recovered accounts are still accessible.
NOTE: The user must make sure to call `close_recovery` on all active
recovery attempts before calling this function else it will fail.!
Payment: By calling this function the recoverable account will unreserve�their recovery configuration deposit.�(`ConfigDepositBase` + `FriendDepositFactor` * #_of_friends)

The dispatch origin for this call must be _Signed_ and must be a�recoverable account (i.e. has a recovery configuration).@cancel_recovered
account
PAccountIdLookupOf<T>�Cancel the ability to use `as_recovered` for `account`.
The dispatch origin for this call must be _Signed_ and registered to�be able to make calls on behalf of the recovered account.,Parameters:
- `account`: The recovered account you are able to call on-behalf-of.0poke_deposit
4maybe_account�
pOption<AccountIdLookupOf<T>>	\
Poke deposits for recovery configurations and / or active recoveries.

This can be used by accounts to possibly lower their locked amount.�The dispatch origin for this call must be _Signed_.,Parameters:U
- `maybe_account`: Optional recoverable account for which you have an active recovery�and want to adjust the deposit for the active recovery.U
This function checks both recovery configuration deposit and active recovery deposits8of the caller:Q
- If the caller has created a recovery configuration, checks and adjusts its depositA
- If the caller has initiated any active recoveries, and provides the account in�`maybe_account`, checks and adjusts those deposits]
If any deposit is updated, the difference will be reserved/unreserved from the caller's account.)
The transaction is made free if any deposit is updated and paid otherwise.�Emits `DepositPoked` if any deposit is updated.)
Multiple events may be emitted in case both types of deposits are updated.

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

NoneSome
�<pallet_multisigpalletCallT
<create_multisig
signersX
DVec<T::AccountId>
$threshold8
u32
nonce(
u648�Create a new multisig account with deterministic address,Parameters:�- `signers`: List of accounts that can sign for this multisig

- `threshold`: Number of approvals required to execute transactions�- `nonce`: User-provided nonce for address uniqueness�The multisig address is deterministically derived from:�hash(pallet_id || sorted_signers || threshold || nonce)%
Signers are automatically sorted before hashing, so order doesn't matter.<Economic costs:�- MultisigFee: burned immediately (spam prevention)propose
@multisig_address
0T::AccountId
call�
@BoundedCallOf<T>
expiry8
DBlockNumberFor<T>
L�Propose a transaction to be executed by the multisig,Parameters:
- `multisig_address`: The multisig account that will execute the call�- `call`: The encoded call to execute�- `expiry`: Block number when this proposal expires�The proposer must be a signer and must pay:%
- A deposit (refundable - returned immediately on execution/cancellation)�- A fee (non-refundable, burned immediately)=
**For threshold=1:** The proposal is created with `Approved` status immediately
and can be executed via `execute()` without additional approvals.9
**Weight:** Charged upfront includes bookkeeping + MaxInnerCallWeight to coverY
the cost of decoding arbitrary RuntimeCall structures and calling get_dispatch_info().A
On success, refunds based on actual inner call weight. On rejection after decode=
(e.g., CallWeightExceedsLimit, CallNotAllowedForHighSecurityMultisig), the fullM
reserved weight is burned to prevent griefing with complex calls that get rejected.approve
@multisig_address
0T::AccountId
,proposal_id8
u32
call�
@BoundedCallOf<T>DxApprove a proposed transaction-
The approver must resubmit the proposal's inner call bytes; the approval is%
only valid if they are byte-equal to the payload stored at `proposal_id`.%
This binds the approver's signature to the actual call being approved, so!
offline/cold-wallet signers can decode and inspect what they are signing�instead of trusting an opaque proposal id.
If this approval brings the total approvals to or above the threshold,9
the proposal status changes to `Approved` and can be executed via `execute()`.,Parameters:�- `multisig_address`: The multisig account�- `proposal_id`: ID (nonce) of the proposal to approveA
- `call`: The encoded inner call of the proposal (must match the stored payload)�Weight: Charges for MAX call size, refunds based on actualcancel
@multisig_address
0T::AccountId
,proposal_id8
u32�Cancel a proposed transaction (only by proposer),Parameters:�- `multisig_address`: The multisig account�- `proposal_id`: ID (nonce) of the proposal to cancel8remove_expired
@multisig_address
0T::AccountId
,proposal_id8
u32,�Remove expired proposals and return deposits to proposers�Can only be called by signers of the multisig.-
Removes Active or Approved proposals that have expired (past expiry block).)
Executed and Cancelled proposals are automatically cleaned up immediately.E
Approved+expired proposals can become stuck if proposer is unavailable (e.g. lostA
keys, compromise). Allowing any signer to remove them prevents permanent deposit�lockup and enables multisig dissolution.!
The deposit is always returned to the original proposer, not the caller.8claim_deposits
@multisig_address
0T::AccountId(�Claim all deposits from expired proposals

This is a batch operation that removes all expired proposals where:`- Caller is the proposer�- Proposal is Active or Approved and past expiry blockA
Note: Executed and Cancelled proposals are automatically cleaned up immediately,)
so only Active+Expired and Approved+Expired proposals need manual cleanup.
Returns all proposal deposits to the proposer in a single transaction.execute
@multisig_address
0T::AccountId
,proposal_id8
u32DpExecute an approved proposal%
Can be called by any signer of the multisig once the proposal has reached5
the approval threshold (status = Approved). The proposal must not be expired.4On execution:�- The call is decoded and dispatched as the multisig account�- Proposal is removed from storage�- Deposit is returned to the proposer,Parameters:�- `multisig_address`: The multisig account�- `proposal_id`: ID (nonce) of the proposal to executeM
Note: The weight charged includes both multisig bookkeeping and MaxInnerCallWeight.
Actual weight is refunded based on the inner call's post-dispatch info.A
The inner call's weight is validated against MaxInnerCallWeight at propose time.

Contains a variant per dispatchable extrinsic that this pallet has.�Lbounded_collections,bounded_vec(BoundedVecT
S
Vec<T>�<pallet_wormholepalletCallT
Pverify_private_batch
,proof_bytes
Vec<u8>%
Verify a private-batch wormhole proof and process all exits in the batch.I
Returns `DispatchResultWithPostInfo` to allow weight correction on early failures.
If validation fails before ZK verification, we return minimal weight.!
If ZK verification fails, we return full weight since the work was done.Lverify_public_batch
,proof_bytes
Vec<u8>%
Verify a public-batch wormhole proof and process all valid exit segments.E
Invalid segments (already-spent nullifiers) are denied individually; dummy-paddedE
segments (all-zero nullifiers) are skipped silently. A portion of the burn bucket-
is minted to the proof's `aggregator_address`; if that mint fails (e.g. the)
account doesn't exist and the rebate is below the existential deposit) the�rebate is burned instead of failing the users' exits.

Contains a variant per dispatchable extrinsic that this pallet has.�8pallet_vestingpalletCallT
claim
,schedule_id(
u64 1
Pay the largest valid claim on `schedule_id` to its beneficiary. Payouts are=
rounded down to [`Config::PayoutQuantum`], must meet [`Config::MinimumPayout`],=
and reserve at least one minimum-sized final claim unless the schedule is fullyvested.5
Permissionless: any signed account may call this for any schedule; the payout
always goes to the stored beneficiary. This is the only claim path for1
beneficiaries that cannot sign (wormhole addresses, high-security accounts).<create_schedule
,beneficiary
0T::AccountId
start(
Moment
cliff(
Moment
end(
Moment
totalP
0BalanceOf<T>

Create a new schedule under the next free id, moving `total` from the�treasury account into the pot in the same call.0end_schedule
,schedule_id(
u64
End a schedule early: the still-unpaid vested part (rounded down to a1
[`Config::PayoutQuantum`] multiple) goes to the beneficiary, everything else%
this schedule still holds — the unvested remainder plus any sub-quantum%
vested dust — returns to the treasury, and the schedule is removed. The1
treasury is signature-controlled and needs no wormhole leaf, so dust is safe1
there but would be stranded on a keyless beneficiary. A non-zero beneficiary=
payout below [`Config::MinimumPayout`] is rejected without ending the schedule.Dretarget_schedule
,schedule_id(
u64
<new_beneficiary
0T::AccountId=
Settle any payout a permissionless claim could currently force, then change the9
beneficiary. This makes retargeting independent of claim transaction ordering.

Contains a variant per dispatchable extrinsic that this pallet has.�Lqp_dilithium_cryptotypes`DilithiumSignatureScheme
,Dilithium87�
xDilithium87SignatureWithPublic,Dilithium65�
xDilithium65SignatureWithPublic
�Lqp_dilithium_cryptotypesxDilithium87SignatureWithPublic
bytes�
�[u8; Dilithium87SignatureWithPublic::TOTAL_LEN]�3�Lqp_dilithium_cryptotypesxDilithium65SignatureWithPublic
bytes�
�[u8; Dilithium65SignatureWithPublic::TOTAL_LEN]���0frame_system(extensionsTcheck_non_zero_senderHCheckNonZeroSenderT�0frame_system(extensionsHcheck_spec_version@CheckSpecVersionT�0frame_system(extensions@check_tx_version8CheckTxVersionT�0frame_system(extensions4check_genesis0CheckGenesisT�0frame_system(extensions<check_mortality8CheckMortalityT�
Era�(sp_runtimegenericeraEra

 ImmortalMortal1
Mortal2Mortal3Mortal4Mortal5Mortal6Mortal7Mortal8Mortal9	 Mortal10
 Mortal11 Mortal12 Mortal13
 Mortal14 Mortal15 Mortal16 Mortal17 Mortal18 Mortal19 Mortal20 Mortal21 Mortal22 Mortal23 Mortal24 Mortal25 Mortal26 Mortal27 Mortal28 Mortal29 Mortal30 Mortal31 Mortal32  Mortal33! Mortal34" Mortal35# Mortal36$ Mortal37% Mortal38& Mortal39' Mortal40( Mortal41) Mortal42* Mortal43+ Mortal44, Mortal45- Mortal46. Mortal47/ Mortal480 Mortal491 Mortal502 Mortal513 Mortal524 Mortal535 Mortal546 Mortal557 Mortal568 Mortal579 Mortal58: Mortal59; Mortal60< Mortal61= Mortal62> Mortal63? Mortal64@ Mortal65A Mortal66B Mortal67C Mortal68D Mortal69E Mortal70F Mortal71G Mortal72H Mortal73I Mortal74J Mortal75K Mortal76L Mortal77M Mortal78N Mortal79O Mortal80P Mortal81Q Mortal82R Mortal83S Mortal84T Mortal85U Mortal86V Mortal87W Mortal88X Mortal89Y Mortal90Z Mortal91[ Mortal92\ Mortal93] Mortal94^ Mortal95_ Mortal96` Mortal97a Mortal98b Mortal99c$Mortal100d$Mortal101e$Mortal102f$Mortal103g$Mortal104h$Mortal105i$Mortal106j$Mortal107k$Mortal108l$Mortal109m$Mortal110n$Mortal111o$Mortal112p$Mortal113q$Mortal114r$Mortal115s$Mortal116t$Mortal117u$Mortal118v$Mortal119w$Mortal120x$Mortal121y$Mortal122z$Mortal123{$Mortal124|$Mortal125}$Mortal126~$Mortal127$Mortal128�$Mortal129�$Mortal130�$Mortal131�$Mortal132�$Mortal133�$Mortal134�$Mortal135�$Mortal136�$Mortal137�$Mortal138�$Mortal139�$Mortal140�$Mortal141�$Mortal142�$Mortal143�$Mortal144�$Mortal145�$Mortal146�$Mortal147�$Mortal148�$Mortal149�$Mortal150�$Mortal151�$Mortal152�$Mortal153�$Mortal154�$Mortal155�$Mortal156�$Mortal157�$Mortal158�$Mortal159�$Mortal160�$Mortal161�$Mortal162�$Mortal163�$Mortal164�$Mortal165�$Mortal166�$Mortal167�$Mortal168�$Mortal169�$Mortal170�$Mortal171�$Mortal172�$Mortal173�$Mortal174�$Mortal175�$Mortal176�$Mortal177�$Mortal178�$Mortal179�$Mortal180�$Mortal181�$Mortal182�$Mortal183�$Mortal184�$Mortal185�$Mortal186�$Mortal187�$Mortal188�$Mortal189�$Mortal190�$Mortal191�$Mortal192�$Mortal193�$Mortal194�$Mortal195�$Mortal196�$Mortal197�$Mortal198�$Mortal199�$Mortal200�$Mortal201�$Mortal202�$Mortal203�$Mortal204�$Mortal205�$Mortal206�$Mortal207�$Mortal208�$Mortal209�$Mortal210�$Mortal211�$Mortal212�$Mortal213�$Mortal214�$Mortal215�$Mortal216�$Mortal217�$Mortal218�$Mortal219�$Mortal220�$Mortal221�$Mortal222�$Mortal223�$Mortal224�$Mortal225�$Mortal226�$Mortal227�$Mortal228�$Mortal229�$Mortal230�$Mortal231�$Mortal232�$Mortal233�$Mortal234�$Mortal235�$Mortal236�$Mortal237�$Mortal238�$Mortal239�$Mortal240�$Mortal241�$Mortal242�$Mortal243�$Mortal244�$Mortal245�$Mortal246�$Mortal247�$Mortal248�$Mortal249�$Mortal250�$Mortal251�$Mortal252�$Mortal253�$Mortal254�$Mortal255��0frame_system(extensions,check_nonce(CheckNonceT�
 T::Nonce�8�0frame_system(extensions0check_weight,CheckWeightT�hpallet_transaction_payment`ChargeTransactionPaymentTL
0BalanceOf<T>

tframe_metadata_hash_extensionDCheckMetadataHashT
mode

Mode
tframe_metadata_hash_extensionMode
 DisabledEnabled
	
OptionT

NoneSome


<quantus_runtimeXtransaction_extensionsxReversibleTransactionExtensionT
<quantus_runtimeXtransaction_extensionsxWormholeProofRecorderExtensionT
0frame_system,AccountInfoNonce
8,AccountData


nonce8
Nonce
$consumers8
 RefCount
$providers8
 RefCount
,sufficients8
 RefCount
data

,AccountData
<pallet_balancestypes,AccountDataBalance
P
freeP
Balance
 reservedP
Balance
frozenP
Balance
flags

(ExtraFlags
<pallet_balancestypes(ExtraFlagsP
u128!
4frame_support dispatch@PerDispatchClassT
|
normal|
T
,operational|
T
$mandatory|
T%
(sp_runtimegenericdigestDigest
logs)

<Vec<DigestItem>)
-
-
(sp_runtimegenericdigest(DigestItem
(PreRuntime1

DConsensusEngineId
Vec<u8>$Consensus1

DConsensusEngineId
Vec<u8>Seal1

DConsensusEngineId
Vec<u8>Other
Vec<u8>dRuntimeEnvironmentUpdated1
5
9
9
0frame_system,EventRecordE
=
T
<
phase
Phase
event=

E
topicsd
Vec<T>=
<quantus_runtime0RuntimeEvent
DSystemA

pframe_system::Event<Runtime> Balancesi

|pallet_balances::Event<Runtime>HTransactionPayment�

�pallet_transaction_payment::Event<Runtime>QPoW�

lpallet_qpow::Event<Runtime>4MiningRewards�

�pallet_mining_rewards::Event<Runtime> Preimage�

|pallet_preimage::Event<Runtime>$Scheduler�

�pallet_scheduler::Event<Runtime>Utility�

Tpallet_utility::Event	LReversibleTransfers�

�pallet_reversible_transfers::Event<Runtime>8TechCollective�

�pallet_ranked_collective::Event<Runtime>
4TechReferenda�

�pallet_referenda::Event<Runtime, pallet_referenda::Instance1>8TreasuryPallet�

|pallet_treasury::Event<Runtime> Recovery�

|pallet_recovery::Event<Runtime> Multisig�

|pallet_multisig::Event<Runtime> Wormhole�

|pallet_wormhole::Event<Runtime>ZkTree�

xpallet_zk_tree::Event<Runtime>Vesting

xpallet_vesting::Event<Runtime>A
0frame_systempalletEventT
 @ExtrinsicSuccess
4dispatch_infoE

DDispatchEventInfo�An extrinsic completed successfully.<ExtrinsicFailed
8dispatch_errorQ

4DispatchError
4dispatch_infoE

DDispatchEventInfo
PAn extrinsic failed.,CodeUpdatedP`:code` was updated.(NewAccount
account
0T::AccountIdhA new account was created.4KilledAccount
account
0T::AccountIdXAn account was reaped. Remarked
sender
0T::AccountId
hash<
T::HashpOn on-chain remark happened.DUpgradeAuthorized
$code_hash<
T::Hash
4check_versionT
boolhAn upgrade was authorized.�RejectedInvalidAuthorizedUpgrade
$code_hash<
T::Hash
errorQ

4DispatchError
An invalid authorized upgrade was rejected while trying to apply it.pEvent for the System pallet.E
0frame_systemDDispatchEventInfo
weight|
Weight
classI

4DispatchClass
 pays_feeM

PaysI
4frame_support dispatch4DispatchClass
Normal,Operational
$MandatoryM
4frame_support dispatchPays
YesNo
Q
(sp_runtime4DispatchError
<Other0CannotLookup
$BadOriginModuleU

,ModuleErrorDConsumerRemaining,NoProviders@TooManyConsumersTokenY

(TokenError(Arithmetic]

<ArithmeticError4Transactionala

HTransactionalError	$Exhausted
(Corruption,Unavailable8RootNotAllowed
Triee

$TrieErrorU
(sp_runtime,ModuleError
index
u8
error1

�[u8; MAX_MODULE_ERROR_ENCODED_SIZE]Y
(sp_runtime(TokenError
(@FundsUnavailable0OnlyProvider
0BelowMinimum0CannotCreate0UnknownAssetFrozen,Unsupported@CannotCreateHold4NotExpendableBlocked	]
4sp_arithmetic<ArithmeticError
$Underflow Overflow
8DivisionByZeroa
(sp_runtimeHTransactionalError
0LimitReachedNoLayer
e
(sp_runtime0proving_trie$TrieError
8@InvalidStateRootHIncompleteDatabase
PValueAtIncompleteKey0DecoderError,InvalidHash0DuplicateKey8ExtraneousNode<ExtraneousValue\ExtraneousHashReferenceTInvalidChildReference	4ValueMismatch
<IncompleteProof0RootMismatch,DecodeError
i
<pallet_balancespalletEventTI
xEndowed
account
0T::AccountId
0free_balanceP
(T::Balance�An account was created with some free balance. DustLost
account
0T::AccountId
amountP
(T::Balance
=
An account was removed whose balance was non-zero but below ExistentialDeposit,xresulting in an outright loss. Transfer
from
0T::AccountId
to
0T::AccountId
amountP
(T::BalanceLTransfer succeeded.(BalanceSet
who
0T::AccountId
freeP
(T::BalancehA balance was set by root. Reserved
who
0T::AccountId
amountP
(T::Balance�Some balance was reserved (moved from free to reserved).(Unreserved
who
0T::AccountId
amountP
(T::Balance�Some balance was unreserved (moved from reserved to free).HReserveRepatriated
from
0T::AccountId
to
0T::AccountId
amountP
(T::Balance
Hdestination_statusm

StatusM
Some balance was moved from the reserve of the first account to the second account.�Final argument indicates the destination balance type.Deposit
who
0T::AccountId
amountP
(T::Balance�Some amount was deposited (e.g. for transaction fees). Withdraw
who
0T::AccountId
amountP
(T::Balance
Some amount was withdrawn from the account (e.g. for transaction fees).Slashed
who
0T::AccountId
amountP
(T::Balance	

Some amount was removed from the account (e.g. for misbehavior).Minted
who
0T::AccountId
amountP
(T::Balance
�Some amount was minted into an account.0MintedCredit
amountP
(T::Balance�Some credit was balanced and added to the TotalIssuance.Burned
who
0T::AccountId
amountP
(T::Balance�Some amount was burned from an account.(BurnedDebt
amountP
(T::Balance
�Some debt has been dropped from the Total Issuance.$Suspended
who
0T::AccountId
amountP
(T::Balance
Some amount was suspended from an account (it can be restored later). Restored
who
0T::AccountId
amountP
(T::Balance�Some amount was restored into an account. Upgraded
who
0T::AccountId`An account was upgraded.Issued
amountP
(T::Balance-
Total issuance was increased by `amount`, creating a credit to be balanced.$Rescinded
amountP
(T::Balance%
Total issuance was decreased by `amount`, creating a debt to be balanced.Locked
who
0T::AccountId
amountP
(T::Balance`Some balance was locked. Unlocked
who
0T::AccountId
amountP
(T::BalancehSome balance was unlocked.Frozen
who
0T::AccountId
amountP
(T::Balance`Some balance was frozen.Thawed
who
0T::AccountId
amountP
(T::Balance`Some balance was thawed.LTotalIssuanceForced
oldP
(T::Balance
newP
(T::Balance�The `TotalIssuance` was forcefully changed.Held
reasonq

PT::RuntimeHoldReason
who
0T::AccountId
amountP
(T::Balance�Some balance was placed on hold.(BurnedHeld
reasonq

PT::RuntimeHoldReason
who
0T::AccountId
amountP
(T::Balance�Held balance was burned from an account.8TransferOnHold
reasonq

PT::RuntimeHoldReason
source
0T::AccountId
dest
0T::AccountId
amountP
(T::Balance
A transfer of `amount` on hold from `source` to `dest` was initiated.<TransferAndHold
reasonq

PT::RuntimeHoldReason
source
0T::AccountId
dest
0T::AccountId
,transferredP
(T::Balance	
The `transferred` balance is placed on hold at the `dest` account. Released
reasonq

PT::RuntimeHoldReason
who
0T::AccountId
amountP
(T::Balance�Some balance was released from hold.(Unexpected}

8UnexpectedKind�An unexpected/defensive event was triggered.|The `Event` enum of this palletm
4frame_supporttraitstokensmisc4BalanceStatus
Free Reserved
q
<quantus_runtimeDRuntimeHoldReason
 Preimageu

lpallet_preimage::HoldReasonLReversibleTransfersy

�pallet_reversible_transfers::HoldReasonu
<pallet_preimagepallet(HoldReason
 Preimagey
lpallet_reversible_transferspallet(HoldReason
DScheduledTransfer}
<pallet_balancespallet8UnexpectedKind
8BalanceUpdatedTFailedToMutateAccount
�
hpallet_transaction_paymentpalletEventT
HTransactionFeePaid
who
0T::AccountId
(actual_feeP
0BalanceOf<T>
tipP
0BalanceOf<T>Y
A transaction fee `actual_fee`, of which `tip` was added to the minimum inclusion fee,\has been paid by `who`.|The `Event` enum of this pallet�
,pallet_qpowpalletEventT
8ProofSubmitted
nonce�

$NonceType
(difficulty�

U512
4hash_achieved�

U512HDifficultyAdjusted
8old_difficulty�

(Difficulty
8new_difficulty�

(Difficulty
Lobserved_block_time(
4BlockDuration
|The `Event` enum of this pallet�
@�
<primitive_typesU512�

 [u64; 8]�
(�
Tpallet_mining_rewardspalletEventT
4MinerRewarded
miner
0T::AccountId4Miner account
rewardP
0BalanceOf<T>hTotal reward (base + fees)�A miner has been identified for a block4FeesCollected
amountP
0BalanceOf<T>PThe amount collected
totalP
0BalanceOf<T>�Total fees waiting for distribution
�Transaction fees were collected for later distribution@TreasuryRewarded
rewardP
0BalanceOf<T>hTotal reward (base + fees)�Rewards were sent to Treasury when no miner was specifiedTMinerRewardRedirected
miner
0T::AccountId�The miner who should have received the reward
rewardP
0BalanceOf<T>�The reward amount redirected to treasury�Miner reward was redirected to treasury due to mint failureHTreasuryMintFailed
rewardP
0BalanceOf<T>�The reward amount that failed to mint
Treasury mint failed; amount retained in [`CollectedFees`] for retry.|The `Event` enum of this pallet�
<pallet_preimagepalletEventT
Noted
hash<
T::HashhA preimage has been noted.$Requested
hash<
T::Hash
xA preimage has been requested.Cleared
hash<
T::HashlA preimage has ben cleared.|The `Event` enum of this pallet�
@pallet_schedulerpalletEventT
 $Scheduled
when�
lBlockNumberOrTimestampOf<T>
index8
u32PScheduled some task. Canceled
when�
lBlockNumberOrTimestampOf<T>
index8
u32
LCanceled some task.(Dispatched
task�

@TaskAddressOf<T>
id	

@Option<TaskName>
result�

8DispatchResultTDispatched some task. RetrySet
task�

@TaskAddressOf<T>
id	

@Option<TaskName>
period�
lBlockNumberOrTimestampOf<T>
retries
u8�Set a retry configuration for some task.8RetryCancelled
task�

@TaskAddressOf<T>
id	

@Option<TaskName>�Cancel a retry configuration for some task.<CallUnavailable
task�

@TaskAddressOf<T>
id	

@Option<TaskName>)
The call for the provided hash was not found so the task has been aborted.,RetryFailed
task�

@TaskAddressOf<T>
id	

@Option<TaskName>]
The given task was unable to be retried since the agenda is full at that block or there�was not enough weight to reschedule it.TPermanentlyOverweight
task�

@TaskAddressOf<T>
id	

@Option<TaskName>�The given task can never be executed since it is overweight.0Events type.�
�8�
ResultT
E
Q

OkErrQ

�
8pallet_utilitypalletEvent
 @BatchInterrupted
index8
u32
errorQ

4DispatchErrorU
Batch of dispatches did not complete fully. Index of first failing dispatch given, asHwell as the error.8BatchCompleted
�Batch of dispatches completed fully with no error.`BatchCompletedWithErrors�Batch of dispatches completed but has errors.4ItemCompleted
A single item within a Batch of dispatches has completed with no error.(ItemFailed
errorQ

4DispatchError
A single item within a Batch of dispatches has completed with error.0DispatchedAs
result�

8DispatchResultXA call was dispatched.DIfElseMainSuccessdMain call was dispatched.PIfElseFallbackCalled
(main_errorQ

4DispatchError�The fallback call was dispatched.|The `Event` enum of this pallet�
lpallet_reversible_transferspalletEventT
<HighSecuritySet
who
0T::AccountId
 guardian
0T::AccountId�The guardian who can cancel transfers and recover funds.
delay�
lBlockNumberOrTimestampOf<T>�A user has enabled their high-security settings.PTransactionScheduled
from
0T::AccountId
to
0T::AccountId
 guardian
0T::AccountId�The guardian who can cancel this transfer.
 asset_id�

POption<AssetIdOf<T>>
amountP
0BalanceOf<T>
tx_id<
T::Hash
(execute_at�

�DispatchTime<BlockNumberFor<T>, T::Moment>
�A transaction has been scheduled for delayed execution.PTransactionCancelled
who
0T::AccountId
tx_id<
T::Hash�A scheduled transaction has been successfully cancelled.LTransactionExecuted
tx_id<
T::Hash
result�

hDispatchResultWithPostInfo�A scheduled transaction was executed by the scheduler.8FundsRecovered
account
0T::AccountId
 guardian
0T::AccountId
All funds were recovered from a high-security account by its guardian.XTransferRecoveryFailed
tx_id<
T::HashA
Failed to release held funds during recovery. The transfer metadata is preservedxfor manual retry via `cancel`.LRecoverySweepFailed
account
0T::AccountId
 guardian
0T::AccountId1
The final free-balance sweep of `recover_funds` failed. All pending-transfer-
cancellations performed by the same call remain in effect; the guardian can-
retry `recover_funds` to sweep the free balance once the cause is resolved.|The `Event` enum of this pallet�
OptionT
8
NoneSome8
�
0qp_scheduler0DispatchTime,BlockNumber
8Moment
(
At8
,BlockNumberAfter�
�BlockNumberOrTimestamp<BlockNumber, Moment>
�
ResultT
�
E
�

Ok�
Err�

�
4frame_support dispatch@PostDispatchInfo
4actual_weight�

8Option<Weight>
 pays_feeM

Pays�
OptionT
|
NoneSome|
�
(sp_runtimedDispatchErrorWithPostInfoInfo
�

$post_info�

Info
errorQ

4DispatchError�
`pallet_ranked_collectivepalletEventTI
,MemberAdded
who
0T::AccountIdxA member `who` has been added.,RankChanged
who
0T::AccountId
rankp
Rank
�The member `who`se rank has been changed to the given `rank`.4MemberRemoved
who
0T::AccountId
rankp
Rank
The member `who` of given `rank` has been removed from the collective.Voted
who
0T::AccountId
poll8
DPollIndexOf<T, I>
vote�

(VoteRecord
tally�

4TallyOf<T, I>U
The member `who` has voted for the `poll` with the given `vote` leading to an updated `tally`.<MemberExchanged
who
0T::AccountId
new_who
0T::AccountId�The member `who` had their `AccountId` changed to `new_who`.|The `Event` enum of this pallet�
`pallet_ranked_collective(VoteRecord
Aye8
VotesNay8
Votes
�
`pallet_ranked_collectiveTallyTIM
$bare_ayes8
,MemberIndex
ayes8
Votes
nays8
Votes�
@pallet_referendapalletEventTI
@$Submitted
index8
<ReferendumIndex`Index of the referendum.
trackp
<TrackIdOf<T, I>%
The track (and by extension proposal dispatch origin) of this referendum.
 proposal�
LBoundedCallOf<T, I>�The proposal for the referendum.�A referendum has been submitted.TDecisionDepositPlaced
index8
<ReferendumIndex`Index of the referendum.
who
0T::AccountId�The account who placed the deposit.
amountP
<BalanceOf<T, I>�The amount placed by the account.
�The decision deposit has been placed.\DecisionDepositRefunded
index8
<ReferendumIndex`Index of the referendum.
who
0T::AccountId�The account who placed the deposit.
amountP
<BalanceOf<T, I>�The amount placed by the account.�The decision deposit has been refunded.8DepositSlashed
who
0T::AccountId�The account who placed the deposit.
amountP
<BalanceOf<T, I>�The amount placed by the account.lA deposit has been slashed.<DecisionStarted
index8
<ReferendumIndex`Index of the referendum.
trackp
<TrackIdOf<T, I>%
The track (and by extension proposal dispatch origin) of this referendum.
 proposal�
LBoundedCallOf<T, I>�The proposal for the referendum.
tally�

 T::Tally�The current tally of votes in this referendum.�A referendum has moved into the deciding phase.8ConfirmStarted
index8
<ReferendumIndex`Index of the referendum.8ConfirmAborted
index8
<ReferendumIndex`Index of the referendum.$Confirmed
index8
<ReferendumIndex`Index of the referendum.
tally�

 T::Tally�The final tally of votes in this referendum.!
A referendum has ended its confirmation phase and is ready for approval. Approved
index8
<ReferendumIndex`Index of the referendum.

A referendum has been approved and its proposal has been scheduled. Rejected
index8
<ReferendumIndex`Index of the referendum.
tally�

 T::Tally�The final tally of votes in this referendum.	�A proposal has been rejected by referendum. TimedOut
index8
<ReferendumIndex`Index of the referendum.
tally�

 T::Tally�The final tally of votes in this referendum.
�A referendum has been timed out without being decided.$Cancelled
index8
<ReferendumIndex`Index of the referendum.
tally�

 T::Tally�The final tally of votes in this referendum.�A referendum has been cancelled.Killed
index8
<ReferendumIndex`Index of the referendum.
tally�

 T::Tally�The final tally of votes in this referendum.tA referendum has been killed.dSubmissionDepositRefunded
index8
<ReferendumIndex`Index of the referendum.
who
0T::AccountId�The account who placed the deposit.
amountP
<BalanceOf<T, I>�The amount placed by the account.
�The submission deposit has been refunded.,MetadataSet
index8
<ReferendumIndex`Index of the referendum.
hash<
T::Hash8Preimage hash.�Metadata for a referendum has been set.<MetadataCleared
index8
<ReferendumIndex`Index of the referendum.
hash<
T::Hash8Preimage hash.�Metadata for a referendum has been cleared.|The `Event` enum of this pallet�
<pallet_treasurypalletEventT
XTreasuryAccountUpdated
,old_account�

POption<T::AccountId>)
The previous treasury account (None if this is the first time setting it).
,new_account
0T::AccountId�The new treasury account that will receive future rewards.�The treasury account was updated.-
Note: This only redirects where future mining rewards are sent. Any balance=
accumulated in the old account remains there and is NOT automatically migrated.�Use a separate balance transfer if funds need to be moved.XTreasuryPortionUpdated
,new_portion�
Permill
�The treasury portion (share of mining rewards) was updated.|The `Event` enum of this pallet�
OptionT

NoneSome
�
<pallet_recoverypalletEventT
<RecoveryCreated
account
0T::AccountId�A recovery process has been set up for an account.DRecoveryInitiated
0lost_account
0T::AccountId
<rescuer_account
0T::AccountId
)
A recovery process has been initiated for lost account by rescuer account.<RecoveryVouched
0lost_account
0T::AccountId
<rescuer_account
0T::AccountId
sender
0T::AccountIdY
A recovery process for lost account by rescuer account has been vouched for by sender.8RecoveryClosed
0lost_account
0T::AccountId
<rescuer_account
0T::AccountId
A recovery process for lost account by rescuer account has been closed.@AccountRecovered
0lost_account
0T::AccountId
<rescuer_account
0T::AccountId

Lost account has been successfully recovered by rescuer account.<RecoveryRemoved
0lost_account
0T::AccountId�A recovery process has been removed for an account.0DepositPoked
who
0T::AccountId
kind�

8DepositKind<T>
,old_depositP
0BalanceOf<T>
,new_depositP
0BalanceOf<T>lA deposit has been updated.0Events type.�
<pallet_recovery,DepositKindT
�

8RecoveryConfigDActiveRecoveryFor
�<T as frame_system::Config>::AccountId
�
<quantus_runtimeRuntime�
<pallet_multisigpalletEventT
 <MultisigCreated
creator
0T::AccountId
@multisig_address
0T::AccountId
signersX
DVec<T::AccountId>
$threshold8
u32
nonce(
u64�A new multisig account was created�[creator, multisig_address, signers, threshold, nonce]<ProposalCreated
@multisig_address
0T::AccountId
 proposer
0T::AccountId
,proposal_id8
u32
lA proposal has been created8SignerApproved
@multisig_address
0T::AccountId
 approver
0T::AccountId
,proposal_id8
u32
<approvals_count8
u32

A signer has approved a proposal (does not imply threshold reached)XProposalReadyToExecute
@multisig_address
0T::AccountId
,proposal_id8
u32
<approvals_count8
u32�A proposal has reached threshold and is ready to execute@ProposalExecuted
@multisig_address
0T::AccountId
,proposal_id8
u32
 proposer
0T::AccountId
call
Vec<u8>
$approversX
DVec<T::AccountId>
result�

8DispatchResultpA proposal has been executed�Contains all data needed for indexing by SubSquidDProposalCancelled
@multisig_address
0T::AccountId
 proposer
0T::AccountId
,proposal_id8
u32�A proposal has been cancelled by the proposer<ProposalRemoved
@multisig_address
0T::AccountId
,proposal_id8
u32
 proposer
0T::AccountId
(removed_by
0T::AccountId�Expired proposal was removed from storage<DepositsClaimed
@multisig_address
0T::AccountId
claimer
0T::AccountId
8total_returnedP
0BalanceOf<T>
Dproposals_removed8
u32XBatch deposits claimed|The `Event` enum of this pallet�
<pallet_wormholepalletEventT
DNativeTransferred
from
�<T as frame_system::Config>::AccountId
to
�<T as frame_system::Config>::AccountId
amountP
0BalanceOf<T>
8transfer_count(
@T::TransferCount
(leaf_index(
u64�Index of this transfer in the ZK trie (for Merkle proof lookup)�A native token transfer was recorded.�The `leaf_index` can be used to fetch Merkle proofs via the�`zkTrie_getMerkleProof` RPC for ZK circuit verification.@AssetTransferred
 asset_id8
(T::AssetId
from
�<T as frame_system::Config>::AccountId
to
�<T as frame_system::Config>::AccountId
amountP
DAssetBalanceOf<T>
8transfer_count(
@T::TransferCount
(leaf_index(
u64�Index of this transfer in the ZK trie (for Merkle proof lookup)
�A non-native asset transfer was recorded.�The `leaf_index` can be used to fetch Merkle proofs via the�`zkTrie_getMerkleProof` RPC for ZK circuit verification.4ProofVerified
,exit_amountP
0BalanceOf<T>
(nullifiers�

4Vec<[u8; 32]>HMinerVolumeFeePaid
miner
�<T as frame_system::Config>::AccountId
amountP
0BalanceOf<T>
The block author's share of the wormhole exit volume fee was minted.
NOTE: keep this as the last variant — indexers decode events by their
position in this enum, so existing variants must never be reordered.8SegmentsDenied
indices�

 Vec<u32>)
Some segments of an exit bundle were denied (their nullifiers were already1
used, e.g. because the underlying private batch landed on-chain separately).�The remaining segments were processed normally.8ExitMintFailed
account
�<T as frame_system::Config>::AccountId
amountP
0BalanceOf<T>1
An exit slot could not be minted (e.g. a below-existential-deposit credit to-
a fresh account) and was skipped so the rest of the bundle still processed.)
The skipped exit's nullifier stays marked, so this exit cannot be retried.=
NOTE: keep new variants appended at the end — indexers decode events by their
position in this enum, so existing variants must never be reordered.|The `Event` enum of this pallet�
�
8�
8pallet_zk_treepalletEventT
0LeafInserted
index(
u64
$leaf_hash
Hash256
 new_root
Hash256�A new leaf was inserted into the tree. TreeGrew
$new_depth
u8
TTree depth increased.|The `Event` enum of this pallet
8pallet_vestingpalletEventT
<ScheduleCreated
,schedule_id(
u64
,beneficiary
0T::AccountId
start(
Moment
cliff(
Moment
end(
Moment
totalP
0BalanceOf<T>

A new schedule was created and the pot funded from the treasury.Claimed
,schedule_id(
u64
,beneficiary
0T::AccountId
amountP
0BalanceOf<T>
�Vested funds were paid out to the beneficiary.4ScheduleEnded
,schedule_id(
u64
,beneficiary
0T::AccountId
,vested_paidP
0BalanceOf<T>
Dunvested_returnedP
0BalanceOf<T>	
A schedule was ended early: unpaid vested part to the beneficiary,�unvested remainder back to the treasury.HScheduleRetargeted
,schedule_id(
u64
<old_beneficiary
0T::AccountId
<new_beneficiary
0T::AccountId
,vested_paidP
0BalanceOf<T>M
A schedule's beneficiary was changed after settling any currently claimable payout.|The `Event` enum of this pallet0frame_systemPhase
8ApplyExtrinsic8
u320Finalization
8Initialization	

880frame_systemXLastRuntimeUpgradeInfo
0spec_version�
Lcodec::Compact<u32>
$spec_name
DCow<'static, str>CowT
0frame_system`CodeUpgradeAuthorizationT
$code_hash<
T::Hash
4check_versionT
bool!0frame_systemlimits0BlockWeights
(base_block|
Weight
$max_block|
Weight
$per_class%
�PerDispatchClass<WeightsPerClass>%4frame_support dispatch@PerDispatchClassT
)
normal)
T
,operational)
T
$mandatory)
T)0frame_systemlimits<WeightsPerClass
8base_extrinsic|
Weight
4max_extrinsic�

8Option<Weight>
$max_total�

8Option<Weight>
 reserved�

8Option<Weight>-0frame_systemlimits,BlockLength
max1
TPerDispatchClass<u32>14frame_support dispatch@PerDispatchClassT
8
normal8
T
,operational8
T
$mandatory8
T5(sp_weights<RuntimeDbWeight
read(
u64
write(
u649(sp_version8RuntimeVersion 
$spec_name
DCow<'static, str>
$impl_name
DCow<'static, str>
Dauthoring_version8
u32
0spec_version8
u32
0impl_version8
u32
apis=
ApisVec
Ltransaction_version8
u32
8system_version
u8=CowT
AAAEEI8IM0frame_systempalletErrorT
(<InvalidSpecName
The name of specification does not match between the current runtimePand the new runtime.hSpecVersionNeedsToIncrease
A
The specification version is not allowed to decrease between the current runtimePand the new runtime.tFailedToExtractRuntimeVersion�Failed to extract the runtime version from the new runtime.	
Either calling `Core_version` or decoding `RuntimeVersion` failed.LNonDefaultComposite�Suicide called when the account has non-default composite data.<NonZeroRefCount5
There is a non-zero reference count preventing the account from being purged.0CallFiltered�The origin filter prevent the call to be dispatched.lMultiBlockMigrationsOngoingU
A multi-block migration is ongoing and prevents the current code from being replaced.DNothingAuthorizedXNo upgrade authorized.0Unauthorized�The submitted code is not authorized.@InvalidHeapPages	E
The provided number of heap pages is outside the supported range of `64..=65536`.lError for the System palletQ(sp_runtimegenericblockBlockHeader
U$Extrinsic
Y
headerU
Header
(extrinsicsa
8Vec<Extrinsic>U$qp_headerHeaderNumber
8Hashing
,parent_hash<
H256
number8
Number
(state_root<
H256
<extrinsics_root<
H256
0zk_tree_root<
H256
digest%

DigestY(sp_runtimegenericLunchecked_extrinsicHUncheckedExtrinsicAddress
Call
 $Signature
�Extra
]],��������




aYeLbounded_collections@weak_bounded_vec8WeakBoundedVecT
iSq
Vec<T>i<pallet_balancestypes,BalanceLockBalance
P
idI
8LockIdentifier
amountP
Balance
reasonsm
Reasonsm<pallet_balancestypesReasons
FeeMisc
AllqiuLbounded_collections,bounded_vec(BoundedVecT
yS}
Vec<T>y<pallet_balancestypes,ReserveDataDReserveIdentifier
IBalance
P
idI
DReserveIdentifier
amountP
Balance}y�Lbounded_collections,bounded_vec(BoundedVecT
�S�
Vec<T>�4frame_supporttraitstokensmisc IdAmountId
q
Balance
P
idq

Id
amountP
Balance���Lbounded_collections,bounded_vec(BoundedVecT
�S�
Vec<T>�4frame_supporttraitstokensmisc IdAmountId
�Balance
P
id�
Id
amountP
Balance�<quantus_runtimeLRuntimeFreezeReason
���<pallet_balancespalletErrorTI
08VestingBalance�Vesting balance too high to send value.TLiquidityRestrictions
�Account liquidity restrictions prevent withdrawal.LInsufficientBalancexBalance too low to send value.HExistentialDeposit�Value too low to create account due to existential deposit.4Expendability�Transfer/payment would kill account.\ExistingVestingSchedule�A vesting schedule already exists for this account.,DeadAccount�Beneficiary account must pre-exist.<TooManyReserves�Number of named reserves exceed `MaxReserves`.0TooManyHolds�Number of holds exceed `VariantCountOf<T::RuntimeHoldReason>`.8TooManyFreezes	�Number of freezes exceed `MaxFreezes`.LIssuanceDeactivated


The issuance cannot be modified since it is already deactivated.$DeltaZerodThe delta cannot be zero.�The `Error` enum of this pallet.�4sp_arithmetic,fixed_point$FixedU128P
u128�hpallet_transaction_payment Releases
$V1AncientV2
�4frame_supporttraitsstorageNoDropT
��
T�4frame_supporttraitstokens fungible$imbalance$ImbalanceB
POnDrop8OppositeOnDrop
amountP
B�<pallet_preimage@OldRequestStatus$AccountId
Balance
P
,Unrequested
deposit�
P(AccountId, Balance)
len8
u32$Requested
deposit�
pOption<(AccountId, Balance)>
count8
u32
len�

,Option<u32>
�P�OptionT
�
NoneSome�
�<pallet_preimage4RequestStatus$AccountId
Ticket
�
,Unrequested
ticket�
L(AccountId, Ticket)
len8
u32$Requested
0maybe_ticket�
lOption<(AccountId, Ticket)>
count8
u32
$maybe_len�

,Option<u32>
�<quantus_runtime(governance,definitions<PreimageDeposit
amountP
Balance���OptionT
�
NoneSome�
�<8�Lbounded_collections,bounded_vec(BoundedVecT
S
Vec<T>�<pallet_preimagepalletErrorT
 TooBig�Preimage is too large to store on-chain.0AlreadyNoted
�Preimage has already been noted on-chain.4NotAuthorized�The user is not authorized to perform this action. NotNoted�The preimage cannot be removed since it has not yet been noted.$Requested	
A preimage may not be removed when there are outstanding requests.0NotRequested-
The preimage request cannot be removed since no outstanding requests exist.TooManyU
More than `MAX_HASH_UPGRADE_BULK_COUNT` hashes were requested to be upgraded at once.TooFew�Too few hashes were requested to be upgraded (i.e. zero).�The `Error` enum of this pallet.�Lbounded_collections,bounded_vec(BoundedVecT
�S�
Vec<T>�OptionT
�
NoneSome�
�@pallet_scheduler$ScheduledName
Call
�,BlockNumber
84PalletsOrigin
t$AccountId
Moment
(
 maybe_id	

0Option<Name>
 priority
Hschedule::Priority
call�
Call
origint
4PalletsOrigin���@pallet_scheduler,RetryConfigPeriod
�
4total_retries
u8
$remaining
u8
period�
Period�@pallet_schedulerpalletErrorT
$@FailedToScheduledFailed to schedule a call NotFound
|Cannot find the scheduled call.\TargetBlockNumberInPast�Given target block number is in the past.TTargetTimestampInPast�Given target timestamp is in the past.HRescheduleNoChange�Reschedule failed because it does not change scheduled time.Named�Attempt to use a non-named function on a named task.PPeriodicNotSupported�Periodic scheduling is not supported.LRetryPeriodMismatch�Retry period type does not match task scheduling type.�Block-scheduled tasks require a block-number retry period,�and timestamp-scheduled tasks require a timestamp retry period.HInvalidRetryPeriodxRetry period value is invalid.=
A retry period must be non-zero, and a timestamp retry period must additionally-
be a whole multiple of [`Config::TimestampBucketSize`]. A zero period would1
re-target the agenda currently being serviced (losing the retry to the stale5
agenda write-back), and a non-bucket-aligned timestamp period would place the�retry in an agenda key the servicing loop never visits.�The `Error` enum of this pallet.�8pallet_utilitypalletErrorT
0TooManyCalls\Too many calls batched.tCallNotAllowedForHighSecurity
�Call is not allowed for a high-security account.�The `Error` enum of this pallet.�lpallet_reversible_transfers\HighSecurityAccountData$AccountId
Delay
�
 guardian
$AccountId
delay�
Delay�lpallet_reversible_transfers<PendingTransfer$AccountId
Balance
PAssetId
8
from
$AccountId
to
$AccountId
 guardian
$AccountId
 asset_id�

<Option<AssetId>
amountP
Balance�Lbounded_collections,bounded_vec(BoundedVecT
<Sd
Vec<T>
Lbounded_collections,bounded_vec(BoundedVecT
SX
Vec<T>lpallet_reversible_transferspalletErrorT
@hAccountAlreadyHighSecurity=
The account attempting to enable reversibility is already marked as reversible.XAccountNotHighSecurity

The account attempting the action is not marked as high security.PGuardianCannotBeSelf�Guardian cannot be the account itself, because it is redundant.DPendingTxNotFound�The specified pending transaction ID was not found. NotOwnerY
The caller is not the original submitter of the transaction they are trying to cancel.hTooManyPendingTransactions9
The account has reached the maximum number of pending reversible transactions.4DelayTooShort�The specified delay period is below the configured minimum.@SchedulingFailed
Failed to schedule the transaction execution with the scheduler pallet.HCancellationFailed�Failed to cancel the scheduled task with the scheduler pallet.,InvalidCall	@Call is invalid.XInvalidSchedulerOrigin
`Invalid scheduler origin<InvalidReverserLReverser is invalid�AccountAlreadyReversibleCannotScheduleOneTimeE
Cannot schedule one time reversible transaction when account is reversible (theft,deterrence)\TooManyGuardianAccounts
%
The guardian has reached the maximum number of accounts they can protect.HAssetsNotSupported�Asset transfers are not supported.(ZeroAmount
Zero-amount transfers cannot be scheduled: there is nothing to hold,Pexecute, or reverse.�The `Error` enum of this pallet.	`pallet_ranked_collective0MemberRecord
rankp
Rank
pp88Lbounded_collections,bounded_vec(BoundedVecT
S
Vec<T>`pallet_ranked_collectivepalletErrorTI
,4AlreadyMemberpAccount is already a member.$NotMember
`Account is not a member.(NotPolling�The given poll index is unknown or has closed.Ongoing�The given poll is still ongoing.4NoneRemaining�There are no further records to be removed.(CorruptionhUnexpected error in state.(RankTooLow�The member's rank is too low to vote.8InvalidWitness�The information provided is incorrect.0NoPermission�The origin is not sufficiently privileged to do the operation.(SameMember	�The new member to exchange is the same as the old member8TooManyMembers
�The max member count for the rank has been reached.�The `Error` enum of this pallet.!@pallet_referendatypes8ReferendumInfo TrackId
p4RuntimeOrigin
tMoment
8Call
�Balance
PTally
�
$AccountId
<ScheduleAddress
�

Ongoing%
�
ReferendumStatus<TrackId, RuntimeOrigin, Moment, Call, Balance, Tally,
AccountId, ScheduleAddress,> Approved8
Moment-
�Option<Deposit<AccountId, Balance>>-
�Option<Deposit<AccountId, Balance>>
 Rejected8
Moment-
�Option<Deposit<AccountId, Balance>>-
�Option<Deposit<AccountId, Balance>>$Cancelled8
Moment-
�Option<Deposit<AccountId, Balance>>-
�Option<Deposit<AccountId, Balance>> TimedOut8
Moment-
�Option<Deposit<AccountId, Balance>>-
�Option<Deposit<AccountId, Balance>>Killed8
Moment%@pallet_referendatypes@ReferendumStatus TrackId
p4RuntimeOrigin
tMoment
8Call
�Balance
PTally
�
$AccountId
<ScheduleAddress
�
,
trackp
TrackId
origint
4RuntimeOrigin
 proposal�
Call
$enactment�
PDispatchTime<Moment>
$submitted8
Moment
Hsubmission_deposit)
lDeposit<AccountId, Balance>
@decision_deposit-
�Option<Deposit<AccountId, Balance>>
 deciding1
xOption<DecidingStatus<Moment>>
tally�

Tally
 in_queueT
bool
alarm9
�Option<(Moment, ScheduleAddress)>)@pallet_referendatypesDeposit$AccountId
Balance
P
who
$AccountId
amountP
Balance-OptionT
)
NoneSome)
1OptionT
5
NoneSome5
5@pallet_referendatypes8DecidingStatus,BlockNumber
8
since8
,BlockNumber
(confirming�

LOption<BlockNumber>9OptionT
=
NoneSome=
=8�
ALbounded_collections,bounded_vec(BoundedVecT

S	
Vec<T>EIIpMM@pallet_referendatypes0TrackDetailsBalance
PMoment
8Name
$
name
Name
0max_deciding8
u32
@decision_depositP
Balance
8prepare_period8
Moment
<decision_period8
Moment
8confirm_period8
Moment
Pmin_enactment_period8
Moment
0min_approvalQ
Curve
,min_supportQ
CurveQ@pallet_referendatypesCurve
@LinearDecreasing
lengthU
Perbill
floorU
Perbill
ceilU
PerbillDSteppedDecreasing
beginU
Perbill
endU
Perbill
stepU
Perbill
periodU
Perbill
(Reciprocal
factorY
 FixedI64
 x_offsetY
 FixedI64
 y_offsetY
 FixedI64U4sp_arithmetic(per_thingsPerbill8
u32Y4sp_arithmetic,fixed_point FixedI64]
i64]a@pallet_referendapalletErrorTI
<(NotOngoinghReferendum is not ongoing.(HasDeposit
�Referendum's decision deposit is already paid. BadTrack�The track identifier given was invalid.Full1
There are already a full complement of referenda in progress for this track.(QueueEmpty�The queue of the track is empty.4BadReferendum�The referendum index provided is invalid in this context.,NothingToDo�There was nothing to do in the advancement.NoTrack�No track exists for the proposal origin.(Unfinished

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

The preimage is stored with a different length than the one provided.TAlarmSchedulingFailed�The referendum's wake-up alarm could not be scheduled.�The `Error` enum of this pallet.e<pallet_treasurypalletErrorT
8InvalidPortionXInvalidTreasuryAccount
1
Treasury account cannot be zero address (funds would be permanently locked).�The `Error` enum of this pallet.i<pallet_recovery8RecoveryConfig,BlockNumber
8Balance
PFriends
m
0delay_period8
,BlockNumber
depositP
Balance
friendsm
Friends
$thresholdp
u16mLbounded_collections,bounded_vec(BoundedVecT
SX
Vec<T>qu<pallet_recovery8ActiveRecovery,BlockNumber
8Balance
PFriends
m
created8
,BlockNumber
depositP
Balance
friendsm
Friendsy<pallet_recoverypalletErrorT
D(NotAllowed�User is not allowed to make a call on behalf of this accounttCallNotAllowedForHighSecurity
�Call is not allowed for a high-security account4ZeroThreshold�Threshold must be greater than zero@NotEnoughFriends�Friends list must be greater than zero and threshold(MaxFriends�Friends list must be less than max friends$NotSorted�Friends list must be sorted and free of duplicates8NotRecoverable�This account is not set up for recoveryHAlreadyRecoverable�This account is already set up for recovery8AlreadyStarted�A recovery process has already started for this account(NotStarted	�A recovery process has not started for this rescuer$NotFriend
�This account is not a friend who can vouch,DelayPeriod
The friend must wait until the delay period to vouch for this recovery8AlreadyVouched�This user has already vouched for this recovery$Threshold
�The threshold for recovering this account has not been met,StillActive�There are still active recovery attempts that need to be closed0AlreadyProxy�This account is already set up for recovery BadStatexSome internal state is broken.�The `Error` enum of this pallet.}<pallet_multisig0MultisigData$AccountId
8BoundedSigners
�dBoundedProposalsPerSigner
�
creator
$AccountId
signers�
8BoundedSigners
$threshold8
u32
8proposal_nonce8
u32
Pproposals_per_signer�
dBoundedProposalsPerSigner�Lbounded_collections,bounded_vec(BoundedVecT
SX
Vec<T>�Lbounded_collectionsDbounded_btree_map<BoundedBTreeMapK
V
8S�
8BTreeMap<K, V>� BTreeMapK
V
8����8�<pallet_multisig0ProposalData$AccountId
Balance
P,BlockNumber
8,BoundedCall
�@BoundedApprovals
�
 proposer
$AccountId
call�
,BoundedCall
expiry8
,BlockNumber
$approvals�
@BoundedApprovals
depositP
Balance
status�
8ProposalStatus�<pallet_multisig8ProposalStatus
Active Approved
�4frame_support PalletIdI
[u8; 8]�<pallet_multisigpalletErrorT
h@NotEnoughSignerslNot enough signers provided�Multisig requires at least 2 unique signers4ThresholdZero
�Threshold must be greater than zero@ThresholdTooHigh�Threshold exceeds number of signers8TooManySigners@Too many signersTMultisigAlreadyExists\Multisig already exists@MultisigNotFoundHMultisig not found(NotASigner�Caller is not a signer of this multisig@ProposalNotFoundHProposal not found,NotProposerhCaller is not the proposer<AlreadyApproved	|Already approved by this signerHNotEnoughApprovals
|Not enough approvals to execute0ExpiryInPastxProposal expiry is in the past0ExpiryTooFar
Proposal expiry is too far in the future (exceeds MaxExpiryDuration)<ProposalExpired
PProposal has expired,InvalidCallhFailed to decode call datadTooManyProposalsInStorage!
Too many total proposals in storage for this multisig (cleanup required)dTooManyProposalsPerSigner
This signer has too many proposals in storage (filibuster protection)LInsufficientBalance�Insufficient balance for depositHProposalHasDepositlProposal has active depositHProposalNotExpiredpProposal has not expired yetDProposalNotActive

Proposal is not in a cancellable state (must be Active or Approved)LProposalNotApproved�Proposal has not been approved yet (threshold not reached)�CallNotAllowedForHighSecurityMultisig�Call is not allowed for high-security multisigXProposalNonceExhausted�Proposal nonce exhausted (u32::MAX reached)XCallWeightExceedsLimit�Call weight exceeds MaxInnerCallWeight limit0CallMismatch�Provided call does not match the stored proposal payload�The `Error` enum of this pallet.�<pallet_wormholepalletErrorT
0LInvalidPublicInputsPNullifierAlreadyUsed
%
No segment of the bundle is spendable: every non-dummy segment contains a!
nullifier that is already used (or the single segment of a private-batch0proof does).<NoValidSegments
The bundle contains only dummy (all-zero) padding segments, so there is)
nothing to exit. Distinct from [`Error::NullifierAlreadyUsed`], which is a`replay of real segments.4BlockNotFoundPVerifierNotAvailablehProofDeserializationFailed4ProofTooLarge1
The submitted proof blob exceeds [`crate::MAX_PROOF_BYTES`]. Rejected before%
any copy or parsing so oversized unsigned spam costs only a length check.dNonCanonicalProofEncoding!
The proof bytes are not the canonical serialization of the decoded proof
(e.g. a valid proof with trailing bytes, which the plonky2 parser would
silently ignore). Every proof has exactly one accepted byte encoding.\ProofVerificationFailed`InvalidProofPublicInputs	PInvalidVolumeFeeRate
	
The volume fee rate in the proof doesn't match the configured ratehNonNativeAssetNotSupported�Only native asset (asset_id = 0) is supported in this version�The `Error` enum of this pallet.�8pallet_zk_treeZkLeaf$AccountId
AssetId
8Balance
P
to
$AccountId
8transfer_count(
u64
 asset_id8
AssetId
amountP
Balance�(�8pallet_zk_treepalletErrorT
PLeafIndexOutOfBoundsdLeaf index out of bounds.0LeafNotFound
<Leaf not found.�The `Error` enum of this pallet.�8pallet_vestingpallet<VestingSchedule$AccountId
Balance
P
,beneficiary
$AccountId
start(
Moment
cliff(
Moment
end(
Moment
totalP
Balance
claimedP
Balance
4last_claim_at�
8Option<Moment>�OptionT
(
NoneSome(
�8pallet_vestingpalletErrorT
$(NoSchedule�No schedule exists under this id.<InvalidSchedule


Schedule parameters violate `start <= cliff <= end`, `start < end`,
`total >= MinimumPayout`, or `total` is not a multiple of the payout quantum.8NothingToClaim-
Nothing is claimable right now (before the cliff, already fully claimed, or�less than the minimum payout accrued).0ClaimTooSoon
This schedule has already paid out within the minimum claim interval.LClaimWouldLeaveDust-
Paying now would leave a remainder below the minimum payout; wait until thepentire remainder has vested.HPayoutBelowMinimum
Ending now would emit a non-zero beneficiary payout below the minimum.TTreasuryNotConfigured	
The treasury account is not configured or aliases the vesting pot.8PotUnderfunded
The pot does not hold its existential-deposit buffer; endow it first.HInvalidBeneficiary5
The beneficiary must not be the pot, and retargeting must change the account.�The `Error` enum of this pallet.�(sp_runtimegenericblock$LazyBlockHeader
U$Extrinsic
Y
headerU
Header
(extrinsics�
PVec<OpaqueExtrinsic>���(sp_runtime<OpaqueExtrinsic
Vec<u8>�(sp_runtimeXExtrinsicInclusionMode
4AllExtrinsics4OnlyInherents
�sp_core8OpaqueMetadata
Vec<u8>�OptionT
�
NoneSome�
�ResultT
�
E
�
Ok�
Err�
�(sp_runtimePtransaction_validity`TransactionValidityError
Invalid�
HInvalidTransactionUnknown�
HUnknownTransaction
�(sp_runtimePtransaction_validityHInvalidTransaction
4CallPayment
FutureStale BadProofDAncientBirthBlockDExhaustsResourcesCustom
u80BadMandatoryLMandatoryValidation	$BadSigner
TIndeterminateImplicit4UnknownOrigin�(sp_runtimePtransaction_validityHUnknownTransaction
0CannotLookupLNoUnsignedValidator
Custom
u8�0sp_inherents0InherentData
data�
�BTreeMap<InherentIdentifier, Vec<u8>>� BTreeMapK
IV
����I�0sp_inherentsPCheckInherentsResult
okayT
bool
,fatal_errorT
bool
errors�
0InherentData�(sp_runtimePtransaction_validityDTransactionSource
InBlockLocal
 External
ResultT
E
�
OkErr�
(sp_runtimePtransaction_validity@ValidTransaction
 priority(
LTransactionPriority
 requires4
LVec<TransactionTag>
 provides4
LVec<TransactionTag>
$longevity(
PTransactionLongevity
$propagateT
bool	OptionT

NoneSome

OptionT

NoneSome
sp_corecrypto$KeyTypeId1

[u8; 4]T�
!OptionT
%
NoneSome%
%8pallet_zk_tree@ZkMerkleProofRpc
(leaf_index(
u64
$leaf_data
Vec<u8>
$leaf_hash
Hash256
 siblings)
DVec<[Hash256; 3]>
root
Hash256
depth
u8)--1hpallet_transaction_paymenttypesLRuntimeDispatchInfoBalance
PWeight
|
weight|
Weight
classI

4DispatchClass
,partial_feeP
Balance5hpallet_transaction_paymenttypes(FeeDetailsBalance
P
4inclusion_fee9
tOption<InclusionFee<Balance>>
tipP
Balance9OptionT
=
NoneSome=
=hpallet_transaction_paymenttypes0InclusionFeeBalance
P
 base_feeP
Balance
len_feeP
Balance
Ladjusted_weight_feeP
BalanceAResultT
E

OkErr
EOptionT

NoneSome
IM<quantus_runtime0RuntimeError
8SystemM
pframe_system::Error<Runtime> Balances�
|pallet_balances::Error<Runtime> Preimage�
|pallet_preimage::Error<Runtime>$Scheduler�
�pallet_scheduler::Error<Runtime>Utility�
xpallet_utility::Error<Runtime>	LReversibleTransfers
�pallet_reversible_transfers::Error<Runtime>8TechCollective
�pallet_ranked_collective::Error<Runtime>
4TechReferendaa
�pallet_referenda::Error<Runtime, pallet_referenda::Instance1>8TreasuryPallete
|pallet_treasury::Error<Runtime> Recoveryy
|pallet_recovery::Error<Runtime> Multisig�
|pallet_multisig::Error<Runtime> Wormhole�
|pallet_wormhole::Error<Runtime>ZkTree�
xpallet_zk_tree::Error<Runtime>Vesting�
xpallet_vesting::Error<Runtime>HSystem
SystemPAccount


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

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

8=
 Extrinsics data for the current block (maps an extrinsic's index to its data).Number
8	
 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.(ZkTreeRoot
<�� ZK tree root for the current block.%
 Set by pallet-zk-tree during block finalization. This is included in the-
 block header as a dedicated field (not in digest) to ensure a fixed offsett for ZK circuit verification.Events
5
� Events deposited for the current block.
 NOTE: The item is unbound and should therefore never be read on chain.� It could otherwise inflate the PoV size of a block.-
 Events have a large in-memory size. Box the events to not go out-of-memory� just in case someone still reads them from within the runtime.(EventCount
8� The number of events in the `Events<T>` list.,EventTopics

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

 no notification will be triggered thus the event might be lost.HLastRuntimeUpgradeU
 Stores the `spec_version` and `spec_name` of when the last runtime upgrade happened.TUpgradedToU32RefCount
TM
 True if we have upgraded so that `type RefCount` is `u32`. False (default) if not.`UpgradedToTripleRefCount
T]
 True if we have upgraded so that AccountInfo contains three types of `RefCount`. FalseH (default) if not.8ExecutionPhase� The execution phase of the block.DAuthorizedUpgrade� `Some` if a code upgrade has been authorized.`ExtrinsicWeightReclaimed
|� The weight reclaimed for the extrinsic.!
 This information is available until the end of the extrinsic execution.!
 More precisely this information is removed in `note_applied_extrinsic`.q
 Logic doing some post dispatch weight reduction must update this storage to avoid duplicate, reduction.
$
A
0BlockWeights!�
 �f`��t��������"a�
���fffffff�
����������
"a�
���(�fffffff�
`��t��������
��>]
@"a�� Block & extrinsics weights: base values and limits.,BlockLength-0<PP� The maximum length of a block (in bytes).8BlockHashCount8U
 Maximum number of block number to block hash mappings to keep (oldest pruned first). DbWeight5@@x}
��	
 The weight of runtime database operations the runtime can invoke.Version9	<quantus-runtime<quantus-runtime
�
0�j�h�`�7��|���@�:�
���Ҽ���Џ��'��?EL�<r)�
(��.0
$XY���i
����O[�?
7ȻP�����իRpY��w��G��

� Get the chain's in-code version.(SS58Prefixp�� The designated SS58 prefix of this chain.9
 This replaces the "ss58Format" property declared in the chain spec. Reason is1
 that the runtime should know about the prefix in order to make use of it asp an identifier of the chain.
M,RuntimeCall � The aggregated `RuntimeCall` type.Nonce8I
 This stores the number of previous transactions associated with a sender account.Hash<� The output of the `Hashing` function.Hashing�!
 The hashing system (algorithm) being used in the runtime (e.g. Blake2).$AccountId� The user account identifier type for the runtime.BlockQa
 The Block type used by the runtime. This is used by `construct_runtime` to retrieve the� extrinsics or other block specific data as needed.M
 The header must implement `ZkTreeRootProvider` to support setting the ZK tree rootl during block finalization.,AccountData
a
 Data to be associated with an account (other than nonce/transaction counter, which thisd pallet does regardless).$Timestamp
$TimestampNow
( � The current time for the current block.$DidUpdate
T� Whether the timestamp has been updated in this block.U
 This value is updated to `true` upon successful submission of a timestamp by a node.E
 It is then checked at the end of each block execution in the `on_finalize` hook.
@4MinimumPeriod( d� The minimum period between blocks.M
 Be aware that this is different to the *expected* period that the block productionI
 apparatus provides. Your chosen consensus system will generally work with this toa
 determine a sensible block time. For example, in the Aura pallet it will be double thisp period on default settings.Moment(� Type used for expressing a timestamp.
 Balances
 Balances4TotalIssuance
P@� The total units issued in the system.@InactiveIssuance
P@	
 The total units of outstanding deactivated balance in the system.Account




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

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

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

�l Holds on account balances.Freezes

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

 The maximum number of named reserves that can exist on an account.�
 Use of reserves is deprecated in favour of holds. See `https://github.com/paritytech/substrate/pull/12951/`(MaxFreezes8a
 The maximum number of individual freeze locks that can exist on an account at any time.
�DRuntimeHoldReasonq
t The overarching hold reason.BalancePl The balance of an account.DReserveIdentifierIh The ID type for reserves.�
 Use of reserves is deprecated in favour of holds. See `https://github.com/paritytech/substrate/pull/12951/`@FreezeIdentifier�d The ID type for freezes.HTransactionPayment
HTransactionPaymentDNextFeeMultiplier
�@d����
8StorageVersion
�<TxPaymentCredit�� The `OnChargeTransaction` stores the withdrawn tx fee here.5
 Use `withdraw_txfee` and `remaining_txfee` to access from outside the crate.
�
`OperationalFeeMultiplierTY
 A fee multiplier for `Operational` extrinsics to compute "virtual tip" to boost their, `priority`Q
 This value is multiplied by the `final_fee` to obtain a "virtual tip" that is later� added to a tip component in regular `priority` calculations.M
 It means that a `Normal` transaction can front-run a similarly-sized `Operational`A
 extrinsic (with no tip), by including a tip value greater than the virtual tip.< ```rust,ignore@ // For `Normal`� let priority = priority_calc(tip);T // For `Operational`
 let virtual_tip = (inclusion_fee + tip) * OperationalFeeMultiplier;� let priority = priority_calc(tip + virtual_tip); ```Q
 Note that since we use `final_fee` the multiplier applies also to the regular `tip`]
 sent with the transaction. So, not only does the transaction get a priority bump baseda
 on the `inclusion_fee`, but we also amplify the impact of tips applied to `Operational`8 transactions.QPoW
QPoW4LastBlockTime
( DLastBlockDuration
( DCurrentDifficulty
�



�
DInitialDifficulty�


	=<TargetBlockTime( �.4MaxReorgDepth8d4MiningRewards
4MiningRewards4CollectedFees
P@
 Fees and failed-mint retries awaiting distribution by `on_finalize`.
�
$MaxSupplyP@4���n#
� The maximum total supply of tokens<EmissionDivisorP@�`�	
 The divisor used to calculate block rewards from remaining supplyUnitP@���� The base unit for token amounts (e.g., 1e12 for 12 decimals)8MintingAccount�































Y
 Account ID used as the "from" account when creating transfer proofs for minted tokens Preimage
 Preimage$StatusFor
<�� The request status of a given hash.@RequestStatusFor@RequestStatusFor
<�� The request status of a given hash.,PreimageFor
��
`
�

�$Scheduler
$SchedulerPIncompleteBlockSince8I
 Tracks incomplete block-based agendas that need to be processed in a later block.`IncompleteTimestampSince(Y
 Tracks incomplete timestamp-based agendas that need to be processed in a later block.XLastProcessedTimestamp(� Tracks the last timestamp bucket that was fully processed.� Used to avoid reprocessing all buckets from 0 on every run.Agenda

��M
 Items to be executed, indexed by the block number that they should be executed on.Retries
�
�!
 Retry configurations for items to be executed, indexed by task address.Lookup
�
� Lookup from a name to the block number and index of the task.
�
4MaximumWeight|@�K�]��������)
 The maximum weight that may be scheduled per block for any dispatchables.PMaxScheduledPerBlock82
 The maximum number of scheduled calls in the queue for a single block. NOTE:Q
 + Dependent pallets' benchmarks might require a higher limit for the setting. Set a� higher limit under `runtime-benchmarks` feature.LTimestampBucketSize( �]� Precision of the timestamp buckets.A
 Timestamp based dispatches are rounded to the nearest bucket of this precision.
�,RuntimeCall h The aggregated call type.Moment(0 Moment typeUtility
h
�
Lbatched_calls_limit8�*� The limit on the number of batched calls.
�,RuntimeCall l The overarching call type.4PalletsOrigint� The caller origin, overarching type of all pallets origins.	LReversibleTransfers
LReversibleTransfersPHighSecurityAccounts
�1
 Maps accounts to their chosen reversibility delay period (in milliseconds).� Accounts present in this map have reversibility enabled.@PendingTransfers
<�1
 Stores the details of pending transactions scheduled for delayed execution.� Keyed by the unique transaction ID.`PendingTransfersBySender

�� Maps sender accounts to their list of pending transaction IDs.4GuardianIndex


� Maps guardian accounts to the list of accounts they protect.Q
 This allows the UI to efficiently query all accounts for which a given account is a( guardian.DNextTransactionId
( )
 Monotonically increasing counter used to generate unique transaction IDs.%
 Each scheduled transfer increments this value to ensure no two transfers	
 produce the same `tx_id`, even if they have identical parameters.
�
�
LMaxGuardianAccounts8 =
 Maximum number of accounts a single guardian can protect. Used for BoundedVec.PMaxPendingPerAccount8� Maximum pending reversible transactions allowed per account.0DefaultDelay� -
 The default delay period for reversible transactions if none is specified.� NOTE: default delay is always in blocks.PMinDelayPeriodBlocks8%
 The minimum delay period allowed for reversible transactions, in blocks.PMinDelayPeriodMoment( �.=
 The minimum delay period allowed for reversible transactions, in milliseconds.$VolumeFee�'5
 Volume fee taken from reversed transactions for high-security accounts only,a
 expressed as a Permill (e.g., Permill::from_percent(1) = 1%). Regular accounts incur no� fees. The fee is burned (removed from total issuance).
AssetId8=
 Identifier used to retain the wire format of unsupported asset transfer calls.Moment(p Moment type for scheduling.8TechCollective
8TechCollective,MemberCount

p8i
 The number of members in the collective who have at least the rank according to the index0 of the vec.Members
	� The current members of the collective.$IdToIndex

8a
 The index of each ranks's member into the group of members who have at least that rank.$IndexToId
]
 The members in the collective by index. All indices in the range `0..MemberCount` wille
 return `Some`, however a member's index is not guaranteed to remain unchanged over time.Voting
�
� Votes on a given proposal, if it is ongoing.4VotingCleanup
8
�
�


4TechReferenda
4TechReferenda<ReferendumCount
81
 The next free referendum index, aka the number of referenda started so far.DReferendumInfoFor
8!� Information concerning any given referendum.(TrackQueue

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

p8� The number of referenda being decided currently.(MetadataOf
8<
 The metadata is a general information concerning the referendum.I
 The `Hash` refers to the preimage of the `Preimages` provider which can be a JSON� dump or IPFS hash of a JSON file.u
 Consider a garbage collection for a metadata of finished referendums to `unrequest` (remove)D large preimages.
�
�
DSubmissionDepositP@@z�Z5
 The minimum amount to be used as a deposit for a public referendum proposal.$MaxQueued8d� Maximum size of the referendum queue for a single track.DUndecidingTimeout8��U
 The number of blocks after submission that a referendum must begin being decided by.� Once this passes, then anyone may cancel the referendum.4AlarmInterval8
]
 Quantization level for the referendum wakeup scheduler. A higher number will result in]
 fewer storage reads/writes needed for smaller voters, but also result in delays to theU
 automatic referendum status changes. Explicit servicing instructions are unaffected.TracksEm
dtech_collective_members
�Ƥ~�X   ʚ;��[$��[$ʚ;F�#F�#H A list of tracks.]
 Note: if the tracks are dynamic, the value in the static metadata might be inaccurate.
a,RuntimeCall Votes8� The counting type for votes. Usually just balance.Tally�
L The tallying type.8TreasuryPallet
8TreasuryPallet<TreasuryAccount� The treasury account that receives mining rewards.<TreasuryPortion�%
 The portion of mining rewards that goes to treasury (Permill, 0–100%).]
 Uses OptionQuery so genesis is required. Permill allows fine granularity (e.g. 33.3%).
�
�

e Recovery
 Recovery,Recoverable
i	
 The set of recoverable accounts and their recovery configuration.@ActiveRecoveries
quh Active recovery attempts.
 First account is the account to be recovered, and the second account� is the user trying to recover the account.Proxy
� The list of allowed proxy accounts.� Map from the user who can access it to the recovered account.
�
�
DConfigDepositBaseP@�rN	U
 The base amount of currency needed to reserve for creating a recovery configuration.

 This is held for an additional storage item whose value size is� `2 + sizeof(BlockNumber, Balance)` bytes.LFriendDepositFactorP@���-
 The amount of currency needed per additional user when creating a recovery< configuration.M
 This is held for adding `sizeof(AccountId)` bytes more into a pre-existing storage value.(MaxFriends8	

 The maximum amount of friends allowed in a recovery configuration.

 NOTE: The threshold programmed in this Pallet uses u16, so it does	
 not really make sense to have a limit here greater than u16::MAX.
 But also, that is a lot more than you should probably set this value4 to anyway...<RecoveryDepositP@�rN	
 The base amount of currency needed to reserve for starting a recovery.5
 This is primarily held for deterring malicious recovery attempts, and should)
 have a value large enough that a bad actor would choose not to place this)
 deposit. It also acts to fund additional storage item whose value size isA
 `sizeof(BlockNumber, Balance + T * AccountId)` bytes. Where T is a configurable, threshold.
y,RuntimeCall l The overarching call type. Multisig
 Multisig$Multisigs
}� Multisigs stored by their deterministic address$Proposals
��� Proposals indexed by (multisig_address, proposal_nonce)
�
�
((MaxSigners8d� Maximum number of signers allowed in a multisighMaxTotalProposalsInStorage8�� Maximum number of proposals in storage per multisig.
 Only Active and Approved proposals are stored; executed and cancelledE
 proposals are removed immediately. This limit prevents unbounded storage growth.,MaxCallSize8(� Maximum size of an encoded call,MultisigFeeP@pɲ�� Fee charged for creating a multisig (non-refundable, burned).� This prevents spam creation of multisig accounts.<ProposalDepositP@���� Deposit required per proposal (returned on execute or cancel),ProposalFeeP@���	
 Fee charged for creating a proposal (non-refundable, paid always)@SignerStepFactor�'
 Percentage increase in ProposalFee for each signer in the multisig.M
 Formula: `FinalFee = ProposalFee + (ProposalFee * SignerCount * SignerStepFactor)`e
 Example: If Fee=100, Signers=5, Factor=1%, then Extra = 100 * 5 * 0.01 = 5. Total = 105. PalletId� py/mltsg� Pallet ID for generating multisig addressesDMaxExpiryDuration8��
E
 Maximum duration (in blocks) that a proposal can be set to expire in the future.-
 This prevents proposals from being created with extremely far expiry dates
 that would lock deposits and bloat storage for extended periods.� Example: If set to 100_000 blocks (~2 weeks at 12s blocks),� a proposal created at block 1000 cannot have expiry > 101_000.HMaxInnerCallWeight|(���� 
 Maximum weight allowed for inner calls executed through the multisig.)
 This bound ensures that the `execute` extrinsic can safely reserve weight!
 for the inner call at pre-dispatch time. Proposals with calls exceeding� this weight limit are rejected at propose time.A
 The execute extrinsic's weight annotation is: bookkeeping + MaxInnerCallWeight.5
 This guarantees the block weight is never exceeded by arbitrary inner calls.
�,RuntimeCall h The overarching call type Wormhole
 Wormhole8UsedNullifiers

T4TransferCount

( Q
 Transfer count per recipient - used to generate unique leaf indices in the ZK trie.A
 Keyed on the *canonical* recipient (each 8-byte limb reduced mod the GoldilocksQ
 prime, matching the ZK leaf encoding — see `canonical_leaf_recipient`), so that a9
 recipient and its non-canonical byte aliases share one count sequence and two� distinct deposits can never commit to identical leaves.
�
�
8MintingAccount�































Y
 Account ID used as the "from" account when creating transfer proofs for minted tokens@VolumeFeeRateBps8� Volume fee rate in basis points (1 basis point = 0.01%).� This must match the fee rate used in proof generation.HVolumeFeesBurnRate� �Y
 Proportion of volume fees to burn (not mint). The remainder goes to the block author.

 Example: Permill::from_percent(50) means 50% burned, 50% to miner.`VolumeFeesAggregatorRate� �5
 For public-batch proofs, the proportion of the burn bucket redirected to the
 aggregator instead of being destroyed. The miner's share is unchanged.]
 Example: Permill::from_percent(50) means half the burn portion goes to the aggregator.
�4NativeBalanceP� Native balance type for transfer proofs.AssetId8� Asset ID type for transfer proofs.0AssetBalanceP� Asset balance type that can convert to/from native balance.4TransferCount(� Transfer count type used in storageDWormholeAccountId� Override system AccountId for wormhole operations
 The `AsRef<[u8]>`/`From<[u8; 32]>` bounds allow `record_transfer` to-
 canonicalize recipients (reduce each 8-byte limb mod the Goldilocks prime)� before keying `TransferCount` and inserting ZK-tree leaves.ZkTree
ZkTreeLeaves
(�l Leaf data stored by index.Nodes
�� Internal tree nodes: (level, index) -> hash.� Level 0 is unused (leaves are hashed on-demand).� Level 1+ contains internal node hashes.$LeafCount
( x Number of leaves in the tree.Depth

 Current depth of the tree (0 = empty, 1 = up to 4 leaves, etc.).Root
�| Current root hash of the tree.
�

�AssetId8< Asset ID type.BalanceP8 Balance type.Vesting
Vesting8NextScheduleId
( 
 Next schedule id to assign. Ids are sequential and never reused.$Schedules
(�A
 All vesting schedules by id. A beneficiary may appear in any number of entries.
�

 PalletId� qvesting� Derives the pot's sovereign account.4PayoutQuantumP@�T5
 Wormhole leaf amount quantum. ZK-tree leaves commit `amount / quantum`, so a)
 payout below one quantum would create a zero-value leaf: funds moved to a-
 keyless beneficiary would be irrecoverable. Every schedule total must be a	
 multiple of this, and every payout is rounded down to a multiple.4MinimumPayoutP@���-
 Smallest beneficiary payout. Must be quantum-aligned, at least two quanta,� and larger than the existential deposit.@MinClaimInterval( \&!
 Minimum elapsed milliseconds between successful claims on one schedule.
� �, $(,HCheckNonZeroSender�@CheckSpecVersion�88CheckTxVersion�80CheckGenesis�<8CheckMortality�<(CheckNonce�,CheckWeight�`ChargeTransactionPayment�DCheckMetadataHash

	
xReversibleTransactionExtension

xWormholeProofRecorderExtension
0Coreversion9� Returns the version of the runtime.4execute_blockblock�d Execute the given block.@initialize_blockheaderU�A
 Initialize a block with the given header and return the runtime executive mode.!
 The `Core` runtime api that every Substrate runtime needs to implement. Metadata metadata�� Returns the metadata of a runtime.Lmetadata_at_versionversion8�� Returns the metadata at a given version.
 If the given `version` isn't supported, this will return `None`.u
 Use [`Self::metadata_versions`] to find out about supported metadata version of the runtime.Dmetadata_versions�
� Returns the supported metadata versions.� This can be used to call `metadata_at_version`.

 The `Metadata` api trait that returns metadata for the runtime.0BlockBuilder<apply_extrinsic$extrinsicY�l Apply the given extrinsic.9
 Returns an inclusion outcome which specifies if this extrinsic is included inL this block or not.8finalize_blockUh Finish the current block.Linherent_extrinsics inherent�a=
 Generate inherent extrinsics. The inherent data will vary from chain to chain.<check_inherentsblock�data��U
 Check that the inherents are valid. The inherent data will vary from chain to chain.q
 The `BlockBuilder` api trait that provides the required functionality for building a block.XTaggedTransactionQueuePvalidate_transactionsource�txY(block_hash<
$h Validate the transaction.e
 This method is invoked by the transaction pool to learn details about given transaction.E
 The implementation should make sure to verify the correctness of the transactionM
 against current state. The given `block_hash` corresponds to the hash of the block| that is used as current state.E
 Note that this call may be performed by the pool multiple times and transactions� might be verified in any possible order.M
 The `TaggedTransactionQueue` api trait for interfering with the transaction queue.DOffchainWorkerApi<offchain_workerheaderU� Starts the off-chain task for given block header.d The offchain worker api.,SessionKeysTgenerate_session_keysseed	
 Generate a set of session keys with optionally using the given seed.	
 The keys should be stored within the keystore exposed via runtime< externalities.� The seed needs to be a valid `utf8` string.� Returns the concatenated SCALE encoded public keys.Ldecode_session_keysencoded
� Decode the given public session keys.� Returns the list of public raw public keys + key type.h Session keys runtime api.QPoWApi$Lget_max_reorg_depth8� Get the max possible reorg depthHget_max_difficulty�
� Get the max possible difficulty for work calculation8get_difficulty�
� Get the current mining difficultyLget_last_block_time(d Get last block timestamp\get_last_block_duration(l Get last block mining time@get_chain_height8pverify_nonce_on_import_block(block_hashnonce�
Tdverify_nonce_local_mining(block_hashnonce�
T�verify_and_get_achieved_difficulty(block_hashnonce�
$ZkTreeApi get_root� Get the current root hash of the ZK tree.8get_leaf_count(� Get the current number of leaves in the tree.$get_depth� Get the current depth of the tree.@get_merkle_proof(leaf_index(!� Get a Merkle proof for a leaf at the given index.� Returns `None` if the leaf index is out of bounds.� Runtime API for the ZK Tree pallet.!
 Provides methods to query the ZK Merkle tree state and generate proofs.<AccountNonceApi4account_nonceaccount8� Get current account nonce of given `AccountId`.� The API to query account nonce.TTransactionPaymentApi(query_infouxtYlen81Dquery_fee_detailsuxtYlen85Lquery_weight_to_feeweight|PLquery_length_to_feelength8PdTransactionPaymentCallApi<query_call_infocall len81I
 Query information of a dispatch class, weight, and fee of a given encoded `Call`.Xquery_call_fee_detailscall len85� Query fee details of a given encoded `Call`.Lquery_weight_to_feeweight|P

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

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

 no named presets are provided by the runtime the list is empty.� API to interact with `RuntimeGenesisConfig` for the runtime =
M