@dedot/chaintypes 0.72.0 → 0.73.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dedot/chaintypes",
-  "version": "0.72.0",
+  "version": "0.73.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": "cf860568f0e7ec8b51e4469dfdc1f4666ecaa673",
+  "gitHead": "904274b4e8bb344ddd4e5dbae115d4a2fb317180",
   "module": "./index.js",
   "types": "./index.d.ts"
 }

package/polkadot-asset-hub/consts.d.ts

@@ -771,6 +771,40 @@ export interface ChainConsts<Rv extends RpcVersion> extends GenericChainConsts<R
      **/
     palletId: FrameSupportPalletId;
 
+    /**
+     * Generic pallet constant
+     **/
+    [name: string]: any;
+  };
+  /**
+   * Pallet `StateTrieMigration`'s constants
+   **/
+  stateTrieMigration: {
+    /**
+     * Maximal number of bytes that a key can have.
+     *
+     * FRAME itself does not limit the key length.
+     * The concrete value must therefore depend on your storage usage.
+     * A [`frame_support::storage::StorageNMap`] for example can have an arbitrary number of
+     * keys which are then hashed and concatenated, resulting in arbitrarily long keys.
+     *
+     * Use the *state migration RPC* to retrieve the length of the longest key in your
+     * storage: <https://github.com/paritytech/substrate/issues/11642>
+     *
+     * The migration will halt with a `Halted` event if this value is too small.
+     * Since there is no real penalty from over-estimating, it is advised to use a large
+     * value. The default is 512 byte.
+     *
+     * Some key lengths for reference:
+     * - [`frame_support::storage::StorageValue`]: 32 byte
+     * - [`frame_support::storage::StorageMap`]: 64 byte
+     * - [`frame_support::storage::StorageDoubleMap`]: 96 byte
+     *
+     * For more info see
+     * <https://www.shawntabrizi.com/blog/substrate/querying-substrate-storage-via-rpc/>
+     **/
+    maxKeyLen: number;
+
     /**
      * Generic pallet constant
      **/

package/polkadot-asset-hub/errors.d.ts

@@ -1517,6 +1517,51 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
      **/
     BelowMinimum: GenericPalletError<Rv>;
 
+    /**
+     * Generic pallet error
+     **/
+    [error: string]: GenericPalletError<Rv>;
+  };
+  /**
+   * Pallet `StateTrieMigration`'s errors
+   **/
+  stateTrieMigration: {
+    /**
+     * Max signed limits not respected.
+     **/
+    MaxSignedLimits: GenericPalletError<Rv>;
+
+    /**
+     * A key was longer than the configured maximum.
+     *
+     * This means that the migration halted at the current [`Progress`] and
+     * can be resumed with a larger [`crate::Config::MaxKeyLen`] value.
+     * Retrying with the same [`crate::Config::MaxKeyLen`] value will not work.
+     * The value should only be increased to avoid a storage migration for the currently
+     * stored [`crate::Progress::LastKey`].
+     **/
+    KeyTooLong: GenericPalletError<Rv>;
+
+    /**
+     * submitter does not have enough funds.
+     **/
+    NotEnoughFunds: GenericPalletError<Rv>;
+
+    /**
+     * Bad witness data provided.
+     **/
+    BadWitness: GenericPalletError<Rv>;
+
+    /**
+     * Signed migration is not allowed because the maximum limit is not set yet.
+     **/
+    SignedMigrationNotAllowed: GenericPalletError<Rv>;
+
+    /**
+     * Bad child root provided.
+     **/
+    BadChildRoot: GenericPalletError<Rv>;
+
     /**
      * Generic pallet error
      **/

package/polkadot-asset-hub/events.d.ts

@@ -30,6 +30,8 @@ import type {
   PalletNftsAttributeNamespace,
   PalletNftsPriceWithDirection,
   PalletNftsPalletAttributes,
+  PalletStateTrieMigrationMigrationCompute,
+  PalletStateTrieMigrationError,
 } from './types';
 
 export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<Rv> {
@@ -2473,6 +2475,41 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
       }
     >;
 
+    /**
+     * Generic pallet event
+     **/
+    [prop: string]: GenericPalletEvent<Rv>;
+  };
+  /**
+   * Pallet `StateTrieMigration`'s events
+   **/
+  stateTrieMigration: {
+    /**
+     * Given number of `(top, child)` keys were migrated respectively, with the given
+     * `compute`.
+     **/
+    Migrated: GenericPalletEvent<
+      Rv,
+      'StateTrieMigration',
+      'Migrated',
+      { top: number; child: number; compute: PalletStateTrieMigrationMigrationCompute }
+    >;
+
+    /**
+     * Some account got slashed by the given amount.
+     **/
+    Slashed: GenericPalletEvent<Rv, 'StateTrieMigration', 'Slashed', { who: AccountId32; amount: bigint }>;
+
+    /**
+     * The auto migration task finished.
+     **/
+    AutoMigrationFinished: GenericPalletEvent<Rv, 'StateTrieMigration', 'AutoMigrationFinished', null>;
+
+    /**
+     * Migration got halted due to an error or miss-configuration.
+     **/
+    Halted: GenericPalletEvent<Rv, 'StateTrieMigration', 'Halted', { error: PalletStateTrieMigrationError }>;
+
     /**
      * Generic pallet event
      **/

package/polkadot-asset-hub/index.d.ts

@@ -23,7 +23,7 @@ export interface VersionedPolkadotAssetHubApi<Rv extends RpcVersion> extends Gen
 
 /**
  * @name: PolkadotAssetHubApi
- * @specVersion: 1004000
+ * @specVersion: 1004002
  **/
 export interface PolkadotAssetHubApi {
   legacy: VersionedPolkadotAssetHubApi<RpcLegacy>;

package/polkadot-asset-hub/query.d.ts

@@ -78,6 +78,8 @@ import type {
   PalletNftsItemConfig,
   StagingXcmV4Location,
   PalletAssetConversionPoolInfo,
+  PalletStateTrieMigrationMigrationTask,
+  PalletStateTrieMigrationMigrationLimits,
 } from './types';
 
 export interface ChainStorage<Rv extends RpcVersion> extends GenericChainStorage<Rv> {
@@ -1721,6 +1723,43 @@ export interface ChainStorage<Rv extends RpcVersion> extends GenericChainStorage
      **/
     nextPoolAssetId: GenericStorageQuery<Rv, () => number | undefined>;
 
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `StateTrieMigration`'s storage queries
+   **/
+  stateTrieMigration: {
+    /**
+     * 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.
+     *
+     * @param {Callback<PalletStateTrieMigrationMigrationTask> =} callback
+     **/
+    migrationProcess: GenericStorageQuery<Rv, () => PalletStateTrieMigrationMigrationTask>;
+
+    /**
+     * The limits that are imposed on automatic migrations.
+     *
+     * If set to None, then no automatic migration happens.
+     *
+     * @param {Callback<PalletStateTrieMigrationMigrationLimits | undefined> =} callback
+     **/
+    autoLimits: GenericStorageQuery<Rv, () => PalletStateTrieMigrationMigrationLimits | undefined>;
+
+    /**
+     * The maximum limits that the signed migration could use.
+     *
+     * If not set, no signed submission is allowed.
+     *
+     * @param {Callback<PalletStateTrieMigrationMigrationLimits | undefined> =} callback
+     **/
+    signedMigrationMaxLimits: GenericStorageQuery<Rv, () => PalletStateTrieMigrationMigrationLimits | undefined>;
+
     /**
      * Generic pallet storage query
      **/

package/polkadot-asset-hub/tx.d.ts

@@ -44,6 +44,9 @@ import type {
   PalletNftsPriceWithDirection,
   PalletNftsPreSignedMint,
   PalletNftsPreSignedAttributes,
+  PalletStateTrieMigrationMigrationLimits,
+  PalletStateTrieMigrationMigrationTask,
+  PalletStateTrieMigrationProgress,
 } from './types';
 
 export type ChainSubmittableExtrinsic<
@@ -9115,6 +9118,191 @@ export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCal
       >
     >;
 
+    /**
+     * Generic pallet tx call
+     **/
+    [callName: string]: GenericTxCall<Rv, TxCall<Rv>>;
+  };
+  /**
+   * Pallet `StateTrieMigration`'s transaction calls
+   **/
+  stateTrieMigration: {
+    /**
+     * Control the automatic migration.
+     *
+     * The dispatch origin of this call must be [`Config::ControlOrigin`].
+     *
+     * @param {PalletStateTrieMigrationMigrationLimits | undefined} maybeConfig
+     **/
+    controlAutoMigration: GenericTxCall<
+      Rv,
+      (maybeConfig: PalletStateTrieMigrationMigrationLimits | undefined) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'StateTrieMigration';
+          palletCall: {
+            name: 'ControlAutoMigration';
+            params: { maybeConfig: PalletStateTrieMigrationMigrationLimits | undefined };
+          };
+        }
+      >
+    >;
+
+    /**
+     * Continue the migration for the given `limits`.
+     *
+     * The dispatch origin of this call can be any signed account.
+     *
+     * This transaction has NO MONETARY INCENTIVES. calling it will not reward anyone. Albeit,
+     * Upon successful execution, the transaction fee is returned.
+     *
+     * The (potentially over-estimated) of the byte length of all the data read must be
+     * provided for up-front fee-payment and weighing. In essence, the caller is guaranteeing
+     * that executing the current `MigrationTask` with the given `limits` will not exceed
+     * `real_size_upper` bytes of read data.
+     *
+     * The `witness_task` is merely a helper to prevent the caller from being slashed or
+     * generally trigger a migration that they do not intend. This parameter is just a message
+     * from caller, saying that they believed `witness_task` was the last state of the
+     * migration, and they only wish for their transaction to do anything, if this assumption
+     * holds. In case `witness_task` does not match, the transaction fails.
+     *
+     * Based on the documentation of [`MigrationTask::migrate_until_exhaustion`], the
+     * recommended way of doing this is to pass a `limit` that only bounds `count`, as the
+     * `size` limit can always be overwritten.
+     *
+     * @param {PalletStateTrieMigrationMigrationLimits} limits
+     * @param {number} realSizeUpper
+     * @param {PalletStateTrieMigrationMigrationTask} witnessTask
+     **/
+    continueMigrate: GenericTxCall<
+      Rv,
+      (
+        limits: PalletStateTrieMigrationMigrationLimits,
+        realSizeUpper: number,
+        witnessTask: PalletStateTrieMigrationMigrationTask,
+      ) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'StateTrieMigration';
+          palletCall: {
+            name: 'ContinueMigrate';
+            params: {
+              limits: PalletStateTrieMigrationMigrationLimits;
+              realSizeUpper: number;
+              witnessTask: PalletStateTrieMigrationMigrationTask;
+            };
+          };
+        }
+      >
+    >;
+
+    /**
+     * Migrate the list of top keys by iterating each of them one by one.
+     *
+     * This does not affect the global migration process tracker ([`MigrationProcess`]), and
+     * should only be used in case any keys are leftover due to a bug.
+     *
+     * @param {Array<BytesLike>} keys
+     * @param {number} witnessSize
+     **/
+    migrateCustomTop: GenericTxCall<
+      Rv,
+      (
+        keys: Array<BytesLike>,
+        witnessSize: number,
+      ) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'StateTrieMigration';
+          palletCall: {
+            name: 'MigrateCustomTop';
+            params: { keys: Array<BytesLike>; witnessSize: number };
+          };
+        }
+      >
+    >;
+
+    /**
+     * Migrate the list of child keys by iterating each of them one by one.
+     *
+     * All of the given child keys must be present under one `child_root`.
+     *
+     * This does not affect the global migration process tracker ([`MigrationProcess`]), and
+     * should only be used in case any keys are leftover due to a bug.
+     *
+     * @param {BytesLike} root
+     * @param {Array<BytesLike>} childKeys
+     * @param {number} totalSize
+     **/
+    migrateCustomChild: GenericTxCall<
+      Rv,
+      (
+        root: BytesLike,
+        childKeys: Array<BytesLike>,
+        totalSize: number,
+      ) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'StateTrieMigration';
+          palletCall: {
+            name: 'MigrateCustomChild';
+            params: { root: BytesLike; childKeys: Array<BytesLike>; totalSize: number };
+          };
+        }
+      >
+    >;
+
+    /**
+     * Set the maximum limit of the signed migration.
+     *
+     * @param {PalletStateTrieMigrationMigrationLimits} limits
+     **/
+    setSignedMaxLimits: GenericTxCall<
+      Rv,
+      (limits: PalletStateTrieMigrationMigrationLimits) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'StateTrieMigration';
+          palletCall: {
+            name: 'SetSignedMaxLimits';
+            params: { limits: PalletStateTrieMigrationMigrationLimits };
+          };
+        }
+      >
+    >;
+
+    /**
+     * Forcefully set the progress the running migration.
+     *
+     * This is only useful in one case: the next key to migrate is too big to be migrated with
+     * a signed account, in a parachain context, and we simply want to skip it. A reasonable
+     * example of this would be `:code:`, which is both very expensive to migrate, and commonly
+     * used, so probably it is already migrated.
+     *
+     * In case you mess things up, you can also, in principle, use this to reset the migration
+     * process.
+     *
+     * @param {PalletStateTrieMigrationProgress} progressTop
+     * @param {PalletStateTrieMigrationProgress} progressChild
+     **/
+    forceSetProgress: GenericTxCall<
+      Rv,
+      (
+        progressTop: PalletStateTrieMigrationProgress,
+        progressChild: PalletStateTrieMigrationProgress,
+      ) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'StateTrieMigration';
+          palletCall: {
+            name: 'ForceSetProgress';
+            params: { progressTop: PalletStateTrieMigrationProgress; progressChild: PalletStateTrieMigrationProgress };
+          };
+        }
+      >
+    >;
+
     /**
      * Generic pallet tx call
      **/

