@dedot/chaintypes 0.0.1-alpha.131 → 0.0.1-alpha.132

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dedot/chaintypes",
-  "version": "0.0.1-alpha.131",
+  "version": "0.0.1-alpha.132",
   "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": "b4eaf7edf0a7c6c94c3f771aaa264ff61ee5bdba",
+  "gitHead": "3b457a7f631276f86344496dd3a872091122aa85",
   "module": "./index.js",
   "types": "./index.d.ts"
 }

package/westendAssetHub/consts.d.ts

@@ -249,6 +249,27 @@ export interface ChainConsts<Rv extends RpcVersion> extends GenericChainConsts<R
      **/
     maxInboundSuspended: number;
 
+    /**
+     * Maximal number of outbound XCMP channels that can have messages queued at the same time.
+     *
+     * If this is reached, then no further messages can be sent to channels that do not yet
+     * have a message queued. This should be set to the expected maximum of outbound channels
+     * which is determined by [`Self::ChannelInfo`]. It is important to set this large enough,
+     * since otherwise the congestion control protocol will not work as intended and messages
+     * may be dropped. This value increases the PoV and should therefore not be picked too
+     * high. Governance needs to pay attention to not open more channels than this value.
+     **/
+    maxActiveOutboundChannels: number;
+
+    /**
+     * The maximal page size for HRMP message pages.
+     *
+     * A lower limit can be set dynamically, but this is the hard-limit for the PoV worst case
+     * benchmarking. The limit for the size of a message is slightly below this, since some
+     * overhead is incurred for encoding the format.
+     **/
+    maxPageSize: number;
+
     /**
      * Generic pallet constant
      **/
@@ -775,6 +796,40 @@ export interface ChainConsts<Rv extends RpcVersion> extends GenericChainConsts<R
      **/
     [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
+     **/
+    [name: string]: any;
+  };
   /**
    * Pallet `AssetConversionMigration`'s constants
    **/

package/westendAssetHub/errors.d.ts

@@ -327,6 +327,16 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
      **/
     AlreadyResumed: GenericPalletError<Rv>;
 
+    /**
+     * There are too many active outbound channels.
+     **/
+    TooManyActiveOutboundChannels: GenericPalletError<Rv>;
+
+    /**
+     * The message is too big.
+     **/
+    TooBig: GenericPalletError<Rv>;
+
     /**
      * Generic pallet error
      **/
@@ -1491,6 +1501,51 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
      **/
     [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
+     **/
+    [error: string]: GenericPalletError<Rv>;
+  };
   /**
    * Pallet `AssetConversionMigration`'s errors
    **/

package/westendAssetHub/events.d.ts

