quantus-cli 2.3.0

meta1(sp_runtime0multiaddress0MultiAddress$AccountId
0AccountIndex

Id
$AccountIdIndex
0AccountIndex
Raw
Vec<u8>$Address32
 [u8; 32]$Address20
 [u8; 20]sp_corecrypto,AccountId32
 [u8; 32]  <quantus_runtime,RuntimeCall
0System$
�
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> PreimageX
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Preimage, Runtime>Utility`
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<Utility, Runtime>	LReversibleTransfersh
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<ReversibleTransfers, Runtime>8TechCollectivep
�
self::sp_api_hidden_includes_construct_runtime::hidden_include::dispatch
::CallableCallFor<TechCollective, Runtime>
4TechReferendax
�
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> 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 `Config::AuthorizeUpgradeOrigin` (Root by default).�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.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).burn
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_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
hashes\
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.\<`8pallet_utilitypalletCallT
$batch_all
callsd
|Vec<<T as Config>::RuntimeCall>@�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.
Call index 2 is preserved from the upstream utility pallet so existing5
`batch_all` encodings keep decoding after the other combinators were removed.

Contains a variant per dispatchable extrinsic that this pallet has.d hlpallet_reversible_transferspalletCallT
Dset_high_security
delayl
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.|# Choose the guardian carefully

The guardian holds instant, total seizure power: `recover_funds`�sweeps every hold plus the entire free balance to the guardian,�with no delay, no second approver, and no way to change the�relationship afterwards. A single-key guardian is therefore a�single point of failure for the whole scheme. **Use a multisig

address as the guardian**: `pallet_multisig` dispatches calls as
its derived address, so a multisig can cancel and recover exactlyTlike a plain account.�Guardianship is discoverable offchain (e.g. Subsquid) via the�`HighSecuritySet` event; there is deliberately no on-chain�guardian index to fill up or grief.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::Hashd1
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 viat`do_schedule_transfer_inner`.0# Parameters
- `tx_id`: The unique identifier of the pending transfer to execute.)
Execution uses `transfer_allow_death` so a sender who spent their leftover1
free balance during the delay still completes. A failed inner transfer (e.g.
dest overflow, or `amount < ED` to a new account) does not fail this-
extrinsic: the hold is already released and the pending transfer is already

