@dedot/chaintypes 0.0.1-next.0 → 0.0.1-next.3

package/astar/query.d.ts

@@ -0,0 +1,1759 @@
+// Generated by @dedot/codegen
+
+import type { GenericChainStorage, GenericStorageQuery, Callback } from '@dedot/types';
+import type {
+  AccountId32Like,
+  H256,
+  Bytes,
+  Digest,
+  Phase,
+  AccountId32,
+  Data,
+  FixedBytes,
+  FixedU128,
+  BytesLike,
+  H160,
+  U256,
+  FixedU64,
+} from '@dedot/codecs';
+import type {
+  FrameSystemAccountInfo,
+  FrameSupportDispatchPerDispatchClass,
+  FrameSystemEventRecord,
+  FrameSystemLastRuntimeUpgradeInfo,
+  PalletIdentityRegistration,
+  PalletIdentityRegistrarInfo,
+  PalletMultisigMultisig,
+  PalletProxyProxyDefinition,
+  PalletProxyAnnouncement,
+  PolkadotPrimitivesV4PersistedValidationData,
+  PolkadotPrimitivesV4UpgradeRestriction,
+  SpTrieStorageProof,
+  CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot,
+  PolkadotPrimitivesV4AbridgedHostConfiguration,
+  CumulusPrimitivesParachainInherentMessageQueueChain,
+  PolkadotParachainPrimitivesId,
+  PolkadotCorePrimitivesOutboundHrmpMessage,
+  SpWeightsWeightV2Weight,
+  CumulusPalletParachainSystemCodeUpgradeAuthorization,
+  PalletTransactionPaymentReleases,
+  PalletBalancesAccountData,
+  PalletBalancesBalanceLock,
+  PalletBalancesReserveData,
+  PalletBalancesIdAmount,
+  PalletBalancesIdAmountRuntimeFreezeReason,
+  PalletVestingVestingInfo,
+  PalletVestingReleases,
+  PalletInflationInflationConfiguration,
+  PalletInflationInflationParameters,
+  PalletDappStakingV3ProtocolState,
+  PalletDappStakingV3DAppInfo,
+  AstarPrimitivesDappStakingSmartContract,
+  PalletDappStakingV3AccountLedger,
+  PalletDappStakingV3SingularStakingInfo,
+  PalletDappStakingV3ContractStakeAmount,
+  PalletDappStakingV3EraInfo,
+  PalletDappStakingV3EraRewardSpan,
+  PalletDappStakingV3PeriodEndInfo,
+  PalletDappStakingV3TierParameters,
+  PalletDappStakingV3TiersConfiguration,
+  PalletDappStakingV3DAppTierRewards,
+  PalletDappStakingV3CleanupMarker,
+  PalletAssetsAssetDetails,
+  PalletAssetsAssetAccount,
+  PalletAssetsApproval,
+  PalletAssetsAssetMetadata,
+  PalletCollatorSelectionCandidateInfo,
+  AstarRuntimeSessionKeys,
+  SpCoreCryptoKeyTypeId,
+  SpConsensusAuraSr25519AppSr25519Public,
+  SpConsensusSlotsSlot,
+  CumulusPalletXcmpQueueInboundChannelDetails,
+  CumulusPalletXcmpQueueOutboundChannelDetails,
+  CumulusPalletXcmpQueueQueueConfigData,
+  PalletXcmQueryStatus,
+  XcmVersionedMultiLocation,
+  PalletXcmVersionMigrationStage,
+  PalletXcmRemoteLockedFungibleRecord,
+  XcmVersionedAssetId,
+  CumulusPalletDmpQueueConfigData,
+  CumulusPalletDmpQueuePageIndexData,
+  PalletEvmCodeMetadata,
+  EthereumTransactionTransactionV2,
+  FpRpcTransactionStatus,
+  EthereumReceiptReceiptV3,
+  EthereumBlock,
+  PalletContractsWasmPrefabWasmModule,
+  PalletContractsWasmOwnerInfo,
+  PalletContractsStorageContractInfo,
+  PalletContractsStorageDeletionQueueManager,
+  PalletDappStakingMigrationMigrationState,
+  PalletDappsStakingAccountLedger,
+  PalletDappsStakingRewardInfo,
+  PalletDappsStakingForcing,
+  PalletDappsStakingDAppInfo,
+  PalletDappsStakingEraInfo,
+  PalletDappsStakingContractStakeInfo,
+  PalletDappsStakingStakerInfo,
+  PalletDappsStakingVersion,
+} from './types';
+
+export interface ChainStorage extends GenericChainStorage {
+  /**
+   * Pallet `System`'s storage queries
+   **/
+  system: {
+    /**
+     * The full account information for a particular account ID.
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<FrameSystemAccountInfo> =} callback
+     **/
+    account: GenericStorageQuery<(arg: AccountId32Like) => FrameSystemAccountInfo>;
+
+    /**
+     * Total extrinsics count for the current block.
+     *
+     * @param {Callback<number | undefined> =} callback
+     **/
+    extrinsicCount: GenericStorageQuery<() => number | undefined>;
+
+    /**
+     * The current weight for the block.
+     *
+     * @param {Callback<FrameSupportDispatchPerDispatchClass> =} callback
+     **/
+    blockWeight: GenericStorageQuery<() => FrameSupportDispatchPerDispatchClass>;
+
+    /**
+     * Total length (in bytes) for all extrinsics put together, for the current block.
+     *
+     * @param {Callback<number | undefined> =} callback
+     **/
+    allExtrinsicsLen: GenericStorageQuery<() => number | undefined>;
+
+    /**
+     * Map of block numbers to block hashes.
+     *
+     * @param {number} arg
+     * @param {Callback<H256> =} callback
+     **/
+    blockHash: GenericStorageQuery<(arg: number) => H256>;
+
+    /**
+     * Extrinsics data for the current block (maps an extrinsic's index to its data).
+     *
+     * @param {number} arg
+     * @param {Callback<Bytes> =} callback
+     **/
+    extrinsicData: GenericStorageQuery<(arg: number) => Bytes>;
+
+    /**
+     * The current block number being processed. Set by `execute_block`.
+     *
+     * @param {Callback<number> =} callback
+     **/
+    number: GenericStorageQuery<() => number>;
+
+    /**
+     * Hash of the previous block.
+     *
+     * @param {Callback<H256> =} callback
+     **/
+    parentHash: GenericStorageQuery<() => H256>;
+
+    /**
+     * Digest of the current block, also part of the block header.
+     *
+     * @param {Callback<Digest> =} callback
+     **/
+    digest: GenericStorageQuery<() => Digest>;
+
+    /**
+     * 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.
+     *
+     * @param {Callback<Array<FrameSystemEventRecord>> =} callback
+     **/
+    events: GenericStorageQuery<() => Array<FrameSystemEventRecord>>;
+
+    /**
+     * The number of events in the `Events<T>` list.
+     *
+     * @param {Callback<number> =} callback
+     **/
+    eventCount: GenericStorageQuery<() => number>;
+
+    /**
+     * 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 `(T::BlockNumber, 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.
+     *
+     * @param {H256} arg
+     * @param {Callback<Array<[number, number]>> =} callback
+     **/
+    eventTopics: GenericStorageQuery<(arg: H256) => Array<[number, number]>>;
+
+    /**
+     * Stores the `spec_version` and `spec_name` of when the last runtime upgrade happened.
+     *
+     * @param {Callback<FrameSystemLastRuntimeUpgradeInfo | undefined> =} callback
+     **/
+    lastRuntimeUpgrade: GenericStorageQuery<() => FrameSystemLastRuntimeUpgradeInfo | undefined>;
+
+    /**
+     * True if we have upgraded so that `type RefCount` is `u32`. False (default) if not.
+     *
+     * @param {Callback<boolean> =} callback
+     **/
+    upgradedToU32RefCount: GenericStorageQuery<() => boolean>;
+
+    /**
+     * True if we have upgraded so that AccountInfo contains three types of `RefCount`. False
+     * (default) if not.
+     *
+     * @param {Callback<boolean> =} callback
+     **/
+    upgradedToTripleRefCount: GenericStorageQuery<() => boolean>;
+
+    /**
+     * The execution phase of the block.
+     *
+     * @param {Callback<Phase | undefined> =} callback
+     **/
+    executionPhase: GenericStorageQuery<() => Phase | undefined>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery;
+  };
+  /**
+   * Pallet `Identity`'s storage queries
+   **/
+  identity: {
+    /**
+     * Information that is pertinent to identify the entity behind an account.
+     *
+     * TWOX-NOTE: OK ― `AccountId` is a secure hash.
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<PalletIdentityRegistration | undefined> =} callback
+     **/
+    identityOf: GenericStorageQuery<(arg: AccountId32Like) => PalletIdentityRegistration | undefined>;
+
+    /**
+     * The super-identity of an alternative "sub" identity together with its name, within that
+     * context. If the account is not some other account's sub-identity, then just `None`.
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<[AccountId32, Data] | undefined> =} callback
+     **/
+    superOf: GenericStorageQuery<(arg: AccountId32Like) => [AccountId32, Data] | undefined>;
+
+    /**
+     * Alternative "sub" identities of this account.
+     *
+     * The first item is the deposit, the second is a vector of the accounts.
+     *
+     * TWOX-NOTE: OK ― `AccountId` is a secure hash.
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<[bigint, Array<AccountId32>]> =} callback
+     **/
+    subsOf: GenericStorageQuery<(arg: AccountId32Like) => [bigint, Array<AccountId32>]>;
+
+    /**
+     * The set of registrars. Not expected to get very big as can only be added through a
+     * special origin (likely a council motion).
+     *
+     * The index into this can be cast to `RegistrarIndex` to get a valid value.
+     *
+     * @param {Callback<Array<PalletIdentityRegistrarInfo | undefined>> =} callback
+     **/
+    registrars: GenericStorageQuery<() => Array<PalletIdentityRegistrarInfo | undefined>>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery;
+  };
+  /**
+   * Pallet `Timestamp`'s storage queries
+   **/
+  timestamp: {
+    /**
+     * Current time for the current block.
+     *
+     * @param {Callback<bigint> =} callback
+     **/
+    now: GenericStorageQuery<() => bigint>;
+
+    /**
+     * Did the timestamp get updated in this block?
+     *
+     * @param {Callback<boolean> =} callback
+     **/
+    didUpdate: GenericStorageQuery<() => boolean>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery;
+  };
+  /**
+   * Pallet `Multisig`'s storage queries
+   **/
+  multisig: {
+    /**
+     * The set of open multisig operations.
+     *
+     * @param {[AccountId32Like, FixedBytes<32>]} arg
+     * @param {Callback<PalletMultisigMultisig | undefined> =} callback
+     **/
+    multisigs: GenericStorageQuery<(arg: [AccountId32Like, FixedBytes<32>]) => PalletMultisigMultisig | undefined>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery;
+  };
+  /**
+   * Pallet `Proxy`'s storage queries
+   **/
+  proxy: {
+    /**
+     * 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.
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<[Array<PalletProxyProxyDefinition>, bigint]> =} callback
+     **/
+    proxies: GenericStorageQuery<(arg: AccountId32Like) => [Array<PalletProxyProxyDefinition>, bigint]>;
+
+    /**
+     * The announcements made by the proxy (key).
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<[Array<PalletProxyAnnouncement>, bigint]> =} callback
+     **/
+    announcements: GenericStorageQuery<(arg: AccountId32Like) => [Array<PalletProxyAnnouncement>, bigint]>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery;
+  };
+  /**
+   * Pallet `ParachainSystem`'s storage queries
+   **/
+  parachainSystem: {
+    /**
+     * 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`][well_known_keys::CODE]
+     * which will result the next block process with the new validation code. This concludes the upgrade process.
+     *
+     * [well_known_keys::CODE]: sp_core::storage::well_known_keys::CODE
+     *
+     * @param {Callback<Bytes> =} callback
+     **/
+    pendingValidationCode: GenericStorageQuery<() => Bytes>;
+
+    /**
+     * 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.
+     *
+     * @param {Callback<Bytes | undefined> =} callback
+     **/
+    newValidationCode: GenericStorageQuery<() => Bytes | undefined>;
+
+    /**
+     * 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.
+     *
+     * @param {Callback<PolkadotPrimitivesV4PersistedValidationData | undefined> =} callback
+     **/
+    validationData: GenericStorageQuery<() => PolkadotPrimitivesV4PersistedValidationData | undefined>;
+
+    /**
+     * Were the validation data set to notify the relay chain?
+     *
+     * @param {Callback<boolean> =} callback
+     **/
+    didSetValidationCode: GenericStorageQuery<() => boolean>;
+
+    /**
+     * The relay chain block number associated with the last parachain block.
+     *
+     * @param {Callback<number> =} callback
+     **/
+    lastRelayChainBlockNumber: GenericStorageQuery<() => number>;
+
+    /**
+     * 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.
+     *
+     * @param {Callback<PolkadotPrimitivesV4UpgradeRestriction | undefined> =} callback
+     **/
+    upgradeRestrictionSignal: GenericStorageQuery<() => PolkadotPrimitivesV4UpgradeRestriction | undefined>;
+
+    /**
+     * 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.
+     *
+     * @param {Callback<SpTrieStorageProof | undefined> =} callback
+     **/
+    relayStateProof: GenericStorageQuery<() => SpTrieStorageProof | undefined>;
+
+    /**
+     * 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.
+     *
+     * @param {Callback<CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot | undefined> =} callback
+     **/
+    relevantMessagingState: GenericStorageQuery<
+      () => CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot | undefined
+    >;
+
+    /**
+     * 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.
+     *
+     * @param {Callback<PolkadotPrimitivesV4AbridgedHostConfiguration | undefined> =} callback
+     **/
+    hostConfiguration: GenericStorageQuery<() => PolkadotPrimitivesV4AbridgedHostConfiguration | undefined>;
+
+    /**
+     * 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.
+     *
+     * @param {Callback<CumulusPrimitivesParachainInherentMessageQueueChain> =} callback
+     **/
+    lastDmqMqcHead: GenericStorageQuery<() => CumulusPrimitivesParachainInherentMessageQueueChain>;
+
+    /**
+     * 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.
+     *
+     * @param {Callback<Array<[PolkadotParachainPrimitivesId, CumulusPrimitivesParachainInherentMessageQueueChain]>> =} callback
+     **/
+    lastHrmpMqcHeads: GenericStorageQuery<
+      () => Array<[PolkadotParachainPrimitivesId, CumulusPrimitivesParachainInherentMessageQueueChain]>
+    >;
+
+    /**
+     * Number of downward messages processed in a block.
+     *
+     * This will be cleared in `on_initialize` of each new block.
+     *
+     * @param {Callback<number> =} callback
+     **/
+    processedDownwardMessages: GenericStorageQuery<() => number>;
+
+    /**
+     * HRMP watermark that was set in a block.
+     *
+     * This will be cleared in `on_initialize` of each new block.
+     *
+     * @param {Callback<number> =} callback
+     **/
+    hrmpWatermark: GenericStorageQuery<() => number>;
+
+    /**
+     * HRMP messages that were sent in a block.
+     *
+     * This will be cleared in `on_initialize` of each new block.
+     *
+     * @param {Callback<Array<PolkadotCorePrimitivesOutboundHrmpMessage>> =} callback
+     **/
+    hrmpOutboundMessages: GenericStorageQuery<() => Array<PolkadotCorePrimitivesOutboundHrmpMessage>>;
+
+    /**
+     * Upward messages that were sent in a block.
+     *
+     * This will be cleared in `on_initialize` of each new block.
+     *
+     * @param {Callback<Array<Bytes>> =} callback
+     **/
+    upwardMessages: GenericStorageQuery<() => Array<Bytes>>;
+
+    /**
+     * Upward messages that are still pending and not yet send to the relay chain.
+     *
+     * @param {Callback<Array<Bytes>> =} callback
+     **/
+    pendingUpwardMessages: GenericStorageQuery<() => Array<Bytes>>;
+
+    /**
+     * 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`.
+     *
+     * @param {Callback<number> =} callback
+     **/
+    announcedHrmpMessagesPerCandidate: GenericStorageQuery<() => number>;
+
+    /**
+     * The weight we reserve at the beginning of the block for processing XCMP messages. This
+     * overrides the amount set in the Config trait.
+     *
+     * @param {Callback<SpWeightsWeightV2Weight | undefined> =} callback
+     **/
+    reservedXcmpWeightOverride: GenericStorageQuery<() => SpWeightsWeightV2Weight | undefined>;
+
+    /**
+     * The weight we reserve at the beginning of the block for processing DMP messages. This
+     * overrides the amount set in the Config trait.
+     *
+     * @param {Callback<SpWeightsWeightV2Weight | undefined> =} callback
+     **/
+    reservedDmpWeightOverride: GenericStorageQuery<() => SpWeightsWeightV2Weight | undefined>;
+
+    /**
+     * The next authorized upgrade, if there is one.
+     *
+     * @param {Callback<CumulusPalletParachainSystemCodeUpgradeAuthorization | undefined> =} callback
+     **/
+    authorizedUpgrade: GenericStorageQuery<() => CumulusPalletParachainSystemCodeUpgradeAuthorization | undefined>;
+
+    /**
+     * A custom head data that should be returned as result of `validate_block`.
+     *
+     * See [`Pallet::set_custom_validation_head_data`] for more information.
+     *
+     * @param {Callback<Bytes | undefined> =} callback
+     **/
+    customValidationHeadData: GenericStorageQuery<() => Bytes | undefined>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery;
+  };
+  /**
+   * Pallet `ParachainInfo`'s storage queries
+   **/
+  parachainInfo: {
+    /**
+     *
+     * @param {Callback<PolkadotParachainPrimitivesId> =} callback
+     **/
+    parachainId: GenericStorageQuery<() => PolkadotParachainPrimitivesId>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery;
+  };
+  /**
+   * Pallet `TransactionPayment`'s storage queries
+   **/
+  transactionPayment: {
+    /**
+     *
+     * @param {Callback<FixedU128> =} callback
+     **/
+    nextFeeMultiplier: GenericStorageQuery<() => FixedU128>;
+
+    /**
+     *
+     * @param {Callback<PalletTransactionPaymentReleases> =} callback
+     **/
+    storageVersion: GenericStorageQuery<() => PalletTransactionPaymentReleases>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery;
+  };
+  /**
+   * Pallet `Balances`'s storage queries
+   **/
+  balances: {
+    /**
+     * The total units issued in the system.
+     *
+     * @param {Callback<bigint> =} callback
+     **/
+    totalIssuance: GenericStorageQuery<() => bigint>;
+
+    /**
+     * The total units of outstanding deactivated balance in the system.
+     *
+     * @param {Callback<bigint> =} callback
+     **/
+    inactiveIssuance: GenericStorageQuery<() => bigint>;
+
+    /**
+     * 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.
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<PalletBalancesAccountData> =} callback
+     **/
+    account: GenericStorageQuery<(arg: AccountId32Like) => PalletBalancesAccountData>;
+
+    /**
+     * Any liquidity locks on some account balances.
+     * NOTE: Should only be accessed when setting, changing and freeing a lock.
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<Array<PalletBalancesBalanceLock>> =} callback
+     **/
+    locks: GenericStorageQuery<(arg: AccountId32Like) => Array<PalletBalancesBalanceLock>>;
+
+    /**
+     * Named reserves on some account balances.
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<Array<PalletBalancesReserveData>> =} callback
+     **/
+    reserves: GenericStorageQuery<(arg: AccountId32Like) => Array<PalletBalancesReserveData>>;
+
+    /**
+     * Holds on account balances.
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<Array<PalletBalancesIdAmount>> =} callback
+     **/
+    holds: GenericStorageQuery<(arg: AccountId32Like) => Array<PalletBalancesIdAmount>>;
+
+    /**
+     * Freeze locks on account balances.
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<Array<PalletBalancesIdAmountRuntimeFreezeReason>> =} callback
+     **/
+    freezes: GenericStorageQuery<(arg: AccountId32Like) => Array<PalletBalancesIdAmountRuntimeFreezeReason>>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery;
+  };
+  /**
+   * Pallet `Vesting`'s storage queries
+   **/
+  vesting: {
+    /**
+     * Information regarding the vesting of a given account.
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<Array<PalletVestingVestingInfo> | undefined> =} callback
+     **/
+    vesting: GenericStorageQuery<(arg: AccountId32Like) => Array<PalletVestingVestingInfo> | undefined>;
+
+    /**
+     * Storage version of the pallet.
+     *
+     * New networks start with latest version, as determined by the genesis build.
+     *
+     * @param {Callback<PalletVestingReleases> =} callback
+     **/
+    storageVersion: GenericStorageQuery<() => PalletVestingReleases>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery;
+  };
+  /**
+   * Pallet `Inflation`'s storage queries
+   **/
+  inflation: {
+    /**
+     * Active inflation configuration parameters.
+     * They describe current rewards, when inflation needs to be recalculated, etc.
+     *
+     * @param {Callback<PalletInflationInflationConfiguration> =} callback
+     **/
+    activeInflationConfig: GenericStorageQuery<() => PalletInflationInflationConfiguration>;
+
+    /**
+     * Static inflation parameters - used to calculate active inflation configuration at certain points in time.
+     *
+     * @param {Callback<PalletInflationInflationParameters> =} callback
+     **/
+    inflationParams: GenericStorageQuery<() => PalletInflationInflationParameters>;
+
+    /**
+     * Flag indicating whether on the first possible opportunity, recalculation of the inflation config should be done.
+     *
+     * @param {Callback<number | undefined> =} callback
+     **/
+    doRecalculation: GenericStorageQuery<() => number | undefined>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery;
+  };
+  /**
+   * Pallet `DappStaking`'s storage queries
+   **/
+  dappStaking: {
+    /**
+     * General information about dApp staking protocol state.
+     *
+     * @param {Callback<PalletDappStakingV3ProtocolState> =} callback
+     **/
+    activeProtocolState: GenericStorageQuery<() => PalletDappStakingV3ProtocolState>;
+
+    /**
+     * Counter for unique dApp identifiers.
+     *
+     * @param {Callback<number> =} callback
+     **/
+    nextDAppId: GenericStorageQuery<() => number>;
+
+    /**
+     * Map of all dApps integrated into dApp staking protocol.
+     *
+     * Even though dApp is integrated, it does not mean it's still actively participating in dApp staking.
+     * It might have been unregistered at some point in history.
+     *
+     * @param {AstarPrimitivesDappStakingSmartContract} arg
+     * @param {Callback<PalletDappStakingV3DAppInfo | undefined> =} callback
+     **/
+    integratedDApps: GenericStorageQuery<
+      (arg: AstarPrimitivesDappStakingSmartContract) => PalletDappStakingV3DAppInfo | undefined
+    >;
+
+    /**
+     * Counter for the related counted storage map
+     *
+     * @param {Callback<number> =} callback
+     **/
+    counterForIntegratedDApps: GenericStorageQuery<() => number>;
+
+    /**
+     * General locked/staked information for each account.
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<PalletDappStakingV3AccountLedger> =} callback
+     **/
+    ledger: GenericStorageQuery<(arg: AccountId32Like) => PalletDappStakingV3AccountLedger>;
+
+    /**
+     * Information about how much each staker has staked for each smart contract in some period.
+     *
+     * @param {[AccountId32Like, AstarPrimitivesDappStakingSmartContract]} arg
+     * @param {Callback<PalletDappStakingV3SingularStakingInfo | undefined> =} callback
+     **/
+    stakerInfo: GenericStorageQuery<
+      (
+        arg: [AccountId32Like, AstarPrimitivesDappStakingSmartContract],
+      ) => PalletDappStakingV3SingularStakingInfo | undefined
+    >;
+
+    /**
+     * Information about how much has been staked on a smart contract in some era or period.
+     *
+     * @param {number} arg
+     * @param {Callback<PalletDappStakingV3ContractStakeAmount> =} callback
+     **/
+    contractStake: GenericStorageQuery<(arg: number) => PalletDappStakingV3ContractStakeAmount>;
+
+    /**
+     * General information about the current era.
+     *
+     * @param {Callback<PalletDappStakingV3EraInfo> =} callback
+     **/
+    currentEraInfo: GenericStorageQuery<() => PalletDappStakingV3EraInfo>;
+
+    /**
+     * Information about rewards for each era.
+     *
+     * Since each entry is a 'span', covering up to `T::EraRewardSpanLength` entries, only certain era value keys can exist in storage.
+     * For the sake of simplicity, valid `era` keys are calculated as:
+     *
+     * era_key = era - (era % T::EraRewardSpanLength)
+     *
+     * This means that e.g. in case `EraRewardSpanLength = 8`, only era values 0, 8, 16, 24, etc. can exist in storage.
+     * Eras 1-7 will be stored in the same entry as era 0, eras 9-15 will be stored in the same entry as era 8, etc.
+     *
+     * @param {number} arg
+     * @param {Callback<PalletDappStakingV3EraRewardSpan | undefined> =} callback
+     **/
+    eraRewards: GenericStorageQuery<(arg: number) => PalletDappStakingV3EraRewardSpan | undefined>;
+
+    /**
+     * Information about period's end.
+     *
+     * @param {number} arg
+     * @param {Callback<PalletDappStakingV3PeriodEndInfo | undefined> =} callback
+     **/
+    periodEnd: GenericStorageQuery<(arg: number) => PalletDappStakingV3PeriodEndInfo | undefined>;
+
+    /**
+     * Static tier parameters used to calculate tier configuration.
+     *
+     * @param {Callback<PalletDappStakingV3TierParameters> =} callback
+     **/
+    staticTierParams: GenericStorageQuery<() => PalletDappStakingV3TierParameters>;
+
+    /**
+     * Tier configuration user for current & preceding eras.
+     *
+     * @param {Callback<PalletDappStakingV3TiersConfiguration> =} callback
+     **/
+    tierConfig: GenericStorageQuery<() => PalletDappStakingV3TiersConfiguration>;
+
+    /**
+     * Information about which tier a dApp belonged to in a specific era.
+     *
+     * @param {number} arg
+     * @param {Callback<PalletDappStakingV3DAppTierRewards | undefined> =} callback
+     **/
+    dAppTiers: GenericStorageQuery<(arg: number) => PalletDappStakingV3DAppTierRewards | undefined>;
+
+    /**
+     * History cleanup marker - holds information about which DB entries should be cleaned up next, when applicable.
+     *
+     * @param {Callback<PalletDappStakingV3CleanupMarker> =} callback
+     **/
+    historyCleanupMarker: GenericStorageQuery<() => PalletDappStakingV3CleanupMarker>;
+
+    /**
+     * Safeguard to prevent unwanted operations in production.
+     * Kept as a storage without extrinsic setter, so we can still enable it for some
+     * chain-fork debugging if required.
+     *
+     * @param {Callback<boolean> =} callback
+     **/
+    safeguard: GenericStorageQuery<() => boolean>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery;
+  };
+  /**
+   * Pallet `Assets`'s storage queries
+   **/
+  assets: {
+    /**
+     * Details of an asset.
+     *
+     * @param {bigint} arg
+     * @param {Callback<PalletAssetsAssetDetails | undefined> =} callback
+     **/
+    asset: GenericStorageQuery<(arg: bigint) => PalletAssetsAssetDetails | undefined>;
+
+    /**
+     * The holdings of a specific account for a specific asset.
+     *
+     * @param {[bigint, AccountId32Like]} arg
+     * @param {Callback<PalletAssetsAssetAccount | undefined> =} callback
+     **/
+    account: GenericStorageQuery<(arg: [bigint, AccountId32Like]) => PalletAssetsAssetAccount | undefined>;
+
+    /**
+     * 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.
+     *
+     * @param {[bigint, AccountId32Like, AccountId32Like]} arg
+     * @param {Callback<PalletAssetsApproval | undefined> =} callback
+     **/
+    approvals: GenericStorageQuery<
+      (arg: [bigint, AccountId32Like, AccountId32Like]) => PalletAssetsApproval | undefined
+    >;
+
+    /**
+     * Metadata of an asset.
+     *
+     * @param {bigint} arg
+     * @param {Callback<PalletAssetsAssetMetadata> =} callback
+     **/
+    metadata: GenericStorageQuery<(arg: bigint) => PalletAssetsAssetMetadata>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery;
+  };
+  /**
+   * Pallet `Authorship`'s storage queries
+   **/
+  authorship: {
+    /**
+     * Author of current block.
+     *
+     * @param {Callback<AccountId32 | undefined> =} callback
+     **/
+    author: GenericStorageQuery<() => AccountId32 | undefined>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery;
+  };
+  /**
+   * Pallet `CollatorSelection`'s storage queries
+   **/
+  collatorSelection: {
+    /**
+     * The invulnerable, fixed collators.
+     *
+     * @param {Callback<Array<AccountId32>> =} callback
+     **/
+    invulnerables: GenericStorageQuery<() => Array<AccountId32>>;
+
+    /**
+     * The (community, limited) collation candidates.
+     *
+     * @param {Callback<Array<PalletCollatorSelectionCandidateInfo>> =} callback
+     **/
+    candidates: GenericStorageQuery<() => Array<PalletCollatorSelectionCandidateInfo>>;
+
+    /**
+     * Last block authored by collator.
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<number> =} callback
+     **/
+    lastAuthoredBlock: GenericStorageQuery<(arg: AccountId32Like) => number>;
+
+    /**
+     * Desired number of candidates.
+     *
+     * This should ideally always be less than [`Config::MaxCandidates`] for weights to be correct.
+     *
+     * @param {Callback<number> =} callback
+     **/
+    desiredCandidates: GenericStorageQuery<() => number>;
+
+    /**
+     * Fixed amount to deposit to become a collator.
+     *
+     * When a collator calls `leave_intent` they immediately receive the deposit back.
+     *
+     * @param {Callback<bigint> =} callback
+     **/
+    candidacyBond: GenericStorageQuery<() => bigint>;
+
+    /**
+     * Destination account for slashed amount.
+     *
+     * @param {Callback<AccountId32 | undefined> =} callback
+     **/
+    slashDestination: GenericStorageQuery<() => AccountId32 | undefined>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery;
+  };
+  /**
+   * Pallet `Session`'s storage queries
+   **/
+  session: {
+    /**
+     * The current set of validators.
+     *
+     * @param {Callback<Array<AccountId32>> =} callback
+     **/
+    validators: GenericStorageQuery<() => Array<AccountId32>>;
+
+    /**
+     * Current index of the session.
+     *
+     * @param {Callback<number> =} callback
+     **/
+    currentIndex: GenericStorageQuery<() => number>;
+
+    /**
+     * True if the underlying economic identities or weighting behind the validators
+     * has changed in the queued validator set.
+     *
+     * @param {Callback<boolean> =} callback
+     **/
+    queuedChanged: GenericStorageQuery<() => boolean>;
+
+    /**
+     * The queued keys for the next session. When the next session begins, these keys
+     * will be used to determine the validator's session keys.
+     *
+     * @param {Callback<Array<[AccountId32, AstarRuntimeSessionKeys]>> =} callback
+     **/
+    queuedKeys: GenericStorageQuery<() => Array<[AccountId32, AstarRuntimeSessionKeys]>>;
+
+    /**
+     * 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.
+     *
+     * @param {Callback<Array<number>> =} callback
+     **/
+    disabledValidators: GenericStorageQuery<() => Array<number>>;
+
+    /**
+     * The next session keys for a validator.
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<AstarRuntimeSessionKeys | undefined> =} callback
+     **/
+    nextKeys: GenericStorageQuery<(arg: AccountId32Like) => AstarRuntimeSessionKeys | undefined>;
+
+    /**
+     * The owner of a key. The key is the `KeyTypeId` + the encoded key.
+     *
+     * @param {[SpCoreCryptoKeyTypeId, BytesLike]} arg
+     * @param {Callback<AccountId32 | undefined> =} callback
+     **/
+    keyOwner: GenericStorageQuery<(arg: [SpCoreCryptoKeyTypeId, BytesLike]) => AccountId32 | undefined>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery;
+  };
+  /**
+   * Pallet `Aura`'s storage queries
+   **/
+  aura: {
+    /**
+     * The current authority set.
+     *
+     * @param {Callback<Array<SpConsensusAuraSr25519AppSr25519Public>> =} callback
+     **/
+    authorities: GenericStorageQuery<() => Array<SpConsensusAuraSr25519AppSr25519Public>>;
+
+    /**
+     * The current slot of this block.
+     *
+     * This will be set in `on_initialize`.
+     *
+     * @param {Callback<SpConsensusSlotsSlot> =} callback
+     **/
+    currentSlot: GenericStorageQuery<() => SpConsensusSlotsSlot>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery;
+  };
+  /**
+   * Pallet `AuraExt`'s storage queries
+   **/
+  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`.
+     *
+     * @param {Callback<Array<SpConsensusAuraSr25519AppSr25519Public>> =} callback
+     **/
+    authorities: GenericStorageQuery<() => Array<SpConsensusAuraSr25519AppSr25519Public>>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery;
+  };
+  /**
+   * Pallet `XcmpQueue`'s storage queries
+   **/
+  xcmpQueue: {
+    /**
+     * Status of the inbound XCMP channels.
+     *
+     * @param {Callback<Array<CumulusPalletXcmpQueueInboundChannelDetails>> =} callback
+     **/
+    inboundXcmpStatus: GenericStorageQuery<() => Array<CumulusPalletXcmpQueueInboundChannelDetails>>;
+
+    /**
+     * Inbound aggregate XCMP messages. It can only be one per ParaId/block.
+     *
+     * @param {[PolkadotParachainPrimitivesId, number]} arg
+     * @param {Callback<Bytes> =} callback
+     **/
+    inboundXcmpMessages: GenericStorageQuery<(arg: [PolkadotParachainPrimitivesId, number]) => Bytes>;
+
+    /**
+     * 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.
+     *
+     * @param {Callback<Array<CumulusPalletXcmpQueueOutboundChannelDetails>> =} callback
+     **/
+    outboundXcmpStatus: GenericStorageQuery<() => Array<CumulusPalletXcmpQueueOutboundChannelDetails>>;
+
+    /**
+     * The messages outbound in a given XCMP channel.
+     *
+     * @param {[PolkadotParachainPrimitivesId, number]} arg
+     * @param {Callback<Bytes> =} callback
+     **/
+    outboundXcmpMessages: GenericStorageQuery<(arg: [PolkadotParachainPrimitivesId, number]) => Bytes>;
+
+    /**
+     * Any signal messages waiting to be sent.
+     *
+     * @param {PolkadotParachainPrimitivesId} arg
+     * @param {Callback<Bytes> =} callback
+     **/
+    signalMessages: GenericStorageQuery<(arg: PolkadotParachainPrimitivesId) => Bytes>;
+
+    /**
+     * The configuration which controls the dynamics of the outbound queue.
+     *
+     * @param {Callback<CumulusPalletXcmpQueueQueueConfigData> =} callback
+     **/
+    queueConfig: GenericStorageQuery<() => CumulusPalletXcmpQueueQueueConfigData>;
+
+    /**
+     * The messages that exceeded max individual message weight budget.
+     *
+     * These message stay in this storage map until they are manually dispatched via
+     * `service_overweight`.
+     *
+     * @param {bigint} arg
+     * @param {Callback<[PolkadotParachainPrimitivesId, number, Bytes] | undefined> =} callback
+     **/
+    overweight: GenericStorageQuery<(arg: bigint) => [PolkadotParachainPrimitivesId, number, Bytes] | undefined>;
+
+    /**
+     * Counter for the related counted storage map
+     *
+     * @param {Callback<number> =} callback
+     **/
+    counterForOverweight: GenericStorageQuery<() => number>;
+
+    /**
+     * The number of overweight messages ever recorded in `Overweight`. Also doubles as the next
+     * available free overweight index.
+     *
+     * @param {Callback<bigint> =} callback
+     **/
+    overweightCount: GenericStorageQuery<() => bigint>;
+
+    /**
+     * Whether or not the XCMP queue is suspended from executing incoming XCMs or not.
+     *
+     * @param {Callback<boolean> =} callback
+     **/
+    queueSuspended: GenericStorageQuery<() => boolean>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery;
+  };
+  /**
+   * Pallet `PolkadotXcm`'s storage queries
+   **/
+  polkadotXcm: {
+    /**
+     * The latest available query index.
+     *
+     * @param {Callback<bigint> =} callback
+     **/
+    queryCounter: GenericStorageQuery<() => bigint>;
+
+    /**
+     * The ongoing queries.
+     *
+     * @param {bigint} arg
+     * @param {Callback<PalletXcmQueryStatus | undefined> =} callback
+     **/
+    queries: GenericStorageQuery<(arg: bigint) => PalletXcmQueryStatus | undefined>;
+
+    /**
+     * The existing asset traps.
+     *
+     * Key is the blake2 256 hash of (origin, versioned `MultiAssets`) pair. Value is the number of
+     * times this pair has been trapped (usually just 1 if it exists at all).
+     *
+     * @param {H256} arg
+     * @param {Callback<number> =} callback
+     **/
+    assetTraps: GenericStorageQuery<(arg: H256) => number>;
+
+    /**
+     * 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.
+     *
+     * @param {Callback<number | undefined> =} callback
+     **/
+    safeXcmVersion: GenericStorageQuery<() => number | undefined>;
+
+    /**
+     * The Latest versions that we know various locations support.
+     *
+     * @param {[number, XcmVersionedMultiLocation]} arg
+     * @param {Callback<number | undefined> =} callback
+     **/
+    supportedVersion: GenericStorageQuery<(arg: [number, XcmVersionedMultiLocation]) => number | undefined>;
+
+    /**
+     * All locations that we have requested version notifications from.
+     *
+     * @param {[number, XcmVersionedMultiLocation]} arg
+     * @param {Callback<bigint | undefined> =} callback
+     **/
+    versionNotifiers: GenericStorageQuery<(arg: [number, XcmVersionedMultiLocation]) => bigint | undefined>;
+
+    /**
+     * The target locations that are subscribed to our version changes, as well as the most recent
+     * of our versions we informed them of.
+     *
+     * @param {[number, XcmVersionedMultiLocation]} arg
+     * @param {Callback<[bigint, SpWeightsWeightV2Weight, number] | undefined> =} callback
+     **/
+    versionNotifyTargets: GenericStorageQuery<
+      (arg: [number, XcmVersionedMultiLocation]) => [bigint, SpWeightsWeightV2Weight, number] | undefined
+    >;
+
+    /**
+     * 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.
+     *
+     * @param {Callback<Array<[XcmVersionedMultiLocation, number]>> =} callback
+     **/
+    versionDiscoveryQueue: GenericStorageQuery<() => Array<[XcmVersionedMultiLocation, number]>>;
+
+    /**
+     * The current migration's stage, if any.
+     *
+     * @param {Callback<PalletXcmVersionMigrationStage | undefined> =} callback
+     **/
+    currentMigration: GenericStorageQuery<() => PalletXcmVersionMigrationStage | undefined>;
+
+    /**
+     * Fungible assets which we know are locked on a remote chain.
+     *
+     * @param {[number, AccountId32Like, XcmVersionedAssetId]} arg
+     * @param {Callback<PalletXcmRemoteLockedFungibleRecord | undefined> =} callback
+     **/
+    remoteLockedFungibles: GenericStorageQuery<
+      (arg: [number, AccountId32Like, XcmVersionedAssetId]) => PalletXcmRemoteLockedFungibleRecord | undefined
+    >;
+
+    /**
+     * Fungible assets which we know are locked on this chain.
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<Array<[bigint, XcmVersionedMultiLocation]> | undefined> =} callback
+     **/
+    lockedFungibles: GenericStorageQuery<
+      (arg: AccountId32Like) => Array<[bigint, XcmVersionedMultiLocation]> | undefined
+    >;
+
+    /**
+     * Global suspension state of the XCM executor.
+     *
+     * @param {Callback<boolean> =} callback
+     **/
+    xcmExecutionSuspended: GenericStorageQuery<() => boolean>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery;
+  };
+  /**
+   * Pallet `DmpQueue`'s storage queries
+   **/
+  dmpQueue: {
+    /**
+     * The configuration.
+     *
+     * @param {Callback<CumulusPalletDmpQueueConfigData> =} callback
+     **/
+    configuration: GenericStorageQuery<() => CumulusPalletDmpQueueConfigData>;
+
+    /**
+     * The page index.
+     *
+     * @param {Callback<CumulusPalletDmpQueuePageIndexData> =} callback
+     **/
+    pageIndex: GenericStorageQuery<() => CumulusPalletDmpQueuePageIndexData>;
+
+    /**
+     * The queue pages.
+     *
+     * @param {number} arg
+     * @param {Callback<Array<[number, Bytes]>> =} callback
+     **/
+    pages: GenericStorageQuery<(arg: number) => Array<[number, Bytes]>>;
+
+    /**
+     * The overweight messages.
+     *
+     * @param {bigint} arg
+     * @param {Callback<[number, Bytes] | undefined> =} callback
+     **/
+    overweight: GenericStorageQuery<(arg: bigint) => [number, Bytes] | undefined>;
+
+    /**
+     * Counter for the related counted storage map
+     *
+     * @param {Callback<number> =} callback
+     **/
+    counterForOverweight: GenericStorageQuery<() => number>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery;
+  };
+  /**
+   * Pallet `XcAssetConfig`'s storage queries
+   **/
+  xcAssetConfig: {
+    /**
+     * Mapping from an asset id to asset type.
+     * Can be used when receiving transaction specifying an asset directly,
+     * like transferring an asset from this chain to another.
+     *
+     * @param {bigint} arg
+     * @param {Callback<XcmVersionedMultiLocation | undefined> =} callback
+     **/
+    assetIdToLocation: GenericStorageQuery<(arg: bigint) => XcmVersionedMultiLocation | undefined>;
+
+    /**
+     * Mapping from an asset type to an asset id.
+     * Can be used when receiving a multilocation XCM message to retrieve
+     * the corresponding asset in which tokens should me minted.
+     *
+     * @param {XcmVersionedMultiLocation} arg
+     * @param {Callback<bigint | undefined> =} callback
+     **/
+    assetLocationToId: GenericStorageQuery<(arg: XcmVersionedMultiLocation) => bigint | undefined>;
+
+    /**
+     * Stores the units per second for local execution for a AssetLocation.
+     * This is used to know how to charge for XCM execution in a particular asset.
+     *
+     * Not all asset types are supported for payment. If value exists here, it means it is supported.
+     *
+     * @param {XcmVersionedMultiLocation} arg
+     * @param {Callback<bigint | undefined> =} callback
+     **/
+    assetLocationUnitsPerSecond: GenericStorageQuery<(arg: XcmVersionedMultiLocation) => bigint | undefined>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery;
+  };
+  /**
+   * Pallet `EVM`'s storage queries
+   **/
+  eVM: {
+    /**
+     *
+     * @param {H160} arg
+     * @param {Callback<Bytes> =} callback
+     **/
+    accountCodes: GenericStorageQuery<(arg: H160) => Bytes>;
+
+    /**
+     *
+     * @param {H160} arg
+     * @param {Callback<PalletEvmCodeMetadata | undefined> =} callback
+     **/
+    accountCodesMetadata: GenericStorageQuery<(arg: H160) => PalletEvmCodeMetadata | undefined>;
+
+    /**
+     *
+     * @param {[H160, H256]} arg
+     * @param {Callback<H256> =} callback
+     **/
+    accountStorages: GenericStorageQuery<(arg: [H160, H256]) => H256>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery;
+  };
+  /**
+   * Pallet `Ethereum`'s storage queries
+   **/
+  ethereum: {
+    /**
+     * Current building block's transactions and receipts.
+     *
+     * @param {Callback<Array<[EthereumTransactionTransactionV2, FpRpcTransactionStatus, EthereumReceiptReceiptV3]>> =} callback
+     **/
+    pending: GenericStorageQuery<
+      () => Array<[EthereumTransactionTransactionV2, FpRpcTransactionStatus, EthereumReceiptReceiptV3]>
+    >;
+
+    /**
+     * The current Ethereum block.
+     *
+     * @param {Callback<EthereumBlock | undefined> =} callback
+     **/
+    currentBlock: GenericStorageQuery<() => EthereumBlock | undefined>;
+
+    /**
+     * The current Ethereum receipts.
+     *
+     * @param {Callback<Array<EthereumReceiptReceiptV3> | undefined> =} callback
+     **/
+    currentReceipts: GenericStorageQuery<() => Array<EthereumReceiptReceiptV3> | undefined>;
+
+    /**
+     * The current transaction statuses.
+     *
+     * @param {Callback<Array<FpRpcTransactionStatus> | undefined> =} callback
+     **/
+    currentTransactionStatuses: GenericStorageQuery<() => Array<FpRpcTransactionStatus> | undefined>;
+
+    /**
+     *
+     * @param {U256} arg
+     * @param {Callback<H256> =} callback
+     **/
+    blockHash: GenericStorageQuery<(arg: U256) => H256>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery;
+  };
+  /**
+   * Pallet `DynamicEvmBaseFee`'s storage queries
+   **/
+  dynamicEvmBaseFee: {
+    /**
+     *
+     * @param {Callback<U256> =} callback
+     **/
+    baseFeePerGas: GenericStorageQuery<() => U256>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery;
+  };
+  /**
+   * Pallet `Contracts`'s storage queries
+   **/
+  contracts: {
+    /**
+     * A mapping from an original code hash to the original code, untouched by instrumentation.
+     *
+     * @param {H256} arg
+     * @param {Callback<Bytes | undefined> =} callback
+     **/
+    pristineCode: GenericStorageQuery<(arg: H256) => Bytes | undefined>;
+
+    /**
+     * A mapping between an original code hash and instrumented wasm code, ready for execution.
+     *
+     * @param {H256} arg
+     * @param {Callback<PalletContractsWasmPrefabWasmModule | undefined> =} callback
+     **/
+    codeStorage: GenericStorageQuery<(arg: H256) => PalletContractsWasmPrefabWasmModule | undefined>;
+
+    /**
+     * A mapping between an original code hash and its owner information.
+     *
+     * @param {H256} arg
+     * @param {Callback<PalletContractsWasmOwnerInfo | undefined> =} callback
+     **/
+    ownerInfoOf: GenericStorageQuery<(arg: H256) => PalletContractsWasmOwnerInfo | undefined>;
+
+    /**
+     * This is a **monotonic** counter incremented on contract instantiation.
+     *
+     * This is used in order to generate unique trie ids for contracts.
+     * The trie id of a new contract is calculated from hash(account_id, nonce).
+     * The nonce is required because otherwise the following sequence would lead to
+     * a possible collision of storage:
+     *
+     * 1. Create a new contract.
+     * 2. Terminate the contract.
+     * 3. Immediately recreate the contract with the same account_id.
+     *
+     * This is bad because the contents of a trie are deleted lazily and there might be
+     * storage of the old instantiation still in it when the new contract is created. Please
+     * note that we can't replace the counter by the block number because the sequence above
+     * can happen in the same block. We also can't keep the account counter in memory only
+     * because storage is the only way to communicate across different extrinsics in the
+     * same block.
+     *
+     * # Note
+     *
+     * Do not use it to determine the number of contracts. It won't be decremented if
+     * a contract is destroyed.
+     *
+     * @param {Callback<bigint> =} callback
+     **/
+    nonce: GenericStorageQuery<() => bigint>;
+
+    /**
+     * The code associated with a given account.
+     *
+     * TWOX-NOTE: SAFE since `AccountId` is a secure hash.
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<PalletContractsStorageContractInfo | undefined> =} callback
+     **/
+    contractInfoOf: GenericStorageQuery<(arg: AccountId32Like) => PalletContractsStorageContractInfo | undefined>;
+
+    /**
+     * 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`.
+     *
+     * @param {number} arg
+     * @param {Callback<Bytes | undefined> =} callback
+     **/
+    deletionQueue: GenericStorageQuery<(arg: number) => Bytes | undefined>;
+
+    /**
+     * A pair of monotonic counters used to track the latest contract marked for deletion
+     * and the latest deleted contract in queue.
+     *
+     * @param {Callback<PalletContractsStorageDeletionQueueManager> =} callback
+     **/
+    deletionQueueCounter: GenericStorageQuery<() => PalletContractsStorageDeletionQueueManager>;
+
+    /**
+     *
+     * @param {Callback<Bytes | undefined> =} callback
+     **/
+    migrationInProgress: GenericStorageQuery<() => Bytes | undefined>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery;
+  };
+  /**
+   * Pallet `Sudo`'s storage queries
+   **/
+  sudo: {
+    /**
+     * The `AccountId` of the sudo key.
+     *
+     * @param {Callback<AccountId32 | undefined> =} callback
+     **/
+    key: GenericStorageQuery<() => AccountId32 | undefined>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery;
+  };
+  /**
+   * Pallet `StaticPriceProvider`'s storage queries
+   **/
+  staticPriceProvider: {
+    /**
+     * Current active native currency price.
+     *
+     * @param {Callback<FixedU64> =} callback
+     **/
+    activePrice: GenericStorageQuery<() => FixedU64>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery;
+  };
+  /**
+   * Pallet `DappStakingMigration`'s storage queries
+   **/
+  dappStakingMigration: {
+    /**
+     * Used to store the current migration state.
+     *
+     * @param {Callback<PalletDappStakingMigrationMigrationState> =} callback
+     **/
+    migrationStateStorage: GenericStorageQuery<() => PalletDappStakingMigrationMigrationState>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery;
+  };
+  /**
+   * Pallet `DappsStaking`'s storage queries
+   **/
+  dappsStaking: {
+    /**
+     * Denotes whether pallet is disabled (in maintenance mode) or not
+     *
+     * @param {Callback<boolean> =} callback
+     **/
+    palletDisabled: GenericStorageQuery<() => boolean>;
+
+    /**
+     * Denotes whether pallet decommissioning has started or not.
+     *
+     * @param {Callback<boolean> =} callback
+     **/
+    decommissionStarted: GenericStorageQuery<() => boolean>;
+
+    /**
+     * General information about the staker (non-smart-contract specific).
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<PalletDappsStakingAccountLedger> =} callback
+     **/
+    ledger: GenericStorageQuery<(arg: AccountId32Like) => PalletDappsStakingAccountLedger>;
+
+    /**
+     * The current era index.
+     *
+     * @param {Callback<number> =} callback
+     **/
+    currentEra: GenericStorageQuery<() => number>;
+
+    /**
+     * Accumulator for block rewards during an era. It is reset at every new era
+     *
+     * @param {Callback<PalletDappsStakingRewardInfo> =} callback
+     **/
+    blockRewardAccumulator: GenericStorageQuery<() => PalletDappsStakingRewardInfo>;
+
+    /**
+     * Mode of era forcing.
+     *
+     * @param {Callback<PalletDappsStakingForcing> =} callback
+     **/
+    forceEra: GenericStorageQuery<() => PalletDappsStakingForcing>;
+
+    /**
+     * Stores the block number of when the next era starts
+     *
+     * @param {Callback<number> =} callback
+     **/
+    nextEraStartingBlock: GenericStorageQuery<() => number>;
+
+    /**
+     * Simple map where developer account points to their smart contract
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<AstarPrimitivesDappStakingSmartContract | undefined> =} callback
+     **/
+    registeredDevelopers: GenericStorageQuery<
+      (arg: AccountId32Like) => AstarPrimitivesDappStakingSmartContract | undefined
+    >;
+
+    /**
+     * Simple map where smart contract points to basic info about it (e.g. developer address, state)
+     *
+     * @param {AstarPrimitivesDappStakingSmartContract} arg
+     * @param {Callback<PalletDappsStakingDAppInfo | undefined> =} callback
+     **/
+    registeredDapps: GenericStorageQuery<
+      (arg: AstarPrimitivesDappStakingSmartContract) => PalletDappsStakingDAppInfo | undefined
+    >;
+
+    /**
+     * General information about an era like TVL, total staked value, rewards.
+     *
+     * @param {number} arg
+     * @param {Callback<PalletDappsStakingEraInfo | undefined> =} callback
+     **/
+    generalEraInfo: GenericStorageQuery<(arg: number) => PalletDappsStakingEraInfo | undefined>;
+
+    /**
+     * Staking information about contract in a particular era.
+     *
+     * @param {[AstarPrimitivesDappStakingSmartContract, number]} arg
+     * @param {Callback<PalletDappsStakingContractStakeInfo | undefined> =} callback
+     **/
+    contractEraStake: GenericStorageQuery<
+      (arg: [AstarPrimitivesDappStakingSmartContract, number]) => PalletDappsStakingContractStakeInfo | undefined
+    >;
+
+    /**
+     * Info about stakers stakes on particular contracts.
+     *
+     * @param {[AccountId32Like, AstarPrimitivesDappStakingSmartContract]} arg
+     * @param {Callback<PalletDappsStakingStakerInfo> =} callback
+     **/
+    generalStakerInfo: GenericStorageQuery<
+      (arg: [AccountId32Like, AstarPrimitivesDappStakingSmartContract]) => PalletDappsStakingStakerInfo
+    >;
+
+    /**
+     * Stores the current pallet storage version.
+     *
+     * @param {Callback<PalletDappsStakingVersion> =} callback
+     **/
+    storageVersion: GenericStorageQuery<() => PalletDappsStakingVersion>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery;
+  };
+}