@dedot/chaintypes 0.55.0 → 0.57.0

package/moonbeam/index.d.ts

@@ -23,7 +23,7 @@ export interface VersionedMoonbeamApi<Rv extends RpcVersion> extends GenericSubs
 
 /**
  * @name: MoonbeamApi
- * @specVersion: 3400
+ * @specVersion: 3401
  **/
 export interface MoonbeamApi {
   legacy: VersionedMoonbeamApi<RpcLegacy>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dedot/chaintypes",
-  "version": "0.55.0",
+  "version": "0.57.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": "157f179ee412760aea87ffa70d6df1df038ecb71",
+  "gitHead": "b37a28c6463ee0ec013645a2e2896e8161c91978",
   "module": "./index.js",
   "types": "./index.d.ts"
 }

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

@@ -108,6 +108,31 @@ export interface ChainConsts<Rv extends RpcVersion> extends GenericChainConsts<R
      **/
     [name: string]: any;
   };
+  /**
+   * Pallet `MultiBlockMigrations`'s constants
+   **/
+  multiBlockMigrations: {
+    /**
+     * The maximal length of an encoded cursor.
+     *
+     * A good default needs to selected such that no migration will ever have a cursor with MEL
+     * above this limit. This is statically checked in `integrity_test`.
+     **/
+    cursorMaxLen: number;
+
+    /**
+     * The maximal length of an encoded identifier.
+     *
+     * A good default needs to selected such that no migration will ever have an identifier
+     * with MEL above this limit. This is statically checked in `integrity_test`.
+     **/
+    identifierMaxLen: number;
+
+    /**
+     * Generic pallet constant
+     **/
+    [name: string]: any;
+  };
   /**
    * Pallet `Balances`'s constants
    **/
@@ -886,9 +911,8 @@ export interface ChainConsts<Rv extends RpcVersion> extends GenericChainConsts<R
 
     /**
      * The percentage of the storage deposit that should be held for using a code hash.
-     * Instantiating a contract, or calling [`chain_extension::Ext::lock_delegate_dependency`]
-     * protects the code from being removed. In order to prevent abuse these actions are
-     * protected with a percentage of the code deposit.
+     * Instantiating a contract, protects the code from being removed. In order to prevent
+     * abuse these actions are protected with a percentage of the code deposit.
      **/
     codeHashLockupDepositPercent: Perbill;
 

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

@@ -111,6 +111,20 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
      **/
     [error: string]: GenericPalletError<Rv>;
   };
+  /**
+   * Pallet `MultiBlockMigrations`'s errors
+   **/
+  multiBlockMigrations: {
+    /**
+     * The operation cannot complete since some MBMs are ongoing.
+     **/
+    Ongoing: GenericPalletError<Rv>;
+
+    /**
+     * Generic pallet error
+     **/
+    [error: string]: GenericPalletError<Rv>;
+  };
   /**
    * Pallet `Balances`'s errors
    **/
@@ -1804,6 +1818,11 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
      **/
     InvalidGenericTransaction: GenericPalletError<Rv>;
 
+    /**
+     * The refcount of a code either over or underflowed.
+     **/
+    RefcountOverOrUnderflow: GenericPalletError<Rv>;
+
     /**
      * Generic pallet error
      **/

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

@@ -6,9 +6,9 @@ import type {
   AccountId32,
   H256,
   FixedBytes,
+  Bytes,
   FixedU128,
   Result,
-  Bytes,
   Permill,
   H160,
 } from 'dedot/codecs';
@@ -144,6 +144,141 @@ export interface ChainEvents<Rv extends RpcVersion> extends GenericChainEvents<R
      **/
     [prop: string]: GenericPalletEvent<Rv>;
   };