removed. Propagating that error would roll back those writes (FRAME-
dispatchables are transactional) while Scheduler terminally drops the named5
task, freezing the funds with no retry. The inner result is still recorded on|[`Event::TransactionExecuted`]. # 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>
delayl
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.l0qp_schedulerXBlockNumberOrTimestamp,BlockNumber
8Moment
(
,BlockNumber8
,BlockNumber$Timestamp(
Moment
p`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_rankt
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.tx@pallet_referendapalletCallTI
$submit
<proposal_origin|
\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
trackt
<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.|<quantus_runtime0OriginCaller
system�
tframe_system::Origin<Runtime>Origins�
tpallet_custom_origins::Origin�4frame_support dispatch$RawOrigin$AccountId

RootSigned
$AccountId
None(Authorized�<quantus_runtime(governanceoriginsTpallet_custom_originsOrigin
,FastUpgrade�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).Y
**Important**: This only changes where *future* treasury credits 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.

Contains a variant per dispatchable extrinsic that this pallet has.�<pallet_multisigpalletCallT
<create_multisig
signers�
DVec<T::AccountId>
$threshold8
u32
nonce(
u64<�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 sorted before hashing, so order doesn't matter.�Duplicate accounts are rejected.<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
u32
call 
|Box<<T as Config>::RuntimeCall>ppExecute 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.%
The executor resubmits the proposal's inner call; execution proceeds only
if it is byte-equal to the payload stored at `proposal_id` — the same�binding `approve` enforces. This serves two purposes:]
- **Clearsigning:** the executor's (hardware) wallet displays and signs the actual call�  being dispatched, not an opaque proposal id.Q
- **Self-describing weight:** the executing extrinsic carries the inner call, so itsM
  declared weight carries the inner call's own declared weight (refunded to actuals9
  post-dispatch) instead of reserving a flat `MaxInnerCallWeight`, and runtime9
  transaction extensions can inspect the inner call and price its side effectsI
  (account-reap cleanup, transfer-proof recording) exactly as they do for directly]
  submitted calls. Nothing about the dispatch is invisible to pre-dispatch admission ora
  fees. (Only the bookkeeping term is reserved at `MaxCallSize`, since the stored bytes'
  length is unknown pre-dispatch; the unused remainder is refunded.)4On execution:�- The call is 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 execute
- `call`: The proposal's inner call, byte-equal to the stored payload

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 )
Pay the largest valid claim on `schedule_id` to its beneficiary. Non-final!
payouts are rounded down to [`NON_FINAL_PAYOUT_QUANTA`] leaf quanta; the
leftover stays on the schedule until a later claim or the exact final�payout (at least one [`Config::PayoutQuantum`]).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 (recorded as a leaf).0end_schedule
,schedule_id(
u64)
End a schedule early: the still-unpaid vested part (rounded to the nearest!
[`Config::PayoutQuantum`]) goes to the beneficiary if it is at least one
quantum; otherwise that sliver is refunded with the unvested remainder.�Both legs are recorded as wormhole leaves.Dretarget_schedule
,schedule_id(
u64
<new_beneficiary
0T::AccountId%
Change the schedule's beneficiary without paying anything out. A retarget1
replaces the wallet of the *same* grantee (lost-key remedy): the old address!
may be lost or stolen, so settling it would burn funds or pay the thief.%
Everything vested but unclaimed stays on the schedule and goes to the new
wallet at its next claim. (A permissionless claim landing before the�retarget still pays the old address, so rotate promptly.)

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�<quantus_runtimeXtransaction_extensionsxReversibleTransactionExtensionT�<quantus_runtimeXtransaction_extensionsxWormholeProofRecorderExtensionT�hpallet_transaction_payment`ChargeTransactionPaymentTL
0BalanceOf<T>�tframe_metadata_hash_extensionDCheckMetadataHashT
mode�
Mode�tframe_metadata_hash_extensionMode
 DisabledEnabled


OptionT

NoneSome

0frame_system(extensions8weight_reclaim4WeightReclaimT	
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_weights$weight_v2Weight
 ref_timeD
u64
(proof_sizeD
u64
(sp_runtimegenericdigestDigest
logs!

<Vec<DigestItem>!
%
%
(sp_runtimegenericdigest(DigestItem
(PreRuntime)

DConsensusEngineId
Vec<u8>$Consensus)

DConsensusEngineId
Vec<u8>Seal)

DConsensusEngineId
Vec<u8>Other
Vec<u8>dRuntimeEnvironmentUpdated)
-
1
1
0frame_system,EventRecordE
5
T
<
phase�

Phase
event5

E
topics\
Vec<T>5
<quantus_runtime0RuntimeEvent
@System9

pframe_system::Event<Runtime> Balancesa

|pallet_balances::Event<Runtime>HTransactionPaymenty

�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> Multisig�

|pallet_multisig::Event<Runtime> Wormhole�

|pallet_wormhole::Event<Runtime>ZkTree�

xpallet_zk_tree::Event<Runtime>Vesting�

xpallet_vesting::Event<Runtime>9
0frame_systempalletEventT
 @ExtrinsicSuccess
4dispatch_info=

DDispatchEventInfo�An extrinsic completed successfully.<ExtrinsicFailed
8dispatch_errorI

4DispatchError
4dispatch_info=

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
errorI

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

Weight
classA

4DispatchClass
 pays_feeE

PaysA
4frame_support dispatch4DispatchClass
Normal,Operational
$MandatoryE
4frame_support dispatchPays
YesNo
I
(sp_runtime4DispatchError
<Other0CannotLookup
$BadOriginModuleM

,ModuleErrorDConsumerRemaining,NoProviders@TooManyConsumersTokenQ

(TokenError(ArithmeticU

<ArithmeticError4TransactionalY

HTransactionalError	$Exhausted
(Corruption,Unavailable8RootNotAllowed
Trie]

$TrieErrorM
(sp_runtime,ModuleError
index
u8
error)

�[u8; MAX_MODULE_ERROR_ENCODED_SIZE]Q
(sp_runtime(TokenError
(@FundsUnavailable0OnlyProvider
0BelowMinimum0CannotCreate0UnknownAssetFrozen,Unsupported@CannotCreateHold4NotExpendableBlocked	U
4sp_arithmetic<ArithmeticError
$Underflow Overflow
8DivisionByZeroY
(sp_runtimeHTransactionalError
0LimitReachedNoLayer
]
(sp_runtime0proving_trie$TrieError
8@InvalidStateRootHIncompleteDatabase
PValueAtIncompleteKey0DecoderError,InvalidHash0DuplicateKey8ExtraneousNode<ExtraneousValue\ExtraneousHashReferenceTInvalidChildReference	4ValueMismatch
<IncompleteProof0RootMismatch,DecodeError
a
<pallet_balancespalletEventTI
tEndowed
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_statuse

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.Held
reasoni

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

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

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

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

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

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

lpallet_preimage::HoldReasonLReversibleTransfersq

�pallet_reversible_transfers::HoldReasonm
<pallet_preimagepallet(HoldReason
 Preimageq
lpallet_reversible_transferspallet(HoldReason
DScheduledTransferu
<pallet_balancespallet8UnexpectedKind
8BalanceUpdatedTFailedToMutateAccount
y
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>
Quantized reward (block reward + fees, aligned to the wormhole quantum)�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 distribution8PayoutDeferred
amountP
0BalanceOf<T>xAmount held for the next miner=
No miner in the digest; the credit stays in `CollectedFees` for the next block.<MinerMintFailed
miner
0T::AccountId�The miner who should have received the reward
rewardP
0BalanceOf<T>hThe reward amount retained
Miner mint failed; the credit stays 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
whenl
lBlockNumberOrTimestampOf<T>
index8
u32PScheduled some task. Canceled
whenl
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>
periodl
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.�
l8�
ResultT
E
I

OkErrI

�
8pallet_utilitypalletEvent
8BatchCompleted�Batch of dispatches completed fully with no error.4ItemCompleted

A single item within a Batch of dispatches has completed with no error.|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.
delayl
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
,BlockNumberAfterl
�BlockNumberOrTimestamp<BlockNumber, Moment>
�
ResultT
�
E
�

Ok�
Err�

�
4frame_support dispatch@PostDispatchInfo
4actual_weight�

8Option<Weight>
 pays_feeE

Pays�
OptionT


NoneSome

�
(sp_runtimedDispatchErrorWithPostInfoInfo
�

$post_info�

Info
errorI

4DispatchError�
`pallet_ranked_collectivepalletEventTI
,MemberAdded
who
0T::AccountIdxA member `who` has been added.,RankChanged
who
0T::AccountId
rankt
Rank
�The member `who`se rank has been changed to the given `rank`.4MemberRemoved
who
0T::AccountId
rankt
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.
trackt
<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.
trackt
<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 credits.�The treasury account was updated.5
Note: This only redirects where future treasury credits 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.|The `Event` enum of this pallet�
OptionT

NoneSome
�
<pallet_multisigpalletEventT
 <MultisigCreated
creator
0T::AccountId
@multisig_address
0T::AccountId
signers�
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>
$approvers�
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
A new leaf was inserted into the tree. The root including this leaf is
computed at the end of the block and published in the block header. The
leaf hash is deliberately not included: it is derivable from `Leaves`
(and served by the RPC), and hashing it here would double the per-leaf�Poseidon work the batched settlement saves. 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!
A schedule's beneficiary was changed. Nothing was paid out: the retarget)
replaces the same grantee's wallet, so the accrued entitlement follows thepschedule to the new address.<LaunchMomentSet
at(
Moment
Offset genesis schedules were rebased onto this unix-ms timestamp. The�genesis block's `Now` is 0 and is never used.|The `Event` enum of this pallet�
0frame_systemPhase
8ApplyExtrinsic8
u320Finalization
8Initialization�
�
�
88�
0frame_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
max
TPerDispatchClass<u32>4frame_support dispatch@PerDispatchClassT
8
normal8
T
,operational8
T
$mandatory8
T!(sp_weights<RuntimeDbWeight
read(
u64
write(
u64%(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
---115859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 pallet=(sp_runtimegenericblockBlockHeader
A$Extrinsic
E
headerA
Header
(extrinsicsM
8Vec<Extrinsic>A$qp_headerHeaderNumber
8Hashing
,parent_hash<
H256
number8
Number
(state_root<
H256
<extrinsics_root<
H256
0zk_tree_root<
H256
digest

DigestE(sp_runtimegenericLunchecked_extrinsicHUncheckedExtrinsicAddress
Call
 $Signature
�Extra
II0�����������
MEQLbounded_collections@weak_bounded_vec8WeakBoundedVecT
US]
Vec<T>U<pallet_balancestypes,BalanceLockBalance
P
id5
8LockIdentifier
amountP
Balance
reasonsY
ReasonsY<pallet_balancestypesReasons
FeeMisc
All]UaLbounded_collections,bounded_vec(BoundedVecT
eSi
Vec<T>e<pallet_balancestypes,ReserveDataDReserveIdentifier
5Balance
P
id5
DReserveIdentifier
amountP
BalanceiemLbounded_collections,bounded_vec(BoundedVecT
qSu
Vec<T>q4frame_supporttraitstokensmisc IdAmountId
i
Balance
P
idi

Id
amountP
BalanceuqyLbounded_collections,bounded_vec(BoundedVecT
}S�
Vec<T>}4frame_supporttraitstokensmisc IdAmountId
�Balance
P
id�
Id
amountP
Balance�<quantus_runtimeLRuntimeFreezeReason
�}�<pallet_balancespalletErrorTI
(8VestingBalance�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`.�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
|$AccountId
Moment
(
 maybe_id


0Option<Name>
 priority
Hschedule::Priority
call�
Call
origin|
4PalletsOrigin���@pallet_scheduler,RetryConfigPeriod
l
4total_retries
u8
$remaining
u8
periodl
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
l
 guardian
$AccountId
delayl
Delay�Lbounded_collections,bounded_vec(BoundedVecT
8S�

Vec<T>�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
<S\
Vec<T>�4sp_arithmetic(per_thingsPermill8
u32�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)HAssetsNotSupported
�Asset transfers are not supported.(ZeroAmount
Zero-amount transfers cannot be scheduled: there is nothing to hold,Pexecute, or reverse.lHighSecurityTxQuotaExceededQ
The high-security account already used its transaction quota for the current window.�The `Error` enum of this pallet.�`pallet_ranked_collective0MemberRecord
rankt
Rank�t
t88	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
t4RuntimeOrigin
|Moment
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
t4RuntimeOrigin
|Moment
8Call
�Balance
PTally
�
$AccountId
<ScheduleAddress
�
,
trackt
TrackId
origin|
4RuntimeOrigin
 proposal�
Call
$enactment�
PDispatchTime<Moment>
$submitted8
Moment
Hsubmission_deposit
lDeposit<AccountId, Balance>
@decision_deposit
�Option<Deposit<AccountId, Balance>>
 deciding!
xOption<DecidingStatus<Moment>>
tally�

Tally
 in_queueT
bool
alarm)
�Option<(Moment, ScheduleAddress)>@pallet_referendatypesDeposit$AccountId
Balance
P
who
$AccountId
amountP
BalanceOptionT

NoneSome
!OptionT
%
NoneSome%
%@pallet_referendatypes8DecidingStatus,BlockNumber
8
since8
,BlockNumber
(confirming�

LOption<BlockNumber>)OptionT
-
NoneSome-
-8�
1Lbounded_collections,bounded_vec(BoundedVecT
�
S�

Vec<T>599t==@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_approvalA
Curve
,min_supportA
CurveA@pallet_referendatypesCurve
@LinearDecreasing
lengthE
Perbill
floorE
Perbill
ceilE
PerbillDSteppedDecreasing
beginE
Perbill
endE
Perbill
stepE
Perbill
periodE
Perbill
(Reciprocal
factorI
 FixedI64
 x_offsetI
 FixedI64
 y_offsetI
 FixedI64E4sp_arithmetic(per_thingsPerbill8
u32I4sp_arithmetic,fixed_point FixedI64M
i64MQ@pallet_referendapalletErrorTI
H(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.4TooManyActive�There are already the maximum number of ongoing referenda.`TooManyActiveBySubmitter	
The submitter already has the maximum number of ongoing referenda.8PreimageTooBig

The proposal's preimage is larger than [`Config::MaxProposalSize`].�The `Error` enum of this pallet.U<pallet_treasurypalletErrorT
XInvalidTreasuryAccount1
Treasury account cannot be zero address (funds would be permanently locked).�The `Error` enum of this pallet.Y<pallet_multisig0MultisigData$AccountId
8BoundedSigners
]dBoundedProposalsPerSigner
a
creator
$AccountId
signers]
8BoundedSigners
$threshold8
u32
8proposal_nonce8
u32
Pproposals_per_signera
dBoundedProposalsPerSigner]Lbounded_collections,bounded_vec(BoundedVecT
S�
Vec<T>aLbounded_collectionsDbounded_btree_map<BoundedBTreeMapK
V
8Se
8BTreeMap<K, V>e BTreeMapK
V
8iimm8q<pallet_multisig0ProposalData$AccountId
Balance
P,BlockNumber
8,BoundedCall
�@BoundedApprovals
]
 proposer
$AccountId
call�
,BoundedCall
expiry8
,BlockNumber
$approvals]
@BoundedApprovals
depositP
Balance
statusu
8ProposalStatusu<pallet_multisig8ProposalStatus
Active Approved
y4frame_support PalletId5
[u8; 8]}<pallet_multisigpalletErrorT
l@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@DuplicateSigners�Signer list contains the same account more than once�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 has nothing to settle: only dummy (all-zero) padding, or9
every valid segment exits zero. 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.DLeafNotYetSettled
Leaf was appended this block and is not yet folded into the root; it�becomes provable once the block is finalized.�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_vestingpallet0LaunchAnchor
Pending Anchored(
Moment
�8pallet_vestingpalletErrorT
 (NoSchedule�No schedule exists under this id.<InvalidSchedule

Schedule parameters violate `start <= cliff <= end`, `start < end`, or�`total` is not a positive multiple of the payout quantum.8NothingToClaim-
Nothing is claimable right now (before the cliff, already fully claimed, or!
the accrual rounds down to zero — below one quantum for a final claim,�below the non-final alignment otherwise).0ClaimTooSoon
This schedule has already paid out within the minimum claim interval.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.`TransferProofNotRecorded1
The proof recorder reported the transfer credit as dropped: no wormhole leaf-
was created, so the transfer is rolled back rather than finalized without aleaf.�The `Error` enum of this pallet.�(sp_runtimegenericblock$LazyBlockHeader
A$Extrinsic
E
headerA
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
5V
����5�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$KeyTypeId)

[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	

hpallet_transaction_paymenttypesLRuntimeDispatchInfoBalance
PWeight


weight

Weight
classA

4DispatchClass
,partial_feeP
Balancehpallet_transaction_paymenttypes(FeeDetailsBalance
P
4inclusion_fee
tOption<InclusionFee<Balance>>
tipP
BalanceOptionT

NoneSome
hpallet_transaction_paymenttypes0InclusionFeeBalance
P
 base_feeP
Balance
len_feeP
Balance
Ladjusted_weight_feeP
Balance!ResultT
E

OkErr
%OptionT

NoneSome
)-<quantus_runtime0RuntimeError
4System9
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>
4TechReferendaQ
�pallet_referenda::Error<Runtime, pallet_referenda::Instance1>8TreasuryPalletU
|pallet_treasury::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
-
� 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.HLastRuntimeUpgrade�
U
 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.
$
9
0BlockWeights
�
bU�`��t����������
@��fffffff�
����������
��
@���fffffff�
`��t��������
��>]
@��� Block & extrinsics weights: base values and limits.,BlockLength0<PP� The maximum length of a block (in bytes).8BlockHashCount8U
 Maximum number of block number to block hash mappings to keep (oldest pruned first). DbWeight!@@x}
��	
 The weight of runtime database operations the runtime can invoke.Version%	<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.(SS58Prefixt�� 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.
9,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.Block=a
 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

Q� 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

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

ml Holds on account balances.Freezes

y� Freeze locks on account balances.
H
a
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.
�DRuntimeHoldReasoni
t The overarching hold reason.BalancePl The balance of an account.DReserveIdentifier5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.
y
`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�


�T<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
��
X
�

�$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

l�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
`
�
Lbatched_calls_limit8�*� The limit on the number of batched calls.
�,RuntimeCall l The overarching call type.	LReversibleTransfers
LReversibleTransfersPHighSecurityAccounts
�1
 Maps accounts to their chosen reversibility delay period (in milliseconds).� Accounts present in this map have reversibility enabled.LHighSecurityTxQuota

�5
 Rolling window of included signed extrinsics for each high-security account.

 Oldest block number is at index 0. Recording a tx is O(1): compare
 `now - oldest` to [`Config::HighSecurityTxWindowBlocks`], maybe evict� that one head, then push. Normal accounts are not stored here.@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.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.
h
�
PMaxPendingPerAccount8� Maximum pending reversible transactions allowed per account.lMaxHighSecurityTxsPerWindow8
 Maximum signed extrinsics a high-security account may include in one� rolling window. Update of the quota ring is O(1).hHighSecurityTxWindowBlocks8 � Length of the high-security extrinsic quota window, in blocks.� At the runtime's 12s target this is one day (`DAYS`).0DefaultDelayl -
 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

t8i
 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	
p
�



4TechReferenda
4TechReferenda<ReferendumCount
81
 The next free referendum index, aka the number of referenda started so far.PActiveReferendaCount
85
 The number of referenda currently in the `Ongoing` state, across all tracks.E
 Incremented on `submit` and decremented whenever a referendum reaches a terminalE
 state (approved, rejected, timed out, cancelled or killed). Bounds admissions at\ [`Config::MaxActive`].TActiveSubmissionCount

8!
 The number of referenda currently in the `Ongoing` state per submitter.Q
 Maintained alongside [`ActiveReferendaCount`] (incremented on `submit`, decremented
 on every terminal transition) and bounds each account's admissions at=
 [`Config::MaxActivePerAccount`], so no single submitter can exhaust the shared� [`Config::MaxActive`] capacity.DReferendumInfoFor
8� Information concerning any given referendum.(TrackQueue

t1]
 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

t8� 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.
x
�
 DSubmissionDepositP@���5
 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.$MaxActive8�(9
 Maximum number of referenda that may be `Ongoing` at once, across all tracks.A
 This is a global admission bound enforced in `submit`. It also covers referenda9
 that never receive a decision deposit and therefore occupy neither a deciding1
 slot nor a `TrackQueue` entry, yet hold storage and a scheduler agenda slot| until the `UndecidingTimeout`.I
 Must be at least `MaxQueued` plus the sum of all tracks' `max_deciding` plus one,A
 so that the deciding slots and track queues remain fully utilizable (checked byL `integrity_test`).LMaxActivePerAccount8$A
 The maximum number of referenda any one account may have in the `Ongoing` state$ at once.-
 [`Config::MaxActive`] is a shared resource: without a per-account cap, any1
 single account passing `SubmitOrigin` could fill it with refundable-deposit=
 referenda and freeze submission for everyone — including the very referendum9
 needed to intervene — until the `UndecidingTimeout` (renewably). Size it so
 that no plausible coalition of submitters can reach `MaxActive`:!
 `MaxActivePerAccount` × (maximum concurrent submitters) < `MaxActive`.<MaxProposalSize8$
 Maximum encoded length of a `Lookup` proposal accepted by `submit`.A
 `submit` `request`s the preimage so a later `unnote_preimage` cannot delete the=
 bytes before enactment; that request also lets the noter reclaim their storage9
 deposit while the bytes stay pinned until the referendum ends. Without a size9
 bound, `MaxActive` × 4 MiB of deposit-free state can accumulate against only5
 the refundable [`Config::SubmissionDeposit`]. Size this so that the preimage=
 deposit for a max-sized blob does not exceed `SubmissionDeposit` — then even-
 after `unnote` the submission deposit still collateralizes the held bytes.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.Tracks5�dtech_collective_members
���X   ʚ;��[$��[$ʚ;F�#F�#
dfast_upgrade
���2 22ʚ;�/�/ʚ;�/�/H A list of tracks.]
 Note: if the tracks are dynamic, the value in the static metadata might be inaccurate.
Q,RuntimeCall Votes8� The counting type for votes. Usually just balance.Tally�
L The tallying type.8TreasuryPallet
8TreasuryPallet<TreasuryAccount� The treasury account that holds treasury funds.
�
�

U Multisig
 Multisig$Multisigs
Y� Multisigs stored by their deterministic address$Proposals
mq� 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@�#�� Fee charged for creating a multisig (non-refundable, burned).� This prevents spam creation of multisig accounts.<ProposalDepositP@�T� Deposit required per proposal (returned on execute or cancel),ProposalFeeP@t;�	
 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. PalletIdy 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.
 Covers exactly the first `LeafCount - UnprocessedLeaves` leaves: root)
 recomputation is batched once per block in `on_finalize`, so during block

 execution this is the root as of the end of the previous block.DUnprocessedLeaves
( 
 Number of trailing leaves appended this block but not yet folded into� `Nodes`/`Root`. Always drained back to 0 by `on_finalize`.
�

�AssetId8< Asset ID type.BalanceP8 Balance type.Vesting
Vesting8NextScheduleId
( 
 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.Launch�
�
�
 PalletIdy 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
 positive multiple of this. Intermediate claims round down further to%
 [`NON_FINAL_PAYOUT_QUANTA`] leaf quanta; the final claim may be a single$ quantum.@MinClaimInterval( \&!
 Minimum elapsed milliseconds between successful claims on one schedule.
�Origins �0 $(,0HCheckNonZeroSender�@CheckSpecVersion�88CheckTxVersion�80CheckGenesis�<8CheckMortality�<(CheckNonce�,CheckWeight�xReversibleTransactionExtension�xWormholeProofRecorderExtension�`ChargeTransactionPayment�DCheckMetadataHash�

4WeightReclaim
0Coreversion%� Returns the version of the runtime.4execute_blockblock�d Execute the given block.@initialize_blockheaderA�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$extrinsicE�l Apply the given extrinsic.9
 Returns an inclusion outcome which specifies if this extrinsic is included inL this block or not.8finalize_blockAh Finish the current block.Linherent_extrinsics inherent�M=
 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�txE(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_workerheaderA� 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uxtElen8Dquery_fee_detailsuxtElen8Lquery_weight_to_feeweight
PLquery_length_to_feelength8PdTransactionPaymentCallApi<query_call_infocall len8I
 Query information of a dispatch class, weight, and fee of a given encoded `Call`.Xquery_call_fee_detailscall len8� 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_statejson!(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_presetid%�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_names)Q
 Returns a list of identifiers for available builtin `RuntimeGenesisConfig` presets.a
 The presets from the list can be queried with [`GenesisBuilder::get_preset`] method. If

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