mirror of
https://github.com/pezkuwichain/pezkuwi-api.git
synced 2026-06-20 08:01:03 +00:00
pezkuwichain
1be455e7ad
- Published from build/ directories for correct npm structure - Updated common dependencies to 14.0.25 - Added AuthorizeCall signed extension support - All packages now have index.js at root level
2357 lines
133 KiB
TypeScript
2357 lines
133 KiB
TypeScript
// Auto-generated via `yarn polkadot-types-from-chain`, do not edit
|
|
/* eslint-disable */
|
|
|
|
// import type lookup before we augment - in some environments
|
|
// this is required to allow for ambient/previous definitions
|
|
import '@pezkuwi/api-base/types/storage';
|
|
|
|
import type { ApiTypes, AugmentedQuery, QueryableStorageEntry } from '@pezkuwi/api-base/types';
|
|
import type { BTreeMap, BTreeSet, Bytes, Null, Option, U8aFixed, Vec, bool, u128, u16, u32, u64, u8 } from '@pezkuwi/types-codec';
|
|
import type { AnyNumber, IMethod, ITuple } from '@pezkuwi/types-codec/types';
|
|
import type { H256, RuntimeCall } from '@pezkuwi/types/interfaces/runtime';
|
|
import type { BinaryHeapEnqueuedOrder, PezframeSupportDispatchPerDispatchClassWeight, PezframeSupportScheduleDispatchTime, PezframeSupportTokensMiscIdAmountRuntimeFreezeReason, PezframeSupportTokensMiscIdAmountRuntimeHoldReason, PezframeSystemAccountInfo, PezframeSystemCodeUpgradeAuthorization, PezframeSystemEventRecord, PezframeSystemLastRuntimeUpgradeInfo, PezframeSystemPhase, PezkuwiCorePrimitivesInboundDownwardMessage, PezkuwiCorePrimitivesInboundHrmpMessage, PezkuwiPrimitivesV8AssignmentAppPublic, PezkuwiPrimitivesV8DisputeState, PezkuwiPrimitivesV8ExecutorParams, PezkuwiPrimitivesV8SessionInfo, PezkuwiPrimitivesV8UpgradeGoAhead, PezkuwiPrimitivesV8UpgradeRestriction, PezkuwiPrimitivesV8ValidatorAppPublic, PezkuwiPrimitivesVstagingPendingSlashes, PezkuwiPrimitivesVstagingScrapedOnChainVotes, PezkuwiRuntimeCommonClaimsEthereumAddress, PezkuwiRuntimeCommonClaimsStatementKind, PezkuwiRuntimeCommonCrowdloanFundInfo, PezkuwiRuntimeCommonImplsVersionedLocatableAsset, PezkuwiRuntimeCommonParasRegistrarParaInfo, PezkuwiRuntimeSessionKeys, PezkuwiRuntimeTeyrchainsAssignerCoretimeCoreDescriptor, PezkuwiRuntimeTeyrchainsAssignerCoretimeSchedule, PezkuwiRuntimeTeyrchainsConfigurationHostConfiguration, PezkuwiRuntimeTeyrchainsHrmpHrmpChannel, PezkuwiRuntimeTeyrchainsHrmpHrmpOpenChannelRequest, PezkuwiRuntimeTeyrchainsInclusionAggregateMessageOrigin, PezkuwiRuntimeTeyrchainsInclusionCandidatePendingAvailability, PezkuwiRuntimeTeyrchainsInitializerBufferedSessionChange, PezkuwiRuntimeTeyrchainsOnDemandTypesCoreAffinityCount, PezkuwiRuntimeTeyrchainsOnDemandTypesEnqueuedOrder, PezkuwiRuntimeTeyrchainsOnDemandTypesQueueStatusType, PezkuwiRuntimeTeyrchainsParasAuthorizedCodeHashAndExpiry, PezkuwiRuntimeTeyrchainsParasParaGenesisArgs, PezkuwiRuntimeTeyrchainsParasParaLifecycle, PezkuwiRuntimeTeyrchainsParasParaPastCodeMeta, PezkuwiRuntimeTeyrchainsParasPvfCheckActiveVoteState, PezkuwiRuntimeTeyrchainsSchedulerCommonAssignment, PezkuwiRuntimeTeyrchainsSharedAllowedRelayParentsTracker, PezkuwiTeyrchainPrimitivesPrimitivesHrmpChannelId, PezpalletBagsListListBag, PezpalletBagsListListNode, PezpalletBalancesAccountData, PezpalletBalancesBalanceLock, PezpalletBalancesReserveData, PezpalletBountiesBounty, PezpalletChildBountiesChildBounty, PezpalletConvictionVotingVoteVoting, PezpalletDelegatedStakingAgentLedger, PezpalletDelegatedStakingDelegation, PezpalletElectionProviderMultiPhasePhase, PezpalletElectionProviderMultiPhaseReadySolution, PezpalletElectionProviderMultiPhaseRoundSnapshot, PezpalletElectionProviderMultiPhaseSignedSignedSubmission, PezpalletElectionProviderMultiPhaseSolutionOrSnapshotSize, PezpalletFastUnstakeUnstakeRequest, PezpalletGrandpaStoredPendingChange, PezpalletGrandpaStoredState, PezpalletMessageQueueBookState, PezpalletMessageQueuePage, PezpalletMultisigMultisig, PezpalletNominationPoolsBondedPoolInner, PezpalletNominationPoolsClaimPermission, PezpalletNominationPoolsPoolMember, PezpalletNominationPoolsRewardPool, PezpalletNominationPoolsSubPools, PezpalletPreimageOldRequestStatus, PezpalletPreimageRequestStatus, PezpalletProxyAnnouncement, PezpalletProxyProxyDefinition, PezpalletRcMigratorAccountsAccountState, PezpalletRcMigratorAccountsMigratedBalances, PezpalletRcMigratorMigrationSettings, PezpalletRcMigratorMigrationStage, PezpalletRcMigratorQueuePriority, PezpalletReferendaReferendumInfo, PezpalletSchedulerRetryConfig, PezpalletSchedulerScheduled, PezpalletStakingActiveEraInfo, PezpalletStakingAsyncAhClientOperatingMode, PezpalletStakingAsyncRcClientOffence, PezpalletStakingAsyncRcClientSessionReport, PezpalletStakingAsyncRcClientValidatorSetReport, PezpalletStakingEraRewardPoints, PezpalletStakingForcing, PezpalletStakingNominations, PezpalletStakingRewardDestination, PezpalletStakingSlashingSlashingSpans, PezpalletStakingSlashingSpanRecord, PezpalletStakingStakingLedger, PezpalletStakingUnappliedSlash, PezpalletStakingValidatorPrefs, PezpalletStateTrieMigrationMigrationLimits, PezpalletStateTrieMigrationMigrationTask, PezpalletTransactionPaymentReleases, PezpalletTreasuryProposal, PezpalletTreasurySpendStatus, PezpalletVestingReleases, PezpalletVestingVestingInfo, PezpalletXcmAuthorizedAliasesEntry, PezpalletXcmQueryStatus, PezpalletXcmRemoteLockedFungibleRecord, PezpalletXcmVersionMigrationStage, PezspAuthorityDiscoveryAppPublic, PezspConsensusBabeAppPublic, PezspConsensusBabeBabeEpochConfiguration, PezspConsensusBabeDigestsNextConfigDescriptor, PezspConsensusBabeDigestsPreDigest, PezspConsensusBeefyEcdsaCryptoPublic, PezspConsensusBeefyMmrBeefyAuthoritySet, PezspConsensusGrandpaAppPublic, PezspCoreCryptoAccountId32, PezspCoreCryptoKeyTypeId, PezspNposElectionsElectionScore, PezspRuntimeDigest, PezspStakingExposure, PezspStakingExposurePage, PezspStakingOffenceOffenceDetails, PezspStakingPagedExposureMetadata, PezspWeightsWeightV2Weight, StagingXcmV5Instruction, StagingXcmV5Xcm, XcmVersionedAssetId, XcmVersionedLocation } from '@pezkuwi/types/lookup';
|
|
import type { Observable } from '@pezkuwi/types/types';
|
|
|
|
export type __AugmentedQuery<ApiType extends ApiTypes> = AugmentedQuery<ApiType, () => unknown>;
|
|
export type __QueryableStorageEntry<ApiType extends ApiTypes> = QueryableStorageEntry<ApiType>;
|
|
|
|
declare module '@pezkuwi/api-base/types/storage' {
|
|
interface AugmentedQueries<ApiType extends ApiTypes> {
|
|
assetRate: {
|
|
/**
|
|
* Maps an asset to its fixed point representation in the native balance.
|
|
*
|
|
* E.g. `native_amount = asset_amount * ConversionRateToNative::<T>::get(asset_kind)`
|
|
**/
|
|
conversionRateToNative: AugmentedQuery<ApiType, (arg: PezkuwiRuntimeCommonImplsVersionedLocatableAsset | { V3: any } | { V4: any } | { V5: any } | string | Uint8Array) => Observable<Option<u128>>, [PezkuwiRuntimeCommonImplsVersionedLocatableAsset]> & QueryableStorageEntry<ApiType, [PezkuwiRuntimeCommonImplsVersionedLocatableAsset]>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
auctions: {
|
|
/**
|
|
* Number of auctions started so far.
|
|
**/
|
|
auctionCounter: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Information relating to the current auction, if there is one.
|
|
*
|
|
* The first item in the tuple is the lease period index that the first of the four
|
|
* contiguous lease periods on auction is for. The second is the block number when the
|
|
* auction will "begin to end", i.e. the first block of the Ending Period of the auction.
|
|
**/
|
|
auctionInfo: AugmentedQuery<ApiType, () => Observable<Option<ITuple<[u32, u32]>>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Amounts currently reserved in the accounts of the bidders currently winning
|
|
* (sub-)ranges.
|
|
**/
|
|
reservedAmounts: AugmentedQuery<ApiType, (arg: ITuple<[PezspCoreCryptoAccountId32, u32]> | string | Uint8Array) => Observable<Option<u128>>, [ITuple<[PezspCoreCryptoAccountId32, u32]>]> & QueryableStorageEntry<ApiType, [ITuple<[PezspCoreCryptoAccountId32, u32]>]>;
|
|
/**
|
|
* The winning bids for each of the 10 ranges at each sample in the final Ending Period of
|
|
* the current auction. The map's key is the 0-based index into the Sample Size. The
|
|
* first sample of the ending period is 0; the last is `Sample Size - 1`.
|
|
**/
|
|
winning: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<Vec<Option<ITuple<[PezspCoreCryptoAccountId32, u32, u128]>>>>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
authorityDiscovery: {
|
|
/**
|
|
* Keys of the current authority set.
|
|
**/
|
|
keys: AugmentedQuery<ApiType, () => Observable<Vec<PezspAuthorityDiscoveryAppPublic>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Keys of the next authority set.
|
|
**/
|
|
nextKeys: AugmentedQuery<ApiType, () => Observable<Vec<PezspAuthorityDiscoveryAppPublic>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
authorship: {
|
|
/**
|
|
* Author of current block.
|
|
**/
|
|
author: AugmentedQuery<ApiType, () => Observable<Option<PezspCoreCryptoAccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
babe: {
|
|
/**
|
|
* Current epoch authorities.
|
|
**/
|
|
authorities: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[PezspConsensusBabeAppPublic, u64]>>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* This field should always be populated during block processing unless
|
|
* secondary plain slots are enabled (which don't contain a VRF output).
|
|
*
|
|
* It is set in `on_finalize`, before it will contain the value from the last block.
|
|
**/
|
|
authorVrfRandomness: AugmentedQuery<ApiType, () => Observable<Option<U8aFixed>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Current slot number.
|
|
**/
|
|
currentSlot: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The configuration for the current epoch. Should never be `None` as it is initialized in
|
|
* genesis.
|
|
**/
|
|
epochConfig: AugmentedQuery<ApiType, () => Observable<Option<PezspConsensusBabeBabeEpochConfiguration>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Current epoch index.
|
|
**/
|
|
epochIndex: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The block numbers when the last and current epoch have started, respectively `N-1` and
|
|
* `N`.
|
|
* NOTE: We track this is in order to annotate the block number when a given pool of
|
|
* entropy was fixed (i.e. it was known to chain observers). Since epochs are defined in
|
|
* slots, which may be skipped, the block numbers may not line up with the slot numbers.
|
|
**/
|
|
epochStart: AugmentedQuery<ApiType, () => Observable<ITuple<[u32, u32]>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The slot at which the first epoch actually started. This is 0
|
|
* until the first block of the chain.
|
|
**/
|
|
genesisSlot: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Temporary value (cleared at block finalization) which is `Some`
|
|
* if per-block initialization has already been called for current block.
|
|
**/
|
|
initialized: AugmentedQuery<ApiType, () => Observable<Option<Option<PezspConsensusBabeDigestsPreDigest>>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* How late the current block is compared to its parent.
|
|
*
|
|
* This entry is populated as part of block execution and is cleaned up
|
|
* on block finalization. Querying this storage entry outside of block
|
|
* execution context should always yield zero.
|
|
**/
|
|
lateness: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Next epoch authorities.
|
|
**/
|
|
nextAuthorities: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[PezspConsensusBabeAppPublic, u64]>>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The configuration for the next epoch, `None` if the config will not change
|
|
* (you can fallback to `EpochConfig` instead in that case).
|
|
**/
|
|
nextEpochConfig: AugmentedQuery<ApiType, () => Observable<Option<PezspConsensusBabeBabeEpochConfiguration>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Next epoch randomness.
|
|
**/
|
|
nextRandomness: AugmentedQuery<ApiType, () => Observable<U8aFixed>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Pending epoch configuration change that will be applied when the next epoch is enacted.
|
|
**/
|
|
pendingEpochConfigChange: AugmentedQuery<ApiType, () => Observable<Option<PezspConsensusBabeDigestsNextConfigDescriptor>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The epoch randomness for the *current* epoch.
|
|
*
|
|
* # Security
|
|
*
|
|
* This MUST NOT be used for gambling, as it can be influenced by a
|
|
* malicious validator in the short term. It MAY be used in many
|
|
* cryptographic protocols, however, so long as one remembers that this
|
|
* (like everything else on-chain) it is public. For example, it can be
|
|
* used where a number is needed that cannot have been chosen by an
|
|
* adversary, for purposes such as public-coin zero-knowledge proofs.
|
|
**/
|
|
randomness: AugmentedQuery<ApiType, () => Observable<U8aFixed>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Randomness under construction.
|
|
*
|
|
* We make a trade-off between storage accesses and list length.
|
|
* We store the under-construction randomness in segments of up to
|
|
* `UNDER_CONSTRUCTION_SEGMENT_LENGTH`.
|
|
*
|
|
* Once a segment reaches this length, we begin the next one.
|
|
* We reset all segments and return to `0` at the beginning of every
|
|
* epoch.
|
|
**/
|
|
segmentIndex: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* A list of the last 100 skipped epochs and the corresponding session index
|
|
* when the epoch was skipped.
|
|
*
|
|
* This is only used for validating equivocation proofs. An equivocation proof
|
|
* must contains a key-ownership proof for a given session, therefore we need a
|
|
* way to tie together sessions and epoch indices, i.e. we need to validate that
|
|
* a validator was the owner of a given key on a given session, and what the
|
|
* active epoch index was during that session.
|
|
**/
|
|
skippedEpochs: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[u64, u32]>>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* TWOX-NOTE: `SegmentIndex` is an increasing integer, so this is okay.
|
|
**/
|
|
underConstruction: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Vec<U8aFixed>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
balances: {
|
|
/**
|
|
* The Balances pallet example of storing the balance of an account.
|
|
*
|
|
* # Example
|
|
*
|
|
* ```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.
|
|
*
|
|
* # Example
|
|
*
|
|
* ```nocompile
|
|
* impl pallet_balances::Config for Runtime {
|
|
* type AccountStore = System
|
|
* }
|
|
* ```
|
|
*
|
|
* But this comes with tradeoffs, storing account balances in the system pallet stores
|
|
* `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.
|
|
* NOTE: This is only used in the case that this pallet is used to store balances.
|
|
**/
|
|
account: AugmentedQuery<ApiType, (arg: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<PezpalletBalancesAccountData>, [PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* Freeze locks on account balances.
|
|
**/
|
|
freezes: AugmentedQuery<ApiType, (arg: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<Vec<PezframeSupportTokensMiscIdAmountRuntimeFreezeReason>>, [PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* Holds on account balances.
|
|
**/
|
|
holds: AugmentedQuery<ApiType, (arg: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<Vec<PezframeSupportTokensMiscIdAmountRuntimeHoldReason>>, [PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* The total units of outstanding deactivated balance in the system.
|
|
**/
|
|
inactiveIssuance: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* 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/`
|
|
**/
|
|
locks: AugmentedQuery<ApiType, (arg: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<Vec<PezpalletBalancesBalanceLock>>, [PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* Named reserves on some account balances.
|
|
*
|
|
* Use of reserves is deprecated in favour of holds. See `https://github.com/paritytech/substrate/pull/12951/`
|
|
**/
|
|
reserves: AugmentedQuery<ApiType, (arg: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<Vec<PezpalletBalancesReserveData>>, [PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* The total units issued in the system.
|
|
**/
|
|
totalIssuance: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
beefy: {
|
|
/**
|
|
* The current authorities set
|
|
**/
|
|
authorities: AugmentedQuery<ApiType, () => Observable<Vec<PezspConsensusBeefyEcdsaCryptoPublic>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Block number where BEEFY consensus is enabled/started.
|
|
* By changing this (through privileged `set_new_genesis()`), BEEFY consensus is effectively
|
|
* restarted from the newly set block number.
|
|
**/
|
|
genesisBlock: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Authorities set scheduled to be used with the next session
|
|
**/
|
|
nextAuthorities: AugmentedQuery<ApiType, () => Observable<Vec<PezspConsensusBeefyEcdsaCryptoPublic>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* A mapping from BEEFY set ID to the index of the *most recent* session for which its
|
|
* members were responsible.
|
|
*
|
|
* This is only used for validating equivocation proofs. An equivocation proof must
|
|
* contains a key-ownership proof for a given session, therefore we need a way to tie
|
|
* together sessions and BEEFY set ids, i.e. we need to validate that a validator
|
|
* was the owner of a given key on a given session, and what the active set ID was
|
|
* during that session.
|
|
*
|
|
* TWOX-NOTE: `ValidatorSetId` is not under user control.
|
|
**/
|
|
setIdSession: AugmentedQuery<ApiType, (arg: u64 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u64]> & QueryableStorageEntry<ApiType, [u64]>;
|
|
/**
|
|
* The current validator set id
|
|
**/
|
|
validatorSetId: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
beefyMmrLeaf: {
|
|
/**
|
|
* Details of current BEEFY authority set.
|
|
**/
|
|
beefyAuthorities: AugmentedQuery<ApiType, () => Observable<PezspConsensusBeefyMmrBeefyAuthoritySet>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Details of next BEEFY authority set.
|
|
*
|
|
* This storage entry is used as cache for calls to `update_beefy_next_authority_set`.
|
|
**/
|
|
beefyNextAuthorities: AugmentedQuery<ApiType, () => Observable<PezspConsensusBeefyMmrBeefyAuthoritySet>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
bounties: {
|
|
/**
|
|
* Bounties that have been made.
|
|
**/
|
|
bounties: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PezpalletBountiesBounty>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* Bounty indices that have been approved but not yet funded.
|
|
**/
|
|
bountyApprovals: AugmentedQuery<ApiType, () => Observable<Vec<u32>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Number of bounty proposals that have been made.
|
|
**/
|
|
bountyCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The description of each bounty.
|
|
**/
|
|
bountyDescriptions: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<Bytes>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
childBounties: {
|
|
/**
|
|
* Child bounties that have been added.
|
|
**/
|
|
childBounties: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<PezpalletChildBountiesChildBounty>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;
|
|
/**
|
|
* DEPRECATED: Replaced with `ParentTotalChildBounties` storage item keeping dedicated counts
|
|
* for each parent bounty. Number of total child bounties. Will be removed in May 2025.
|
|
**/
|
|
childBountyCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The description of each child-bounty. Indexed by `(parent_id, child_id)`.
|
|
*
|
|
* This item replaces the `ChildBountyDescriptions` storage item from the V0 storage version.
|
|
**/
|
|
childBountyDescriptionsV1: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<Bytes>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;
|
|
/**
|
|
* The cumulative child-bounty curator fee for each parent bounty.
|
|
**/
|
|
childrenCuratorFees: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u128>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* Number of active child bounties per parent bounty.
|
|
* Map of parent bounty index to number of child bounties.
|
|
**/
|
|
parentChildBounties: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* Number of total child bounties per parent bounty, including completed bounties.
|
|
**/
|
|
parentTotalChildBounties: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* The mapping of the child bounty ids from storage version `V0` to the new `V1` version.
|
|
*
|
|
* The `V0` ids based on total child bounty count [`ChildBountyCount`]`. The `V1` version ids
|
|
* based on the child bounty count per parent bounty [`ParentTotalChildBounties`].
|
|
* The item intended solely for client convenience and not used in the pallet's core logic.
|
|
**/
|
|
v0ToV1ChildBountyIds: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<ITuple<[u32, u32]>>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
claims: {
|
|
claims: AugmentedQuery<ApiType, (arg: PezkuwiRuntimeCommonClaimsEthereumAddress | string | Uint8Array) => Observable<Option<u128>>, [PezkuwiRuntimeCommonClaimsEthereumAddress]> & QueryableStorageEntry<ApiType, [PezkuwiRuntimeCommonClaimsEthereumAddress]>;
|
|
/**
|
|
* Pre-claimed Ethereum accounts, by the Account ID that they are claimed to.
|
|
**/
|
|
preclaims: AugmentedQuery<ApiType, (arg: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<Option<PezkuwiRuntimeCommonClaimsEthereumAddress>>, [PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* The statement kind that must be signed, if any.
|
|
**/
|
|
signing: AugmentedQuery<ApiType, (arg: PezkuwiRuntimeCommonClaimsEthereumAddress | string | Uint8Array) => Observable<Option<PezkuwiRuntimeCommonClaimsStatementKind>>, [PezkuwiRuntimeCommonClaimsEthereumAddress]> & QueryableStorageEntry<ApiType, [PezkuwiRuntimeCommonClaimsEthereumAddress]>;
|
|
total: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Vesting schedule for a claim.
|
|
* First balance is the total amount that should be held for vesting.
|
|
* Second balance is how much should be unlocked per block.
|
|
* The block number is when the vesting should start.
|
|
**/
|
|
vesting: AugmentedQuery<ApiType, (arg: PezkuwiRuntimeCommonClaimsEthereumAddress | string | Uint8Array) => Observable<Option<ITuple<[u128, u128, u32]>>>, [PezkuwiRuntimeCommonClaimsEthereumAddress]> & QueryableStorageEntry<ApiType, [PezkuwiRuntimeCommonClaimsEthereumAddress]>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
configuration: {
|
|
/**
|
|
* The active configuration for the current session.
|
|
**/
|
|
activeConfig: AugmentedQuery<ApiType, () => Observable<PezkuwiRuntimeTeyrchainsConfigurationHostConfiguration>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* If this is set, then the configuration setters will bypass the consistency checks. This
|
|
* is meant to be used only as the last resort.
|
|
**/
|
|
bypassConsistencyCheck: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Pending configuration changes.
|
|
*
|
|
* This is a list of configuration changes, each with a session index at which it should
|
|
* be applied.
|
|
*
|
|
* The list is sorted ascending by session index. Also, this list can only contain at most
|
|
* 2 items: for the next session and for the `scheduled_session`.
|
|
**/
|
|
pendingConfigs: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[u32, PezkuwiRuntimeTeyrchainsConfigurationHostConfiguration]>>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
convictionVoting: {
|
|
/**
|
|
* The voting classes which have a non-zero lock requirement and the lock amounts which they
|
|
* require. The actual amount locked on behalf of this pallet should always be the maximum of
|
|
* this list.
|
|
**/
|
|
classLocksFor: AugmentedQuery<ApiType, (arg: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<Vec<ITuple<[u16, u128]>>>, [PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* All voting for a particular voter in a particular voting class. We store the balance for the
|
|
* number of votes that we have recorded.
|
|
**/
|
|
votingFor: AugmentedQuery<ApiType, (arg1: PezspCoreCryptoAccountId32 | string | Uint8Array, arg2: u16 | AnyNumber | Uint8Array) => Observable<PezpalletConvictionVotingVoteVoting>, [PezspCoreCryptoAccountId32, u16]> & QueryableStorageEntry<ApiType, [PezspCoreCryptoAccountId32, u16]>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
coretimeAssignmentProvider: {
|
|
/**
|
|
* Assignments which are currently active.
|
|
*
|
|
* They will be picked from `PendingAssignments` once we reach the scheduled block number in
|
|
* `PendingAssignments`.
|
|
**/
|
|
coreDescriptors: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<PezkuwiRuntimeTeyrchainsAssignerCoretimeCoreDescriptor>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* Scheduled assignment sets.
|
|
*
|
|
* Assignments as of the given block number. They will go into state once the block number is
|
|
* reached (and replace whatever was in there before).
|
|
**/
|
|
coreSchedules: AugmentedQuery<ApiType, (arg: ITuple<[u32, u32]> | [u32 | AnyNumber | Uint8Array, u32 | AnyNumber | Uint8Array]) => Observable<Option<PezkuwiRuntimeTeyrchainsAssignerCoretimeSchedule>>, [ITuple<[u32, u32]>]> & QueryableStorageEntry<ApiType, [ITuple<[u32, u32]>]>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
crowdloan: {
|
|
/**
|
|
* The number of auctions that have entered into their ending period so far.
|
|
**/
|
|
endingsCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Info on all of the funds.
|
|
**/
|
|
funds: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PezkuwiRuntimeCommonCrowdloanFundInfo>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* The funds that have had additional contributions during the last block. This is used
|
|
* in order to determine which funds should submit new or updated bids.
|
|
**/
|
|
newRaise: AugmentedQuery<ApiType, () => Observable<Vec<u32>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Tracker for the next available fund index
|
|
**/
|
|
nextFundIndex: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
delegatedStaking: {
|
|
/**
|
|
* Map of `Agent` to their `Ledger`.
|
|
**/
|
|
agents: AugmentedQuery<ApiType, (arg: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<Option<PezpalletDelegatedStakingAgentLedger>>, [PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* Counter for the related counted storage map
|
|
**/
|
|
counterForAgents: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Counter for the related counted storage map
|
|
**/
|
|
counterForDelegators: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Map of Delegators to their `Delegation`.
|
|
*
|
|
* Implementation note: We are not using a double map with `delegator` and `agent` account
|
|
* as keys since we want to restrict delegators to delegate only to one account at a time.
|
|
**/
|
|
delegators: AugmentedQuery<ApiType, (arg: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<Option<PezpalletDelegatedStakingDelegation>>, [PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
dmp: {
|
|
/**
|
|
* The factor to multiply the base delivery fee by.
|
|
**/
|
|
deliveryFeeFactor: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u128>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* A mapping that stores the downward message queue MQC head for each para.
|
|
*
|
|
* Each link in this chain has a form:
|
|
* `(prev_head, B, H(M))`, where
|
|
* - `prev_head`: is the previous head hash or zero if none.
|
|
* - `B`: is the relay-chain block number in which a message was appended.
|
|
* - `H(M)`: is the hash of the message being appended.
|
|
**/
|
|
downwardMessageQueueHeads: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<H256>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* The downward messages addressed for a certain para.
|
|
**/
|
|
downwardMessageQueues: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Vec<PezkuwiCorePrimitivesInboundDownwardMessage>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
electionProviderMultiPhase: {
|
|
/**
|
|
* Current phase.
|
|
**/
|
|
currentPhase: AugmentedQuery<ApiType, () => Observable<PezpalletElectionProviderMultiPhasePhase>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Desired number of targets to elect for this round.
|
|
*
|
|
* Only exists when [`Snapshot`] is present.
|
|
* Note: This storage type must only be mutated through [`SnapshotWrapper`].
|
|
**/
|
|
desiredTargets: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The minimum score that each 'untrusted' solution must attain in order to be considered
|
|
* feasible.
|
|
*
|
|
* Can be set via `set_minimum_untrusted_score`.
|
|
**/
|
|
minimumUntrustedScore: AugmentedQuery<ApiType, () => Observable<Option<PezspNposElectionsElectionScore>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Current best solution, signed or unsigned, queued to be returned upon `elect`.
|
|
*
|
|
* Always sorted by score.
|
|
**/
|
|
queuedSolution: AugmentedQuery<ApiType, () => Observable<Option<PezpalletElectionProviderMultiPhaseReadySolution>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Internal counter for the number of rounds.
|
|
*
|
|
* This is useful for de-duplication of transactions submitted to the pool, and general
|
|
* diagnostics of the pallet.
|
|
*
|
|
* This is merely incremented once per every time that an upstream `elect` is called.
|
|
**/
|
|
round: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* A sorted, bounded vector of `(score, block_number, index)`, where each `index` points to a
|
|
* value in `SignedSubmissions`.
|
|
*
|
|
* We never need to process more than a single signed submission at a time. Signed submissions
|
|
* can be quite large, so we're willing to pay the cost of multiple database accesses to access
|
|
* them one at a time instead of reading and decoding all of them at once.
|
|
**/
|
|
signedSubmissionIndices: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[PezspNposElectionsElectionScore, u32, u32]>>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The next index to be assigned to an incoming signed submission.
|
|
*
|
|
* Every accepted submission is assigned a unique index; that index is bound to that particular
|
|
* submission for the duration of the election. On election finalization, the next index is
|
|
* reset to 0.
|
|
*
|
|
* We can't just use `SignedSubmissionIndices.len()`, because that's a bounded set; past its
|
|
* capacity, it will simply saturate. We can't just iterate over `SignedSubmissionsMap`,
|
|
* because iteration is slow. Instead, we store the value here.
|
|
**/
|
|
signedSubmissionNextIndex: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Unchecked, signed solutions.
|
|
*
|
|
* Together with `SubmissionIndices`, this stores a bounded set of `SignedSubmissions` while
|
|
* allowing us to keep only a single one in memory at a time.
|
|
*
|
|
* Twox note: the key of the map is an auto-incrementing index which users cannot inspect or
|
|
* affect; we shouldn't need a cryptographically secure hasher.
|
|
**/
|
|
signedSubmissionsMap: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PezpalletElectionProviderMultiPhaseSignedSignedSubmission>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* Snapshot data of the round.
|
|
*
|
|
* This is created at the beginning of the signed phase and cleared upon calling `elect`.
|
|
* Note: This storage type must only be mutated through [`SnapshotWrapper`].
|
|
**/
|
|
snapshot: AugmentedQuery<ApiType, () => Observable<Option<PezpalletElectionProviderMultiPhaseRoundSnapshot>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The metadata of the [`RoundSnapshot`]
|
|
*
|
|
* Only exists when [`Snapshot`] is present.
|
|
* Note: This storage type must only be mutated through [`SnapshotWrapper`].
|
|
**/
|
|
snapshotMetadata: AugmentedQuery<ApiType, () => Observable<Option<PezpalletElectionProviderMultiPhaseSolutionOrSnapshotSize>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
fastUnstake: {
|
|
/**
|
|
* Counter for the related counted storage map
|
|
**/
|
|
counterForQueue: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Number of eras to check per block.
|
|
*
|
|
* If set to 0, this pallet does absolutely nothing. Cannot be set to more than
|
|
* [`Config::MaxErasToCheckPerBlock`].
|
|
*
|
|
* Based on the amount of weight available at [`Pallet::on_idle`], up to this many eras are
|
|
* checked. The checking is represented by updating [`UnstakeRequest::checked`], which is
|
|
* stored in [`Head`].
|
|
**/
|
|
erasToCheckPerBlock: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The current "head of the queue" being unstaked.
|
|
*
|
|
* The head in itself can be a batch of up to [`Config::BatchSize`] stakers.
|
|
**/
|
|
head: AugmentedQuery<ApiType, () => Observable<Option<PezpalletFastUnstakeUnstakeRequest>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The map of all accounts wishing to be unstaked.
|
|
*
|
|
* Keeps track of `AccountId` wishing to unstake and it's corresponding deposit.
|
|
**/
|
|
queue: AugmentedQuery<ApiType, (arg: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<Option<u128>>, [PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
grandpa: {
|
|
/**
|
|
* The current list of authorities.
|
|
**/
|
|
authorities: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[PezspConsensusGrandpaAppPublic, u64]>>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The number of changes (both in terms of keys and underlying economic responsibilities)
|
|
* in the "set" of Grandpa validators from genesis.
|
|
**/
|
|
currentSetId: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* next block number where we can force a change.
|
|
**/
|
|
nextForced: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Pending change: (signaled at, scheduled change).
|
|
**/
|
|
pendingChange: AugmentedQuery<ApiType, () => Observable<Option<PezpalletGrandpaStoredPendingChange>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* A mapping from grandpa set ID to the index of the *most recent* session for which its
|
|
* members were responsible.
|
|
*
|
|
* This is only used for validating equivocation proofs. An equivocation proof must
|
|
* contains a key-ownership proof for a given session, therefore we need a way to tie
|
|
* together sessions and GRANDPA set ids, i.e. we need to validate that a validator
|
|
* was the owner of a given key on a given session, and what the active set ID was
|
|
* during that session.
|
|
*
|
|
* TWOX-NOTE: `SetId` is not under user control.
|
|
**/
|
|
setIdSession: AugmentedQuery<ApiType, (arg: u64 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u64]> & QueryableStorageEntry<ApiType, [u64]>;
|
|
/**
|
|
* `true` if we are currently stalled.
|
|
**/
|
|
stalled: AugmentedQuery<ApiType, () => Observable<Option<ITuple<[u32, u32]>>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* State of the current authority set.
|
|
**/
|
|
state: AugmentedQuery<ApiType, () => Observable<PezpalletGrandpaStoredState>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
historical: {
|
|
/**
|
|
* Mapping from historical session indices to session-data root hash and validator count.
|
|
**/
|
|
historicalSessions: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<ITuple<[H256, u32]>>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* The range of historical sessions we store. [first, last)
|
|
**/
|
|
storedRange: AugmentedQuery<ApiType, () => Observable<Option<ITuple<[u32, u32]>>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
hrmp: {
|
|
/**
|
|
* This mapping tracks how many open channel requests were accepted by a given recipient para.
|
|
* Invariant: `HrmpOpenChannelRequests` should contain the same number of items `(_, X)` with
|
|
* `confirmed` set to true, as the number of `HrmpAcceptedChannelRequestCount` for `X`.
|
|
**/
|
|
hrmpAcceptedChannelRequestCount: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* Storage for the messages for each channel.
|
|
* Invariant: cannot be non-empty if the corresponding channel in `HrmpChannels` is `None`.
|
|
**/
|
|
hrmpChannelContents: AugmentedQuery<ApiType, (arg: PezkuwiTeyrchainPrimitivesPrimitivesHrmpChannelId | { sender?: any; recipient?: any } | string | Uint8Array) => Observable<Vec<PezkuwiCorePrimitivesInboundHrmpMessage>>, [PezkuwiTeyrchainPrimitivesPrimitivesHrmpChannelId]> & QueryableStorageEntry<ApiType, [PezkuwiTeyrchainPrimitivesPrimitivesHrmpChannelId]>;
|
|
/**
|
|
* Maintains a mapping that can be used to answer the question: What paras sent a message at
|
|
* the given block number for a given receiver. Invariants:
|
|
* - The inner `Vec<ParaId>` is never empty.
|
|
* - The inner `Vec<ParaId>` cannot store two same `ParaId`.
|
|
* - The outer vector is sorted ascending by block number and cannot store two items with the
|
|
* same block number.
|
|
**/
|
|
hrmpChannelDigests: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Vec<ITuple<[u32, Vec<u32>]>>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* HRMP channel data associated with each para.
|
|
* Invariant:
|
|
* - each participant in the channel should satisfy `Paras::is_valid_para(P)` within a session.
|
|
**/
|
|
hrmpChannels: AugmentedQuery<ApiType, (arg: PezkuwiTeyrchainPrimitivesPrimitivesHrmpChannelId | { sender?: any; recipient?: any } | string | Uint8Array) => Observable<Option<PezkuwiRuntimeTeyrchainsHrmpHrmpChannel>>, [PezkuwiTeyrchainPrimitivesPrimitivesHrmpChannelId]> & QueryableStorageEntry<ApiType, [PezkuwiTeyrchainPrimitivesPrimitivesHrmpChannelId]>;
|
|
/**
|
|
* A set of pending HRMP close channel requests that are going to be closed during the session
|
|
* change. Used for checking if a given channel is registered for closure.
|
|
*
|
|
* The set is accompanied by a list for iteration.
|
|
*
|
|
* Invariant:
|
|
* - There are no channels that exists in list but not in the set and vice versa.
|
|
**/
|
|
hrmpCloseChannelRequests: AugmentedQuery<ApiType, (arg: PezkuwiTeyrchainPrimitivesPrimitivesHrmpChannelId | { sender?: any; recipient?: any } | string | Uint8Array) => Observable<Option<Null>>, [PezkuwiTeyrchainPrimitivesPrimitivesHrmpChannelId]> & QueryableStorageEntry<ApiType, [PezkuwiTeyrchainPrimitivesPrimitivesHrmpChannelId]>;
|
|
hrmpCloseChannelRequestsList: AugmentedQuery<ApiType, () => Observable<Vec<PezkuwiTeyrchainPrimitivesPrimitivesHrmpChannelId>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
hrmpEgressChannelsIndex: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Vec<u32>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* Ingress/egress indexes allow to find all the senders and receivers given the opposite side.
|
|
* I.e.
|
|
*
|
|
* (a) ingress index allows to find all the senders for a given recipient.
|
|
* (b) egress index allows to find all the recipients for a given sender.
|
|
*
|
|
* Invariants:
|
|
* - for each ingress index entry for `P` each item `I` in the index should present in
|
|
* `HrmpChannels` as `(I, P)`.
|
|
* - for each egress index entry for `P` each item `E` in the index should present in
|
|
* `HrmpChannels` as `(P, E)`.
|
|
* - there should be no other dangling channels in `HrmpChannels`.
|
|
* - the vectors are sorted.
|
|
**/
|
|
hrmpIngressChannelsIndex: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Vec<u32>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* This mapping tracks how many open channel requests are initiated by a given sender para.
|
|
* Invariant: `HrmpOpenChannelRequests` should contain the same number of items that has
|
|
* `(X, _)` as the number of `HrmpOpenChannelRequestCount` for `X`.
|
|
**/
|
|
hrmpOpenChannelRequestCount: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* The set of pending HRMP open channel requests.
|
|
*
|
|
* The set is accompanied by a list for iteration.
|
|
*
|
|
* Invariant:
|
|
* - There are no channels that exists in list but not in the set and vice versa.
|
|
**/
|
|
hrmpOpenChannelRequests: AugmentedQuery<ApiType, (arg: PezkuwiTeyrchainPrimitivesPrimitivesHrmpChannelId | { sender?: any; recipient?: any } | string | Uint8Array) => Observable<Option<PezkuwiRuntimeTeyrchainsHrmpHrmpOpenChannelRequest>>, [PezkuwiTeyrchainPrimitivesPrimitivesHrmpChannelId]> & QueryableStorageEntry<ApiType, [PezkuwiTeyrchainPrimitivesPrimitivesHrmpChannelId]>;
|
|
hrmpOpenChannelRequestsList: AugmentedQuery<ApiType, () => Observable<Vec<PezkuwiTeyrchainPrimitivesPrimitivesHrmpChannelId>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The HRMP watermark associated with each para.
|
|
* Invariant:
|
|
* - each para `P` used here as a key should satisfy `Paras::is_valid_para(P)` within a
|
|
* session.
|
|
**/
|
|
hrmpWatermarks: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
indices: {
|
|
/**
|
|
* The lookup from index to account.
|
|
**/
|
|
accounts: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<ITuple<[PezspCoreCryptoAccountId32, u128, bool]>>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
initializer: {
|
|
/**
|
|
* Buffered session changes.
|
|
*
|
|
* Typically this will be empty or one element long. Apart from that this item never hits
|
|
* the storage.
|
|
*
|
|
* However this is a `Vec` regardless to handle various edge cases that may occur at runtime
|
|
* upgrade boundaries or if governance intervenes.
|
|
**/
|
|
bufferedSessionChanges: AugmentedQuery<ApiType, () => Observable<Vec<PezkuwiRuntimeTeyrchainsInitializerBufferedSessionChange>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Whether the parachains modules have been initialized within this block.
|
|
*
|
|
* Semantically a `bool`, but this guarantees it should never hit the trie,
|
|
* as this is cleared in `on_finalize` and Frame optimizes `None` values to be empty values.
|
|
*
|
|
* As a `bool`, `set(false)` and `remove()` both lead to the next `get()` being false, but one
|
|
* of them writes to the trie and one does not. This confusion makes `Option<()>` more suitable
|
|
* for the semantics of this variable.
|
|
**/
|
|
hasInitialized: AugmentedQuery<ApiType, () => Observable<Option<Null>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
messageQueue: {
|
|
/**
|
|
* The index of the first and last (non-empty) pages.
|
|
**/
|
|
bookStateFor: AugmentedQuery<ApiType, (arg: PezkuwiRuntimeTeyrchainsInclusionAggregateMessageOrigin | { Ump: any } | string | Uint8Array) => Observable<PezpalletMessageQueueBookState>, [PezkuwiRuntimeTeyrchainsInclusionAggregateMessageOrigin]> & QueryableStorageEntry<ApiType, [PezkuwiRuntimeTeyrchainsInclusionAggregateMessageOrigin]>;
|
|
/**
|
|
* The map of page indices to pages.
|
|
**/
|
|
pages: AugmentedQuery<ApiType, (arg1: PezkuwiRuntimeTeyrchainsInclusionAggregateMessageOrigin | { Ump: any } | string | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<PezpalletMessageQueuePage>>, [PezkuwiRuntimeTeyrchainsInclusionAggregateMessageOrigin, u32]> & QueryableStorageEntry<ApiType, [PezkuwiRuntimeTeyrchainsInclusionAggregateMessageOrigin, u32]>;
|
|
/**
|
|
* The origin at which we should begin servicing.
|
|
**/
|
|
serviceHead: AugmentedQuery<ApiType, () => Observable<Option<PezkuwiRuntimeTeyrchainsInclusionAggregateMessageOrigin>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
mmr: {
|
|
/**
|
|
* Hashes of the nodes in the MMR.
|
|
*
|
|
* Note this collection only contains MMR peaks, the inner nodes (and leaves)
|
|
* are pruned and only stored in the Offchain DB.
|
|
**/
|
|
nodes: AugmentedQuery<ApiType, (arg: u64 | AnyNumber | Uint8Array) => Observable<Option<H256>>, [u64]> & QueryableStorageEntry<ApiType, [u64]>;
|
|
/**
|
|
* Current size of the MMR (number of leaves).
|
|
**/
|
|
numberOfLeaves: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Latest MMR Root hash.
|
|
**/
|
|
rootHash: AugmentedQuery<ApiType, () => Observable<H256>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
multisig: {
|
|
/**
|
|
* The set of open multisig operations.
|
|
**/
|
|
multisigs: AugmentedQuery<ApiType, (arg1: PezspCoreCryptoAccountId32 | string | Uint8Array, arg2: U8aFixed | string | Uint8Array) => Observable<Option<PezpalletMultisigMultisig>>, [PezspCoreCryptoAccountId32, U8aFixed]> & QueryableStorageEntry<ApiType, [PezspCoreCryptoAccountId32, U8aFixed]>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
nominationPools: {
|
|
/**
|
|
* Storage for bonded pools.
|
|
**/
|
|
bondedPools: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PezpalletNominationPoolsBondedPoolInner>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* Map from a pool member account to their opted claim permission.
|
|
**/
|
|
claimPermissions: AugmentedQuery<ApiType, (arg: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<PezpalletNominationPoolsClaimPermission>, [PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* Counter for the related counted storage map
|
|
**/
|
|
counterForBondedPools: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Counter for the related counted storage map
|
|
**/
|
|
counterForMetadata: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Counter for the related counted storage map
|
|
**/
|
|
counterForPoolMembers: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Counter for the related counted storage map
|
|
**/
|
|
counterForReversePoolIdLookup: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Counter for the related counted storage map
|
|
**/
|
|
counterForRewardPools: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Counter for the related counted storage map
|
|
**/
|
|
counterForSubPoolsStorage: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The maximum commission that can be charged by a pool. Used on commission payouts to bound
|
|
* pool commissions that are > `GlobalMaxCommission`, necessary if a future
|
|
* `GlobalMaxCommission` is lower than some current pool commissions.
|
|
**/
|
|
globalMaxCommission: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Ever increasing number of all pools created so far.
|
|
**/
|
|
lastPoolId: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Maximum number of members that can exist in the system. If `None`, then the count
|
|
* members are not bound on a system wide basis.
|
|
**/
|
|
maxPoolMembers: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Maximum number of members that may belong to pool. If `None`, then the count of
|
|
* members is not bound on a per pool basis.
|
|
**/
|
|
maxPoolMembersPerPool: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Maximum number of nomination pools that can exist. If `None`, then an unbounded number of
|
|
* pools can exist.
|
|
**/
|
|
maxPools: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Metadata for the pool.
|
|
**/
|
|
metadata: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Bytes>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* Minimum bond required to create a pool.
|
|
*
|
|
* This is the amount that the depositor must put as their initial stake in the pool, as an
|
|
* indication of "skin in the game".
|
|
*
|
|
* This is the value that will always exist in the staking ledger of the pool bonded account
|
|
* while all other accounts leave.
|
|
**/
|
|
minCreateBond: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Minimum amount to bond to join a pool.
|
|
**/
|
|
minJoinBond: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Active members.
|
|
*
|
|
* TWOX-NOTE: SAFE since `AccountId` is a secure hash.
|
|
**/
|
|
poolMembers: AugmentedQuery<ApiType, (arg: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<Option<PezpalletNominationPoolsPoolMember>>, [PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* A reverse lookup from the pool's account id to its id.
|
|
*
|
|
* This is only used for slashing and on automatic withdraw update. In all other instances, the
|
|
* pool id is used, and the accounts are deterministically derived from it.
|
|
**/
|
|
reversePoolIdLookup: AugmentedQuery<ApiType, (arg: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<Option<u32>>, [PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* Reward pools. This is where there rewards for each pool accumulate. When a members payout is
|
|
* claimed, the balance comes out of the reward pool. Keyed by the bonded pools account.
|
|
**/
|
|
rewardPools: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PezpalletNominationPoolsRewardPool>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* Groups of unbonding pools. Each group of unbonding pools belongs to a
|
|
* bonded pool, hence the name sub-pools. Keyed by the bonded pools account.
|
|
**/
|
|
subPoolsStorage: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PezpalletNominationPoolsSubPools>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* The sum of funds across all pools.
|
|
*
|
|
* This might be lower but never higher than the sum of `total_balance` of all [`PoolMembers`]
|
|
* because calling `pool_withdraw_unbonded` might decrease the total stake of the pool's
|
|
* `bonded_account` without adjusting the pallet-internal `UnbondingPool`'s.
|
|
**/
|
|
totalValueLocked: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
offences: {
|
|
/**
|
|
* A vector of reports of the same kind that happened at the same time slot.
|
|
**/
|
|
concurrentReportsIndex: AugmentedQuery<ApiType, (arg1: U8aFixed | string | Uint8Array, arg2: Bytes | string | Uint8Array) => Observable<Vec<H256>>, [U8aFixed, Bytes]> & QueryableStorageEntry<ApiType, [U8aFixed, Bytes]>;
|
|
/**
|
|
* The primary structure that holds all offence records keyed by report identifiers.
|
|
**/
|
|
reports: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Option<PezspStakingOffenceOffenceDetails>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
onDemand: {
|
|
/**
|
|
* Queue entries that are currently bound to a particular core due to core affinity.
|
|
**/
|
|
affinityEntries: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<BinaryHeapEnqueuedOrder>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* Keeps track of credits owned by each account.
|
|
**/
|
|
credits: AugmentedQuery<ApiType, (arg: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<u128>, [PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* Priority queue for all orders which don't yet (or not any more) have any core affinity.
|
|
**/
|
|
freeEntries: AugmentedQuery<ApiType, () => Observable<Vec<PezkuwiRuntimeTeyrchainsOnDemandTypesEnqueuedOrder>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Maps a `ParaId` to `CoreIndex` and keeps track of how many assignments the scheduler has in
|
|
* it's lookahead. Keeping track of this affinity prevents parallel execution of the same
|
|
* `ParaId` on two or more `CoreIndex`es.
|
|
**/
|
|
paraIdAffinity: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PezkuwiRuntimeTeyrchainsOnDemandTypesCoreAffinityCount>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* Overall status of queue (both free + affinity entries)
|
|
**/
|
|
queueStatus: AugmentedQuery<ApiType, () => Observable<PezkuwiRuntimeTeyrchainsOnDemandTypesQueueStatusType>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Keeps track of accumulated revenue from on demand order sales.
|
|
**/
|
|
revenue: AugmentedQuery<ApiType, () => Observable<Vec<u128>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
paraInclusion: {
|
|
/**
|
|
* Candidates pending availability by `ParaId`. They form a chain starting from the latest
|
|
* included head of the para.
|
|
* Use a different prefix post-migration to v1, since the v0 `PendingAvailability` storage
|
|
* would otherwise have the exact same prefix which could cause undefined behaviour when doing
|
|
* the migration.
|
|
**/
|
|
v1: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<Vec<PezkuwiRuntimeTeyrchainsInclusionCandidatePendingAvailability>>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
paraInherent: {
|
|
/**
|
|
* Whether the paras inherent was included within this block.
|
|
*
|
|
* The `Option<()>` is effectively a `bool`, but it never hits storage in the `None` variant
|
|
* due to the guarantees of FRAME's storage APIs.
|
|
*
|
|
* If this is `None` at the end of the block, we panic and render the block invalid.
|
|
**/
|
|
included: AugmentedQuery<ApiType, () => Observable<Option<Null>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Scraped on chain data for extracting resolved disputes as well as backing votes.
|
|
**/
|
|
onChainVotes: AugmentedQuery<ApiType, () => Observable<Option<PezkuwiPrimitivesVstagingScrapedOnChainVotes>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
paras: {
|
|
/**
|
|
* The actions to perform during the start of a specific session index.
|
|
**/
|
|
actionsQueue: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Vec<u32>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* The code hash authorizations for a para which will expire `expire_at` `BlockNumberFor<T>`.
|
|
**/
|
|
authorizedCodeHash: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PezkuwiRuntimeTeyrchainsParasAuthorizedCodeHashAndExpiry>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* Validation code stored by its hash.
|
|
*
|
|
* This storage is consistent with [`FutureCodeHash`], [`CurrentCodeHash`] and
|
|
* [`PastCodeHash`].
|
|
**/
|
|
codeByHash: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Option<Bytes>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;
|
|
/**
|
|
* The number of reference on the validation code in [`CodeByHash`] storage.
|
|
**/
|
|
codeByHashRefs: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<u32>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;
|
|
/**
|
|
* The validation code hash of every live para.
|
|
*
|
|
* Corresponding code can be retrieved with [`CodeByHash`].
|
|
**/
|
|
currentCodeHash: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<H256>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* The actual future code hash of a para.
|
|
*
|
|
* Corresponding code can be retrieved with [`CodeByHash`].
|
|
**/
|
|
futureCodeHash: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<H256>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* The block number at which the planned code change is expected for a parachain.
|
|
*
|
|
* The change will be applied after the first parablock for this ID included which executes
|
|
* in the context of a relay chain block with a number >= `expected_at`.
|
|
**/
|
|
futureCodeUpgrades: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* The list of upcoming future code upgrades.
|
|
*
|
|
* Each item is a pair of the parachain and the expected block at which the upgrade should be
|
|
* applied. The upgrade will be applied at the given relay chain block. In contrast to
|
|
* [`FutureCodeUpgrades`] this code upgrade will be applied regardless the parachain making any
|
|
* progress or not.
|
|
*
|
|
* Ordered ascending by block number.
|
|
**/
|
|
futureCodeUpgradesAt: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[u32, u32]>>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The head-data of every registered para.
|
|
**/
|
|
heads: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<Bytes>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* The context (relay-chain block number) of the most recent parachain head.
|
|
**/
|
|
mostRecentContext: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* All lease holding parachains. Ordered ascending by `ParaId`. On demand parachains are not
|
|
* included.
|
|
*
|
|
* Consider using the [`ParachainsCache`] type of modifying.
|
|
**/
|
|
parachains: AugmentedQuery<ApiType, () => Observable<Vec<u32>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The current lifecycle of a all known Para IDs.
|
|
**/
|
|
paraLifecycles: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PezkuwiRuntimeTeyrchainsParasParaLifecycle>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* Actual past code hash, indicated by the para id as well as the block number at which it
|
|
* became outdated.
|
|
*
|
|
* Corresponding code can be retrieved with [`CodeByHash`].
|
|
**/
|
|
pastCodeHash: AugmentedQuery<ApiType, (arg: ITuple<[u32, u32]> | [u32 | AnyNumber | Uint8Array, u32 | AnyNumber | Uint8Array]) => Observable<Option<H256>>, [ITuple<[u32, u32]>]> & QueryableStorageEntry<ApiType, [ITuple<[u32, u32]>]>;
|
|
/**
|
|
* Past code of parachains. The parachains themselves may not be registered anymore,
|
|
* but we also keep their code on-chain for the same amount of time as outdated code
|
|
* to keep it available for approval checkers.
|
|
**/
|
|
pastCodeMeta: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<PezkuwiRuntimeTeyrchainsParasParaPastCodeMeta>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* Which paras have past code that needs pruning and the relay-chain block at which the code
|
|
* was replaced. Note that this is the actual height of the included block, not the expected
|
|
* height at which the code upgrade would be applied, although they may be equal.
|
|
* This is to ensure the entire acceptance period is covered, not an offset acceptance period
|
|
* starting from the time at which the parachain perceives a code upgrade as having occurred.
|
|
* Multiple entries for a single para are permitted. Ordered ascending by block number.
|
|
**/
|
|
pastCodePruning: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[u32, u32]>>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The list of all currently active PVF votes. Auxiliary to `PvfActiveVoteMap`.
|
|
**/
|
|
pvfActiveVoteList: AugmentedQuery<ApiType, () => Observable<Vec<H256>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* All currently active PVF pre-checking votes.
|
|
*
|
|
* Invariant:
|
|
* - There are no PVF pre-checking votes that exists in list but not in the set and vice versa.
|
|
**/
|
|
pvfActiveVoteMap: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Option<PezkuwiRuntimeTeyrchainsParasPvfCheckActiveVoteState>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;
|
|
/**
|
|
* Upcoming paras instantiation arguments.
|
|
*
|
|
* NOTE that after PVF pre-checking is enabled the para genesis arg will have it's code set
|
|
* to empty. Instead, the code will be saved into the storage right away via `CodeByHash`.
|
|
**/
|
|
upcomingParasGenesis: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PezkuwiRuntimeTeyrchainsParasParaGenesisArgs>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* The list of upcoming code upgrades.
|
|
*
|
|
* Each item is a pair of which para performs a code upgrade and at which relay-chain block it
|
|
* is expected at.
|
|
*
|
|
* Ordered ascending by block number.
|
|
**/
|
|
upcomingUpgrades: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[u32, u32]>>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The list of parachains that are awaiting for their upgrade restriction to cooldown.
|
|
*
|
|
* Ordered ascending by block number.
|
|
**/
|
|
upgradeCooldowns: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[u32, u32]>>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* This is used by the relay-chain to communicate to a parachain a go-ahead with in the upgrade
|
|
* procedure.
|
|
*
|
|
* This value is absent when there are no upgrades scheduled or during the time the relay chain
|
|
* performs the checks. It is set at the first relay-chain block when the corresponding
|
|
* parachain can switch its upgrade function. As soon as the parachain's block is included, the
|
|
* value gets reset to `None`.
|
|
*
|
|
* NOTE that this field is used by parachains via merkle storage proofs, therefore changing
|
|
* the format will require migration of parachains.
|
|
**/
|
|
upgradeGoAheadSignal: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PezkuwiPrimitivesV8UpgradeGoAhead>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* This is used by the relay-chain to communicate that there are restrictions for performing
|
|
* an upgrade for this parachain.
|
|
*
|
|
* This may be a because the parachain waits for the upgrade cooldown to expire. Another
|
|
* potential use case is when we want to perform some maintenance (such as storage migration)
|
|
* we could restrict upgrades to make the process simpler.
|
|
*
|
|
* NOTE that this field is used by parachains via merkle storage proofs, therefore changing
|
|
* the format will require migration of parachains.
|
|
**/
|
|
upgradeRestrictionSignal: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PezkuwiPrimitivesV8UpgradeRestriction>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
paraScheduler: {
|
|
/**
|
|
* One entry for each availability core. The `VecDeque` represents the assignments to be
|
|
* scheduled on that core.
|
|
**/
|
|
claimQueue: AugmentedQuery<ApiType, () => Observable<BTreeMap<u32, Vec<PezkuwiRuntimeTeyrchainsSchedulerCommonAssignment>>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The block number where the session start occurred. Used to track how many group rotations
|
|
* have occurred.
|
|
*
|
|
* Note that in the context of parachains modules the session change is signaled during
|
|
* the block and enacted at the end of the block (at the finalization stage, to be exact).
|
|
* Thus for all intents and purposes the effect of the session change is observed at the
|
|
* block following the session change, block number of which we save in this storage value.
|
|
**/
|
|
sessionStartBlock: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* All the validator groups. One for each core. Indices are into `ActiveValidators` - not the
|
|
* broader set of Polkadot validators, but instead just the subset used for parachains during
|
|
* this session.
|
|
*
|
|
* Bound: The number of cores is the sum of the numbers of parachains and parathread
|
|
* multiplexers. Reasonably, 100-1000. The dominant factor is the number of validators: safe
|
|
* upper bound at 10k.
|
|
**/
|
|
validatorGroups: AugmentedQuery<ApiType, () => Observable<Vec<Vec<u32>>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
parasDisputes: {
|
|
/**
|
|
* Backing votes stored for each dispute.
|
|
* This storage is used for slashing.
|
|
**/
|
|
backersOnDisputes: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: H256 | string | Uint8Array) => Observable<Option<BTreeSet<u32>>>, [u32, H256]> & QueryableStorageEntry<ApiType, [u32, H256]>;
|
|
/**
|
|
* All ongoing or concluded disputes for the last several sessions.
|
|
**/
|
|
disputes: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: H256 | string | Uint8Array) => Observable<Option<PezkuwiPrimitivesV8DisputeState>>, [u32, H256]> & QueryableStorageEntry<ApiType, [u32, H256]>;
|
|
/**
|
|
* Whether the chain is frozen. Starts as `None`. When this is `Some`,
|
|
* the chain will not accept any new parachain blocks for backing or inclusion,
|
|
* and its value indicates the last valid block number in the chain.
|
|
* It can only be set back to `None` by governance intervention.
|
|
**/
|
|
frozen: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* All included blocks on the chain, as well as the block number in this chain that
|
|
* should be reverted back to if the candidate is disputed and determined to be invalid.
|
|
**/
|
|
included: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: H256 | string | Uint8Array) => Observable<Option<u32>>, [u32, H256]> & QueryableStorageEntry<ApiType, [u32, H256]>;
|
|
/**
|
|
* The last pruned session, if any. All data stored by this module
|
|
* references sessions.
|
|
**/
|
|
lastPrunedSession: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
paraSessionInfo: {
|
|
/**
|
|
* The validator account keys of the validators actively participating in parachain consensus.
|
|
**/
|
|
accountKeys: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<Vec<PezspCoreCryptoAccountId32>>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* Assignment keys for the current session.
|
|
* Note that this API is private due to it being prone to 'off-by-one' at session boundaries.
|
|
* When in doubt, use `Sessions` API instead.
|
|
**/
|
|
assignmentKeysUnsafe: AugmentedQuery<ApiType, () => Observable<Vec<PezkuwiPrimitivesV8AssignmentAppPublic>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The earliest session for which previous session info is stored.
|
|
**/
|
|
earliestStoredSession: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Executor parameter set for a given session index
|
|
**/
|
|
sessionExecutorParams: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PezkuwiPrimitivesV8ExecutorParams>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* Session information in a rolling window.
|
|
* Should have an entry in range `EarliestStoredSession..=CurrentSessionIndex`.
|
|
* Does not have any entries before the session index in the first session change notification.
|
|
**/
|
|
sessions: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PezkuwiPrimitivesV8SessionInfo>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
parasShared: {
|
|
/**
|
|
* All the validators actively participating in parachain consensus.
|
|
* Indices are into the broader validator set.
|
|
**/
|
|
activeValidatorIndices: AugmentedQuery<ApiType, () => Observable<Vec<u32>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The parachain attestation keys of the validators actively participating in parachain
|
|
* consensus. This should be the same length as `ActiveValidatorIndices`.
|
|
**/
|
|
activeValidatorKeys: AugmentedQuery<ApiType, () => Observable<Vec<PezkuwiPrimitivesV8ValidatorAppPublic>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* All allowed relay-parents.
|
|
**/
|
|
allowedRelayParents: AugmentedQuery<ApiType, () => Observable<PezkuwiRuntimeTeyrchainsSharedAllowedRelayParentsTracker>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The current session index.
|
|
**/
|
|
currentSessionIndex: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
parasSlashing: {
|
|
/**
|
|
* Validators pending dispute slashes.
|
|
**/
|
|
unappliedSlashes: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: H256 | string | Uint8Array) => Observable<Option<PezkuwiPrimitivesVstagingPendingSlashes>>, [u32, H256]> & QueryableStorageEntry<ApiType, [u32, H256]>;
|
|
/**
|
|
* `ValidatorSetCount` per session.
|
|
**/
|
|
validatorSetCounts: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
preimage: {
|
|
preimageFor: AugmentedQuery<ApiType, (arg: ITuple<[H256, u32]> | [H256 | string | Uint8Array, u32 | AnyNumber | Uint8Array]) => Observable<Option<Bytes>>, [ITuple<[H256, u32]>]> & QueryableStorageEntry<ApiType, [ITuple<[H256, u32]>]>;
|
|
/**
|
|
* The request status of a given hash.
|
|
**/
|
|
requestStatusFor: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Option<PezpalletPreimageRequestStatus>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;
|
|
/**
|
|
* The request status of a given hash.
|
|
**/
|
|
statusFor: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Option<PezpalletPreimageOldRequestStatus>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
proxy: {
|
|
/**
|
|
* The announcements made by the proxy (key).
|
|
**/
|
|
announcements: AugmentedQuery<ApiType, (arg: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<ITuple<[Vec<PezpalletProxyAnnouncement>, u128]>>, [PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* The set of account proxies. Maps the account which has delegated to the accounts
|
|
* which are being delegated to, together with the amount held on deposit.
|
|
**/
|
|
proxies: AugmentedQuery<ApiType, (arg: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<ITuple<[Vec<PezpalletProxyProxyDefinition>, u128]>>, [PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
rcMigrator: {
|
|
/**
|
|
* The priority of the Asset Hub UMP queue during migration.
|
|
*
|
|
* Controls how the Asset Hub UMP (Upward Message Passing) queue is processed relative to other
|
|
* queues during the migration process. This helps ensure timely processing of migration
|
|
* messages. The default priority pattern is defined in the pallet configuration, but can be
|
|
* overridden by a storage value of this type.
|
|
**/
|
|
ahUmpQueuePriorityConfig: AugmentedQuery<ApiType, () => Observable<PezpalletRcMigratorQueuePriority>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* An optional account id of a canceller.
|
|
*
|
|
* This account id can only stop scheduled migration.
|
|
**/
|
|
canceller: AugmentedQuery<ApiType, () => Observable<Option<PezspCoreCryptoAccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The duration of the post migration cool-off period.
|
|
*
|
|
* This is the duration of the cool-off period after the data migration is finished. During
|
|
* this period, the migration will be still in ongoing state and the concerned extrinsics will
|
|
* be locked.
|
|
**/
|
|
coolOffPeriod: AugmentedQuery<ApiType, () => Observable<Option<PezframeSupportScheduleDispatchTime>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Counter for the related counted storage map
|
|
**/
|
|
counterForPendingXcmMessages: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Counter for the related counted storage map
|
|
**/
|
|
counterForRcAccounts: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* An optional account id of a manager.
|
|
*
|
|
* This account id has similar privileges to [`Config::AdminOrigin`] except that it
|
|
* can not set the manager account id via `set_manager` call.
|
|
**/
|
|
manager: AugmentedQuery<ApiType, () => Observable<Option<PezspCoreCryptoAccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The current round of the multisig voting.
|
|
*
|
|
* Votes are only valid for the current round.
|
|
**/
|
|
managerMultisigRound: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The multisig AccountIDs that votes to execute a specific call.
|
|
**/
|
|
managerMultisigs: AugmentedQuery<ApiType, (arg: RuntimeCall | IMethod | string | Uint8Array) => Observable<Vec<PezspCoreCryptoAccountId32>>, [RuntimeCall]> & QueryableStorageEntry<ApiType, [RuntimeCall]>;
|
|
/**
|
|
* How often each participant voted in the current round.
|
|
*
|
|
* Will be cleared at the end of each round.
|
|
**/
|
|
managerVotesInCurrentRound: AugmentedQuery<ApiType, (arg: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<u32>, [PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* Block number when migration finished and extrinsics were unlocked.
|
|
*
|
|
* This is set when entering the `MigrationDone` stage hence when
|
|
* `RcMigrationStage::is_finished()` becomes `true`.
|
|
**/
|
|
migrationEndBlock: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The block number at which the migration began and the pallet's extrinsics were locked.
|
|
*
|
|
* This value is set when entering the `WaitingForAh` stage, i.e., when
|
|
* `RcMigrationStage::is_ongoing()` becomes `true`.
|
|
**/
|
|
migrationStartBlock: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The pending XCM messages.
|
|
*
|
|
* Contains data messages that have been sent to the Asset Hub but not yet confirmed.
|
|
*
|
|
* Unconfirmed messages can be resent by calling the [`Pallet::resend_xcm`] function.
|
|
**/
|
|
pendingXcmMessages: AugmentedQuery<ApiType, (arg: ITuple<[u64, H256]> | [u64 | AnyNumber | Uint8Array, H256 | string | Uint8Array]) => Observable<Option<StagingXcmV5Xcm>>, [ITuple<[u64, H256]>]> & QueryableStorageEntry<ApiType, [ITuple<[u64, H256]>]>;
|
|
/**
|
|
* The pending XCM response queries and their XCM hash referencing the message in the
|
|
* [`PendingXcmMessages`] storage.
|
|
*
|
|
* The `QueryId` is the identifier from the [`pallet_xcm`] query handler registry. The XCM
|
|
* pallet will notify about the status of the message by calling the
|
|
* [`Pallet::receive_query_response`] function with the `QueryId` and the
|
|
* response.
|
|
**/
|
|
pendingXcmQueries: AugmentedQuery<ApiType, (arg: u64 | AnyNumber | Uint8Array) => Observable<Option<H256>>, [u64]> & QueryableStorageEntry<ApiType, [u64]>;
|
|
/**
|
|
* Accounts that use the proxy pallet to delegate permissions and have no nonce.
|
|
*
|
|
* Boolean value is whether they have been migrated to the Asset Hub. Needed for idempotency.
|
|
**/
|
|
pureProxyCandidatesMigrated: AugmentedQuery<ApiType, (arg: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<Option<bool>>, [PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* Helper storage item to obtain and store the known accounts that should be kept partially or
|
|
* fully on Relay Chain.
|
|
**/
|
|
rcAccounts: AugmentedQuery<ApiType, (arg: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<Option<PezpalletRcMigratorAccountsAccountState>>, [PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* Helper storage item to store the total balance that should be kept on Relay Chain.
|
|
**/
|
|
rcMigratedBalance: AugmentedQuery<ApiType, () => Observable<PezpalletRcMigratorAccountsMigratedBalances>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Helper storage item to store the total balance that should be kept on Relay Chain after
|
|
* it is consumed from the `RcMigratedBalance` storage item and sent to the Asset Hub.
|
|
*
|
|
* This let us to take the value from the `RcMigratedBalance` storage item and keep the
|
|
* `SignalMigrationFinish` stage to be idempotent while preserving these values for tests and
|
|
* later discoveries.
|
|
**/
|
|
rcMigratedBalanceArchive: AugmentedQuery<ApiType, () => Observable<PezpalletRcMigratorAccountsMigratedBalances>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The Relay Chain migration state.
|
|
**/
|
|
rcMigrationStage: AugmentedQuery<ApiType, () => Observable<PezpalletRcMigratorMigrationStage>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The migration settings.
|
|
**/
|
|
settings: AugmentedQuery<ApiType, () => Observable<Option<PezpalletRcMigratorMigrationSettings>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Manual override for `type UnprocessedMsgBuffer: Get<u32>`. Look there for docs.
|
|
**/
|
|
unprocessedMsgBuffer: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The duration of the pre migration warm-up period.
|
|
*
|
|
* This is the duration of the warm-up period before the data migration starts. During this
|
|
* period, the migration will be in ongoing state and the concerned extrinsics will be locked.
|
|
**/
|
|
warmUpPeriod: AugmentedQuery<ApiType, () => Observable<Option<PezframeSupportScheduleDispatchTime>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
referenda: {
|
|
/**
|
|
* The number of referenda being decided currently.
|
|
**/
|
|
decidingCount: AugmentedQuery<ApiType, (arg: u16 | AnyNumber | Uint8Array) => Observable<u32>, [u16]> & QueryableStorageEntry<ApiType, [u16]>;
|
|
/**
|
|
* The metadata is a general information concerning the referendum.
|
|
* The `Hash` refers to the preimage of the `Preimages` provider which can be a JSON
|
|
* dump or IPFS hash of a JSON file.
|
|
*
|
|
* Consider a garbage collection for a metadata of finished referendums to `unrequest` (remove)
|
|
* large preimages.
|
|
**/
|
|
metadataOf: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<H256>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* The next free referendum index, aka the number of referenda started so far.
|
|
**/
|
|
referendumCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Information concerning any given referendum.
|
|
**/
|
|
referendumInfoFor: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PezpalletReferendaReferendumInfo>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* The sorted list of referenda ready to be decided but not yet being decided, ordered by
|
|
* conviction-weighted approvals.
|
|
*
|
|
* This should be empty if `DecidingCount` is less than `TrackInfo::max_deciding`.
|
|
**/
|
|
trackQueue: AugmentedQuery<ApiType, (arg: u16 | AnyNumber | Uint8Array) => Observable<Vec<ITuple<[u32, u128]>>>, [u16]> & QueryableStorageEntry<ApiType, [u16]>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
registrar: {
|
|
/**
|
|
* The next free `ParaId`.
|
|
**/
|
|
nextFreeParaId: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Amount held on deposit for each para and the original depositor.
|
|
*
|
|
* The given account ID is responsible for registering the code and initial head data, but may
|
|
* only do so if it isn't yet registered. (After that, it's up to governance to do so.)
|
|
**/
|
|
paras: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PezkuwiRuntimeCommonParasRegistrarParaInfo>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* Pending swap operations.
|
|
**/
|
|
pendingSwap: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
scheduler: {
|
|
/**
|
|
* Items to be executed, indexed by the block number that they should be executed on.
|
|
**/
|
|
agenda: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Vec<Option<PezpalletSchedulerScheduled>>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* Block number at which the agenda began incomplete execution.
|
|
**/
|
|
incompleteSince: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Lookup from a name to the block number and index of the task.
|
|
*
|
|
* For v3 -> v4 the previously unbounded identities are Blake2-256 hashed to form the v4
|
|
* identities.
|
|
**/
|
|
lookup: AugmentedQuery<ApiType, (arg: U8aFixed | string | Uint8Array) => Observable<Option<ITuple<[u32, u32]>>>, [U8aFixed]> & QueryableStorageEntry<ApiType, [U8aFixed]>;
|
|
/**
|
|
* Retry configurations for items to be executed, indexed by task address.
|
|
**/
|
|
retries: AugmentedQuery<ApiType, (arg: ITuple<[u32, u32]> | [u32 | AnyNumber | Uint8Array, u32 | AnyNumber | Uint8Array]) => Observable<Option<PezpalletSchedulerRetryConfig>>, [ITuple<[u32, u32]>]> & QueryableStorageEntry<ApiType, [ITuple<[u32, u32]>]>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
session: {
|
|
/**
|
|
* Current index of the session.
|
|
**/
|
|
currentIndex: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Indices of disabled validators.
|
|
*
|
|
* The vec is always kept sorted so that we can find whether a given validator is
|
|
* disabled using binary search. It gets cleared when `on_session_ending` returns
|
|
* a new set of identities.
|
|
**/
|
|
disabledValidators: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[u32, u32]>>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The owner of a key. The key is the `KeyTypeId` + the encoded key.
|
|
**/
|
|
keyOwner: AugmentedQuery<ApiType, (arg: ITuple<[PezspCoreCryptoKeyTypeId, Bytes]> | [PezspCoreCryptoKeyTypeId | string | Uint8Array, Bytes | string | Uint8Array]) => Observable<Option<PezspCoreCryptoAccountId32>>, [ITuple<[PezspCoreCryptoKeyTypeId, Bytes]>]> & QueryableStorageEntry<ApiType, [ITuple<[PezspCoreCryptoKeyTypeId, Bytes]>]>;
|
|
/**
|
|
* The next session keys for a validator.
|
|
**/
|
|
nextKeys: AugmentedQuery<ApiType, (arg: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<Option<PezkuwiRuntimeSessionKeys>>, [PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* True if the underlying economic identities or weighting behind the validators
|
|
* has changed in the queued validator set.
|
|
**/
|
|
queuedChanged: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The queued keys for the next session. When the next session begins, these keys
|
|
* will be used to determine the validator's session keys.
|
|
**/
|
|
queuedKeys: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[PezspCoreCryptoAccountId32, PezkuwiRuntimeSessionKeys]>>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The current set of validators.
|
|
**/
|
|
validators: AugmentedQuery<ApiType, () => Observable<Vec<PezspCoreCryptoAccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
slots: {
|
|
/**
|
|
* Amounts held on deposit for each (possibly future) leased parachain.
|
|
*
|
|
* The actual amount locked on its behalf by any account at any time is the maximum of the
|
|
* second values of the items in this list whose first value is the account.
|
|
*
|
|
* The first item in the list is the amount locked for the current Lease Period. Following
|
|
* items are for the subsequent lease periods.
|
|
*
|
|
* The default value (an empty list) implies that the parachain no longer exists (or never
|
|
* existed) as far as this pallet is concerned.
|
|
*
|
|
* If a parachain doesn't exist *yet* but is scheduled to exist in the future, then it
|
|
* will be left-padded with one or more `None`s to denote the fact that nothing is held on
|
|
* deposit for the non-existent chain currently, but is held at some point in the future.
|
|
*
|
|
* It is illegal for a `None` value to trail in the list.
|
|
**/
|
|
leases: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Vec<Option<ITuple<[PezspCoreCryptoAccountId32, u128]>>>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
staking: {
|
|
/**
|
|
* The active era information, it holds index and start.
|
|
*
|
|
* The active era is the era being currently rewarded. Validator set of this era must be
|
|
* equal to [`SessionInterface::validators`].
|
|
**/
|
|
activeEra: AugmentedQuery<ApiType, () => Observable<Option<PezpalletStakingActiveEraInfo>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Map from all locked "stash" accounts to the controller account.
|
|
*
|
|
* TWOX-NOTE: SAFE since `AccountId` is a secure hash.
|
|
**/
|
|
bonded: AugmentedQuery<ApiType, (arg: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<Option<PezspCoreCryptoAccountId32>>, [PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* A mapping from still-bonded eras to the first session index of that era.
|
|
*
|
|
* Must contains information for eras for the range:
|
|
* `[active_era - bounding_duration; active_era]`
|
|
**/
|
|
bondedEras: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[u32, u32]>>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The amount of currency given to reporters of a slash event which was
|
|
* canceled by extraordinary circumstances (e.g. governance).
|
|
**/
|
|
canceledSlashPayout: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The threshold for when users can start calling `chill_other` for other validators /
|
|
* nominators. The threshold is compared to the actual number of validators / nominators
|
|
* (`CountFor*`) in the system compared to the configured max (`Max*Count`).
|
|
**/
|
|
chillThreshold: AugmentedQuery<ApiType, () => Observable<Option<u8>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* History of claimed paged rewards by era and validator.
|
|
*
|
|
* This is keyed by era and validator stash which maps to the set of page indexes which have
|
|
* been claimed.
|
|
*
|
|
* It is removed after [`Config::HistoryDepth`] eras.
|
|
**/
|
|
claimedRewards: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<Vec<u32>>, [u32, PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [u32, PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* Counter for the related counted storage map
|
|
**/
|
|
counterForNominators: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Counter for the related counted storage map
|
|
**/
|
|
counterForValidators: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Counter for the related counted storage map
|
|
**/
|
|
counterForVirtualStakers: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The current era index.
|
|
*
|
|
* This is the latest planned era, depending on how the Session pallet queues the validator
|
|
* set, it might be active or not.
|
|
**/
|
|
currentEra: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The last planned session scheduled by the session pallet.
|
|
*
|
|
* This is basically in sync with the call to [`pallet_session::SessionManager::new_session`].
|
|
**/
|
|
currentPlannedSession: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Rewards for the last [`Config::HistoryDepth`] eras.
|
|
* If reward hasn't been set or has been removed then 0 reward is returned.
|
|
**/
|
|
erasRewardPoints: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<PezpalletStakingEraRewardPoints>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* Exposure of validator at era.
|
|
*
|
|
* This is keyed first by the era index to allow bulk deletion and then the stash account.
|
|
*
|
|
* Is it removed after [`Config::HistoryDepth`] eras.
|
|
* If stakers hasn't been set or has been removed then empty exposure is returned.
|
|
*
|
|
* Note: Deprecated since v14. Use `EraInfo` instead to work with exposures.
|
|
**/
|
|
erasStakers: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<PezspStakingExposure>, [u32, PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [u32, PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* Clipped Exposure of validator at era.
|
|
*
|
|
* Note: This is deprecated, should be used as read-only and will be removed in the future.
|
|
* New `Exposure`s are stored in a paged manner in `ErasStakersPaged` instead.
|
|
*
|
|
* This is similar to [`ErasStakers`] but number of nominators exposed is reduced to the
|
|
* `T::MaxExposurePageSize` biggest stakers.
|
|
* (Note: the field `total` and `own` of the exposure remains unchanged).
|
|
* This is used to limit the i/o cost for the nominator payout.
|
|
*
|
|
* This is keyed fist by the era index to allow bulk deletion and then the stash account.
|
|
*
|
|
* It is removed after [`Config::HistoryDepth`] eras.
|
|
* If stakers hasn't been set or has been removed then empty exposure is returned.
|
|
*
|
|
* Note: Deprecated since v14. Use `EraInfo` instead to work with exposures.
|
|
**/
|
|
erasStakersClipped: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<PezspStakingExposure>, [u32, PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [u32, PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* Summary of validator exposure at a given era.
|
|
*
|
|
* This contains the total stake in support of the validator and their own stake. In addition,
|
|
* it can also be used to get the number of nominators backing this validator and the number of
|
|
* exposure pages they are divided into. The page count is useful to determine the number of
|
|
* pages of rewards that needs to be claimed.
|
|
*
|
|
* This is keyed first by the era index to allow bulk deletion and then the stash account.
|
|
* Should only be accessed through `EraInfo`.
|
|
*
|
|
* Is it removed after [`Config::HistoryDepth`] eras.
|
|
* If stakers hasn't been set or has been removed then empty overview is returned.
|
|
**/
|
|
erasStakersOverview: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<Option<PezspStakingPagedExposureMetadata>>, [u32, PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [u32, PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* Paginated exposure of a validator at given era.
|
|
*
|
|
* This is keyed first by the era index to allow bulk deletion, then stash account and finally
|
|
* the page. Should only be accessed through `EraInfo`.
|
|
*
|
|
* This is cleared after [`Config::HistoryDepth`] eras.
|
|
**/
|
|
erasStakersPaged: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PezspCoreCryptoAccountId32 | string | Uint8Array, arg3: u32 | AnyNumber | Uint8Array) => Observable<Option<PezspStakingExposurePage>>, [u32, PezspCoreCryptoAccountId32, u32]> & QueryableStorageEntry<ApiType, [u32, PezspCoreCryptoAccountId32, u32]>;
|
|
/**
|
|
* The session index at which the era start for the last [`Config::HistoryDepth`] eras.
|
|
*
|
|
* Note: This tracks the starting session (i.e. session index when era start being active)
|
|
* for the eras in `[CurrentEra - HISTORY_DEPTH, CurrentEra]`.
|
|
**/
|
|
erasStartSessionIndex: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* The total amount staked for the last [`Config::HistoryDepth`] eras.
|
|
* If total hasn't been set or has been removed then 0 stake is returned.
|
|
**/
|
|
erasTotalStake: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u128>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* Similar to `ErasStakers`, this holds the preferences of validators.
|
|
*
|
|
* This is keyed first by the era index to allow bulk deletion and then the stash account.
|
|
*
|
|
* Is it removed after [`Config::HistoryDepth`] eras.
|
|
**/
|
|
erasValidatorPrefs: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<PezpalletStakingValidatorPrefs>, [u32, PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [u32, PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* The total validator era payout for the last [`Config::HistoryDepth`] eras.
|
|
*
|
|
* Eras that haven't finished yet or has been removed doesn't have reward.
|
|
**/
|
|
erasValidatorReward: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<u128>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* Mode of era forcing.
|
|
**/
|
|
forceEra: AugmentedQuery<ApiType, () => Observable<PezpalletStakingForcing>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Any validators that may never be slashed or forcibly kicked. It's a Vec since they're
|
|
* easy to initialize and the performance hit is minimal (we expect no more than four
|
|
* invulnerables) and restricted to testnets.
|
|
**/
|
|
invulnerables: AugmentedQuery<ApiType, () => Observable<Vec<PezspCoreCryptoAccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Map from all (unlocked) "controller" accounts to the info regarding the staking.
|
|
*
|
|
* Note: All the reads and mutations to this storage *MUST* be done through the methods exposed
|
|
* by [`StakingLedger`] to ensure data and lock consistency.
|
|
**/
|
|
ledger: AugmentedQuery<ApiType, (arg: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<Option<PezpalletStakingStakingLedger>>, [PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* The maximum nominator count before we stop allowing new validators to join.
|
|
*
|
|
* When this value is not set, no limits are enforced.
|
|
**/
|
|
maxNominatorsCount: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Maximum staked rewards, i.e. the percentage of the era inflation that
|
|
* is used for stake rewards.
|
|
* See [Era payout](./index.html#era-payout).
|
|
**/
|
|
maxStakedRewards: AugmentedQuery<ApiType, () => Observable<Option<u8>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The maximum validator count before we stop allowing new validators to join.
|
|
*
|
|
* When this value is not set, no limits are enforced.
|
|
**/
|
|
maxValidatorsCount: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The minimum amount of commission that validators can set.
|
|
*
|
|
* If set to `0`, no limit exists.
|
|
**/
|
|
minCommission: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The minimum active nominator stake of the last successful election.
|
|
**/
|
|
minimumActiveStake: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Minimum number of staking participants before emergency conditions are imposed.
|
|
**/
|
|
minimumValidatorCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The minimum active bond to become and maintain the role of a nominator.
|
|
**/
|
|
minNominatorBond: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The minimum active bond to become and maintain the role of a validator.
|
|
**/
|
|
minValidatorBond: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The map from nominator stash key to their nomination preferences, namely the validators that
|
|
* they wish to support.
|
|
*
|
|
* Note that the keys of this storage map might become non-decodable in case the
|
|
* account's [`NominationsQuota::MaxNominations`] configuration is decreased.
|
|
* In this rare case, these nominators
|
|
* are still existent in storage, their key is correct and retrievable (i.e. `contains_key`
|
|
* indicates that they exist), but their value cannot be decoded. Therefore, the non-decodable
|
|
* nominators will effectively not-exist, until they re-submit their preferences such that it
|
|
* is within the bounds of the newly set `Config::MaxNominations`.
|
|
*
|
|
* This implies that `::iter_keys().count()` and `::iter().count()` might return different
|
|
* values for this map. Moreover, the main `::count()` is aligned with the former, namely the
|
|
* number of keys that exist.
|
|
*
|
|
* Lastly, if any of the nominators become non-decodable, they can be chilled immediately via
|
|
* [`Call::chill_other`] dispatchable by anyone.
|
|
*
|
|
* TWOX-NOTE: SAFE since `AccountId` is a secure hash.
|
|
**/
|
|
nominators: AugmentedQuery<ApiType, (arg: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<Option<PezpalletStakingNominations>>, [PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* All slashing events on nominators, mapped by era to the highest slash value of the era.
|
|
**/
|
|
nominatorSlashInEra: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<Option<u128>>, [u32, PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [u32, PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* Where the reward payment should be made. Keyed by stash.
|
|
*
|
|
* TWOX-NOTE: SAFE since `AccountId` is a secure hash.
|
|
**/
|
|
payee: AugmentedQuery<ApiType, (arg: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<Option<PezpalletStakingRewardDestination>>, [PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* Slashing spans for stash accounts.
|
|
**/
|
|
slashingSpans: AugmentedQuery<ApiType, (arg: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<Option<PezpalletStakingSlashingSlashingSpans>>, [PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* The percentage of the slash that is distributed to reporters.
|
|
*
|
|
* The rest of the slashed value is handled by the `Slash`.
|
|
**/
|
|
slashRewardFraction: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Records information about the maximum slash of a stash within a slashing span,
|
|
* as well as how much reward has been paid out.
|
|
**/
|
|
spanSlash: AugmentedQuery<ApiType, (arg: ITuple<[PezspCoreCryptoAccountId32, u32]> | string | Uint8Array) => Observable<PezpalletStakingSlashingSpanRecord>, [ITuple<[PezspCoreCryptoAccountId32, u32]>]> & QueryableStorageEntry<ApiType, [ITuple<[PezspCoreCryptoAccountId32, u32]>]>;
|
|
/**
|
|
* All unapplied slashes that are queued for later.
|
|
**/
|
|
unappliedSlashes: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Vec<PezpalletStakingUnappliedSlash>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* The ideal number of active validators.
|
|
**/
|
|
validatorCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The map from (wannabe) validator stash key to the preferences of that validator.
|
|
*
|
|
* TWOX-NOTE: SAFE since `AccountId` is a secure hash.
|
|
**/
|
|
validators: AugmentedQuery<ApiType, (arg: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<PezpalletStakingValidatorPrefs>, [PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* All slashing events on validators, mapped by era to the highest slash proportion
|
|
* and slash value of the era.
|
|
**/
|
|
validatorSlashInEra: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<Option<ITuple<[u32, u128]>>>, [u32, PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [u32, PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* Stakers whose funds are managed by other pallets.
|
|
*
|
|
* This pallet does not apply any locks on them, therefore they are only virtually bonded. They
|
|
* are expected to be keyless accounts and hence should not be allowed to mutate their ledger
|
|
* directly via this pallet. Instead, these accounts are managed by other pallets and accessed
|
|
* via low level apis. We keep track of them to do minimal integrity checks.
|
|
**/
|
|
virtualStakers: AugmentedQuery<ApiType, (arg: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<Option<Null>>, [PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
stakingAhClient: {
|
|
/**
|
|
* An incomplete validator set report.
|
|
**/
|
|
incompleteValidatorSetReport: AugmentedQuery<ApiType, () => Observable<Option<PezpalletStakingAsyncRcClientValidatorSetReport>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Indicates the current operating mode of the pallet.
|
|
*
|
|
* This value determines how the pallet behaves in response to incoming and outgoing messages,
|
|
* particularly whether it should execute logic directly, defer it, or delegate it entirely.
|
|
**/
|
|
mode: AugmentedQuery<ApiType, () => Observable<PezpalletStakingAsyncAhClientOperatingMode>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* A storage value that is set when a `new_session` gives a new validator set to the session
|
|
* pallet, and is cleared on the next call.
|
|
*
|
|
* The inner u32 is the id of the said activated validator set. While not relevant here, good
|
|
* to know this is the planning era index of staking-async on AH.
|
|
*
|
|
* Once cleared, we know a validator set has been activated, and therefore we can send a
|
|
* timestamp to AH.
|
|
**/
|
|
nextSessionChangesValidators: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Internal storage item of [`OffenceSendQueue`]. Should not be used manually.
|
|
**/
|
|
offenceSendQueueCursor: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Internal storage item of [`OffenceSendQueue`]. Should not be used manually.
|
|
**/
|
|
offenceSendQueueOffences: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Vec<ITuple<[u32, PezpalletStakingAsyncRcClientOffence]>>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* A session report that is outgoing, and should be sent.
|
|
*
|
|
* This will be attempted to be sent, possibly on every `on_initialize` call, until it is sent,
|
|
* or the second value reaches zero, at which point we drop it.
|
|
**/
|
|
outgoingSessionReport: AugmentedQuery<ApiType, () => Observable<Option<ITuple<[PezpalletStakingAsyncRcClientSessionReport, u32]>>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* All of the points of the validators.
|
|
*
|
|
* This is populated during a session, and is flushed and sent over via [`SendToAssetHub`]
|
|
* at each session end.
|
|
**/
|
|
validatorPoints: AugmentedQuery<ApiType, (arg: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<u32>, [PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* The queued validator sets for a given planning session index.
|
|
*
|
|
* This is received via a call from AssetHub.
|
|
**/
|
|
validatorSet: AugmentedQuery<ApiType, () => Observable<Option<ITuple<[u32, Vec<PezspCoreCryptoAccountId32>]>>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The session index at which the latest elected validator set was applied.
|
|
*
|
|
* This is used to determine if an offence, given a session index, is in the current active era
|
|
* or not.
|
|
**/
|
|
validatorSetAppliedAt: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
stateTrieMigration: {
|
|
/**
|
|
* The limits that are imposed on automatic migrations.
|
|
*
|
|
* If set to None, then no automatic migration happens.
|
|
**/
|
|
autoLimits: AugmentedQuery<ApiType, () => Observable<Option<PezpalletStateTrieMigrationMigrationLimits>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Migration progress.
|
|
*
|
|
* This stores the snapshot of the last migrated keys. It can be set into motion and move
|
|
* forward by any of the means provided by this pallet.
|
|
**/
|
|
migrationProcess: AugmentedQuery<ApiType, () => Observable<PezpalletStateTrieMigrationMigrationTask>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The maximum limits that the signed migration could use.
|
|
*
|
|
* If not set, no signed submission is allowed.
|
|
**/
|
|
signedMigrationMaxLimits: AugmentedQuery<ApiType, () => Observable<Option<PezpalletStateTrieMigrationMigrationLimits>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
system: {
|
|
/**
|
|
* The full account information for a particular account ID.
|
|
**/
|
|
account: AugmentedQuery<ApiType, (arg: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<PezframeSystemAccountInfo>, [PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* Total length (in bytes) for all extrinsics put together, for the current block.
|
|
**/
|
|
allExtrinsicsLen: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* `Some` if a code upgrade has been authorized.
|
|
**/
|
|
authorizedUpgrade: AugmentedQuery<ApiType, () => Observable<Option<PezframeSystemCodeUpgradeAuthorization>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Map of block numbers to block hashes.
|
|
**/
|
|
blockHash: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<H256>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* The current weight for the block.
|
|
**/
|
|
blockWeight: AugmentedQuery<ApiType, () => Observable<PezframeSupportDispatchPerDispatchClassWeight>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Digest of the current block, also part of the block header.
|
|
**/
|
|
digest: AugmentedQuery<ApiType, () => Observable<PezspRuntimeDigest>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The number of events in the `Events<T>` list.
|
|
**/
|
|
eventCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* 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.
|
|
**/
|
|
events: AugmentedQuery<ApiType, () => Observable<Vec<PezframeSystemEventRecord>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Mapping between a topic (represented by T::Hash) and a vector of indexes
|
|
* of events in the `<Events<T>>` list.
|
|
*
|
|
* All topic vectors have deterministic storage locations depending on the topic. This
|
|
* allows light-clients to leverage the changes trie storage tracking mechanism and
|
|
* in case of changes fetch the list of events of interest.
|
|
*
|
|
* The value has the type `(BlockNumberFor<T>, EventIndex)` because if we used only just
|
|
* 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.
|
|
**/
|
|
eventTopics: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Vec<ITuple<[u32, u32]>>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;
|
|
/**
|
|
* The execution phase of the block.
|
|
**/
|
|
executionPhase: AugmentedQuery<ApiType, () => Observable<Option<PezframeSystemPhase>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Total extrinsics count for the current block.
|
|
**/
|
|
extrinsicCount: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Extrinsics data for the current block (maps an extrinsic's index to its data).
|
|
**/
|
|
extrinsicData: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Bytes>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* 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`.
|
|
*
|
|
* Logic doing some post dispatch weight reduction must update this storage to avoid duplicate
|
|
* reduction.
|
|
**/
|
|
extrinsicWeightReclaimed: AugmentedQuery<ApiType, () => Observable<PezspWeightsWeightV2Weight>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Whether all inherents have been applied.
|
|
**/
|
|
inherentsApplied: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Stores the `spec_version` and `spec_name` of when the last runtime upgrade happened.
|
|
**/
|
|
lastRuntimeUpgrade: AugmentedQuery<ApiType, () => Observable<Option<PezframeSystemLastRuntimeUpgradeInfo>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The current block number being processed. Set by `execute_block`.
|
|
**/
|
|
number: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Hash of the previous block.
|
|
**/
|
|
parentHash: AugmentedQuery<ApiType, () => Observable<H256>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* True if we have upgraded so that AccountInfo contains three types of `RefCount`. False
|
|
* (default) if not.
|
|
**/
|
|
upgradedToTripleRefCount: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* True if we have upgraded so that `type RefCount` is `u32`. False (default) if not.
|
|
**/
|
|
upgradedToU32RefCount: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
timestamp: {
|
|
/**
|
|
* Whether the timestamp has been updated in this block.
|
|
*
|
|
* This value is updated to `true` upon successful submission of a timestamp by a node.
|
|
* It is then checked at the end of each block execution in the `on_finalize` hook.
|
|
**/
|
|
didUpdate: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The current time for the current block.
|
|
**/
|
|
now: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
transactionPayment: {
|
|
nextFeeMultiplier: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
|
|
storageVersion: AugmentedQuery<ApiType, () => Observable<PezpalletTransactionPaymentReleases>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
treasury: {
|
|
/**
|
|
* DEPRECATED: associated with `spend_local` call and will be removed in May 2025.
|
|
* Refer to <https://github.com/paritytech/polkadot-sdk/pull/5961> for migration to `spend`.
|
|
*
|
|
* Proposal indices that have been approved but not yet awarded.
|
|
**/
|
|
approvals: AugmentedQuery<ApiType, () => Observable<Vec<u32>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The amount which has been reported as inactive to Currency.
|
|
**/
|
|
deactivated: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The blocknumber for the last triggered spend period.
|
|
**/
|
|
lastSpendPeriod: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* DEPRECATED: associated with `spend_local` call and will be removed in May 2025.
|
|
* Refer to <https://github.com/paritytech/polkadot-sdk/pull/5961> for migration to `spend`.
|
|
*
|
|
* Number of proposals that have been made.
|
|
**/
|
|
proposalCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* DEPRECATED: associated with `spend_local` call and will be removed in May 2025.
|
|
* Refer to <https://github.com/paritytech/polkadot-sdk/pull/5961> for migration to `spend`.
|
|
*
|
|
* Proposals that have been made.
|
|
**/
|
|
proposals: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PezpalletTreasuryProposal>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* The count of spends that have been made.
|
|
**/
|
|
spendCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Spends that have been approved and being processed.
|
|
**/
|
|
spends: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PezpalletTreasurySpendStatus>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
vesting: {
|
|
/**
|
|
* Storage version of the pallet.
|
|
*
|
|
* New networks start with latest version, as determined by the genesis build.
|
|
**/
|
|
storageVersion: AugmentedQuery<ApiType, () => Observable<PezpalletVestingReleases>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Information regarding the vesting of a given account.
|
|
**/
|
|
vesting: AugmentedQuery<ApiType, (arg: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<Option<Vec<PezpalletVestingVestingInfo>>>, [PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
voterList: {
|
|
/**
|
|
* Counter for the related counted storage map
|
|
**/
|
|
counterForListNodes: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* A bag stored in storage.
|
|
*
|
|
* Stores a `Bag` struct, which stores head and tail pointers to itself.
|
|
**/
|
|
listBags: AugmentedQuery<ApiType, (arg: u64 | AnyNumber | Uint8Array) => Observable<Option<PezpalletBagsListListBag>>, [u64]> & QueryableStorageEntry<ApiType, [u64]>;
|
|
/**
|
|
* A single node, within some bag.
|
|
*
|
|
* Nodes store links forward and back within their respective bags.
|
|
**/
|
|
listNodes: AugmentedQuery<ApiType, (arg: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<Option<PezpalletBagsListListNode>>, [PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* Lock all updates to this pallet.
|
|
*
|
|
* If any nodes needs updating, removal or addition due to a temporary lock, the
|
|
* [`Call::rebag`] can be used.
|
|
**/
|
|
lock: AugmentedQuery<ApiType, () => Observable<Option<Null>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Pointer that remembers the next node that will be auto-rebagged.
|
|
* When `None`, the next scan will start from the list head again.
|
|
**/
|
|
nextNodeAutoRebagged: AugmentedQuery<ApiType, () => Observable<Option<PezspCoreCryptoAccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
whitelist: {
|
|
whitelistedCall: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Option<Null>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
xcmPallet: {
|
|
/**
|
|
* The existing asset traps.
|
|
*
|
|
* Key is the blake2 256 hash of (origin, versioned `Assets`) pair. Value is the number of
|
|
* times this pair has been trapped (usually just 1 if it exists at all).
|
|
**/
|
|
assetTraps: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<u32>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;
|
|
/**
|
|
* Map of authorized aliasers of local origins. Each local location can authorize a list of
|
|
* other locations to alias into it. Each aliaser is only valid until its inner `expiry`
|
|
* block number.
|
|
**/
|
|
authorizedAliases: AugmentedQuery<ApiType, (arg: XcmVersionedLocation | { V3: any } | { V4: any } | { V5: any } | string | Uint8Array) => Observable<Option<PezpalletXcmAuthorizedAliasesEntry>>, [XcmVersionedLocation]> & QueryableStorageEntry<ApiType, [XcmVersionedLocation]>;
|
|
/**
|
|
* The current migration's stage, if any.
|
|
**/
|
|
currentMigration: AugmentedQuery<ApiType, () => Observable<Option<PezpalletXcmVersionMigrationStage>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Fungible assets which we know are locked on this chain.
|
|
**/
|
|
lockedFungibles: AugmentedQuery<ApiType, (arg: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<Option<Vec<ITuple<[u128, XcmVersionedLocation]>>>>, [PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* The ongoing queries.
|
|
**/
|
|
queries: AugmentedQuery<ApiType, (arg: u64 | AnyNumber | Uint8Array) => Observable<Option<PezpalletXcmQueryStatus>>, [u64]> & QueryableStorageEntry<ApiType, [u64]>;
|
|
/**
|
|
* The latest available query index.
|
|
**/
|
|
queryCounter: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* If [`ShouldRecordXcm`] is set to true, then the last XCM program executed locally
|
|
* will be stored here.
|
|
* Runtime APIs can fetch the XCM that was executed by accessing this value.
|
|
*
|
|
* Only relevant if this pallet is being used as the [`xcm_executor::traits::RecordXcm`]
|
|
* implementation in the XCM executor configuration.
|
|
**/
|
|
recordedXcm: AugmentedQuery<ApiType, () => Observable<Option<Vec<StagingXcmV5Instruction>>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Fungible assets which we know are locked on a remote chain.
|
|
**/
|
|
remoteLockedFungibles: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PezspCoreCryptoAccountId32 | string | Uint8Array, arg3: XcmVersionedAssetId | { V3: any } | { V4: any } | { V5: any } | string | Uint8Array) => Observable<Option<PezpalletXcmRemoteLockedFungibleRecord>>, [u32, PezspCoreCryptoAccountId32, XcmVersionedAssetId]> & QueryableStorageEntry<ApiType, [u32, PezspCoreCryptoAccountId32, XcmVersionedAssetId]>;
|
|
/**
|
|
* Default version to encode XCM when latest version of destination is unknown. If `None`,
|
|
* then the destinations whose XCM version is unknown are considered unreachable.
|
|
**/
|
|
safeXcmVersion: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Whether or not incoming XCMs (both executed locally and received) should be recorded.
|
|
* Only one XCM program will be recorded at a time.
|
|
* This is meant to be used in runtime APIs, and it's advised it stays false
|
|
* for all other use cases, so as to not degrade regular performance.
|
|
*
|
|
* Only relevant if this pallet is being used as the [`xcm_executor::traits::RecordXcm`]
|
|
* implementation in the XCM executor configuration.
|
|
**/
|
|
shouldRecordXcm: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The Latest versions that we know various locations support.
|
|
**/
|
|
supportedVersion: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: XcmVersionedLocation | { V3: any } | { V4: any } | { V5: any } | string | Uint8Array) => Observable<Option<u32>>, [u32, XcmVersionedLocation]> & QueryableStorageEntry<ApiType, [u32, XcmVersionedLocation]>;
|
|
/**
|
|
* Destinations whose latest XCM version we would like to know. Duplicates not allowed, and
|
|
* the `u32` counter is the number of times that a send to the destination has been attempted,
|
|
* which is used as a prioritization.
|
|
**/
|
|
versionDiscoveryQueue: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[XcmVersionedLocation, u32]>>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* All locations that we have requested version notifications from.
|
|
**/
|
|
versionNotifiers: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: XcmVersionedLocation | { V3: any } | { V4: any } | { V5: any } | string | Uint8Array) => Observable<Option<u64>>, [u32, XcmVersionedLocation]> & QueryableStorageEntry<ApiType, [u32, XcmVersionedLocation]>;
|
|
/**
|
|
* The target locations that are subscribed to our version changes, as well as the most recent
|
|
* of our versions we informed them of.
|
|
**/
|
|
versionNotifyTargets: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: XcmVersionedLocation | { V3: any } | { V4: any } | { V5: any } | string | Uint8Array) => Observable<Option<ITuple<[u64, PezspWeightsWeightV2Weight, u32]>>>, [u32, XcmVersionedLocation]> & QueryableStorageEntry<ApiType, [u32, XcmVersionedLocation]>;
|
|
/**
|
|
* Global suspension state of the XCM executor.
|
|
**/
|
|
xcmExecutionSuspended: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
} // AugmentedQueries
|
|
} // declare module
|