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
2193 lines
129 KiB
TypeScript
2193 lines
129 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, Struct, U8aFixed, Vec, bool, u128, u16, u32, u64, u8 } from '@pezkuwi/types-codec';
|
|
import type { AnyNumber, ITuple } from '@pezkuwi/types-codec/types';
|
|
import type { H160, H256 } from '@pezkuwi/types/interfaces/runtime';
|
|
import type { AssetHubDicleRuntimeRuntimeParametersKey, AssetHubDicleRuntimeRuntimeParametersValue, AssetHubDicleRuntimeSessionKeys, AssetHubDicleRuntimeStakingNposCompactSolution24, BpXcmBridgeHubRouterBridgeState, PezcumulusPezpalletTeyrchainSystemRelayStateSnapshotMessagingStateSnapshot, PezcumulusPezpalletTeyrchainSystemTeyrchainInherentInboundMessageId, PezcumulusPezpalletTeyrchainSystemUnincludedSegmentAncestor, PezcumulusPezpalletTeyrchainSystemUnincludedSegmentSegmentTracker, PezcumulusPezpalletXcmpQueueOutboundChannelDetails, PezcumulusPezpalletXcmpQueueQueueConfigData, PezcumulusPrimitivesCoreAggregateMessageOrigin, PezframeElectionProviderSupportBoundedSupports, PezframeSupportDispatchPerDispatchClassWeight, PezframeSupportTokensMiscIdAmountRuntimeFreezeReason, PezframeSupportTokensMiscIdAmountRuntimeHoldReason, PezframeSystemAccountInfo, PezframeSystemCodeUpgradeAuthorization, PezframeSystemEventRecord, PezframeSystemLastRuntimeUpgradeInfo, PezframeSystemPhase, PezkuwiCorePrimitivesOutboundHrmpMessage, PezkuwiPrimitivesV8AbridgedHostConfiguration, PezkuwiPrimitivesV8PersistedValidationData, PezkuwiPrimitivesV8UpgradeGoAhead, PezkuwiPrimitivesV8UpgradeRestriction, PezkuwiRuntimeCommonClaimsEthereumAddress, PezkuwiRuntimeCommonClaimsStatementKind, PezkuwiRuntimeCommonImplsVersionedLocatableAsset, PezpalletAhMigratorBalancesBefore, PezpalletAhMigratorMigrationStage, PezpalletAssetConversionPoolInfo, PezpalletAssetsApproval, PezpalletAssetsAssetAccount, PezpalletAssetsAssetDetails, PezpalletAssetsAssetMetadata, PezpalletBagsListListBag, PezpalletBagsListListNode, PezpalletBalancesAccountData, PezpalletBalancesBalanceLock, PezpalletBalancesReserveData, PezpalletBountiesBounty, PezpalletChildBountiesChildBounty, PezpalletCollatorSelectionCandidateInfo, PezpalletConvictionVotingVoteVoting, PezpalletDelegatedStakingAgentLedger, PezpalletDelegatedStakingDelegation, PezpalletElectionProviderMultiBlockPhase, PezpalletElectionProviderMultiBlockSignedSubmissionMetadata, PezpalletElectionProviderMultiBlockVerifierImplsPartialBackings, PezpalletElectionProviderMultiBlockVerifierImplsStatus, PezpalletElectionProviderMultiBlockVerifierImplsValidSolution, PezpalletMessageQueueBookState, PezpalletMessageQueuePage, PezpalletMigrationsMigrationCursor, PezpalletMultisigMultisig, PezpalletNftFractionalizationDetails, PezpalletNftsAttributeDeposit, PezpalletNftsAttributeNamespace, PezpalletNftsCollectionConfig, PezpalletNftsCollectionDetails, PezpalletNftsCollectionMetadata, PezpalletNftsItemConfig, PezpalletNftsItemDetails, PezpalletNftsItemMetadata, PezpalletNftsPendingSwap, PezpalletNominationPoolsBondedPoolInner, PezpalletNominationPoolsClaimPermission, PezpalletNominationPoolsPoolMember, PezpalletNominationPoolsRewardPool, PezpalletNominationPoolsSubPools, PezpalletPreimageOldRequestStatus, PezpalletPreimageRequestStatus, PezpalletProxyAnnouncement, PezpalletProxyProxyDefinitionAssetHubDicleRuntimeProxyType, PezpalletRcMigratorAccountsAccount, PezpalletRcMigratorQueuePriority, PezpalletRecoveryActiveRecovery, PezpalletRecoveryRecoveryConfig, PezpalletReferendaReferendumInfoOriginCaller, PezpalletReviveStorageAccountInfo, PezpalletReviveStorageDeletionQueueManager, PezpalletReviveVmCodeInfo, PezpalletSchedulerRetryConfig, PezpalletSchedulerScheduled, PezpalletSocietyBid, PezpalletSocietyCandidacy, PezpalletSocietyGroupParams, PezpalletSocietyIntakeRecord, PezpalletSocietyMemberRecord, PezpalletSocietyPayoutRecord, PezpalletSocietyTally, PezpalletSocietyVote, PezpalletStakingAsyncActiveEraInfo, PezpalletStakingAsyncEraRewardPoints, PezpalletStakingAsyncForcing, PezpalletStakingAsyncLedgerStakingLedger, PezpalletStakingAsyncNominations, PezpalletStakingAsyncPezpalletBoundedExposurePage, PezpalletStakingAsyncPezpalletPruningStep, PezpalletStakingAsyncRcClientSessionReport, PezpalletStakingAsyncRcClientValidatorSetReport, PezpalletStakingAsyncRewardDestination, PezpalletStakingAsyncSlashingOffenceRecord, PezpalletStakingAsyncSnapshotStatus, PezpalletStakingAsyncUnappliedSlash, PezpalletStakingAsyncValidatorPrefs, PezpalletStateTrieMigrationMigrationLimits, PezpalletStateTrieMigrationMigrationTask, PezpalletTransactionPaymentReleases, PezpalletTreasuryProposal, PezpalletTreasurySpendStatus, PezpalletUniquesCollectionDetails, PezpalletUniquesCollectionMetadata, PezpalletUniquesItemDetails, PezpalletUniquesItemMetadata, PezpalletVestingReleases, PezpalletVestingVestingInfo, PezpalletXcmAuthorizedAliasesEntry, PezpalletXcmQueryStatus, PezpalletXcmRemoteLockedFungibleRecord, PezpalletXcmVersionMigrationStage, PezspConsensusAuraSr25519AppSr25519Public, PezspCoreCryptoAccountId32, PezspCoreCryptoKeyTypeId, PezspNposElectionsElectionScore, PezspRuntimeDigest, PezspStakingPagedExposureMetadata, PezspTrieStorageProof, PezspWeightsWeightV2Weight, StagingXcmV5Instruction, StagingXcmV5Location, 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> {
|
|
ahMigrator: {
|
|
/**
|
|
* Helper storage item to store the total balance / total issuance of native token at the start
|
|
* of the migration. Since teleports are disabled during migration, the total issuance will not
|
|
* change for other reason than the migration itself.
|
|
**/
|
|
ahBalancesBefore: AugmentedQuery<ApiType, () => Observable<PezpalletAhMigratorBalancesBefore>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The Asset Hub migration state.
|
|
**/
|
|
ahMigrationStage: AugmentedQuery<ApiType, () => Observable<PezpalletAhMigratorMigrationStage>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The priority of the DMP queue during migration.
|
|
*
|
|
* Controls how the DMP (Downward 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.
|
|
**/
|
|
dmpQueuePriorityConfig: AugmentedQuery<ApiType, () => Observable<PezpalletRcMigratorQueuePriority>, []> & 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, []>;
|
|
/**
|
|
* 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, []>;
|
|
/**
|
|
* RC accounts that failed to migrate when were received on the Asset Hub.
|
|
*
|
|
* This is unlikely to happen, since we dry run the migration, but we keep it for completeness.
|
|
**/
|
|
rcAccounts: AugmentedQuery<ApiType, (arg: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<Option<PezpalletRcMigratorAccountsAccount>>, [PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
ahOps: {
|
|
/**
|
|
* Amount of balance that a contributor made towards a crowdloan.
|
|
*
|
|
* `withdraw_crowdloan_contribution` can be permissionlessly called once the block number
|
|
* passed to unlock the balance for a specific account.
|
|
*
|
|
* The keys are as follows:
|
|
* - Block number after which the balance can be unlocked.
|
|
* - The para_id of the crowdloan.
|
|
* - The account that made the contribution.
|
|
*
|
|
* The value is (fund_pot, balance). The contribution pot is the second key in the
|
|
* `RcCrowdloanContribution` storage.
|
|
**/
|
|
rcCrowdloanContribution: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array, arg3: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<Option<ITuple<[PezspCoreCryptoAccountId32, u128]>>>, [u32, u32, PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [u32, u32, PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* The reserve that was taken to create a crowdloan.
|
|
*
|
|
* This is normally 500 DOT and can be refunded as last step after all
|
|
* `RcCrowdloanContribution`s of this loan have been withdrawn.
|
|
*
|
|
* Keys:
|
|
* - Block number after which this can be unreserved
|
|
* - The para_id of the crowdloan
|
|
* - The account that will have the balance unreserved
|
|
**/
|
|
rcCrowdloanReserve: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array, arg3: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<Option<u128>>, [u32, u32, PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [u32, u32, PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* Amount of balance that was reserved for winning a lease auction.
|
|
*
|
|
* `unreserve_lease_deposit` can be permissionlessly called once the block number passed to
|
|
* unreserve the deposit. It is implicitly called by `withdraw_crowdloan_contribution`.
|
|
*
|
|
* The account here can either be a crowdloan account or a solo bidder. If it is a crowdloan
|
|
* account, then the summed up contributions for it in the contributions map will equate the
|
|
* reserved balance here.
|
|
*
|
|
* The keys are as follows:
|
|
* - Block number after which the deposit can be unreserved.
|
|
* - The para_id of the lease slot.
|
|
* - The account that will have the balance unreserved.
|
|
* - The balance to be unreserved.
|
|
**/
|
|
rcLeaseReserve: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array, arg3: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<Option<u128>>, [u32, u32, PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [u32, u32, PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
assetConversion: {
|
|
/**
|
|
* Stores the `PoolAssetId` that is going to be used for the next lp token.
|
|
* This gets incremented whenever a new lp pool is created.
|
|
**/
|
|
nextPoolAssetId: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Map from `PoolAssetId` to `PoolInfo`. This establishes whether a pool has been officially
|
|
* created rather than people sending tokens directly to a pool's public account.
|
|
**/
|
|
pools: AugmentedQuery<ApiType, (arg: ITuple<[StagingXcmV5Location, StagingXcmV5Location]> | [StagingXcmV5Location | { parents?: any; interior?: any } | string | Uint8Array, StagingXcmV5Location | { parents?: any; interior?: any } | string | Uint8Array]) => Observable<Option<PezpalletAssetConversionPoolInfo>>, [ITuple<[StagingXcmV5Location, StagingXcmV5Location]>]> & QueryableStorageEntry<ApiType, [ITuple<[StagingXcmV5Location, StagingXcmV5Location]>]>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
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>;
|
|
};
|
|
assets: {
|
|
/**
|
|
* The holdings of a specific account for a specific asset.
|
|
**/
|
|
account: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<Option<PezpalletAssetsAssetAccount>>, [u32, PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [u32, PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* Approved balance transfers. First balance is the amount approved for transfer. Second
|
|
* is the amount of `T::Currency` reserved for storing this.
|
|
* First key is the asset ID, second key is the owner and third key is the delegate.
|
|
**/
|
|
approvals: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PezspCoreCryptoAccountId32 | string | Uint8Array, arg3: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<Option<PezpalletAssetsApproval>>, [u32, PezspCoreCryptoAccountId32, PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [u32, PezspCoreCryptoAccountId32, PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* Details of an asset.
|
|
**/
|
|
asset: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PezpalletAssetsAssetDetails>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* Metadata of an asset.
|
|
**/
|
|
metadata: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<{
|
|
readonly deposit: u128;
|
|
readonly name: Bytes;
|
|
readonly symbol: Bytes;
|
|
readonly decimals: u8;
|
|
readonly isFrozen: bool;
|
|
} & Struct>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* The asset ID enforced for the next asset creation, if any present. Otherwise, this storage
|
|
* item has no effect.
|
|
*
|
|
* This can be useful for setting up constraints for IDs of the new assets. For example, by
|
|
* providing an initial [`NextAssetId`] and using the [`crate::AutoIncAssetId`] callback, an
|
|
* auto-increment model can be applied to all new asset IDs.
|
|
*
|
|
* The initial next asset ID can be set using the [`GenesisConfig`] or the
|
|
* [SetNextAssetId](`migration::next_asset_id::SetNextAssetId`) migration.
|
|
**/
|
|
nextAssetId: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
aura: {
|
|
/**
|
|
* The current authority set.
|
|
**/
|
|
authorities: AugmentedQuery<ApiType, () => Observable<Vec<PezspConsensusAuraSr25519AppSr25519Public>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The current slot of this block.
|
|
*
|
|
* This will be set in `on_initialize`.
|
|
**/
|
|
currentSlot: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
auraExt: {
|
|
/**
|
|
* Serves as cache for the authorities.
|
|
*
|
|
* The authorities in AuRa are overwritten in `on_initialize` when we switch to a new session,
|
|
* but we require the old authorities to verify the seal when validating a PoV. This will
|
|
* always be updated to the latest AuRa authorities in `on_finalize`.
|
|
**/
|
|
authorities: AugmentedQuery<ApiType, () => Observable<Vec<PezspConsensusAuraSr25519AppSr25519Public>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Current relay chain slot paired with a number of authored blocks.
|
|
*
|
|
* This is updated in [`FixedVelocityConsensusHook::on_state_proof`] with the current relay
|
|
* chain slot as provided by the relay chain state proof.
|
|
**/
|
|
relaySlotInfo: AugmentedQuery<ApiType, () => Observable<Option<ITuple<[u64, u32]>>>, []> & 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>;
|
|
};
|
|
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>;
|
|
};
|
|
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>;
|
|
};
|
|
collatorSelection: {
|
|
/**
|
|
* Fixed amount to deposit to become a collator.
|
|
*
|
|
* When a collator calls `leave_intent` they immediately receive the deposit back.
|
|
**/
|
|
candidacyBond: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The (community, limited) collation candidates. `Candidates` and `Invulnerables` should be
|
|
* mutually exclusive.
|
|
*
|
|
* This list is sorted in ascending order by deposit and when the deposits are equal, the least
|
|
* recently updated is considered greater.
|
|
**/
|
|
candidateList: AugmentedQuery<ApiType, () => Observable<Vec<PezpalletCollatorSelectionCandidateInfo>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Desired number of candidates.
|
|
*
|
|
* This should ideally always be less than [`Config::MaxCandidates`] for weights to be correct.
|
|
**/
|
|
desiredCandidates: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The invulnerable, permissioned collators. This list must be sorted.
|
|
**/
|
|
invulnerables: AugmentedQuery<ApiType, () => Observable<Vec<PezspCoreCryptoAccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Last block authored by collator.
|
|
**/
|
|
lastAuthoredBlock: AugmentedQuery<ApiType, (arg: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<u32>, [PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* 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>;
|
|
};
|
|
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>;
|
|
};
|
|
foreignAssets: {
|
|
/**
|
|
* The holdings of a specific account for a specific asset.
|
|
**/
|
|
account: AugmentedQuery<ApiType, (arg1: StagingXcmV5Location | { parents?: any; interior?: any } | string | Uint8Array, arg2: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<Option<PezpalletAssetsAssetAccount>>, [StagingXcmV5Location, PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [StagingXcmV5Location, PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* Approved balance transfers. First balance is the amount approved for transfer. Second
|
|
* is the amount of `T::Currency` reserved for storing this.
|
|
* First key is the asset ID, second key is the owner and third key is the delegate.
|
|
**/
|
|
approvals: AugmentedQuery<ApiType, (arg1: StagingXcmV5Location | { parents?: any; interior?: any } | string | Uint8Array, arg2: PezspCoreCryptoAccountId32 | string | Uint8Array, arg3: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<Option<PezpalletAssetsApproval>>, [StagingXcmV5Location, PezspCoreCryptoAccountId32, PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [StagingXcmV5Location, PezspCoreCryptoAccountId32, PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* Details of an asset.
|
|
**/
|
|
asset: AugmentedQuery<ApiType, (arg: StagingXcmV5Location | { parents?: any; interior?: any } | string | Uint8Array) => Observable<Option<PezpalletAssetsAssetDetails>>, [StagingXcmV5Location]> & QueryableStorageEntry<ApiType, [StagingXcmV5Location]>;
|
|
/**
|
|
* Metadata of an asset.
|
|
**/
|
|
metadata: AugmentedQuery<ApiType, (arg: StagingXcmV5Location | { parents?: any; interior?: any } | string | Uint8Array) => Observable<{
|
|
readonly deposit: u128;
|
|
readonly name: Bytes;
|
|
readonly symbol: Bytes;
|
|
readonly decimals: u8;
|
|
readonly isFrozen: bool;
|
|
} & Struct>, [StagingXcmV5Location]> & QueryableStorageEntry<ApiType, [StagingXcmV5Location]>;
|
|
/**
|
|
* The asset ID enforced for the next asset creation, if any present. Otherwise, this storage
|
|
* item has no effect.
|
|
*
|
|
* This can be useful for setting up constraints for IDs of the new assets. For example, by
|
|
* providing an initial [`NextAssetId`] and using the [`crate::AutoIncAssetId`] callback, an
|
|
* auto-increment model can be applied to all new asset IDs.
|
|
*
|
|
* The initial next asset ID can be set using the [`GenesisConfig`] or the
|
|
* [SetNextAssetId](`migration::next_asset_id::SetNextAssetId`) migration.
|
|
**/
|
|
nextAssetId: AugmentedQuery<ApiType, () => Observable<Option<StagingXcmV5Location>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* 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>;
|
|
};
|
|
messageQueue: {
|
|
/**
|
|
* The index of the first and last (non-empty) pages.
|
|
**/
|
|
bookStateFor: AugmentedQuery<ApiType, (arg: PezcumulusPrimitivesCoreAggregateMessageOrigin | { Here: any } | { Parent: any } | { Sibling: any } | string | Uint8Array) => Observable<PezpalletMessageQueueBookState>, [PezcumulusPrimitivesCoreAggregateMessageOrigin]> & QueryableStorageEntry<ApiType, [PezcumulusPrimitivesCoreAggregateMessageOrigin]>;
|
|
/**
|
|
* The map of page indices to pages.
|
|
**/
|
|
pages: AugmentedQuery<ApiType, (arg1: PezcumulusPrimitivesCoreAggregateMessageOrigin | { Here: any } | { Parent: any } | { Sibling: any } | string | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<PezpalletMessageQueuePage>>, [PezcumulusPrimitivesCoreAggregateMessageOrigin, u32]> & QueryableStorageEntry<ApiType, [PezcumulusPrimitivesCoreAggregateMessageOrigin, u32]>;
|
|
/**
|
|
* The origin at which we should begin servicing.
|
|
**/
|
|
serviceHead: AugmentedQuery<ApiType, () => Observable<Option<PezcumulusPrimitivesCoreAggregateMessageOrigin>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
multiBlockElection: {
|
|
/**
|
|
* Current phase.
|
|
**/
|
|
currentPhase: AugmentedQuery<ApiType, () => Observable<PezpalletElectionProviderMultiBlockPhase>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Desired number of targets to elect for this round.
|
|
**/
|
|
desiredTargets: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* Paginated target snapshot.
|
|
*
|
|
* For the time being, since we assume one pages of targets, at most ONE key will exist.
|
|
**/
|
|
pagedTargetSnapshot: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<Vec<PezspCoreCryptoAccountId32>>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;
|
|
/**
|
|
* Same as [`PagedTargetSnapshot`], but it will store the hash of the snapshot.
|
|
*
|
|
* The hash is generated using [`frame_system::Config::Hashing`].
|
|
**/
|
|
pagedTargetSnapshotHash: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<H256>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;
|
|
/**
|
|
* Paginated voter snapshot. At most [`T::Pages`] keys will exist.
|
|
**/
|
|
pagedVoterSnapshot: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<Vec<ITuple<[PezspCoreCryptoAccountId32, u64, Vec<PezspCoreCryptoAccountId32>]>>>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;
|
|
/**
|
|
* Same as [`PagedVoterSnapshot`], but it will store the hash of the snapshot.
|
|
*
|
|
* The hash is generated using [`frame_system::Config::Hashing`].
|
|
**/
|
|
pagedVoterSnapshotHash: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<H256>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;
|
|
/**
|
|
* 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, []>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
multiBlockElectionSigned: {
|
|
/**
|
|
* Accounts whitelisted by governance to always submit their solutions.
|
|
*
|
|
* They are different in that:
|
|
*
|
|
* * They always pay a fixed deposit for submission, specified by
|
|
* [`Config::InvulnerableDeposit`]. They pay no page deposit.
|
|
* * If _ejected_ by better solution from [`SortedScores`], they will get their full deposit
|
|
* back.
|
|
* * They always get their tx-fee back even if they are _discarded_.
|
|
**/
|
|
invulnerables: AugmentedQuery<ApiType, () => Observable<Vec<PezspCoreCryptoAccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
sortedScores: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Vec<ITuple<[PezspCoreCryptoAccountId32, PezspNposElectionsElectionScore]>>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* Map from account to the metadata of their submission.
|
|
*
|
|
* invariant: for any Key1 of type `AccountId` in [`Submissions`], this storage map also has a
|
|
* value.
|
|
**/
|
|
submissionMetadataStorage: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<Option<PezpalletElectionProviderMultiBlockSignedSubmissionMetadata>>, [u32, PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [u32, PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* Triple map from (round, account, page) to a solution page.
|
|
**/
|
|
submissionStorage: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PezspCoreCryptoAccountId32 | string | Uint8Array, arg3: u32 | AnyNumber | Uint8Array) => Observable<Option<AssetHubDicleRuntimeStakingNposCompactSolution24>>, [u32, PezspCoreCryptoAccountId32, u32]> & QueryableStorageEntry<ApiType, [u32, PezspCoreCryptoAccountId32, u32]>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
multiBlockElectionVerifier: {
|
|
/**
|
|
* The minimum score that each solution must attain in order to be considered feasible.
|
|
**/
|
|
minimumScore: AugmentedQuery<ApiType, () => Observable<Option<PezspNposElectionsElectionScore>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The `(amount, count)` of backings, divided per page.
|
|
*
|
|
* This is stored because in the last block of verification we need them to compute the score,
|
|
* and check `MaxBackersPerWinnerFinal`.
|
|
*
|
|
* This can only ever live for the invalid variant of the solution. Once it is valid, we don't
|
|
* need this information anymore; the score is already computed once in
|
|
* [`QueuedSolutionScore`], and the backing counts are checked.
|
|
**/
|
|
queuedSolutionBackings: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<Vec<ITuple<[PezspCoreCryptoAccountId32, PezpalletElectionProviderMultiBlockVerifierImplsPartialBackings]>>>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;
|
|
/**
|
|
* The score of the valid variant of [`QueuedSolution`].
|
|
*
|
|
* This only ever lives for the `valid` variant.
|
|
**/
|
|
queuedSolutionScore: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PezspNposElectionsElectionScore>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* The `X` variant of the current queued solution. Might be the valid one or not.
|
|
*
|
|
* The two variants of this storage item is to avoid the need of copying. Recall that once a
|
|
* `VerifyingSolution` is being processed, it needs to write its partial supports *somewhere*.
|
|
* Writing theses supports on top of a *good* queued supports is wrong, since we might bail.
|
|
* Writing them to a bugger and copying at the ned is slightly better, but expensive. This flag
|
|
* system is best of both worlds.
|
|
**/
|
|
queuedSolutionX: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<PezframeElectionProviderSupportBoundedSupports>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;
|
|
/**
|
|
* The `Y` variant of the current queued solution. Might be the valid one or not.
|
|
**/
|
|
queuedSolutionY: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<PezframeElectionProviderSupportBoundedSupports>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;
|
|
/**
|
|
* Pointer to the variant of [`QueuedSolutionX`] or [`QueuedSolutionY`] that is currently
|
|
* valid.
|
|
**/
|
|
queuedValidVariant: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<PezpalletElectionProviderMultiBlockVerifierImplsValidSolution>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* Storage item for [`Status`].
|
|
**/
|
|
statusStorage: AugmentedQuery<ApiType, () => Observable<PezpalletElectionProviderMultiBlockVerifierImplsStatus>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
multiBlockMigrations: {
|
|
/**
|
|
* The currently active migration to run and its cursor.
|
|
*
|
|
* `None` indicates that no migration is running.
|
|
**/
|
|
cursor: AugmentedQuery<ApiType, () => Observable<Option<PezpalletMigrationsMigrationCursor>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Set of all successfully executed migrations.
|
|
*
|
|
* This is used as blacklist, to not re-execute migrations that have not been removed from the
|
|
* codebase yet. Governance can regularly clear this out via `clear_historic`.
|
|
**/
|
|
historic: AugmentedQuery<ApiType, (arg: Bytes | string | Uint8Array) => Observable<Option<Null>>, [Bytes]> & QueryableStorageEntry<ApiType, [Bytes]>;
|
|
/**
|
|
* 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>;
|
|
};
|
|
nftFractionalization: {
|
|
/**
|
|
* Keeps track of the corresponding NFT ID, asset ID and amount minted.
|
|
**/
|
|
nftToAsset: AugmentedQuery<ApiType, (arg: ITuple<[u32, u32]> | [u32 | AnyNumber | Uint8Array, u32 | AnyNumber | Uint8Array]) => Observable<Option<PezpalletNftFractionalizationDetails>>, [ITuple<[u32, u32]>]> & QueryableStorageEntry<ApiType, [ITuple<[u32, u32]>]>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
nfts: {
|
|
/**
|
|
* The items held by any given account; set out this way so that items owned by a single
|
|
* account can be enumerated.
|
|
**/
|
|
account: AugmentedQuery<ApiType, (arg1: PezspCoreCryptoAccountId32 | string | Uint8Array, arg2: u32 | AnyNumber | Uint8Array, arg3: u32 | AnyNumber | Uint8Array) => Observable<Option<Null>>, [PezspCoreCryptoAccountId32, u32, u32]> & QueryableStorageEntry<ApiType, [PezspCoreCryptoAccountId32, u32, u32]>;
|
|
/**
|
|
* Attributes of a collection.
|
|
**/
|
|
attribute: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: Option<u32> | null | Uint8Array | u32 | AnyNumber, arg3: PezpalletNftsAttributeNamespace | { Pallet: any } | { CollectionOwner: any } | { ItemOwner: any } | { Account: any } | string | Uint8Array, arg4: Bytes | string | Uint8Array) => Observable<Option<ITuple<[Bytes, PezpalletNftsAttributeDeposit]>>>, [u32, Option<u32>, PezpalletNftsAttributeNamespace, Bytes]> & QueryableStorageEntry<ApiType, [u32, Option<u32>, PezpalletNftsAttributeNamespace, Bytes]>;
|
|
/**
|
|
* Details of a collection.
|
|
**/
|
|
collection: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PezpalletNftsCollectionDetails>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* The collections owned by any given account; set out this way so that collections owned by
|
|
* a single account can be enumerated.
|
|
**/
|
|
collectionAccount: AugmentedQuery<ApiType, (arg1: PezspCoreCryptoAccountId32 | string | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<Null>>, [PezspCoreCryptoAccountId32, u32]> & QueryableStorageEntry<ApiType, [PezspCoreCryptoAccountId32, u32]>;
|
|
/**
|
|
* Config of a collection.
|
|
**/
|
|
collectionConfigOf: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PezpalletNftsCollectionConfig>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* Metadata of a collection.
|
|
**/
|
|
collectionMetadataOf: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PezpalletNftsCollectionMetadata>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* The items in existence and their ownership details.
|
|
* Stores collection roles as per account.
|
|
**/
|
|
collectionRoleOf: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<Option<u8>>, [u32, PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [u32, PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* The items in existence and their ownership details.
|
|
**/
|
|
item: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<PezpalletNftsItemDetails>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;
|
|
/**
|
|
* Item attribute approvals.
|
|
**/
|
|
itemAttributesApprovalsOf: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<BTreeSet<PezspCoreCryptoAccountId32>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;
|
|
/**
|
|
* Config of an item.
|
|
**/
|
|
itemConfigOf: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<PezpalletNftsItemConfig>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;
|
|
/**
|
|
* Metadata of an item.
|
|
**/
|
|
itemMetadataOf: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<PezpalletNftsItemMetadata>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;
|
|
/**
|
|
* A price of an item.
|
|
**/
|
|
itemPriceOf: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<ITuple<[u128, Option<PezspCoreCryptoAccountId32>]>>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;
|
|
/**
|
|
* Stores the `CollectionId` that is going to be used for the next collection.
|
|
* This gets incremented whenever a new collection is created.
|
|
**/
|
|
nextCollectionId: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The collection, if any, of which an account is willing to take ownership.
|
|
**/
|
|
ownershipAcceptance: AugmentedQuery<ApiType, (arg: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<Option<u32>>, [PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* Handles all the pending swaps.
|
|
**/
|
|
pendingSwapOf: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<PezpalletNftsPendingSwap>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;
|
|
/**
|
|
* 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>;
|
|
};
|
|
parachainInfo: {
|
|
parachainId: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
parachainSystem: {
|
|
/**
|
|
* Storage field that keeps track of bandwidth used by the unincluded segment along with the
|
|
* latest HRMP watermark. Used for limiting the acceptance of new blocks with
|
|
* respect to relay chain constraints.
|
|
**/
|
|
aggregatedUnincludedSegment: AugmentedQuery<ApiType, () => Observable<Option<PezcumulusPezpalletTeyrchainSystemUnincludedSegmentSegmentTracker>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The number of HRMP messages we observed in `on_initialize` and thus used that number for
|
|
* announcing the weight of `on_initialize` and `on_finalize`.
|
|
**/
|
|
announcedHrmpMessagesPerCandidate: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* A custom head data that should be returned as result of `validate_block`.
|
|
*
|
|
* See `Pallet::set_custom_validation_head_data` for more information.
|
|
**/
|
|
customValidationHeadData: AugmentedQuery<ApiType, () => Observable<Option<Bytes>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Were the validation data set to notify the relay chain?
|
|
**/
|
|
didSetValidationCode: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The parachain host configuration that was obtained from the relay parent.
|
|
*
|
|
* This field is meant to be updated each block with the validation data inherent. Therefore,
|
|
* before processing of the inherent, e.g. in `on_initialize` this data may be stale.
|
|
*
|
|
* This data is also absent from the genesis.
|
|
**/
|
|
hostConfiguration: AugmentedQuery<ApiType, () => Observable<Option<PezkuwiPrimitivesV8AbridgedHostConfiguration>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* HRMP messages that were sent in a block.
|
|
*
|
|
* This will be cleared in `on_initialize` of each new block.
|
|
**/
|
|
hrmpOutboundMessages: AugmentedQuery<ApiType, () => Observable<Vec<PezkuwiCorePrimitivesOutboundHrmpMessage>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* HRMP watermark that was set in a block.
|
|
**/
|
|
hrmpWatermark: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The last downward message queue chain head we have observed.
|
|
*
|
|
* This value is loaded before and saved after processing inbound downward messages carried
|
|
* by the system inherent.
|
|
**/
|
|
lastDmqMqcHead: AugmentedQuery<ApiType, () => Observable<H256>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The message queue chain heads we have observed per each channel incoming channel.
|
|
*
|
|
* This value is loaded before and saved after processing inbound downward messages carried
|
|
* by the system inherent.
|
|
**/
|
|
lastHrmpMqcHeads: AugmentedQuery<ApiType, () => Observable<BTreeMap<u32, H256>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The last processed downward message.
|
|
*
|
|
* We need to keep track of this to filter the messages that have been already processed.
|
|
**/
|
|
lastProcessedDownwardMessage: AugmentedQuery<ApiType, () => Observable<Option<PezcumulusPezpalletTeyrchainSystemTeyrchainInherentInboundMessageId>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The last processed HRMP message.
|
|
*
|
|
* We need to keep track of this to filter the messages that have been already processed.
|
|
**/
|
|
lastProcessedHrmpMessage: AugmentedQuery<ApiType, () => Observable<Option<PezcumulusPezpalletTeyrchainSystemTeyrchainInherentInboundMessageId>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The relay chain block number associated with the last parachain block.
|
|
*
|
|
* This is updated in `on_finalize`.
|
|
**/
|
|
lastRelayChainBlockNumber: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Validation code that is set by the parachain and is to be communicated to collator and
|
|
* consequently the relay-chain.
|
|
*
|
|
* This will be cleared in `on_initialize` of each new block if no other pallet already set
|
|
* the value.
|
|
**/
|
|
newValidationCode: AugmentedQuery<ApiType, () => Observable<Option<Bytes>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Upward messages that are still pending and not yet send to the relay chain.
|
|
**/
|
|
pendingUpwardMessages: AugmentedQuery<ApiType, () => Observable<Vec<Bytes>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* In case of a scheduled upgrade, this storage field contains the validation code to be
|
|
* applied.
|
|
*
|
|
* As soon as the relay chain gives us the go-ahead signal, we will overwrite the
|
|
* [`:code`][sp_core::storage::well_known_keys::CODE] which will result the next block process
|
|
* with the new validation code. This concludes the upgrade process.
|
|
**/
|
|
pendingValidationCode: AugmentedQuery<ApiType, () => Observable<Bytes>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Number of downward messages processed in a block.
|
|
*
|
|
* This will be cleared in `on_initialize` of each new block.
|
|
**/
|
|
processedDownwardMessages: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The state proof for the last relay parent block.
|
|
*
|
|
* This field is meant to be updated each block with the validation data inherent. Therefore,
|
|
* before processing of the inherent, e.g. in `on_initialize` this data may be stale.
|
|
*
|
|
* This data is also absent from the genesis.
|
|
**/
|
|
relayStateProof: AugmentedQuery<ApiType, () => Observable<Option<PezspTrieStorageProof>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The snapshot of some state related to messaging relevant to the current parachain as per
|
|
* the relay parent.
|
|
*
|
|
* This field is meant to be updated each block with the validation data inherent. Therefore,
|
|
* before processing of the inherent, e.g. in `on_initialize` this data may be stale.
|
|
*
|
|
* This data is also absent from the genesis.
|
|
**/
|
|
relevantMessagingState: AugmentedQuery<ApiType, () => Observable<Option<PezcumulusPezpalletTeyrchainSystemRelayStateSnapshotMessagingStateSnapshot>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The weight we reserve at the beginning of the block for processing DMP messages. This
|
|
* overrides the amount set in the Config trait.
|
|
**/
|
|
reservedDmpWeightOverride: AugmentedQuery<ApiType, () => Observable<Option<PezspWeightsWeightV2Weight>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The weight we reserve at the beginning of the block for processing XCMP messages. This
|
|
* overrides the amount set in the Config trait.
|
|
**/
|
|
reservedXcmpWeightOverride: AugmentedQuery<ApiType, () => Observable<Option<PezspWeightsWeightV2Weight>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Latest included block descendants the runtime accepted. In other words, these are
|
|
* ancestors of the currently executing block which have not been included in the observed
|
|
* relay-chain state.
|
|
*
|
|
* The segment length is limited by the capacity returned from the [`ConsensusHook`] configured
|
|
* in the pallet.
|
|
**/
|
|
unincludedSegment: AugmentedQuery<ApiType, () => Observable<Vec<PezcumulusPezpalletTeyrchainSystemUnincludedSegmentAncestor>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Optional upgrade go-ahead signal from the relay-chain.
|
|
*
|
|
* This storage item is a mirror of the corresponding value for the current parachain from the
|
|
* relay-chain. This value is ephemeral which means it doesn't hit the storage. This value is
|
|
* set after the inherent.
|
|
**/
|
|
upgradeGoAhead: AugmentedQuery<ApiType, () => Observable<Option<PezkuwiPrimitivesV8UpgradeGoAhead>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* An option which indicates if the relay-chain restricts signalling a validation code upgrade.
|
|
* In other words, if this is `Some` and [`NewValidationCode`] is `Some` then the produced
|
|
* candidate will be invalid.
|
|
*
|
|
* This storage item is a mirror of the corresponding value for the current parachain from the
|
|
* relay-chain. This value is ephemeral which means it doesn't hit the storage. This value is
|
|
* set after the inherent.
|
|
**/
|
|
upgradeRestrictionSignal: AugmentedQuery<ApiType, () => Observable<Option<PezkuwiPrimitivesV8UpgradeRestriction>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The factor to multiply the base delivery fee by for UMP.
|
|
**/
|
|
upwardDeliveryFeeFactor: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Upward messages that were sent in a block.
|
|
*
|
|
* This will be cleared in `on_initialize` of each new block.
|
|
**/
|
|
upwardMessages: AugmentedQuery<ApiType, () => Observable<Vec<Bytes>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The [`PersistedValidationData`] set for this block.
|
|
* This value is expected to be set only once per block and it's never stored
|
|
* in the trie.
|
|
**/
|
|
validationData: AugmentedQuery<ApiType, () => Observable<Option<PezkuwiPrimitivesV8PersistedValidationData>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
parameters: {
|
|
/**
|
|
* Stored parameters.
|
|
**/
|
|
parameters: AugmentedQuery<ApiType, (arg: AssetHubDicleRuntimeRuntimeParametersKey | { Issuance: any } | { Treasury: any } | { StakingElection: any } | { Scheduler: any } | { MessageQueue: any } | string | Uint8Array) => Observable<Option<AssetHubDicleRuntimeRuntimeParametersValue>>, [AssetHubDicleRuntimeRuntimeParametersKey]> & QueryableStorageEntry<ApiType, [AssetHubDicleRuntimeRuntimeParametersKey]>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
polkadotXcm: {
|
|
/**
|
|
* 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>;
|
|
};
|
|
poolAssets: {
|
|
/**
|
|
* The holdings of a specific account for a specific asset.
|
|
**/
|
|
account: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<Option<PezpalletAssetsAssetAccount>>, [u32, PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [u32, PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* Approved balance transfers. First balance is the amount approved for transfer. Second
|
|
* is the amount of `T::Currency` reserved for storing this.
|
|
* First key is the asset ID, second key is the owner and third key is the delegate.
|
|
**/
|
|
approvals: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PezspCoreCryptoAccountId32 | string | Uint8Array, arg3: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<Option<PezpalletAssetsApproval>>, [u32, PezspCoreCryptoAccountId32, PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [u32, PezspCoreCryptoAccountId32, PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* Details of an asset.
|
|
**/
|
|
asset: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PezpalletAssetsAssetDetails>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* Metadata of an asset.
|
|
**/
|
|
metadata: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<PezpalletAssetsAssetMetadata>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* The asset ID enforced for the next asset creation, if any present. Otherwise, this storage
|
|
* item has no effect.
|
|
*
|
|
* This can be useful for setting up constraints for IDs of the new assets. For example, by
|
|
* providing an initial [`NextAssetId`] and using the [`crate::AutoIncAssetId`] callback, an
|
|
* auto-increment model can be applied to all new asset IDs.
|
|
*
|
|
* The initial next asset ID can be set using the [`GenesisConfig`] or the
|
|
* [SetNextAssetId](`migration::next_asset_id::SetNextAssetId`) migration.
|
|
**/
|
|
nextAssetId: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* 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<PezpalletProxyProxyDefinitionAssetHubDicleRuntimeProxyType>, u128]>>, [PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
recovery: {
|
|
/**
|
|
* Active recovery attempts.
|
|
*
|
|
* First account is the account to be recovered, and the second account
|
|
* is the user trying to recover the account.
|
|
**/
|
|
activeRecoveries: AugmentedQuery<ApiType, (arg1: PezspCoreCryptoAccountId32 | string | Uint8Array, arg2: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<Option<PezpalletRecoveryActiveRecovery>>, [PezspCoreCryptoAccountId32, PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [PezspCoreCryptoAccountId32, PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* The list of allowed proxy accounts.
|
|
*
|
|
* Map from the user who can access it to the recovered account.
|
|
**/
|
|
proxy: AugmentedQuery<ApiType, (arg: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<Option<PezspCoreCryptoAccountId32>>, [PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* The set of recoverable accounts and their recovery configuration.
|
|
**/
|
|
recoverable: AugmentedQuery<ApiType, (arg: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<Option<PezpalletRecoveryRecoveryConfig>>, [PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* 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<PezpalletReferendaReferendumInfoOriginCaller>>, [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>;
|
|
};
|
|
remoteProxyRelayChain: {
|
|
/**
|
|
* Stores the last [`Config::MaxStorageRootsToKeep`] block to storage root mappings of the
|
|
* target chain.
|
|
**/
|
|
blockToRoot: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[u32, H256]>>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
revive: {
|
|
/**
|
|
* The data associated to a contract or externally owned account.
|
|
**/
|
|
accountInfoOf: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<Option<PezpalletReviveStorageAccountInfo>>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;
|
|
/**
|
|
* A mapping from a contract's code hash to its code info.
|
|
**/
|
|
codeInfoOf: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Option<PezpalletReviveVmCodeInfo>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;
|
|
/**
|
|
* Evicted contracts that await child trie deletion.
|
|
*
|
|
* Child trie deletion is a heavy operation depending on the amount of storage items
|
|
* stored in said trie. Therefore this operation is performed lazily in `on_idle`.
|
|
**/
|
|
deletionQueue: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<Bytes>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* A pair of monotonic counters used to track the latest contract marked for deletion
|
|
* and the latest deleted contract in queue.
|
|
**/
|
|
deletionQueueCounter: AugmentedQuery<ApiType, () => Observable<PezpalletReviveStorageDeletionQueueManager>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The immutable data associated with a given account.
|
|
**/
|
|
immutableDataOf: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<Option<Bytes>>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;
|
|
/**
|
|
* Map a Ethereum address to its original `AccountId32`.
|
|
*
|
|
* When deriving a `H160` from an `AccountId32` we use a hash function. In order to
|
|
* reconstruct the original account we need to store the reverse mapping here.
|
|
* Register your `AccountId32` using [`Pallet::map_account`] in order to
|
|
* use it with this pallet.
|
|
**/
|
|
originalAccount: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<Option<PezspCoreCryptoAccountId32>>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;
|
|
/**
|
|
* A mapping from a contract's code hash to its code.
|
|
**/
|
|
pristineCode: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Option<Bytes>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;
|
|
/**
|
|
* 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<AssetHubDicleRuntimeSessionKeys>>, [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, AssetHubDicleRuntimeSessionKeys]>>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The current set of validators.
|
|
**/
|
|
validators: AugmentedQuery<ApiType, () => Observable<Vec<PezspCoreCryptoAccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
society: {
|
|
/**
|
|
* The current bids, stored ordered by the value of the bid.
|
|
**/
|
|
bids: AugmentedQuery<ApiType, () => Observable<Vec<PezpalletSocietyBid>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
candidates: AugmentedQuery<ApiType, (arg: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<Option<PezpalletSocietyCandidacy>>, [PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* The number of challenge rounds there have been. Used to identify stale DefenderVotes.
|
|
**/
|
|
challengeRoundCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Votes for the defender, keyed by challenge round.
|
|
**/
|
|
defenderVotes: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<Option<PezpalletSocietyVote>>, [u32, PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [u32, PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* The defending member currently being challenged, along with a running tally of votes.
|
|
**/
|
|
defending: AugmentedQuery<ApiType, () => Observable<Option<ITuple<[PezspCoreCryptoAccountId32, PezspCoreCryptoAccountId32, PezpalletSocietyTally]>>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The first member.
|
|
**/
|
|
founder: AugmentedQuery<ApiType, () => Observable<Option<PezspCoreCryptoAccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The most primary from the most recently approved rank 0 members in the society.
|
|
**/
|
|
head: AugmentedQuery<ApiType, () => Observable<Option<PezspCoreCryptoAccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The current items in `Members` keyed by their unique index. Keys are densely populated
|
|
* `0..MemberCount` (does not include `MemberCount`).
|
|
**/
|
|
memberByIndex: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PezspCoreCryptoAccountId32>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* The number of items in `Members` currently. (Doesn't include `SuspendedMembers`.)
|
|
**/
|
|
memberCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The current members and their rank. Doesn't include `SuspendedMembers`.
|
|
**/
|
|
members: AugmentedQuery<ApiType, (arg: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<Option<PezpalletSocietyMemberRecord>>, [PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* Next challenge rotation scheduled with [Config::BlockNumberProvider].
|
|
**/
|
|
nextChallengeAt: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* At the end of the claim period, this contains the most recently approved members (along with
|
|
* their bid and round ID) who is from the most recent round with the lowest bid. They will
|
|
* become the new `Head`.
|
|
**/
|
|
nextHead: AugmentedQuery<ApiType, () => Observable<Option<PezpalletSocietyIntakeRecord>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Next intake rotation scheduled with [Config::BlockNumberProvider].
|
|
**/
|
|
nextIntakeAt: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The max number of members for the society at one time.
|
|
**/
|
|
parameters: AugmentedQuery<ApiType, () => Observable<Option<PezpalletSocietyGroupParams>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Information regarding rank-0 payouts, past and future.
|
|
**/
|
|
payouts: AugmentedQuery<ApiType, (arg: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<PezpalletSocietyPayoutRecord>, [PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* Amount of our account balance that is specifically for the next round's bid(s).
|
|
**/
|
|
pot: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The number of rounds which have passed.
|
|
**/
|
|
roundCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* A hash of the rules of this society concerning membership. Can only be set once and
|
|
* only by the founder.
|
|
**/
|
|
rules: AugmentedQuery<ApiType, () => Observable<Option<H256>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The current skeptic.
|
|
**/
|
|
skeptic: AugmentedQuery<ApiType, () => Observable<Option<PezspCoreCryptoAccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The set of suspended members, with their old membership record.
|
|
**/
|
|
suspendedMembers: AugmentedQuery<ApiType, (arg: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<Option<PezpalletSocietyMemberRecord>>, [PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* Clear-cursor for Vote, map from Candidate -> (Maybe) Cursor.
|
|
**/
|
|
voteClearCursor: AugmentedQuery<ApiType, (arg: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<Option<Bytes>>, [PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* Double map from Candidate -> Voter -> (Maybe) Vote.
|
|
**/
|
|
votes: AugmentedQuery<ApiType, (arg1: PezspCoreCryptoAccountId32 | string | Uint8Array, arg2: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<Option<PezpalletSocietyVote>>, [PezspCoreCryptoAccountId32, PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [PezspCoreCryptoAccountId32, PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* 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 what is RC's session pallet.
|
|
**/
|
|
activeEra: AugmentedQuery<ApiType, () => Observable<Option<PezpalletStakingAsyncActiveEraInfo>>, []> & 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, []>;
|
|
/**
|
|
* Cancelled slashes by era and validator with maximum slash fraction to be cancelled.
|
|
*
|
|
* When slashes are cancelled by governance, this stores the era and the validators
|
|
* whose slashes should be cancelled, along with the maximum slash fraction that should
|
|
* be cancelled for each validator.
|
|
**/
|
|
cancelledSlashes: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Vec<ITuple<[PezspCoreCryptoAccountId32, u32]>>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* 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 planned 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, []>;
|
|
/**
|
|
* A bounded list of the "electable" stashes that resulted from a successful election.
|
|
**/
|
|
electableStashes: AugmentedQuery<ApiType, () => Observable<BTreeSet<PezspCoreCryptoAccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Tracks the current step of era pruning process for each era being lazily pruned.
|
|
**/
|
|
eraPruningState: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PezpalletStakingAsyncPezpalletPruningStep>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* 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<PezpalletStakingAsyncEraRewardPoints>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* 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 `Eras`.
|
|
*
|
|
* 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 `Eras`.
|
|
*
|
|
* This is cleared after [`Config::HistoryDepth`] eras.
|
|
**/
|
|
erasStakersPaged: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PezspCoreCryptoAccountId32 | string | Uint8Array, arg3: u32 | AnyNumber | Uint8Array) => Observable<Option<PezpalletStakingAsyncPezpalletBoundedExposurePage>>, [u32, PezspCoreCryptoAccountId32, u32]> & QueryableStorageEntry<ApiType, [u32, PezspCoreCryptoAccountId32, 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]>;
|
|
/**
|
|
* Exposure of validator at era with 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<PezpalletStakingAsyncValidatorPrefs>, [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<PezpalletStakingAsyncForcing>, []> & 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<PezpalletStakingAsyncLedgerStakingLedger>>, [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, []>;
|
|
/**
|
|
* 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, []>;
|
|
/**
|
|
* Keeps track of an ongoing multi-page election solution request.
|
|
*
|
|
* If `Some(_)``, it is the next page that we intend to elect. If `None`, we are not in the
|
|
* election process.
|
|
*
|
|
* This is only set in multi-block elections. Should always be `None` otherwise.
|
|
**/
|
|
nextElectionPage: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & 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<PezpalletStakingAsyncNominations>>, [PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* Stores reported offences in a queue until they are processed in subsequent blocks.
|
|
*
|
|
* Each offence is recorded under the corresponding era index and the offending validator's
|
|
* account. If an offence spans multiple pages, only one page is processed at a time. Offences
|
|
* are handled sequentially, with their associated slashes computed and stored in
|
|
* `UnappliedSlashes`. These slashes are then applied in a future era as determined by
|
|
* `SlashDeferDuration`.
|
|
*
|
|
* Any offences tied to an era older than `BondingDuration` are automatically dropped.
|
|
* Processing always prioritizes the oldest era first.
|
|
**/
|
|
offenceQueue: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<Option<PezpalletStakingAsyncSlashingOffenceRecord>>, [u32, PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [u32, PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* Tracks the eras that contain offences in `OffenceQueue`, sorted from **earliest to latest**.
|
|
*
|
|
* - This ensures efficient retrieval of the oldest offence without iterating through
|
|
* `OffenceQueue`.
|
|
* - When a new offence is added to `OffenceQueue`, its era is **inserted in sorted order**
|
|
* if not already present.
|
|
* - When all offences for an era are processed, it is **removed** from this list.
|
|
* - The maximum length of this vector is bounded by `BondingDuration`.
|
|
*
|
|
* This eliminates the need for expensive iteration and sorting when fetching the next offence
|
|
* to process.
|
|
**/
|
|
offenceQueueEras: AugmentedQuery<ApiType, () => Observable<Option<Vec<u32>>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* 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<PezpalletStakingAsyncRewardDestination>>, [PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* Tracks the currently processed offence record from the `OffenceQueue`.
|
|
*
|
|
* - When processing offences, an offence record is **popped** from the oldest era in
|
|
* `OffenceQueue` and stored here.
|
|
* - The function `process_offence` reads from this storage, processing one page of exposure at
|
|
* a time.
|
|
* - After processing a page, the `exposure_page` count is **decremented** until it reaches
|
|
* zero.
|
|
* - Once fully processed, the offence record is removed from this storage.
|
|
*
|
|
* This ensures that offences are processed incrementally, preventing excessive computation
|
|
* in a single block while maintaining correct slashing behavior.
|
|
**/
|
|
processingOffence: AugmentedQuery<ApiType, () => Observable<Option<ITuple<[u32, PezspCoreCryptoAccountId32, PezpalletStakingAsyncSlashingOffenceRecord]>>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* 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, []>;
|
|
/**
|
|
* All unapplied slashes that are queued for later.
|
|
**/
|
|
unappliedSlashes: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: ITuple<[PezspCoreCryptoAccountId32, u32, u32]> | string | Uint8Array) => Observable<Option<PezpalletStakingAsyncUnappliedSlash>>, [u32, ITuple<[PezspCoreCryptoAccountId32, u32, u32]>]> & QueryableStorageEntry<ApiType, [u32, ITuple<[PezspCoreCryptoAccountId32, u32, 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<PezpalletStakingAsyncValidatorPrefs>, [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]>;
|
|
/**
|
|
* Voter snapshot progress status.
|
|
*
|
|
* If the status is `Ongoing`, it keeps a cursor of the last voter retrieved to proceed when
|
|
* creating the next snapshot page.
|
|
**/
|
|
voterSnapshotStatus: AugmentedQuery<ApiType, () => Observable<PezpalletStakingAsyncSnapshotStatus>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
stakingRcClient: {
|
|
/**
|
|
* An incomplete incoming session report that we have not acted upon yet.
|
|
**/
|
|
incompleteSessionReport: AugmentedQuery<ApiType, () => Observable<Option<PezpalletStakingAsyncRcClientSessionReport>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The last session report's `end_index` that we have acted upon.
|
|
*
|
|
* This allows this pallet to ensure a sequentially increasing sequence of session reports
|
|
* passed to staking.
|
|
*
|
|
* Note that with the XCM being the backbone of communication, we have a guarantee on the
|
|
* ordering of messages. As long as the RC sends session reports in order, we _eventually_
|
|
* receive them in the same correct order as well.
|
|
**/
|
|
lastSessionReportEndingIndex: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* A validator set 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.
|
|
**/
|
|
outgoingValidatorSet: AugmentedQuery<ApiType, () => Observable<Option<ITuple<[PezpalletStakingAsyncRcClientValidatorSetReport, 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>;
|
|
};
|
|
toPolkadotXcmRouter: {
|
|
/**
|
|
* Bridge that we are using.
|
|
*
|
|
* **bridges-v1** assumptions: all outbound messages through this router are using single lane
|
|
* and to single remote consensus. If there is some other remote consensus that uses the same
|
|
* bridge hub, the separate pallet instance shall be used, In `v2` we'll have all required
|
|
* primitives (lane-id aka bridge-id, derived from XCM locations) to support multiple bridges
|
|
* by the same pallet instance.
|
|
**/
|
|
bridge: AugmentedQuery<ApiType, () => Observable<BpXcmBridgeHubRouterBridgeState>, []> & 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>;
|
|
};
|
|
uniques: {
|
|
/**
|
|
* The items held by any given account; set out this way so that items owned by a single
|
|
* account can be enumerated.
|
|
**/
|
|
account: AugmentedQuery<ApiType, (arg1: PezspCoreCryptoAccountId32 | string | Uint8Array, arg2: u32 | AnyNumber | Uint8Array, arg3: u32 | AnyNumber | Uint8Array) => Observable<Option<Null>>, [PezspCoreCryptoAccountId32, u32, u32]> & QueryableStorageEntry<ApiType, [PezspCoreCryptoAccountId32, u32, u32]>;
|
|
/**
|
|
* The items in existence and their ownership details.
|
|
**/
|
|
asset: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<PezpalletUniquesItemDetails>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;
|
|
/**
|
|
* Attributes of a collection.
|
|
**/
|
|
attribute: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: Option<u32> | null | Uint8Array | u32 | AnyNumber, arg3: Bytes | string | Uint8Array) => Observable<Option<ITuple<[Bytes, u128]>>>, [u32, Option<u32>, Bytes]> & QueryableStorageEntry<ApiType, [u32, Option<u32>, Bytes]>;
|
|
/**
|
|
* Details of a collection.
|
|
**/
|
|
class: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PezpalletUniquesCollectionDetails>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* The collections owned by any given account; set out this way so that collections owned by
|
|
* a single account can be enumerated.
|
|
**/
|
|
classAccount: AugmentedQuery<ApiType, (arg1: PezspCoreCryptoAccountId32 | string | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<Null>>, [PezspCoreCryptoAccountId32, u32]> & QueryableStorageEntry<ApiType, [PezspCoreCryptoAccountId32, u32]>;
|
|
/**
|
|
* Metadata of a collection.
|
|
**/
|
|
classMetadataOf: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PezpalletUniquesCollectionMetadata>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* Keeps track of the number of items a collection might have.
|
|
**/
|
|
collectionMaxSupply: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* Metadata of an item.
|
|
**/
|
|
instanceMetadataOf: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<PezpalletUniquesItemMetadata>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;
|
|
/**
|
|
* Price of an asset instance.
|
|
**/
|
|
itemPriceOf: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<ITuple<[u128, Option<PezspCoreCryptoAccountId32>]>>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;
|
|
/**
|
|
* The collection, if any, of which an account is willing to take ownership.
|
|
**/
|
|
ownershipAcceptance: AugmentedQuery<ApiType, (arg: PezspCoreCryptoAccountId32 | string | Uint8Array) => Observable<Option<u32>>, [PezspCoreCryptoAccountId32]> & QueryableStorageEntry<ApiType, [PezspCoreCryptoAccountId32]>;
|
|
/**
|
|
* 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>;
|
|
};
|
|
xcmpQueue: {
|
|
/**
|
|
* The factor to multiply the base delivery fee by.
|
|
**/
|
|
deliveryFeeFactor: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u128>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* The suspended inbound XCMP channels. All others are not suspended.
|
|
*
|
|
* This is a `StorageValue` instead of a `StorageMap` since we expect multiple reads per block
|
|
* to different keys with a one byte payload. The access to `BoundedBTreeSet` will be cached
|
|
* within the block and therefore only included once in the proof size.
|
|
*
|
|
* NOTE: The PoV benchmarking cannot know this and will over-estimate, but the actual proof
|
|
* will be smaller.
|
|
**/
|
|
inboundXcmpSuspended: AugmentedQuery<ApiType, () => Observable<BTreeSet<u32>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The messages outbound in a given XCMP channel.
|
|
**/
|
|
outboundXcmpMessages: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u16 | AnyNumber | Uint8Array) => Observable<Bytes>, [u32, u16]> & QueryableStorageEntry<ApiType, [u32, u16]>;
|
|
/**
|
|
* The non-empty XCMP channels in order of becoming non-empty, and the index of the first
|
|
* and last outbound message. If the two indices are equal, then it indicates an empty
|
|
* queue and there must be a non-`Ok` `OutboundStatus`. We assume queues grow no greater
|
|
* than 65535 items. Queue indices for normal messages begin at one; zero is reserved in
|
|
* case of the need to send a high-priority signal message this block.
|
|
* The bool is true if there is a signal message waiting to be sent.
|
|
**/
|
|
outboundXcmpStatus: AugmentedQuery<ApiType, () => Observable<Vec<PezcumulusPezpalletXcmpQueueOutboundChannelDetails>>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* The configuration which controls the dynamics of the outbound queue.
|
|
**/
|
|
queueConfig: AugmentedQuery<ApiType, () => Observable<PezcumulusPezpalletXcmpQueueQueueConfigData>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Whether or not the XCMP queue is suspended from executing incoming XCMs or not.
|
|
**/
|
|
queueSuspended: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;
|
|
/**
|
|
* Any signal messages waiting to be sent.
|
|
**/
|
|
signalMessages: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Bytes>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
|
|
/**
|
|
* Generic query
|
|
**/
|
|
[key: string]: QueryableStorageEntry<ApiType>;
|
|
};
|
|
} // AugmentedQueries
|
|
} // declare module
|