@dedot/chaintypes 0.96.0 → 0.97.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dedot/chaintypes",
-  "version": "0.96.0",
+  "version": "0.97.0",
   "description": "Types for substrate-based chains",
   "author": "Thang X. Vu <thang@coongcrafts.io>",
   "main": "",
@@ -19,7 +19,7 @@
     "directory": "dist"
   },
   "license": "Apache-2.0",
-  "gitHead": "b4fe69d0a2fbcc182ded6fe3f7e1b1deecc34831",
+  "gitHead": "d7eca2ab18e1e83fd127f623513441e1c868a500",
   "module": "./index.js",
   "types": "./index.d.ts",
   "exports": {

package/westend/consts.d.ts

@@ -269,6 +269,11 @@ export interface ChainConsts<Rv extends RpcVersion> extends GenericChainConsts<R
      **/
     maxExposurePageSize: number;
 
+    /**
+     * The absolute maximum of winner validators this pallet should return.
+     **/
+    maxValidatorSet: number;
+
     /**
      * The maximum number of `unlocking` chunks a [`StakingLedger`] can
      * have. Effectively determines how many unique eras a staker may be
@@ -690,12 +695,18 @@ export interface ChainConsts<Rv extends RpcVersion> extends GenericChainConsts<R
     signedDepositWeight: bigint;
 
     /**
-     * The maximum number of winners that can be elected by this `ElectionProvider`
-     * implementation.
+     * Maximum number of winners that an election supports.
      *
      * Note: This must always be greater or equal to `T::DataProvider::desired_targets()`.
      **/
     maxWinners: number;
+
+    /**
+     * Maximum number of voters that can support a winner in an election solution.
+     *
+     * This is needed to ensure election computation is bounded.
+     **/
+    maxBackersPerWinner: number;
     minerMaxLength: number;
     minerMaxWeight: SpWeightsWeightV2Weight;
     minerMaxVotesPerVoter: number;
@@ -1250,6 +1261,15 @@ export interface ChainConsts<Rv extends RpcVersion> extends GenericChainConsts<R
      **/
     [name: string]: any;
   };
+  /**
+   * Pallet `AssetHubStakingClient`'s constants
+   **/
+  assetHubStakingClient: {
+    /**
+     * Generic pallet constant
+     **/
+    [name: string]: any;
+  };
   /**
    * Pallet `MultiBlockMigrations`'s constants
    **/
@@ -1279,6 +1299,12 @@ export interface ChainConsts<Rv extends RpcVersion> extends GenericChainConsts<R
    * Pallet `XcmPallet`'s constants
    **/
   xcmPallet: {
+    /**
+     * The latest supported version that we advertise. Generally just set it to
+     * `pallet_xcm::CurrentXcmVersion`.
+     **/
+    advertisedXcmVersion: number;
+
     /**
      * Generic pallet constant
      **/
@@ -1420,4 +1446,13 @@ export interface ChainConsts<Rv extends RpcVersion> extends GenericChainConsts<R
      **/
     [name: string]: any;
   };
+  /**
+   * Pallet `RcMigrator`'s constants
+   **/
+  rcMigrator: {
+    /**
+     * Generic pallet constant
+     **/
+    [name: string]: any;
+  };
 }

package/westend/errors.d.ts

@@ -1074,6 +1074,11 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
      **/
     List: GenericPalletError<Rv>;
 
+    /**
+     * Could not update a node, because the pallet is locked.
+     **/
+    Locked: GenericPalletError<Rv>;
+
     /**
      * Generic pallet error
      **/
@@ -2512,6 +2517,20 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
      **/
     [error: string]: GenericPalletError<Rv>;
   };
+  /**
+   * Pallet `AssetHubStakingClient`'s errors
+   **/
+  assetHubStakingClient: {
+    /**
+     * Could not process incoming message because incoming messages are blocked.
+     **/
+    Blocked: GenericPalletError<Rv>;
+
+    /**
+     * Generic pallet error
+     **/
+    [error: string]: GenericPalletError<Rv>;
+  };
   /**
    * Pallet `MultiBlockMigrations`'s errors
    **/
@@ -2835,6 +2854,43 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
      **/
     InvalidConfiguration: GenericPalletError<Rv>;
 