@@ -21,6 +21,8 @@ import type {
   PalletNftsAttributeNamespace,
   PalletNftsPriceWithDirection,
   PalletNftsPalletAttributes,
+  PalletStateTrieMigrationMigrationCompute,
+  PalletStateTrieMigrationError,
 } from './types';
 
 export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<Rv> {
@@ -1168,6 +1170,16 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      **/
     Blocked: GenericPalletEvent<Rv, 'Assets', 'Blocked', { assetId: number; who: AccountId32 }>;
 
+    /**
+     * Some assets were deposited (e.g. for transaction fees).
+     **/
+    Deposited: GenericPalletEvent<Rv, 'Assets', 'Deposited', { assetId: number; who: AccountId32; amount: bigint }>;
+
+    /**
+     * Some assets were withdrawn from the account (e.g. for transaction fees).
+     **/
+    Withdrawn: GenericPalletEvent<Rv, 'Assets', 'Withdrawn', { assetId: number; who: AccountId32; amount: bigint }>;
+
     /**
      * Generic pallet event
      **/
@@ -2002,6 +2014,26 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
       { assetId: StagingXcmV3MultilocationMultiLocation; who: AccountId32 }
     >;
 
+    /**
+     * Some assets were deposited (e.g. for transaction fees).
+     **/
+    Deposited: GenericPalletEvent<
+      Rv,
+      'ForeignAssets',
+      'Deposited',
+      { assetId: StagingXcmV3MultilocationMultiLocation; who: AccountId32; amount: bigint }
+    >;
+
+    /**
+     * Some assets were withdrawn from the account (e.g. for transaction fees).
+     **/
+    Withdrawn: GenericPalletEvent<
+      Rv,
+      'ForeignAssets',
+      'Withdrawn',
+      { assetId: StagingXcmV3MultilocationMultiLocation; who: AccountId32; amount: bigint }
+    >;
+
     /**
      * Generic pallet event
      **/
@@ -2216,6 +2248,16 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      **/
     Blocked: GenericPalletEvent<Rv, 'PoolAssets', 'Blocked', { assetId: number; who: AccountId32 }>;
 
+    /**
+     * Some assets were deposited (e.g. for transaction fees).
+     **/
+    Deposited: GenericPalletEvent<Rv, 'PoolAssets', 'Deposited', { assetId: number; who: AccountId32; amount: bigint }>;
+
+    /**
+     * Some assets were withdrawn from the account (e.g. for transaction fees).
+     **/
+    Withdrawn: GenericPalletEvent<Rv, 'PoolAssets', 'Withdrawn', { assetId: number; who: AccountId32; amount: bigint }>;
+
     /**
      * Generic pallet event
      **/
@@ -2440,6 +2482,41 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      **/
     [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
+     **/
+    [prop: string]: GenericPalletEvent<Rv>;
+  };
   /**
    * Pallet `AssetConversionMigration`'s events
    **/

package/westendAssetHub/query.d.ts

@@ -48,6 +48,7 @@ import type {
   PalletXcmVersionMigrationStage,
   PalletXcmRemoteLockedFungibleRecord,
   XcmVersionedAssetId,
+  StagingXcmV4Xcm,
   BpXcmBridgeHubRouterBridgeState,
   PalletMessageQueueBookState,
   CumulusPrimitivesCoreAggregateMessageOrigin,
@@ -76,6 +77,8 @@ import type {
   StagingXcmV3MultilocationMultiLocation,
   PalletNftFractionalizationDetails,
   PalletAssetConversionPoolInfo,
+  PalletStateTrieMigrationMigrationTask,
+  PalletStateTrieMigrationMigrationLimits,
 } from './types';
 
 export interface ChainStorage<Rv extends RpcVersion> extends GenericChainStorage<Rv> {
@@ -1042,6 +1045,31 @@ export interface ChainStorage<Rv extends RpcVersion> extends GenericChainStorage
      **/
     xcmExecutionSuspended: GenericStorageQuery<Rv, () => boolean>;
 
+    /**
+     * Whether or not incoming XCMs (both executed locally and received) should be recorded.
+     * Only one XCM program will be recorded at a time.
+     * This is meant to be used in runtime APIs, and it's advised it stays false
+     * for all other use cases, so as to not degrade regular performance.
+     *
+     * Only relevant if this pallet is being used as the [`xcm_executor::traits::RecordXcm`]
+     * implementation in the XCM executor configuration.
+     *
+     * @param {Callback<boolean> =} callback
+     **/
+    shouldRecordXcm: GenericStorageQuery<Rv, () => boolean>;
+
+    /**
+     * If [`ShouldRecordXcm`] is set to true, then the last XCM program executed locally
+     * will be stored here.
+     * Runtime APIs can fetch the XCM that was executed by accessing this value.
+     *
+     * Only relevant if this pallet is being used as the [`xcm_executor::traits::RecordXcm`]
+     * implementation in the XCM executor configuration.
+     *
+     * @param {Callback<StagingXcmV4Xcm | undefined> =} callback
+     **/
+    recordedXcm: GenericStorageQuery<Rv, () => StagingXcmV4Xcm | undefined>;
+
     /**
      * Generic pallet storage query
      **/
@@ -1648,6 +1676,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/westendAssetHub/runtime.d.ts

@@ -31,8 +31,16 @@ import type {
   PalletTransactionPaymentRuntimeDispatchInfo,
   PalletTransactionPaymentFeeDetails,
   SpWeightsWeightV2Weight,
-  AssetHubWestendRuntimeRuntimeCallLike,
+  XcmVersionedAssetId,
+  XcmFeePaymentRuntimeApiFeesError,
+  XcmVersionedXcm,
   XcmVersionedAssets,
+  XcmVersionedLocation,
+  XcmFeePaymentRuntimeApiDryRunCallDryRunEffects,
+  XcmFeePaymentRuntimeApiDryRunError,
+  AssetHubWestendRuntimeOriginCaller,
+  AssetHubWestendRuntimeRuntimeCallLike,
+  XcmFeePaymentRuntimeApiDryRunXcmDryRunEffects,
   AssetsCommonRuntimeApiFungiblesAccessError,
   CumulusPrimitivesCoreCollationInfo,
 } from './types';
@@ -504,6 +512,126 @@ export interface RuntimeApis<Rv extends RpcVersion> extends GenericRuntimeApis<R
      **/
     [method: string]: GenericRuntimeApiMethod<Rv>;
   };
+  /**
+   * @runtimeapi: XcmPaymentApi - 0x6ff52ee858e6c5bd
+   **/
+  xcmPaymentApi: {
+    /**
+     * Returns a list of acceptable payment assets.
+     *
+     * # Arguments
+     *
+     * * `xcm_version`: Version.
+     *
+     * @callname: XcmPaymentApi_query_acceptable_payment_assets
+     * @param {number} xcm_version
+     **/
+    queryAcceptablePaymentAssets: GenericRuntimeApiMethod<
+      Rv,
+      (xcmVersion: number) => Promise<Result<Array<XcmVersionedAssetId>, XcmFeePaymentRuntimeApiFeesError>>
+    >;
+
+    /**
+     * Returns a weight needed to execute a XCM.
+     *
+     * # Arguments
+     *
+     * * `message`: `VersionedXcm`.
+     *
+     * @callname: XcmPaymentApi_query_xcm_weight
+     * @param {XcmVersionedXcm} message
+     **/
+    queryXcmWeight: GenericRuntimeApiMethod<
+      Rv,
+      (message: XcmVersionedXcm) => Promise<Result<SpWeightsWeightV2Weight, XcmFeePaymentRuntimeApiFeesError>>
+    >;
+
+    /**
+     * Converts a weight into a fee for the specified `AssetId`.
+     *
+     * # Arguments
+     *
+     * * `weight`: convertible `Weight`.
+     * * `asset`: `VersionedAssetId`.
+     *
+     * @callname: XcmPaymentApi_query_weight_to_asset_fee
+     * @param {SpWeightsWeightV2Weight} weight
+     * @param {XcmVersionedAssetId} asset
+     **/
+    queryWeightToAssetFee: GenericRuntimeApiMethod<
+      Rv,
+      (
+        weight: SpWeightsWeightV2Weight,
+        asset: XcmVersionedAssetId,
+      ) => Promise<Result<bigint, XcmFeePaymentRuntimeApiFeesError>>
+    >;
+
+    /**
+     * Get delivery fees for sending a specific `message` to a `destination`.
+     * These always come in a specific asset, defined by the chain.
+     *
+     * # Arguments
+     * * `message`: The message that'll be sent, necessary because most delivery fees are based on the
+     * size of the message.
+     * * `destination`: The destination to send the message to. Different destinations may use
+     * different senders that charge different fees.
+     *
+     * @callname: XcmPaymentApi_query_delivery_fees
+     * @param {XcmVersionedLocation} destination
+     * @param {XcmVersionedXcm} message
+     **/
+    queryDeliveryFees: GenericRuntimeApiMethod<
+      Rv,
+      (
+        destination: XcmVersionedLocation,
+        message: XcmVersionedXcm,
+      ) => Promise<Result<XcmVersionedAssets, XcmFeePaymentRuntimeApiFeesError>>
+    >;
+
+    /**
+     * Generic runtime api call
+     **/
+    [method: string]: GenericRuntimeApiMethod<Rv>;
+  };
+  /**
+   * @runtimeapi: DryRunApi - 0x91b1c8b16328eb92
+   **/
+  dryRunApi: {
+    /**
+     * Dry run call.
+     *
+     * @callname: DryRunApi_dry_run_call
+     * @param {AssetHubWestendRuntimeOriginCaller} origin
+     * @param {AssetHubWestendRuntimeRuntimeCallLike} call
+     **/
+    dryRunCall: GenericRuntimeApiMethod<
+      Rv,
+      (
+        origin: AssetHubWestendRuntimeOriginCaller,
+        call: AssetHubWestendRuntimeRuntimeCallLike,
+      ) => Promise<Result<XcmFeePaymentRuntimeApiDryRunCallDryRunEffects, XcmFeePaymentRuntimeApiDryRunError>>
+    >;
+
+    /**
+     * Dry run XCM program
+     *
+     * @callname: DryRunApi_dry_run_xcm
+     * @param {XcmVersionedLocation} origin_location
+     * @param {XcmVersionedXcm} xcm
+     **/
+    dryRunXcm: GenericRuntimeApiMethod<
+      Rv,
+      (
+        originLocation: XcmVersionedLocation,
+        xcm: XcmVersionedXcm,
+      ) => Promise<Result<XcmFeePaymentRuntimeApiDryRunXcmDryRunEffects, XcmFeePaymentRuntimeApiDryRunError>>
+    >;
+
+    /**
+     * Generic runtime api call
+     **/
+    [method: string]: GenericRuntimeApiMethod<Rv>;
+  };
   /**
    * @runtimeapi: TransactionPaymentCallApi - 0xf3ff14d5ab527059
    **/

package/westendAssetHub/tx.d.ts

@@ -46,6 +46,9 @@ import type {
   PalletNftsPreSignedMint,
   PalletNftsPreSignedAttributes,
   StagingXcmV3MultilocationMultiLocation,
+  PalletStateTrieMigrationMigrationLimits,
+  PalletStateTrieMigrationMigrationTask,
+  PalletStateTrieMigrationProgress,
 } from './types';
 
 export type ChainSubmittableExtrinsic<
@@ -700,6 +703,35 @@ export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCal
       >
     >;
 
+    /**
+     * Burn the specified liquid free balance from the origin account.
+     *
+     * If the origin's account ends up below the existential deposit as a result
+     * of the burn and `keep_alive` is false, the account will be reaped.
+     *
+     * Unlike sending funds to a _burn_ address, which merely makes the funds inaccessible,
+     * this `burn` operation will reduce total issuance by the amount _burned_.
+     *
+     * @param {bigint} value
+     * @param {boolean} keepAlive
+     **/
+    burn: GenericTxCall<
+      Rv,
+      (
+        value: bigint,
+        keepAlive: boolean,
+      ) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'Balances';
+          palletCall: {
+            name: 'Burn';
+            params: { value: bigint; keepAlive: boolean };
+          };
+        }
+      >
+    >;
+
     /**
      * Generic pallet tx call
      **/
@@ -8946,6 +8978,191 @@ export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCal
      **/
     [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
+     **/
+    [callName: string]: GenericTxCall<Rv, TxCall<Rv>>;
+  };
   /**
    * Pallet `AssetConversionMigration`'s transaction calls
    **/

package/westendAssetHub/types.d.ts

@@ -70,6 +70,7 @@ export type AssetHubWestendRuntimeRuntimeEvent =
   | { pallet: 'NftFractionalization'; palletEvent: PalletNftFractionalizationEvent }
   | { pallet: 'PoolAssets'; palletEvent: PalletAssetsEvent }
   | { pallet: 'AssetConversion'; palletEvent: PalletAssetConversionEvent }
+  | { pallet: 'StateTrieMigration'; palletEvent: PalletStateTrieMigrationEvent }
   | { pallet: 'AssetConversionMigration'; palletEvent: PalletAssetConversionOpsEvent };
 
 /**
@@ -692,7 +693,7 @@ export type StagingXcmV4Instruction =
     }
   | {
       tag: 'Transact';
-      value: { originKind: XcmV2OriginKind; requireWeightAtMost: SpWeightsWeightV2Weight; call: XcmDoubleEncoded };
+      value: { originKind: XcmV3OriginKind; requireWeightAtMost: SpWeightsWeightV2Weight; call: XcmDoubleEncoded };
     }
   | { tag: 'HrmpNewChannelOpenRequest'; value: { sender: number; maxMessageSize: number; maxCapacity: number } }
   | { tag: 'HrmpChannelAccepted'; value: { recipient: number } }
@@ -800,7 +801,7 @@ export type XcmV3MaybeErrorCode =
   | { tag: 'Error'; value: Bytes }
   | { tag: 'TruncatedError'; value: Bytes };
 
-export type XcmV2OriginKind = 'Native' | 'SovereignAccount' | 'Superuser' | 'Xcm';
+export type XcmV3OriginKind = 'Native' | 'SovereignAccount' | 'Superuser' | 'Xcm';
 
 export type XcmDoubleEncoded = { encoded: Bytes };
 
@@ -1076,7 +1077,8 @@ export type FrameSupportMessagesProcessMessageError =
   | { tag: 'Corrupt' }
   | { tag: 'Unsupported' }
   | { tag: 'Overweight'; value: SpWeightsWeightV2Weight }
-  | { tag: 'Yield' };
+  | { tag: 'Yield' }
+  | { tag: 'StackLimitReached' };
 
 /**
  * The `Event` enum of this pallet
@@ -1318,7 +1320,15 @@ export type PalletAssetsEvent =
   /**
    * Some account `who` was blocked.
    **/
-  | { name: 'Blocked'; data: { assetId: number; who: AccountId32 } };
+  | { name: 'Blocked'; data: { assetId: number; who: AccountId32 } }
+  /**
+   * Some assets were deposited (e.g. for transaction fees).
+   **/
+  | { name: 'Deposited'; data: { assetId: number; who: AccountId32; amount: bigint } }
+  /**
+   * Some assets were withdrawn from the account (e.g. for transaction fees).
+   **/
+  | { name: 'Withdrawn'; data: { assetId: number; who: AccountId32; amount: bigint } };
 
 /**
  * The `Event` enum of this pallet
@@ -1844,7 +1854,15 @@ export type PalletAssetsEvent002 =
   /**
    * Some account `who` was blocked.
    **/
-  | { name: 'Blocked'; data: { assetId: StagingXcmV3MultilocationMultiLocation; who: AccountId32 } };
+  | { name: 'Blocked'; data: { assetId: StagingXcmV3MultilocationMultiLocation; who: AccountId32 } }
+  /**
+   * Some assets were deposited (e.g. for transaction fees).
+   **/
+  | { name: 'Deposited'; data: { assetId: StagingXcmV3MultilocationMultiLocation; who: AccountId32; amount: bigint } }
+  /**
+   * Some assets were withdrawn from the account (e.g. for transaction fees).
+   **/
+  | { name: 'Withdrawn'; data: { assetId: StagingXcmV3MultilocationMultiLocation; who: AccountId32; amount: bigint } };
 
 /**
  * The `Event` enum of this pallet
@@ -2059,6 +2077,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';
+
 /**
  * The `Event` enum of this pallet
  **/
@@ -2584,13 +2661,14 @@ export type PalletBalancesReserveData = { id: FixedBytes<8>; amount: bigint };
 
 export type PalletBalancesIdAmount = { id: AssetHubWestendRuntimeRuntimeHoldReason; amount: bigint };
 
-export type AssetHubWestendRuntimeRuntimeHoldReason = {
-  tag: 'NftFractionalization';
-  value: PalletNftFractionalizationHoldReason;
-};
+export type AssetHubWestendRuntimeRuntimeHoldReason =
+  | { tag: 'NftFractionalization'; value: PalletNftFractionalizationHoldReason }
+  | { tag: 'StateTrieMigration'; value: PalletStateTrieMigrationHoldReason };
 
 export type PalletNftFractionalizationHoldReason = 'Fractionalized';
 
+export type PalletStateTrieMigrationHoldReason = 'SlashForMigrate';
+
 export type PalletBalancesIdAmount002 = { id: []; amount: bigint };
 
 /**
@@ -2669,7 +2747,17 @@ export type PalletBalancesCall =
    *
    * # Example
    **/
-  | { name: 'ForceAdjustTotalIssuance'; params: { direction: PalletBalancesAdjustmentDirection; delta: bigint } };
+  | { name: 'ForceAdjustTotalIssuance'; params: { direction: PalletBalancesAdjustmentDirection; delta: bigint } }
+  /**
+   * Burn the specified liquid free balance from the origin account.
+   *
+   * If the origin's account ends up below the existential deposit as a result
+   * of the burn and `keep_alive` is false, the account will be reaped.
+   *
+   * Unlike sending funds to a _burn_ address, which merely makes the funds inaccessible,
+   * this `burn` operation will reduce total issuance by the amount _burned_.
+   **/
+  | { name: 'Burn'; params: { value: bigint; keepAlive: boolean } };
 
 export type PalletBalancesCallLike =
   /**
@@ -2744,7 +2832,17 @@ export type PalletBalancesCallLike =
    *
    * # Example
    **/
-  | { name: 'ForceAdjustTotalIssuance'; params: { direction: PalletBalancesAdjustmentDirection; delta: bigint } };
+  | { name: 'ForceAdjustTotalIssuance'; params: { direction: PalletBalancesAdjustmentDirection; delta: bigint } }
+  /**
+   * Burn the specified liquid free balance from the origin account.
+   *
+   * If the origin's account ends up below the existential deposit as a result
+   * of the burn and `keep_alive` is false, the account will be reaped.
+   *
+   * Unlike sending funds to a _burn_ address, which merely makes the funds inaccessible,
+   * this `burn` operation will reduce total issuance by the amount _burned_.
+   **/
+  | { name: 'Burn'; params: { value: bigint; keepAlive: boolean } };
 
 export type PalletBalancesAdjustmentDirection = 'Increase' | 'Decrease';
 
@@ -3259,7 +3357,15 @@ export type CumulusPalletXcmpQueueError =
   /**
    * The execution is already resumed.
    **/
-  | 'AlreadyResumed';
+  | 'AlreadyResumed'
+  /**
+   * There are too many active outbound channels.
+   **/
+  | 'TooManyActiveOutboundChannels'
+  /**
+   * The message is too big.
+   **/
+  | 'TooBig';
 
 export type PalletXcmQueryStatus =
   | {
@@ -4046,6 +4152,8 @@ export type XcmV2Instruction =
   | { tag: 'SubscribeVersion'; value: { queryId: bigint; maxResponseWeight: bigint } }
   | { tag: 'UnsubscribeVersion' };
 
+export type XcmV2OriginKind = 'Native' | 'SovereignAccount' | 'Superuser' | 'Xcm';
+
 export type XcmV2MultiassetMultiAssetFilter =
   | { tag: 'Definite'; value: XcmV2MultiassetMultiAssets }
   | { tag: 'Wild'; value: XcmV2MultiassetWildMultiAsset };
@@ -4083,7 +4191,7 @@ export type XcmV3Instruction =
     }
   | {
       tag: 'Transact';
-      value: { originKind: XcmV2OriginKind; requireWeightAtMost: SpWeightsWeightV2Weight; call: XcmDoubleEncoded };
+      value: { originKind: XcmV3OriginKind; requireWeightAtMost: SpWeightsWeightV2Weight; call: XcmDoubleEncoded };
     }
   | { tag: 'HrmpNewChannelOpenRequest'; value: { sender: number; maxMessageSize: number; maxCapacity: number } }
   | { tag: 'HrmpChannelAccepted'; value: { recipient: number } }
@@ -4653,6 +4761,7 @@ export type AssetHubWestendRuntimeRuntimeCall =
   | { pallet: 'NftFractionalization'; palletCall: PalletNftFractionalizationCall }
   | { pallet: 'PoolAssets'; palletCall: PalletAssetsCall003 }
   | { pallet: 'AssetConversion'; palletCall: PalletAssetConversionCall }
+  | { pallet: 'StateTrieMigration'; palletCall: PalletStateTrieMigrationCall }
   | { pallet: 'AssetConversionMigration'; palletCall: PalletAssetConversionOpsCall };
 
 export type AssetHubWestendRuntimeRuntimeCallLike =
@@ -4678,6 +4787,7 @@ export type AssetHubWestendRuntimeRuntimeCallLike =
   | { pallet: 'NftFractionalization'; palletCall: PalletNftFractionalizationCallLike }
   | { pallet: 'PoolAssets'; palletCall: PalletAssetsCallLike003 }
   | { pallet: 'AssetConversion'; palletCall: PalletAssetConversionCallLike }
+  | { pallet: 'StateTrieMigration'; palletCall: PalletStateTrieMigrationCallLike }
   | { pallet: 'AssetConversionMigration'; palletCall: PalletAssetConversionOpsCallLike };
 
 /**
@@ -11400,6 +11510,172 @@ export type PalletAssetConversionCallLike =
       params: { asset1: StagingXcmV3MultilocationMultiLocation; asset2: StagingXcmV3MultilocationMultiLocation };
     };
 
+/**
+ * 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 =
+  | { tag: 'ToStart' }
+  | { tag: 'LastKey'; value: Bytes }
+  | { tag: 'Complete' };
+
 /**
  * Pallet's callable functions.
  **/
@@ -12261,6 +12537,39 @@ export type PalletTransactionPaymentFeeDetails = {
 
 export type PalletTransactionPaymentInclusionFee = { baseFee: bigint; lenFee: bigint; adjustedWeightFee: bigint };
 
+export type XcmFeePaymentRuntimeApiFeesError =
+  | 'Unimplemented'
+  | 'VersionedConversionFailed'
+  | 'WeightNotComputable'
+  | 'UnhandledXcmVersion'
+  | 'AssetNotFound'
+  | 'Unroutable';
+
+export type XcmFeePaymentRuntimeApiDryRunCallDryRunEffects = {
+  executionResult: Result<FrameSupportDispatchPostDispatchInfo, SpRuntimeDispatchErrorWithPostInfo>;
+  emittedEvents: Array<AssetHubWestendRuntimeRuntimeEvent>;
+  localXcm?: XcmVersionedXcm | undefined;
+  forwardedXcms: Array<[XcmVersionedLocation, Array<XcmVersionedXcm>]>;
+};
+
+export type FrameSupportDispatchPostDispatchInfo = {
+  actualWeight?: SpWeightsWeightV2Weight | undefined;
+  paysFee: FrameSupportDispatchPays;
+};
+
+export type SpRuntimeDispatchErrorWithPostInfo = {
+  postInfo: FrameSupportDispatchPostDispatchInfo;
+  error: DispatchError;
+};
+
+export type XcmFeePaymentRuntimeApiDryRunError = 'Unimplemented' | 'VersionedConversionFailed';
+
+export type XcmFeePaymentRuntimeApiDryRunXcmDryRunEffects = {
+  executionResult: StagingXcmV4TraitsOutcome;
+  emittedEvents: Array<AssetHubWestendRuntimeRuntimeEvent>;
+  forwardedXcms: Array<[XcmVersionedLocation, Array<XcmVersionedXcm>]>;
+};
+
 export type AssetsCommonRuntimeApiFungiblesAccessError = 'AssetIdConversionFailed' | 'AmountToBalanceConversionFailed';
 
 export type CumulusPrimitivesCoreCollationInfo = {
@@ -12293,4 +12602,5 @@ export type AssetHubWestendRuntimeRuntimeError =
   | { tag: 'NftFractionalization'; value: PalletNftFractionalizationError }
   | { tag: 'PoolAssets'; value: PalletAssetsError }
   | { tag: 'AssetConversion'; value: PalletAssetConversionError }
+  | { tag: 'StateTrieMigration'; value: PalletStateTrieMigrationError }
   | { tag: 'AssetConversionMigration'; value: PalletAssetConversionOpsError };