package/polkadot-asset-hub/types.d.ts

@@ -70,7 +70,8 @@ export type AssetHubPolkadotRuntimeRuntimeEvent =
   | { pallet: 'Nfts'; palletEvent: PalletNftsEvent }
   | { pallet: 'ForeignAssets'; palletEvent: PalletAssetsEvent002 }
   | { pallet: 'PoolAssets'; palletEvent: PalletAssetsEvent }
-  | { pallet: 'AssetConversion'; palletEvent: PalletAssetConversionEvent };
+  | { pallet: 'AssetConversion'; palletEvent: PalletAssetConversionEvent }
+  | { pallet: 'StateTrieMigration'; palletEvent: PalletStateTrieMigrationEvent };
 
 /**
  * Event for the System pallet.
@@ -2079,6 +2080,65 @@ export type PalletAssetConversionEvent =
       };
     };
 
+/**
+ * Inner events of this pallet.
+ **/
+export type PalletStateTrieMigrationEvent =
+  /**
+   * Given number of `(top, child)` keys were migrated respectively, with the given
+   * `compute`.
+   **/
+  | { name: 'Migrated'; data: { top: number; child: number; compute: PalletStateTrieMigrationMigrationCompute } }
+  /**
+   * Some account got slashed by the given amount.
+   **/
+  | { name: 'Slashed'; data: { who: AccountId32; amount: bigint } }
+  /**
+   * The auto migration task finished.
+   **/
+  | { name: 'AutoMigrationFinished' }
+  /**
+   * Migration got halted due to an error or miss-configuration.
+   **/
+  | { name: 'Halted'; data: { error: PalletStateTrieMigrationError } };
+
+export type PalletStateTrieMigrationMigrationCompute = 'Signed' | 'Auto';
+
+/**
+ * The `Error` enum of this pallet.
+ **/
+export type PalletStateTrieMigrationError =
+  /**
+   * Max signed limits not respected.
+   **/
+  | 'MaxSignedLimits'
+  /**
+   * A key was longer than the configured maximum.
+   *
+   * This means that the migration halted at the current [`Progress`] and
+   * can be resumed with a larger [`crate::Config::MaxKeyLen`] value.
+   * Retrying with the same [`crate::Config::MaxKeyLen`] value will not work.
+   * The value should only be increased to avoid a storage migration for the currently
+   * stored [`crate::Progress::LastKey`].
+   **/
+  | 'KeyTooLong'
+  /**
+   * submitter does not have enough funds.
+   **/
+  | 'NotEnoughFunds'
+  /**
+   * Bad witness data provided.
+   **/
+  | 'BadWitness'
+  /**
+   * Signed migration is not allowed because the maximum limit is not set yet.
+   **/
+  | 'SignedMigrationNotAllowed'
+  /**
+   * Bad child root provided.
+   **/
+  | 'BadChildRoot';
+
 export type FrameSystemLastRuntimeUpgradeInfo = { specVersion: number; specName: string };
 
 export type FrameSystemCodeUpgradeAuthorization = { codeHash: H256; checkVersion: boolean };