+  /**
+   * Pallet `MultiBlockMigrations`'s events
+   **/
+  multiBlockMigrations: {
+    /**
+     * A Runtime upgrade started.
+     *
+     * Its end is indicated by `UpgradeCompleted` or `UpgradeFailed`.
+     **/
+    UpgradeStarted: GenericPalletEvent<
+      Rv,
+      'MultiBlockMigrations',
+      'UpgradeStarted',
+      {
+        /**
+         * The number of migrations that this upgrade contains.
+         *
+         * This can be used to design a progress indicator in combination with counting the
+         * `MigrationCompleted` and `MigrationSkipped` events.
+         **/
+        migrations: number;
+      }
+    >;
+
+    /**
+     * The current runtime upgrade completed.
+     *
+     * This implies that all of its migrations completed successfully as well.
+     **/
+    UpgradeCompleted: GenericPalletEvent<Rv, 'MultiBlockMigrations', 'UpgradeCompleted', null>;
+
+    /**
+     * Runtime upgrade failed.
+     *
+     * This is very bad and will require governance intervention.
+     **/
+    UpgradeFailed: GenericPalletEvent<Rv, 'MultiBlockMigrations', 'UpgradeFailed', null>;
+
+    /**
+     * A migration was skipped since it was already executed in the past.
+     **/
+    MigrationSkipped: GenericPalletEvent<
+      Rv,
+      'MultiBlockMigrations',
+      'MigrationSkipped',
+      {
+        /**
+         * The index of the skipped migration within the [`Config::Migrations`] list.
+         **/
+        index: number;
+      }
+    >;
+
+    /**
+     * A migration progressed.
+     **/
+    MigrationAdvanced: GenericPalletEvent<
+      Rv,
+      'MultiBlockMigrations',
+      'MigrationAdvanced',
+      {
+        /**
+         * The index of the migration within the [`Config::Migrations`] list.
+         **/
+        index: number;
+
+        /**
+         * The number of blocks that this migration took so far.
+         **/
+        took: number;
+      }
+    >;
+
+    /**
+     * A Migration completed.
+     **/
+    MigrationCompleted: GenericPalletEvent<
+      Rv,
+      'MultiBlockMigrations',
+      'MigrationCompleted',
+      {
+        /**
+         * The index of the migration within the [`Config::Migrations`] list.
+         **/
+        index: number;
+
+        /**
+         * The number of blocks that this migration took so far.
+         **/
+        took: number;
+      }
+    >;
+
+    /**
+     * A Migration failed.
+     *
+     * This implies that the whole upgrade failed and governance intervention is required.
+     **/
+    MigrationFailed: GenericPalletEvent<
+      Rv,
+      'MultiBlockMigrations',
+      'MigrationFailed',
+      {
+        /**
+         * The index of the migration within the [`Config::Migrations`] list.
+         **/
+        index: number;
+
+        /**
+         * The number of blocks that this migration took so far.
+         **/
+        took: number;
+      }
+    >;
+
+    /**
+     * The set of historical migrations has been cleared.
+     **/
+    HistoricCleared: GenericPalletEvent<
+      Rv,
+      'MultiBlockMigrations',
+      'HistoricCleared',
+      {
+        /**
+         * Should be passed to `clear_historic` in a successive call.
+         **/
+        nextCursor?: Bytes | undefined;
+      }
+    >;
+
+    /**
+     * Generic pallet event
+     **/
+    [prop: string]: GenericPalletEvent<Rv>;
+  };
   /**
    * Pallet `Balances`'s events
    **/

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