+    /**
+     * Generic pallet error
+     **/
+    [error: string]: GenericPalletError<Rv>;
+  };
+  /**
+   * Pallet `RcMigrator`'s errors
+   **/
+  rcMigrator: {
+    Unreachable: GenericPalletError<Rv>;
+    OutOfWeight: GenericPalletError<Rv>;
+
+    /**
+     * Failed to send XCM message to AH.
+     **/
+    XcmError: GenericPalletError<Rv>;
+
+    /**
+     * Failed to withdraw account from RC for migration to AH.
+     **/
+    FailedToWithdrawAccount: GenericPalletError<Rv>;
+
+    /**
+     * Indicates that the specified block number is in the past.
+     **/
+    PastBlockNumber: GenericPalletError<Rv>;
+
+    /**
+     * Balance accounting overflow.
+     **/
+    BalanceOverflow: GenericPalletError<Rv>;
+
+    /**
+     * Balance accounting underflow.
+     **/
+    BalanceUnderflow: GenericPalletError<Rv>;
+
     /**
      * Generic pallet error
      **/

package/westend/events.d.ts

@@ -11,6 +11,7 @@ import type {
   WestendRuntimeRuntimeParametersKey,
   WestendRuntimeRuntimeParametersValue,
   SpConsensusGrandpaAppPublic,
+  PalletRecoveryDepositKind,
   WestendRuntimeProxyType,
   PalletProxyDepositKind,
   PalletMultisigTimepoint,
@@ -38,6 +39,7 @@ import type {
   PolkadotCorePrimitivesCandidateHash,
   PolkadotRuntimeParachainsDisputesDisputeLocation,
   PolkadotRuntimeParachainsDisputesDisputeResult,
+  PalletStakingAsyncAhClientUnexpectedKind,
   StagingXcmV5TraitsOutcome,
   StagingXcmV5Location,
   StagingXcmV5Xcm,
@@ -49,6 +51,7 @@ import type {
   StagingXcmV5AssetAssets,
   PolkadotRuntimeParachainsInclusionAggregateMessageOrigin,
   FrameSupportMessagesProcessMessageError,
+  PalletRcMigratorMigrationStage,
 } from './types.js';
 
 export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<Rv> {
@@ -459,6 +462,25 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      **/
     [prop: string]: GenericPalletEvent<Rv>;
   };
+  /**
+   * Pallet `Historical`'s events
+   **/
+  historical: {
+    /**
+     * The merkle root of the validators of the said session were stored
+     **/
+    RootStored: GenericPalletEvent<Rv, 'Historical', 'RootStored', { index: number }>;
+
+    /**
+     * The merkle roots of up to this session index were pruned
+     **/
+    RootsPruned: GenericPalletEvent<Rv, 'Historical', 'RootsPruned', { upTo: number }>;
+
+    /**
+     * Generic pallet event
+     **/
+    [prop: string]: GenericPalletEvent<Rv>;
+  };
   /**
    * Pallet `Parameters`'s events
    **/
@@ -505,6 +527,12 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      **/
     NewSession: GenericPalletEvent<Rv, 'Session', 'NewSession', { sessionIndex: number }>;
 
+    /**
+     * The `NewSession` event in the current block also implies a new validator set to be
+     * queued.
+     **/
+    NewQueued: GenericPalletEvent<Rv, 'Session', 'NewQueued', null>;
+
     /**
      * Validator has been disabled.
      **/
@@ -824,6 +852,16 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      **/
     RecoveryRemoved: GenericPalletEvent<Rv, 'Recovery', 'RecoveryRemoved', { lostAccount: AccountId32 }>;
 
+    /**
+     * A deposit has been updated.
+     **/
+    DepositPoked: GenericPalletEvent<
+      Rv,
+      'Recovery',
+      'DepositPoked',
+      { who: AccountId32; kind: PalletRecoveryDepositKind; oldDeposit: bigint; newDeposit: bigint }
+    >;
+
     /**
      * Generic pallet event
      **/
@@ -833,6 +871,16 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
    * Pallet `Vesting`'s events
    **/
   vesting: {
+    /**
+     * A vesting schedule has been created.
+     **/
+    VestingCreated: GenericPalletEvent<
+      Rv,
+      'Vesting',
+      'VestingCreated',
+      { account: AccountId32; scheduleIndex: number }
+    >;
+
     /**
      * The amount vested has been updated. This could indicate a change in funds available.
      * The balance given is the amount which is left unvested (and thus locked).
@@ -1052,6 +1100,16 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
       { pure: AccountId32; who: AccountId32; proxyType: WestendRuntimeProxyType; disambiguationIndex: number }
     >;
 
+    /**
+     * A pure proxy was killed by its spawner.
+     **/
+    PureKilled: GenericPalletEvent<
+      Rv,
+      'Proxy',
+      'PureKilled',
+      { pure: AccountId32; spawner: AccountId32; proxyType: WestendRuntimeProxyType; disambiguationIndex: number }
+    >;
+
     /**
      * An announcement was placed to make a call in the future.
      **/
@@ -2210,6 +2268,21 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
       [PolkadotParachainPrimitivesPrimitivesValidationCodeHash, PolkadotParachainPrimitivesPrimitivesId]
     >;
 
+    /**
+     * The upgrade cooldown was removed.
+     **/
+    UpgradeCooldownRemoved: GenericPalletEvent<
+      Rv,
+      'Paras',
+      'UpgradeCooldownRemoved',
+      {
+        /**
+         * The parachain for which the cooldown got removed.
+         **/
+        paraId: PolkadotParachainPrimitivesPrimitivesId;
+      }
+    >;
+
     /**
      * Generic pallet event
      **/
@@ -2681,6 +2754,45 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      **/
     [prop: string]: GenericPalletEvent<Rv>;
   };
+  /**
+   * Pallet `AssetHubStakingClient`'s events
+   **/
+  assetHubStakingClient: {
+    /**
+     * A new validator set has been received.
+     **/
+    ValidatorSetReceived: GenericPalletEvent<
+      Rv,
+      'AssetHubStakingClient',
+      'ValidatorSetReceived',
+      { id: number; newValidatorSetCount: number; pruneUpTo?: number | undefined; leftover: boolean }
+    >;
+
+    /**
+     * We could not merge, and therefore dropped a buffered message.
+     *
+     * Note that this event is more resembling an error, but we use an event because in this
+     * pallet we need to mutate storage upon some failures.
+     **/
+    CouldNotMergeAndDropped: GenericPalletEvent<Rv, 'AssetHubStakingClient', 'CouldNotMergeAndDropped', null>;
+
+    /**
+     * The validator set received is way too small, as per
+     * [`Config::MinimumValidatorSetSize`].
+     **/
+    SetTooSmallAndDropped: GenericPalletEvent<Rv, 'AssetHubStakingClient', 'SetTooSmallAndDropped', null>;
+
+    /**
+     * Something occurred that should never happen under normal operation. Logged as an event
+     * for fail-safe observability.
+     **/
+    Unexpected: GenericPalletEvent<Rv, 'AssetHubStakingClient', 'Unexpected', PalletStakingAsyncAhClientUnexpectedKind>;
+
+    /**
+     * Generic pallet event
+     **/
+    [prop: string]: GenericPalletEvent<Rv>;
+  };
   /**
    * Pallet `MultiBlockMigrations`'s events
    **/
@@ -3360,6 +3472,54 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
       { who: AccountId32; identity: bigint; subs: bigint }
     >;
 
+    /**
+     * Generic pallet event
+     **/
+    [prop: string]: GenericPalletEvent<Rv>;
+  };
+  /**
+   * Pallet `RcMigrator`'s events
+   **/
+  rcMigrator: {
+    /**
+     * A stage transition has occurred.
+     **/
+    StageTransition: GenericPalletEvent<
+      Rv,
+      'RcMigrator',
+      'StageTransition',
+      {
+        /**
+         * The old stage before the transition.
+         **/
+        old: PalletRcMigratorMigrationStage;
+
+        /**
+         * The new stage after the transition.
+         **/
+        new: PalletRcMigratorMigrationStage;
+      }
+    >;
+
+    /**
+     * The Asset Hub Migration started and is active until `AssetHubMigrationFinished` is
+     * emitted.
+     *
+     * This event is equivalent to `StageTransition { new: Initializing, .. }` but is easier
+     * to understand. The activation is immediate and affects all events happening
+     * afterwards.
+     **/
+    AssetHubMigrationStarted: GenericPalletEvent<Rv, 'RcMigrator', 'AssetHubMigrationStarted', null>;
+
+    /**
+     * The Asset Hub Migration finished.
+     *
+     * This event is equivalent to `StageTransition { new: MigrationDone, .. }` but is easier
+     * to understand. The finishing is immediate and affects all events happening
+     * afterwards.
+     **/
+    AssetHubMigrationFinished: GenericPalletEvent<Rv, 'RcMigrator', 'AssetHubMigrationFinished', null>;
+
     /**
      * Generic pallet event
      **/

package/westend/index.d.ts

@@ -23,7 +23,7 @@ export interface VersionedWestendApi<Rv extends RpcVersion> extends GenericSubst
 
 /**
  * @name: WestendApi
- * @specVersion: 1018002
+ * @specVersion: 1018003
  **/
 export interface WestendApi {
   legacy: VersionedWestendApi<RpcLegacy>;

package/westend/query.d.ts

@@ -131,6 +131,9 @@ import type {
   PolkadotRuntimeCommonParasRegistrarParaInfo,
   PolkadotRuntimeCommonCrowdloanFundInfo,
   PolkadotRuntimeCommonAssignedSlotsParachainTemporarySlot,
+  PalletStakingAsyncRcClientValidatorSetReport,
+  PalletStakingAsyncAhClientOperatingMode,
+  PalletStakingAsyncRcClientOffence,
   PalletMigrationsMigrationCursor,
   PalletXcmQueryStatus,
   XcmVersionedLocation,
@@ -145,6 +148,9 @@ import type {
   PolkadotRuntimeCommonImplsVersionedLocatableAsset,
   SpConsensusBeefyEcdsaCryptoPublic,
   SpConsensusBeefyMmrBeefyAuthoritySet,
+  PalletRcMigratorMigrationStage,
+  PalletRcMigratorAccountsAccountState,
+  PalletRcMigratorAccountsMigratedBalances,
 } from './types.js';
 
 export interface ChainStorage<Rv extends RpcVersion> extends GenericChainStorage<Rv> {
@@ -1852,6 +1858,16 @@ export interface ChainStorage<Rv extends RpcVersion> extends GenericChainStorage
      **/
     listBags: GenericStorageQuery<Rv, (arg: bigint) => PalletBagsListListBag | undefined, bigint>;
 
+    /**
+     * 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.
+     *
+     * @param {Callback<[] | undefined> =} callback
+     **/
+    lock: GenericStorageQuery<Rv, () => [] | undefined>;
+
     /**
      * Generic pallet storage query
      **/
@@ -3577,6 +3593,94 @@ export interface ChainStorage<Rv extends RpcVersion> extends GenericChainStorage
      **/
     [storage: string]: GenericStorageQuery<Rv>;
   };
+  /**
+   * Pallet `AssetHubStakingClient`'s storage queries
+   **/
+  assetHubStakingClient: {
+    /**
+     * The queued validator sets for a given planning session index.
+     *
+     * This is received via a call from AssetHub.
+     *
+     * @param {Callback<[number, Array<AccountId32>] | undefined> =} callback
+     **/
+    validatorSet: GenericStorageQuery<Rv, () => [number, Array<AccountId32>] | undefined>;
+
+    /**
+     * An incomplete validator set report.
+     *
+     * @param {Callback<PalletStakingAsyncRcClientValidatorSetReport | undefined> =} callback
+     **/
+    incompleteValidatorSetReport: GenericStorageQuery<
+      Rv,
+      () => PalletStakingAsyncRcClientValidatorSetReport | undefined
+    >;
+
+    /**
+     * All of the points of the validators.
+     *
+     * This is populated during a session, and is flushed and sent over via [`SendToAssetHub`]
+     * at each session end.
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<number> =} callback
+     **/
+    validatorPoints: GenericStorageQuery<Rv, (arg: AccountId32Like) => number, AccountId32>;
+
+    /**
+     * Indicates the current operating mode of the pallet.
+     *
+     * This value determines how the pallet behaves in response to incoming and outgoing messages,
+     * particularly whether it should execute logic directly, defer it, or delegate it entirely.
+     *
+     * @param {Callback<PalletStakingAsyncAhClientOperatingMode> =} callback
+     **/
+    mode: GenericStorageQuery<Rv, () => PalletStakingAsyncAhClientOperatingMode>;
+
+    /**
+     * A storage value that is set when a `new_session` gives a new validator set to the session
+     * pallet, and is cleared on the next call.
+     *
+     * The inner u32 is the id of the said activated validator set. While not relevant here, good
+     * to know this is the planning era index of staking-async on AH.
+     *
+     * Once cleared, we know a validator set has been activated, and therefore we can send a
+     * timestamp to AH.
+     *
+     * @param {Callback<number | undefined> =} callback
+     **/
+    nextSessionChangesValidators: GenericStorageQuery<Rv, () => number | undefined>;
+
+    /**
+     * The session index at which the latest elected validator set was applied.
+     *
+     * This is used to determine if an offence, given a session index, is in the current active era
+     * or not.
+     *
+     * @param {Callback<number | undefined> =} callback
+     **/
+    validatorSetAppliedAt: GenericStorageQuery<Rv, () => number | undefined>;
+
+    /**
+     * Stores offences that have been received while the pallet is in [`OperatingMode::Buffered`]
+     * mode.
+     *
+     * These offences are collected and buffered for later processing when the pallet transitions
+     * to [`OperatingMode::Active`]. This allows the system to defer slashing or reporting logic
+     * until communication with the counterpart pallet on AssetHub is fully established.
+     *
+     * This storage is only used in `Buffered` mode; in `Active` mode, offences are immediately
+     * sent, and in `Passive` mode, they are delegated to the [`Config::Fallback`] implementation.
+     *
+     * @param {Callback<Array<[number, Array<PalletStakingAsyncRcClientOffence>]>> =} callback
+     **/
+    bufferedOffences: GenericStorageQuery<Rv, () => Array<[number, Array<PalletStakingAsyncRcClientOffence>]>>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
   /**
    * Pallet `MultiBlockMigrations`'s storage queries
    **/
@@ -3945,6 +4049,53 @@ export interface ChainStorage<Rv extends RpcVersion> extends GenericChainStorage
      **/
     beefyNextAuthorities: GenericStorageQuery<Rv, () => SpConsensusBeefyMmrBeefyAuthoritySet>;
 
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `RcMigrator`'s storage queries
+   **/
+  rcMigrator: {
+    /**
+     * The Relay Chain migration state.
+     *
+     * @param {Callback<PalletRcMigratorMigrationStage> =} callback
+     **/
+    rcMigrationStage: GenericStorageQuery<Rv, () => PalletRcMigratorMigrationStage>;
+
+    /**
+     * Helper storage item to obtain and store the known accounts that should be kept partially or
+     * fully on Relay Chain.
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<PalletRcMigratorAccountsAccountState | undefined> =} callback
+     **/
+    rcAccounts: GenericStorageQuery<
+      Rv,
+      (arg: AccountId32Like) => PalletRcMigratorAccountsAccountState | undefined,
+      AccountId32
+    >;
+
+    /**
+     * Helper storage item to store the total balance that should be kept on Relay Chain.
+     *
+     * @param {Callback<PalletRcMigratorAccountsMigratedBalances> =} callback
+     **/
+    rcMigratedBalance: GenericStorageQuery<Rv, () => PalletRcMigratorAccountsMigratedBalances>;
+
+    /**
+     * The total number of XCM data messages sent to the Asset Hub and the number of XCM messages
+     * the Asset Hub has confirmed as processed.
+     *
+     * The difference between these two numbers are the messages that are "in-flight". We aim to
+     * keep this number low to not accidentally overload the asset hub.
+     *
+     * @param {Callback<[number, number]> =} callback
+     **/
+    dmpDataMessageCounts: GenericStorageQuery<Rv, () => [number, number]>;
+
     /**
      * Generic pallet storage query
      **/