@@ -2531,7 +2591,12 @@ export type PalletBalancesReserveData = { id: FixedBytes<8>; amount: bigint };
 
 export type FrameSupportTokensMiscIdAmount = { id: AssetHubPolkadotRuntimeRuntimeHoldReason; amount: bigint };
 
-export type AssetHubPolkadotRuntimeRuntimeHoldReason = null;
+export type AssetHubPolkadotRuntimeRuntimeHoldReason = {
+  type: 'StateTrieMigration';
+  value: PalletStateTrieMigrationHoldReason;
+};
+
+export type PalletStateTrieMigrationHoldReason = 'SlashForMigrate';
 
 export type FrameSupportTokensMiscIdAmount002 = { id: []; amount: bigint };
 
@@ -4857,7 +4922,8 @@ export type AssetHubPolkadotRuntimeRuntimeCall =
   | { pallet: 'Nfts'; palletCall: PalletNftsCall }
   | { pallet: 'ForeignAssets'; palletCall: PalletAssetsCall002 }
   | { pallet: 'PoolAssets'; palletCall: PalletAssetsCall003 }
-  | { pallet: 'AssetConversion'; palletCall: PalletAssetConversionCall };
+  | { pallet: 'AssetConversion'; palletCall: PalletAssetConversionCall }
+  | { pallet: 'StateTrieMigration'; palletCall: PalletStateTrieMigrationCall };
 
 export type AssetHubPolkadotRuntimeRuntimeCallLike =
   | { pallet: 'System'; palletCall: FrameSystemCallLike }