@@ -23,7 +23,7 @@ export interface VersionedWestendAssetHubApi<Rv extends RpcVersion> extends Gene
 
 /**
  * @name: WestendAssetHubApi
- * @specVersion: 1017006
+ * @specVersion: 1017007
  **/
 export interface WestendAssetHubApi {
   legacy: VersionedWestendAssetHubApi<RpcLegacy>;

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

@@ -31,6 +31,7 @@ import type {
   CumulusPrimitivesParachainInherentMessageQueueChain,
   PolkadotParachainPrimitivesPrimitivesId,
   PolkadotCorePrimitivesOutboundHrmpMessage,
+  PalletMigrationsMigrationCursor,
   PalletBalancesAccountData,
   PalletBalancesBalanceLock,
   PalletBalancesReserveData,
@@ -549,6 +550,35 @@ export interface ChainStorage<Rv extends RpcVersion> extends GenericChainStorage
      **/
     [storage: string]: GenericStorageQuery<Rv>;
   };
+  /**
+   * Pallet `MultiBlockMigrations`'s storage queries
+   **/
+  multiBlockMigrations: {
+    /**
+     * The currently active migration to run and its cursor.
+     *
+     * `None` indicates that no migration is running.
+     *
+     * @param {Callback<PalletMigrationsMigrationCursor | undefined> =} callback
+     **/
+    cursor: GenericStorageQuery<Rv, () => PalletMigrationsMigrationCursor | undefined>;
+
+    /**
+     * Set of all successfully executed migrations.
+     *
+     * This is used as blacklist, to not re-execute migrations that have not been removed from the
+     * codebase yet. Governance can regularly clear this out via `clear_historic`.
+     *
+     * @param {BytesLike} arg
+     * @param {Callback<[] | undefined> =} callback
+     **/
+    historic: GenericStorageQuery<Rv, (arg: BytesLike) => [] | undefined, Bytes>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
   /**
    * Pallet `Balances`'s storage queries
    **/

package/westend-asset-hub/runtime.d.ts

@@ -59,6 +59,8 @@ import type {
   PalletReviveEvmApiRpcTypesGenGenericTransaction,
   PalletRevivePrimitivesCodeUploadReturnValue,
   PalletRevivePrimitivesContractAccessError,
+  PalletReviveEvmApiDebugRpcTypesCallTrace,
+  PalletReviveEvmApiDebugRpcTypesTracerConfig,
 } from './types';
 
 export interface RuntimeApis<Rv extends RpcVersion> extends GenericRuntimeApis<Rv> {
@@ -911,6 +913,13 @@ export interface RuntimeApis<Rv extends RpcVersion> extends GenericRuntimeApis<R
      **/
     balance: GenericRuntimeApiMethod<Rv, (address: H160) => Promise<U256>>;
 
+    /**
+     * Returns the gas price.
+     *
+     * @callname: ReviveApi_gas_price
+     **/
+    gasPrice: GenericRuntimeApiMethod<Rv, () => Promise<U256>>;
+
     /**
      * Returns the nonce of the given `[H160]` address.
      *
@@ -1024,6 +1033,65 @@ export interface RuntimeApis<Rv extends RpcVersion> extends GenericRuntimeApis<R
       ) => Promise<Result<Bytes | undefined, PalletRevivePrimitivesContractAccessError>>
     >;
 
+    /**
+     * Traces the execution of an entire block and returns call traces.
+     *
+     * This is intended to be called through `state_call` to replay the block from the
+     * parent block.
+     *
+     * See eth-rpc `debug_traceBlockByNumber` for usage.
+     *
+     * @callname: ReviveApi_trace_block
+     * @param {SpRuntimeBlock} block
+     * @param {PalletReviveEvmApiDebugRpcTypesTracerConfig} config
+     **/
+    traceBlock: GenericRuntimeApiMethod<
+      Rv,
+      (
+        block: SpRuntimeBlock,
+        config: PalletReviveEvmApiDebugRpcTypesTracerConfig,
+      ) => Promise<Array<[number, PalletReviveEvmApiDebugRpcTypesCallTrace]>>
+    >;
+
+    /**
+     * Traces the execution of a specific transaction within a block.
+     *
+     * This is intended to be called through `state_call` to replay the block from the
+     * parent hash up to the transaction.
+     *
+     * See eth-rpc `debug_traceTransaction` for usage.
+     *
+     * @callname: ReviveApi_trace_tx
+     * @param {SpRuntimeBlock} block
+     * @param {number} tx_index
+     * @param {PalletReviveEvmApiDebugRpcTypesTracerConfig} config
+     **/
+    traceTx: GenericRuntimeApiMethod<
+      Rv,
+      (
+        block: SpRuntimeBlock,
+        txIndex: number,
+        config: PalletReviveEvmApiDebugRpcTypesTracerConfig,
+      ) => Promise<PalletReviveEvmApiDebugRpcTypesCallTrace | undefined>
+    >;
+
+    /**
+     * Dry run and return the trace of the given call.
+     *
+     * See eth-rpc `debug_traceCall` for usage.
+     *
+     * @callname: ReviveApi_trace_call
+     * @param {PalletReviveEvmApiRpcTypesGenGenericTransaction} tx
+     * @param {PalletReviveEvmApiDebugRpcTypesTracerConfig} config
+     **/
+    traceCall: GenericRuntimeApiMethod<
+      Rv,
+      (
+        tx: PalletReviveEvmApiRpcTypesGenGenericTransaction,
+        config: PalletReviveEvmApiDebugRpcTypesTracerConfig,
+      ) => Promise<Result<PalletReviveEvmApiDebugRpcTypesCallTrace, PalletRevivePrimitivesEthTransactError>>
+    >;
+
     /**
      * Generic runtime api call
      **/

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

@@ -16,6 +16,8 @@ import type {
   SpRuntimeMultiSignature,
   FrameSystemEventRecord,
   CumulusPrimitivesParachainInherentParachainInherentData,
+  PalletMigrationsMigrationCursor,
+  PalletMigrationsHistoricCleanupSelector,
   PalletBalancesAdjustmentDirection,
   AssetHubWestendRuntimeSessionKeys,
   XcmVersionedLocation,
@@ -417,6 +419,111 @@ export interface ChainTx<Rv extends RpcVersion> extends GenericChainTx<Rv, TxCal
      **/
     [callName: string]: GenericTxCall<Rv, TxCall<Rv>>;
   };
+  /**
+   * Pallet `MultiBlockMigrations`'s transaction calls
+   **/
+  multiBlockMigrations: {
+    /**
+     * Allows root to set a cursor to forcefully start, stop or forward the migration process.
+     *
+     * Should normally not be needed and is only in place as emergency measure. Note that
+     * restarting the migration process in this manner will not call the
+     * [`MigrationStatusHandler::started`] hook or emit an `UpgradeStarted` event.
+     *
+     * @param {PalletMigrationsMigrationCursor | undefined} cursor
+     **/
+    forceSetCursor: GenericTxCall<
+      Rv,
+      (cursor: PalletMigrationsMigrationCursor | undefined) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'MultiBlockMigrations';
+          palletCall: {
+            name: 'ForceSetCursor';
+            params: { cursor: PalletMigrationsMigrationCursor | undefined };
+          };
+        }
+      >
+    >;
+
+    /**
+     * Allows root to set an active cursor to forcefully start/forward the migration process.
+     *
+     * This is an edge-case version of [`Self::force_set_cursor`] that allows to set the
+     * `started_at` value to the next block number. Otherwise this would not be possible, since
+     * `force_set_cursor` takes an absolute block number. Setting `started_at` to `None`
+     * indicates that the current block number plus one should be used.
+     *
+     * @param {number} index
+     * @param {BytesLike | undefined} innerCursor
+     * @param {number | undefined} startedAt
+     **/
+    forceSetActiveCursor: GenericTxCall<
+      Rv,
+      (
+        index: number,
+        innerCursor: BytesLike | undefined,
+        startedAt: number | undefined,
+      ) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'MultiBlockMigrations';
+          palletCall: {
+            name: 'ForceSetActiveCursor';
+            params: { index: number; innerCursor: BytesLike | undefined; startedAt: number | undefined };
+          };
+        }
+      >
+    >;
+
+    /**
+     * Forces the onboarding of the migrations.
+     *
+     * This process happens automatically on a runtime upgrade. It is in place as an emergency
+     * measurement. The cursor needs to be `None` for this to succeed.
+     *
+     **/
+    forceOnboardMbms: GenericTxCall<
+      Rv,
+      () => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'MultiBlockMigrations';
+          palletCall: {
+            name: 'ForceOnboardMbms';
+          };
+        }
+      >
+    >;
+
+    /**
+     * Clears the `Historic` set.
+     *
+     * `map_cursor` must be set to the last value that was returned by the
+     * `HistoricCleared` event. The first time `None` can be used. `limit` must be chosen in a
+     * way that will result in a sensible weight.
+     *
+     * @param {PalletMigrationsHistoricCleanupSelector} selector
+     **/
+    clearHistoric: GenericTxCall<
+      Rv,
+      (selector: PalletMigrationsHistoricCleanupSelector) => ChainSubmittableExtrinsic<
+        Rv,
+        {
+          pallet: 'MultiBlockMigrations';
+          palletCall: {
+            name: 'ClearHistoric';
+            params: { selector: PalletMigrationsHistoricCleanupSelector };
+          };
+        }
+      >
+    >;
+
+    /**
+     * Generic pallet tx call
+     **/
+    [callName: string]: GenericTxCall<Rv, TxCall<Rv>>;
+  };
   /**
    * Pallet `Balances`'s transaction calls
    **/

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

@@ -6,8 +6,8 @@ import type {
   DispatchError,
   AccountId32,
   FixedBytes,
-  FixedArray,
   Bytes,
+  FixedArray,
   FixedU128,
   Result,
   Permill,
@@ -52,6 +52,7 @@ export type FrameSystemEventRecord = { phase: Phase; event: AssetHubWestendRunti
 export type AssetHubWestendRuntimeRuntimeEvent =
   | { pallet: 'System'; palletEvent: FrameSystemEvent }
   | { pallet: 'ParachainSystem'; palletEvent: CumulusPalletParachainSystemEvent }
+  | { pallet: 'MultiBlockMigrations'; palletEvent: PalletMigrationsEvent }
   | { pallet: 'Balances'; palletEvent: PalletBalancesEvent }
   | { pallet: 'TransactionPayment'; palletEvent: PalletTransactionPaymentEvent }
   | { pallet: 'AssetTxPayment'; palletEvent: PalletAssetConversionTxPaymentEvent }
@@ -168,6 +169,117 @@ export type CumulusPalletParachainSystemEvent =
    **/
   | { name: 'UpwardMessageSent'; data: { messageHash?: FixedBytes<32> | undefined } };
 
+/**
+ * The `Event` enum of this pallet
+ **/
+export type PalletMigrationsEvent =
+  /**
+   * A Runtime upgrade started.
+   *
+   * Its end is indicated by `UpgradeCompleted` or `UpgradeFailed`.
+   **/
+  | {
+      name: 'UpgradeStarted';
+      data: {
+        /**
+         * The number of migrations that this upgrade contains.
+         *
+         * This can be used to design a progress indicator in combination with counting the
+         * `MigrationCompleted` and `MigrationSkipped` events.
+         **/
+        migrations: number;
+      };
+    }
+  /**
+   * The current runtime upgrade completed.
+   *
+   * This implies that all of its migrations completed successfully as well.
+   **/
+  | { name: 'UpgradeCompleted' }
+  /**
+   * Runtime upgrade failed.
+   *
+   * This is very bad and will require governance intervention.
+   **/
+  | { name: 'UpgradeFailed' }
+  /**
+   * A migration was skipped since it was already executed in the past.
+   **/
+  | {
+      name: 'MigrationSkipped';
+      data: {
+        /**
+         * The index of the skipped migration within the [`Config::Migrations`] list.
+         **/
+        index: number;
+      };
+    }
+  /**
+   * A migration progressed.
+   **/
+  | {
+      name: 'MigrationAdvanced';
+      data: {
+        /**
+         * The index of the migration within the [`Config::Migrations`] list.
+         **/
+        index: number;
+
+        /**
+         * The number of blocks that this migration took so far.
+         **/
+        took: number;
+      };
+    }
+  /**
+   * A Migration completed.
+   **/
+  | {
+      name: 'MigrationCompleted';
+      data: {
+        /**
+         * The index of the migration within the [`Config::Migrations`] list.
+         **/
+        index: number;
+
+        /**
+         * The number of blocks that this migration took so far.
+         **/
+        took: number;
+      };
+    }
+  /**
+   * A Migration failed.
+   *
+   * This implies that the whole upgrade failed and governance intervention is required.
+   **/
+  | {
+      name: 'MigrationFailed';
+      data: {
+        /**
+         * The index of the migration within the [`Config::Migrations`] list.
+         **/
+        index: number;
+
+        /**
+         * The number of blocks that this migration took so far.
+         **/
+        took: number;
+      };
+    }
+  /**
+   * The set of historical migrations has been cleared.
+   **/
+  | {
+      name: 'HistoricCleared';
+      data: {
+        /**
+         * Should be passed to `clear_historic` in a successive call.
+         **/
+        nextCursor?: Bytes | undefined;
+      };
+    };
+
 /**
  * The `Event` enum of this pallet
  **/
@@ -2863,6 +2975,102 @@ export type StagingParachainInfoCall = null;
 
 export type StagingParachainInfoCallLike = null;
 
+export type PalletMigrationsMigrationCursor =
+  | { type: 'Active'; value: PalletMigrationsActiveCursor }
+  | { type: 'Stuck' };
+
+export type PalletMigrationsActiveCursor = { index: number; innerCursor?: Bytes | undefined; startedAt: number };
+
+/**
+ * Contains a variant per dispatchable extrinsic that this pallet has.
+ **/
+export type PalletMigrationsCall =
+  /**
+   * Allows root to set a cursor to forcefully start, stop or forward the migration process.
+   *
+   * Should normally not be needed and is only in place as emergency measure. Note that
+   * restarting the migration process in this manner will not call the
+   * [`MigrationStatusHandler::started`] hook or emit an `UpgradeStarted` event.
+   **/
+  | { name: 'ForceSetCursor'; params: { cursor?: PalletMigrationsMigrationCursor | undefined } }
+  /**
+   * Allows root to set an active cursor to forcefully start/forward the migration process.
+   *
+   * This is an edge-case version of [`Self::force_set_cursor`] that allows to set the
+   * `started_at` value to the next block number. Otherwise this would not be possible, since
+   * `force_set_cursor` takes an absolute block number. Setting `started_at` to `None`
+   * indicates that the current block number plus one should be used.
+   **/
+  | {
+      name: 'ForceSetActiveCursor';
+      params: { index: number; innerCursor?: Bytes | undefined; startedAt?: number | undefined };
+    }
+  /**
+   * Forces the onboarding of the migrations.
+   *
+   * This process happens automatically on a runtime upgrade. It is in place as an emergency
+   * measurement. The cursor needs to be `None` for this to succeed.
+   **/
+  | { name: 'ForceOnboardMbms' }
+  /**
+   * Clears the `Historic` set.
+   *
+   * `map_cursor` must be set to the last value that was returned by the
+   * `HistoricCleared` event. The first time `None` can be used. `limit` must be chosen in a
+   * way that will result in a sensible weight.
+   **/
+  | { name: 'ClearHistoric'; params: { selector: PalletMigrationsHistoricCleanupSelector } };
+
+export type PalletMigrationsCallLike =
+  /**
+   * Allows root to set a cursor to forcefully start, stop or forward the migration process.
+   *
+   * Should normally not be needed and is only in place as emergency measure. Note that
+   * restarting the migration process in this manner will not call the
+   * [`MigrationStatusHandler::started`] hook or emit an `UpgradeStarted` event.
+   **/
+  | { name: 'ForceSetCursor'; params: { cursor?: PalletMigrationsMigrationCursor | undefined } }
+  /**
+   * Allows root to set an active cursor to forcefully start/forward the migration process.
+   *
+   * This is an edge-case version of [`Self::force_set_cursor`] that allows to set the
+   * `started_at` value to the next block number. Otherwise this would not be possible, since
+   * `force_set_cursor` takes an absolute block number. Setting `started_at` to `None`
+   * indicates that the current block number plus one should be used.
+   **/
+  | {
+      name: 'ForceSetActiveCursor';
+      params: { index: number; innerCursor?: BytesLike | undefined; startedAt?: number | undefined };
+    }
+  /**
+   * Forces the onboarding of the migrations.
+   *
+   * This process happens automatically on a runtime upgrade. It is in place as an emergency
+   * measurement. The cursor needs to be `None` for this to succeed.
+   **/
+  | { name: 'ForceOnboardMbms' }
+  /**
+   * Clears the `Historic` set.
+   *
+   * `map_cursor` must be set to the last value that was returned by the
+   * `HistoricCleared` event. The first time `None` can be used. `limit` must be chosen in a
+   * way that will result in a sensible weight.
+   **/
+  | { name: 'ClearHistoric'; params: { selector: PalletMigrationsHistoricCleanupSelector } };
+
+export type PalletMigrationsHistoricCleanupSelector =
+  | { type: 'Specific'; value: Array<Bytes> }
+  | { type: 'Wildcard'; value: { limit?: number | undefined; previousCursor?: Bytes | undefined } };
+
+/**
+ * The `Error` enum of this pallet.
+ **/
+export type PalletMigrationsError =
+  /**
+   * The operation cannot complete since some MBMs are ongoing.
+   **/
+  'Ongoing';
+
 export type PalletBalancesBalanceLock = { id: FixedBytes<8>; amount: bigint; reasons: PalletBalancesReasons };
 
 export type PalletBalancesReasons = 'Fee' | 'Misc' | 'All';
@@ -5027,6 +5235,7 @@ export type AssetHubWestendRuntimeRuntimeCall =
   | { pallet: 'ParachainSystem'; palletCall: CumulusPalletParachainSystemCall }
   | { pallet: 'Timestamp'; palletCall: PalletTimestampCall }
   | { pallet: 'ParachainInfo'; palletCall: StagingParachainInfoCall }
+  | { pallet: 'MultiBlockMigrations'; palletCall: PalletMigrationsCall }
   | { pallet: 'Balances'; palletCall: PalletBalancesCall }
   | { pallet: 'CollatorSelection'; palletCall: PalletCollatorSelectionCall }
   | { pallet: 'Session'; palletCall: PalletSessionCall }
@@ -5055,6 +5264,7 @@ export type AssetHubWestendRuntimeRuntimeCallLike =
   | { pallet: 'ParachainSystem'; palletCall: CumulusPalletParachainSystemCallLike }
   | { pallet: 'Timestamp'; palletCall: PalletTimestampCallLike }
   | { pallet: 'ParachainInfo'; palletCall: StagingParachainInfoCallLike }
+  | { pallet: 'MultiBlockMigrations'; palletCall: PalletMigrationsCallLike }
   | { pallet: 'Balances'; palletCall: PalletBalancesCallLike }
   | { pallet: 'CollatorSelection'; palletCall: PalletCollatorSelectionCallLike }
   | { pallet: 'Session'; palletCall: PalletSessionCallLike }
@@ -12524,8 +12734,7 @@ export type PalletAssetConversionOpsCallLike =
 export type AssetHubWestendRuntimeOriginCaller =
   | { type: 'System'; value: FrameSupportDispatchRawOrigin }
   | { type: 'PolkadotXcm'; value: PalletXcmOrigin }
-  | { type: 'CumulusXcm'; value: CumulusPalletXcmOrigin }
-  | { type: 'Void'; value: SpCoreVoid };
+  | { type: 'CumulusXcm'; value: CumulusPalletXcmOrigin };
 
 export type FrameSupportDispatchRawOrigin =
   | { type: 'Root' }
@@ -12540,8 +12749,6 @@ export type CumulusPalletXcmOrigin =
   | { type: 'Relay' }
   | { type: 'SiblingParachain'; value: PolkadotParachainPrimitivesPrimitivesId };
 
-export type SpCoreVoid = null;
-
 /**
  * The `Error` enum of this pallet.
  **/
@@ -13280,7 +13487,6 @@ export type PalletReviveStorageContractInfo = {
   storageByteDeposit: bigint;
   storageItemDeposit: bigint;
   storageBaseDeposit: bigint;
-  delegateDependencies: Array<[H256, bigint]>;
   immutableDataLen: number;
 };
 
@@ -13486,7 +13692,11 @@ export type PalletReviveError =
   /**
    * The transaction used to dry-run a contract is invalid.
    **/
-  | 'InvalidGenericTransaction';
+  | 'InvalidGenericTransaction'
+  /**
+   * The refcount of a code either over or underflowed.
+   **/
+  | 'RefcountOverOrUnderflow';
 
 export type PalletAssetRewardsPoolStakerInfo = { amount: bigint; rewards: bigint; rewardPerTokenPaid: bigint };
 
@@ -13793,9 +14003,36 @@ export type PalletRevivePrimitivesCodeUploadReturnValue = { codeHash: H256; depo
 
 export type PalletRevivePrimitivesContractAccessError = 'DoesntExist' | 'KeyDecodingFailed';
 
+export type PalletReviveEvmApiDebugRpcTypesTracerConfig = { type: 'CallTracer'; value: { withLogs: boolean } };
+
+export type PalletReviveEvmApiDebugRpcTypesCallTrace = {
+  from: H160;
+  gas: U256;
+  gasUsed: U256;
+  to: H160;
+  input: PalletReviveEvmApiByteBytes;
+  output: PalletReviveEvmApiByteBytes;
+  error?: string | undefined;
+  revertReason?: string | undefined;
+  calls: Array<PalletReviveEvmApiDebugRpcTypesCallTrace>;
+  logs: Array<PalletReviveEvmApiDebugRpcTypesCallLog>;
+  value: U256;
+  callType: PalletReviveEvmApiDebugRpcTypesCallType;
+};
+
+export type PalletReviveEvmApiDebugRpcTypesCallLog = {
+  address: H160;
+  topics: Array<H256>;
+  data: PalletReviveEvmApiByteBytes;
+  position: number;
+};
+
+export type PalletReviveEvmApiDebugRpcTypesCallType = 'Call' | 'StaticCall' | 'DelegateCall';
+
 export type AssetHubWestendRuntimeRuntimeError =
   | { pallet: 'System'; palletError: FrameSystemError }
   | { pallet: 'ParachainSystem'; palletError: CumulusPalletParachainSystemError }
+  | { pallet: 'MultiBlockMigrations'; palletError: PalletMigrationsError }
   | { pallet: 'Balances'; palletError: PalletBalancesError }
   | { pallet: 'CollatorSelection'; palletError: PalletCollatorSelectionError }
   | { pallet: 'Session'; palletError: PalletSessionError }