@@ -4881,7 +4947,8 @@ export type AssetHubPolkadotRuntimeRuntimeCallLike =
   | { pallet: 'Nfts'; palletCall: PalletNftsCallLike }
   | { pallet: 'ForeignAssets'; palletCall: PalletAssetsCallLike002 }
   | { pallet: 'PoolAssets'; palletCall: PalletAssetsCallLike003 }
-  | { pallet: 'AssetConversion'; palletCall: PalletAssetConversionCallLike };
+  | { pallet: 'AssetConversion'; palletCall: PalletAssetConversionCallLike }
+  | { pallet: 'StateTrieMigration'; palletCall: PalletStateTrieMigrationCallLike };
 
 /**
  * Contains a variant per dispatchable extrinsic that this pallet has.
@@ -11521,6 +11588,172 @@ export type PalletAssetConversionCallLike =
    **/
   | { name: 'Touch'; params: { asset1: StagingXcmV4Location; asset2: StagingXcmV4Location } };
 
+/**
+ * Contains a variant per dispatchable extrinsic that this pallet has.
+ **/
+export type PalletStateTrieMigrationCall =
+  /**
+   * Control the automatic migration.
+   *
+   * The dispatch origin of this call must be [`Config::ControlOrigin`].
+   **/
+  | { name: 'ControlAutoMigration'; params: { maybeConfig?: PalletStateTrieMigrationMigrationLimits | undefined } }
+  /**
+   * Continue the migration for the given `limits`.
+   *
+   * The dispatch origin of this call can be any signed account.
+   *
+   * This transaction has NO MONETARY INCENTIVES. calling it will not reward anyone. Albeit,
+   * Upon successful execution, the transaction fee is returned.
+   *
+   * The (potentially over-estimated) of the byte length of all the data read must be
+   * provided for up-front fee-payment and weighing. In essence, the caller is guaranteeing
+   * that executing the current `MigrationTask` with the given `limits` will not exceed
+   * `real_size_upper` bytes of read data.
+   *
+   * The `witness_task` is merely a helper to prevent the caller from being slashed or
+   * generally trigger a migration that they do not intend. This parameter is just a message
+   * from caller, saying that they believed `witness_task` was the last state of the
+   * migration, and they only wish for their transaction to do anything, if this assumption
+   * holds. In case `witness_task` does not match, the transaction fails.
+   *
+   * Based on the documentation of [`MigrationTask::migrate_until_exhaustion`], the
+   * recommended way of doing this is to pass a `limit` that only bounds `count`, as the
+   * `size` limit can always be overwritten.
+   **/
+  | {
+      name: 'ContinueMigrate';
+      params: {
+        limits: PalletStateTrieMigrationMigrationLimits;
+        realSizeUpper: number;
+        witnessTask: PalletStateTrieMigrationMigrationTask;
+      };
+    }
+  /**
+   * Migrate the list of top keys by iterating each of them one by one.
+   *
+   * This does not affect the global migration process tracker ([`MigrationProcess`]), and
+   * should only be used in case any keys are leftover due to a bug.
+   **/
+  | { name: 'MigrateCustomTop'; params: { keys: Array<Bytes>; witnessSize: number } }
+  /**
+   * Migrate the list of child keys by iterating each of them one by one.
+   *
+   * All of the given child keys must be present under one `child_root`.
+   *
+   * This does not affect the global migration process tracker ([`MigrationProcess`]), and
+   * should only be used in case any keys are leftover due to a bug.
+   **/
+  | { name: 'MigrateCustomChild'; params: { root: Bytes; childKeys: Array<Bytes>; totalSize: number } }
+  /**
+   * Set the maximum limit of the signed migration.
+   **/
+  | { name: 'SetSignedMaxLimits'; params: { limits: PalletStateTrieMigrationMigrationLimits } }
+  /**
+   * Forcefully set the progress the running migration.
+   *
+   * This is only useful in one case: the next key to migrate is too big to be migrated with
+   * a signed account, in a parachain context, and we simply want to skip it. A reasonable
+   * example of this would be `:code:`, which is both very expensive to migrate, and commonly
+   * used, so probably it is already migrated.
+   *
+   * In case you mess things up, you can also, in principle, use this to reset the migration
+   * process.
+   **/
+  | {
+      name: 'ForceSetProgress';
+      params: { progressTop: PalletStateTrieMigrationProgress; progressChild: PalletStateTrieMigrationProgress };
+    };
+
+export type PalletStateTrieMigrationCallLike =
+  /**
+   * Control the automatic migration.
+   *
+   * The dispatch origin of this call must be [`Config::ControlOrigin`].
+   **/
+  | { name: 'ControlAutoMigration'; params: { maybeConfig?: PalletStateTrieMigrationMigrationLimits | undefined } }
+  /**
+   * Continue the migration for the given `limits`.
+   *
+   * The dispatch origin of this call can be any signed account.
+   *
+   * This transaction has NO MONETARY INCENTIVES. calling it will not reward anyone. Albeit,
+   * Upon successful execution, the transaction fee is returned.
+   *
+   * The (potentially over-estimated) of the byte length of all the data read must be
+   * provided for up-front fee-payment and weighing. In essence, the caller is guaranteeing
+   * that executing the current `MigrationTask` with the given `limits` will not exceed
+   * `real_size_upper` bytes of read data.
+   *
+   * The `witness_task` is merely a helper to prevent the caller from being slashed or
+   * generally trigger a migration that they do not intend. This parameter is just a message
+   * from caller, saying that they believed `witness_task` was the last state of the
+   * migration, and they only wish for their transaction to do anything, if this assumption
+   * holds. In case `witness_task` does not match, the transaction fails.
+   *
+   * Based on the documentation of [`MigrationTask::migrate_until_exhaustion`], the
+   * recommended way of doing this is to pass a `limit` that only bounds `count`, as the
+   * `size` limit can always be overwritten.
+   **/
+  | {
+      name: 'ContinueMigrate';
+      params: {
+        limits: PalletStateTrieMigrationMigrationLimits;
+        realSizeUpper: number;
+        witnessTask: PalletStateTrieMigrationMigrationTask;
+      };
+    }
+  /**
+   * Migrate the list of top keys by iterating each of them one by one.
+   *
+   * This does not affect the global migration process tracker ([`MigrationProcess`]), and
+   * should only be used in case any keys are leftover due to a bug.
+   **/
+  | { name: 'MigrateCustomTop'; params: { keys: Array<BytesLike>; witnessSize: number } }
+  /**
+   * Migrate the list of child keys by iterating each of them one by one.
+   *
+   * All of the given child keys must be present under one `child_root`.
+   *
+   * This does not affect the global migration process tracker ([`MigrationProcess`]), and
+   * should only be used in case any keys are leftover due to a bug.
+   **/
+  | { name: 'MigrateCustomChild'; params: { root: BytesLike; childKeys: Array<BytesLike>; totalSize: number } }
+  /**
+   * Set the maximum limit of the signed migration.
+   **/
+  | { name: 'SetSignedMaxLimits'; params: { limits: PalletStateTrieMigrationMigrationLimits } }
+  /**
+   * Forcefully set the progress the running migration.
+   *
+   * This is only useful in one case: the next key to migrate is too big to be migrated with
+   * a signed account, in a parachain context, and we simply want to skip it. A reasonable
+   * example of this would be `:code:`, which is both very expensive to migrate, and commonly
+   * used, so probably it is already migrated.
+   *
+   * In case you mess things up, you can also, in principle, use this to reset the migration
+   * process.
+   **/
+  | {
+      name: 'ForceSetProgress';
+      params: { progressTop: PalletStateTrieMigrationProgress; progressChild: PalletStateTrieMigrationProgress };
+    };
+
+export type PalletStateTrieMigrationMigrationLimits = { size: number; item: number };
+
+export type PalletStateTrieMigrationMigrationTask = {
+  progressTop: PalletStateTrieMigrationProgress;
+  progressChild: PalletStateTrieMigrationProgress;
+  size: number;
+  topItems: number;
+  childItems: number;
+};
+
+export type PalletStateTrieMigrationProgress =
+  | { type: 'ToStart' }
+  | { type: 'LastKey'; value: Bytes }
+  | { type: 'Complete' };
+
 export type AssetHubPolkadotRuntimeOriginCaller =
   | { type: 'System'; value: FrameSupportDispatchRawOrigin }
   | { type: 'PolkadotXcm'; value: PalletXcmOrigin }
@@ -12377,4 +12610,5 @@ export type AssetHubPolkadotRuntimeRuntimeError =
   | { pallet: 'Nfts'; palletError: PalletNftsError }
   | { pallet: 'ForeignAssets'; palletError: PalletAssetsError }
   | { pallet: 'PoolAssets'; palletError: PalletAssetsError }
-  | { pallet: 'AssetConversion'; palletError: PalletAssetConversionError };
+  | { pallet: 'AssetConversion'; palletError: PalletAssetConversionError }
+  | { pallet: 'StateTrieMigration'; palletError: PalletStateTrieMigrationError };