@dedot/chaintypes 0.233.0 → 0.235.0

package/hydration/tx.d.ts

@@ -63,31 +63,23 @@ import type {
   PalletSignetErrorResponse,
   PalletDispenserEvmTransactionParams,
   OrmlVestingVestingSchedule,
-  EthereumTransactionTransactionV2,
+  EthereumTransactionEip7702AuthorizationListItem,
+  EthereumTransactionTransactionV3,
   PalletXykAssetPair,
   PalletDcaSchedule,
   CumulusPrimitivesParachainInherentParachainInherentData,
   XcmVersionedLocation,
   XcmVersionedXcm,
   XcmVersionedAssets,
-  StagingXcmV4Location,
+  StagingXcmV5Location,
   XcmV3WeightLimit,
   StagingXcmExecutorAssetTransferTransferType,
   XcmVersionedAssetId,
   CumulusPrimitivesCoreAggregateMessageOrigin,
+  PalletMigrationsMigrationCursor,
+  PalletMigrationsHistoricCleanupSelector,
   XcmVersionedAsset,
   HydradxRuntimeOpaqueSessionKeys,
-  IsmpMessagingMessage,
-  IsmpMessagingCreateConsensusState,
-  PalletIsmpUtilsUpdateConsensusState,
-  PalletIsmpUtilsFundMessageParams,
-  IsmpMessagingConsensusMessage,
-  IsmpParachainParachainData,
-  PalletTokenGatewayTeleportParams,
-  IsmpHostStateMachine,
-  PalletTokenGatewayAssetRegistration,
-  TokenGatewayPrimitivesGatewayAssetUpdate,
-  PalletTokenGatewayPrecisionUpdate,
 } from './types.js';
 
 export type ChainSubmittableExtrinsic<
@@ -1226,6 +1218,76 @@ export interface ChainTx<
       >
     >;
 
+    /**
+     * Dispatch a fallback call in the event the main call fails to execute.
+     * May be called from any origin except `None`.
+     *
+     * This function first attempts to dispatch the `main` call.
+     * If the `main` call fails, the `fallback` is attemted.
+     * if the fallback is successfully dispatched, the weights of both calls
+     * are accumulated and an event containing the main call error is deposited.
+     *
+     * In the event of a fallback failure the whole call fails
+     * with the weights returned.
+     *
+     * - `main`: The main call to be dispatched. This is the primary action to execute.
+     * - `fallback`: The fallback call to be dispatched in case the `main` call fails.
+     *
+     * ## Dispatch Logic
+     * - If the origin is `root`, both the main and fallback calls are executed without
+     * applying any origin filters.
+     * - If the origin is not `root`, the origin filter is applied to both the `main` and
+     * `fallback` calls.
+     *
+     * ## Use Case
+     * - Some use cases might involve submitting a `batch` type call in either main, fallback
+     * or both.
+     *
+     * @param {HydradxRuntimeRuntimeCallLike} main
+     * @param {HydradxRuntimeRuntimeCallLike} fallback
+     **/
+    ifElse: GenericTxCall<
+      (
+        main: HydradxRuntimeRuntimeCallLike,
+        fallback: HydradxRuntimeRuntimeCallLike,
+      ) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'Utility';
+          palletCall: {
+            name: 'IfElse';
+            params: { main: HydradxRuntimeRuntimeCallLike; fallback: HydradxRuntimeRuntimeCallLike };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
+    /**
+     * Dispatches a function call with a provided origin.
+     *
+     * Almost the same as [`Pallet::dispatch_as`] but forwards any error of the inner call.
+     *
+     * The dispatch origin for this call must be _Root_.
+     *
+     * @param {HydradxRuntimeOriginCaller} asOrigin
+     * @param {HydradxRuntimeRuntimeCallLike} call
+     **/
+    dispatchAsFallible: GenericTxCall<
+      (
+        asOrigin: HydradxRuntimeOriginCaller,
+        call: HydradxRuntimeRuntimeCallLike,
+      ) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'Utility';
+          palletCall: {
+            name: 'DispatchAsFallible';
+            params: { asOrigin: HydradxRuntimeOriginCaller; call: HydradxRuntimeRuntimeCallLike };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
     /**
      * Generic pallet tx call
      **/
@@ -1321,7 +1383,7 @@ export interface ChainTx<
     >;
 
     /**
-     * Ensure that the a bulk of pre-images is upgraded.
+     * Ensure that the bulk of pre-images is upgraded.
      *
      * The caller pays no fee if at least 90% of pre-images were successfully updated.
      *
@@ -1771,8 +1833,9 @@ export interface ChainTx<
     /**
      * Add an `AccountId` with permission to grant usernames with a given `suffix` appended.
      *
-     * The authority can grant up to `allocation` usernames. To top up their allocation, they
-     * should just issue (or request via governance) a new `add_username_authority` call.
+     * The authority can grant up to `allocation` usernames. To top up the allocation or
+     * change the account used to grant usernames, this call can be used with the updated
+     * parameters to overwrite the existing configuration.
      *
      * @param {AccountId32Like} authority
      * @param {BytesLike} suffix
@@ -1798,15 +1861,19 @@ export interface ChainTx<
     /**
      * Remove `authority` from the username authorities.
      *
+     * @param {BytesLike} suffix
      * @param {AccountId32Like} authority
      **/
     removeUsernameAuthority: GenericTxCall<
-      (authority: AccountId32Like) => ChainSubmittableExtrinsic<
+      (
+        suffix: BytesLike,
+        authority: AccountId32Like,
+      ) => ChainSubmittableExtrinsic<
         {
           pallet: 'Identity';
           palletCall: {
             name: 'RemoveUsernameAuthority';
-            params: { authority: AccountId32Like };
+            params: { suffix: BytesLike; authority: AccountId32Like };
           };
         },
         ChainKnownTypes
@@ -1816,7 +1883,11 @@ export interface ChainTx<
     /**
      * Set the username for `who`. Must be called by a username authority.
      *
-     * The authority must have an `allocation`. Users can either pre-sign their usernames or
+     * If `use_allocation` is set, the authority must have a username allocation available to
+     * spend. Otherwise, the authority will need to put up a deposit for registering the
+     * username.
+     *
+     * Users can either pre-sign their usernames or
      * accept them later.
      *
      * Usernames must:
@@ -1827,18 +1898,25 @@ export interface ChainTx<
      * @param {AccountId32Like} who
      * @param {BytesLike} username
      * @param {SpRuntimeMultiSignature | undefined} signature
+     * @param {boolean} useAllocation
      **/
     setUsernameFor: GenericTxCall<
       (
         who: AccountId32Like,
         username: BytesLike,
         signature: SpRuntimeMultiSignature | undefined,
+        useAllocation: boolean,
       ) => ChainSubmittableExtrinsic<
         {
           pallet: 'Identity';
           palletCall: {
             name: 'SetUsernameFor';
-            params: { who: AccountId32Like; username: BytesLike; signature: SpRuntimeMultiSignature | undefined };
+            params: {
+              who: AccountId32Like;
+              username: BytesLike;
+              signature: SpRuntimeMultiSignature | undefined;
+              useAllocation: boolean;
+            };
           };
         },
         ChainKnownTypes
@@ -1903,17 +1981,56 @@ export interface ChainTx<
     >;
 
     /**
-     * Remove a username that corresponds to an account with no identity. Exists when a user
-     * gets a username but then calls `clear_identity`.
+     * Start the process of removing a username by placing it in the unbinding usernames map.
+     * Once the grace period has passed, the username can be deleted by calling
+     * [remove_username](crate::Call::remove_username).
      *
      * @param {BytesLike} username
      **/
-    removeDanglingUsername: GenericTxCall<
+    unbindUsername: GenericTxCall<
       (username: BytesLike) => ChainSubmittableExtrinsic<
         {
           pallet: 'Identity';
           palletCall: {
-            name: 'RemoveDanglingUsername';
+            name: 'UnbindUsername';
+            params: { username: BytesLike };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
+    /**
+     * Permanently delete a username which has been unbinding for longer than the grace period.
+     * Caller is refunded the fee if the username expired and the removal was successful.
+     *
+     * @param {BytesLike} username
+     **/
+    removeUsername: GenericTxCall<
+      (username: BytesLike) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'Identity';
+          palletCall: {
+            name: 'RemoveUsername';
+            params: { username: BytesLike };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
+    /**
+     * Call with [ForceOrigin](crate::Config::ForceOrigin) privileges which deletes a username
+     * and slashes any deposit associated with it.
+     *
+     * @param {BytesLike} username
+     **/
+    killUsername: GenericTxCall<
+      (username: BytesLike) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'Identity';
+          palletCall: {
+            name: 'KillUsername';
             params: { username: BytesLike };
           };
         },
@@ -2766,6 +2883,56 @@ export interface ChainTx<
       >
     >;
 
+    /**
+     * Disapprove the proposal and burn the cost held for storing this proposal.
+     *
+     * Parameters:
+     * - `origin`: must be the `KillOrigin`.
+     * - `proposal_hash`: The hash of the proposal that should be killed.
+     *
+     * Emits `Killed` and `ProposalCostBurned` if any cost was held for a given proposal.
+     *
+     * @param {H256} proposalHash
+     **/
+    kill: GenericTxCall<
+      (proposalHash: H256) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'TechnicalCommittee';
+          palletCall: {
+            name: 'Kill';
+            params: { proposalHash: H256 };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
+    /**
+     * Release the cost held for storing a proposal once the given proposal is completed.
+     *
+     * If there is no associated cost for the given proposal, this call will have no effect.
+     *
+     * Parameters:
+     * - `origin`: must be `Signed` or `Root`.
+     * - `proposal_hash`: The hash of the proposal.
+     *
+     * Emits `ProposalCostReleased` if any cost held for a given proposal.
+     *
+     * @param {H256} proposalHash
+     **/
+    releaseProposalCost: GenericTxCall<
+      (proposalHash: H256) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'TechnicalCommittee';
+          palletCall: {
+            name: 'ReleaseProposalCost';
+            params: { proposalHash: H256 };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
     /**
      * Generic pallet tx call
      **/
@@ -3123,6 +3290,29 @@ export interface ChainTx<
       >
     >;
 
+    /**
+     * Poke / Adjust deposits made for proxies and announcements based on current values.
+     * This can be used by accounts to possibly lower their locked amount.
+     *
+     * The dispatch origin for this call must be _Signed_.
+     *
+     * The transaction fee is waived if the deposit amount has changed.
+     *
+     * Emits `DepositPoked` if successful.
+     *
+     **/
+    pokeDeposit: GenericTxCall<
+      () => ChainSubmittableExtrinsic<
+        {
+          pallet: 'Proxy';
+          palletCall: {
+            name: 'PokeDeposit';
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
     /**
      * Generic pallet tx call
      **/
@@ -3351,6 +3541,42 @@ export interface ChainTx<
       >
     >;
 
+    /**
+     * Poke the deposit reserved for an existing multisig operation.
+     *
+     * The dispatch origin for this call must be _Signed_ and must be the original depositor of
+     * the multisig operation.
+     *
+     * The transaction fee is waived if the deposit amount has changed.
+     *
+     * - `threshold`: The total number of approvals needed for this multisig.
+     * - `other_signatories`: The accounts (other than the sender) who are part of the
+     * multisig.
+     * - `call_hash`: The hash of the call this deposit is reserved for.
+     *
+     * Emits `DepositPoked` if successful.
+     *
+     * @param {number} threshold
+     * @param {Array<AccountId32Like>} otherSignatories
+     * @param {FixedBytes<32>} callHash
+     **/
+    pokeDeposit: GenericTxCall<
+      (
+        threshold: number,
+        otherSignatories: Array<AccountId32Like>,
+        callHash: FixedBytes<32>,
+      ) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'Multisig';
+          palletCall: {
+            name: 'PokeDeposit';
+            params: { threshold: number; otherSignatories: Array<AccountId32Like>; callHash: FixedBytes<32> };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
     /**
      * Generic pallet tx call
      **/
@@ -5991,7 +6217,8 @@ export interface ChainTx<
      * IF account balance is < min. existential deposit of given currency, and account is allowed to
      * be dusted, the remaining balance is transferred to treasury account.
      *
-     * In case of AToken, we perform an erc20 dust, which does a wihtdraw all then supply atoken on behalf of the dust receiver
+     * In case of AToken, we perform an erc20 dust, which does a wihtdraw all to the treasury account
+     * Note that in this case, the treasury will just receive the underlying token, not the atoken variant.
      *
      * The transaction fee is returned back in case of successful dusting.
      *
@@ -6699,6 +6926,8 @@ export interface ChainTx<
      * - `stable_pool_id`: id of the stableswap pool to add liquidity to.
      * - `stable_asset_amounts`: amount of each asset to be deposited into the stableswap pool.
      * - `farm_entries`: list of farms to join.
+     * - `min_shares_limit`: optional minimum Omnipool shares to receive (slippage protection).
+     * Applies to Omnipool step only. None defaults to no protection.
      *
      * Emits `LiquidityAdded` events from both pool
      * Emits `SharesDeposited` event for the first farm entry
@@ -6708,12 +6937,14 @@ export interface ChainTx<
      * @param {number} stablePoolId
      * @param {Array<HydradxTraitsStableswapAssetAmount>} stableAssetAmounts
      * @param {Array<[number, number]> | undefined} farmEntries
+     * @param {bigint | undefined} minSharesLimit
      **/
     addLiquidityStableswapOmnipoolAndJoinFarms: GenericTxCall<
       (
         stablePoolId: number,
         stableAssetAmounts: Array<HydradxTraitsStableswapAssetAmount>,
         farmEntries: Array<[number, number]> | undefined,
+        minSharesLimit: bigint | undefined,
       ) => ChainSubmittableExtrinsic<
         {
           pallet: 'OmnipoolLiquidityMining';
@@ -6723,6 +6954,62 @@ export interface ChainTx<
               stablePoolId: number;
               stableAssetAmounts: Array<HydradxTraitsStableswapAssetAmount>;
               farmEntries: Array<[number, number]> | undefined;
+              minSharesLimit: bigint | undefined;
+            };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
+    /**
+     * Remove liquidity from stableswap and omnipool, optionally exiting associated yield farms.
+     *
+     * This extrinsic reverses the operation performed by `add_liquidity_stableswap_omnipool_and_join_farms`,
+     * with optional farm exit to match the optional farm join in the add function.
+     *
+     * It performs the following steps in order:
+     * 1. [OPTIONAL] If deposit_id is provided: Exits from ALL yield farms associated with the deposit (claiming rewards)
+     * 2. Removes liquidity from the omnipool to retrieve stableswap shares (protected by omnipool_min_limit)
+     * 3. Removes liquidity from the stableswap pool to retrieve underlying assets (protected by stableswap_min_amounts_out)
+     *
+     * The stabelswap liquidity asset removal strategy is determined by the `min_amounts_out` parameter length:
+     * - If 1 asset is specified: Uses `remove_liquidity_one_asset` (trading fee applies)
+     * - If multiple assets: Uses `remove_liquidity` (proportional, no trading fee)
+     *
+     * Parameters:
+     * - `origin`: Owner of the omnipool position
+     * - `position_id`: The omnipool position NFT ID to remove liquidity from
+     * - `omnipool_min_limit`: The min amount of asset to be removed from omnipool (slippage protection)
+     * - `stableswap_min_amounts_out`: Asset IDs and minimum amounts minimum amounts of each asset to receive from omnipool.
+     * - `deposit_id`: Optional liquidity mining deposit NFT ID. If provided, exits all farms first.
+     *
+     * Emits events:
+     * - If deposit_id provided: `RewardClaimed`, `SharesWithdrawn`, `DepositDestroyed`
+     * - Always: Omnipool's `LiquidityRemoved`, Stableswap's `LiquidityRemoved`
+     *
+     *
+     * @param {bigint} positionId
+     * @param {bigint} omnipoolMinLimit
+     * @param {Array<HydradxTraitsStableswapAssetAmount>} stableswapMinAmountsOut
+     * @param {bigint | undefined} depositId
+     **/
+    removeLiquidityStableswapOmnipoolAndExitFarms: GenericTxCall<
+      (
+        positionId: bigint,
+        omnipoolMinLimit: bigint,
+        stableswapMinAmountsOut: Array<HydradxTraitsStableswapAssetAmount>,
+        depositId: bigint | undefined,
+      ) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'OmnipoolLiquidityMining';
+          palletCall: {
+            name: 'RemoveLiquidityStableswapOmnipoolAndExitFarms';
+            params: {
+              positionId: bigint;
+              omnipoolMinLimit: bigint;
+              stableswapMinAmountsOut: Array<HydradxTraitsStableswapAssetAmount>;
+              depositId: bigint | undefined;
             };
           };
         },
@@ -9575,14 +9862,14 @@ export interface ChainTx<
      * - `request_id`: Client-supplied request ID; must match derived ID.
      * - `tx`: Parameters for the EVM transaction submitted to the faucet.
      *
-     * @param {FixedBytes<20>} to
+     * @param {H160} to
      * @param {bigint} amount
      * @param {FixedBytes<32>} requestId
      * @param {PalletDispenserEvmTransactionParams} tx
      **/
     requestFund: GenericTxCall<
       (
-        to: FixedBytes<20>,
+        to: H160,
         amount: bigint,
         requestId: FixedBytes<32>,
         tx: PalletDispenserEvmTransactionParams,
@@ -9591,12 +9878,7 @@ export interface ChainTx<
           pallet: 'EthDispenser';
           palletCall: {
             name: 'RequestFund';
-            params: {
-              to: FixedBytes<20>;
-              amount: bigint;
-              requestId: FixedBytes<32>;
-              tx: PalletDispenserEvmTransactionParams;
-            };
+            params: { to: H160; amount: bigint; requestId: FixedBytes<32>; tx: PalletDispenserEvmTransactionParams };
           };
         },
         ChainKnownTypes
@@ -9688,7 +9970,7 @@ export interface ChainTx<
      *
      * - `dest`: The recipient of the transfer.
      * - `currency_id`: currency type.
-     * - `amount`: free balance amount to tranfer.
+     * - `amount`: free balance amount to transfer.
      *
      * @param {AccountId32Like} dest
      * @param {number} currencyId
@@ -9764,7 +10046,7 @@ export interface ChainTx<
      *
      * - `dest`: The recipient of the transfer.
      * - `currency_id`: currency type.
-     * - `amount`: free balance amount to tranfer.
+     * - `amount`: free balance amount to transfer.
      *
      * @param {AccountId32Like} dest
      * @param {number} currencyId
@@ -9796,7 +10078,7 @@ export interface ChainTx<
      * - `source`: The sender of the transfer.
      * - `dest`: The recipient of the transfer.
      * - `currency_id`: currency type.
-     * - `amount`: free balance amount to tranfer.
+     * - `amount`: free balance amount to transfer.
      *
      * @param {AccountId32Like} source
      * @param {AccountId32Like} dest
@@ -10067,6 +10349,7 @@ export interface ChainTx<
      * @param {U256 | undefined} maxPriorityFeePerGas
      * @param {U256 | undefined} nonce
      * @param {Array<[H160, Array<H256>]>} accessList
+     * @param {Array<EthereumTransactionEip7702AuthorizationListItem>} authorizationList
      **/
     call: GenericTxCall<
       (
@@ -10079,6 +10362,7 @@ export interface ChainTx<
         maxPriorityFeePerGas: U256 | undefined,
         nonce: U256 | undefined,
         accessList: Array<[H160, Array<H256>]>,
+        authorizationList: Array<EthereumTransactionEip7702AuthorizationListItem>,
       ) => ChainSubmittableExtrinsic<
         {
           pallet: 'Evm';
@@ -10094,6 +10378,7 @@ export interface ChainTx<
               maxPriorityFeePerGas: U256 | undefined;
               nonce: U256 | undefined;
               accessList: Array<[H160, Array<H256>]>;
+              authorizationList: Array<EthereumTransactionEip7702AuthorizationListItem>;
             };
           };
         },
@@ -10113,6 +10398,7 @@ export interface ChainTx<
      * @param {U256 | undefined} maxPriorityFeePerGas
      * @param {U256 | undefined} nonce
      * @param {Array<[H160, Array<H256>]>} accessList
+     * @param {Array<EthereumTransactionEip7702AuthorizationListItem>} authorizationList
      **/
     create: GenericTxCall<
       (
@@ -10124,6 +10410,7 @@ export interface ChainTx<
         maxPriorityFeePerGas: U256 | undefined,
         nonce: U256 | undefined,
         accessList: Array<[H160, Array<H256>]>,
+        authorizationList: Array<EthereumTransactionEip7702AuthorizationListItem>,
       ) => ChainSubmittableExtrinsic<
         {
           pallet: 'Evm';
@@ -10138,6 +10425,7 @@ export interface ChainTx<
               maxPriorityFeePerGas: U256 | undefined;
               nonce: U256 | undefined;
               accessList: Array<[H160, Array<H256>]>;
+              authorizationList: Array<EthereumTransactionEip7702AuthorizationListItem>;
             };
           };
         },
@@ -10157,6 +10445,7 @@ export interface ChainTx<
      * @param {U256 | undefined} maxPriorityFeePerGas
      * @param {U256 | undefined} nonce
      * @param {Array<[H160, Array<H256>]>} accessList
+     * @param {Array<EthereumTransactionEip7702AuthorizationListItem>} authorizationList
      **/
     create2: GenericTxCall<
       (
@@ -10169,6 +10458,7 @@ export interface ChainTx<
         maxPriorityFeePerGas: U256 | undefined,
         nonce: U256 | undefined,
         accessList: Array<[H160, Array<H256>]>,
+        authorizationList: Array<EthereumTransactionEip7702AuthorizationListItem>,
       ) => ChainSubmittableExtrinsic<
         {
           pallet: 'Evm';
@@ -10184,6 +10474,7 @@ export interface ChainTx<
               maxPriorityFeePerGas: U256 | undefined;
               nonce: U256 | undefined;
               accessList: Array<[H160, Array<H256>]>;
+              authorizationList: Array<EthereumTransactionEip7702AuthorizationListItem>;
             };
           };
         },
@@ -10203,15 +10494,15 @@ export interface ChainTx<
     /**
      * Transact an Ethereum transaction.
      *
-     * @param {EthereumTransactionTransactionV2} transaction
+     * @param {EthereumTransactionTransactionV3} transaction
      **/
     transact: GenericTxCall<
-      (transaction: EthereumTransactionTransactionV2) => ChainSubmittableExtrinsic<
+      (transaction: EthereumTransactionTransactionV3) => ChainSubmittableExtrinsic<
         {
           pallet: 'Ethereum';
           palletCall: {
             name: 'Transact';
-            params: { transaction: EthereumTransactionTransactionV2 };
+            params: { transaction: EthereumTransactionTransactionV3 };
           };
         },
         ChainKnownTypes
@@ -11691,19 +11982,19 @@ export interface ChainTx<
      * - `location`: The destination that is being described.
      * - `xcm_version`: The latest version of XCM that `location` supports.
      *
-     * @param {StagingXcmV4Location} location
+     * @param {StagingXcmV5Location} location
      * @param {number} version
      **/
     forceXcmVersion: GenericTxCall<
       (
-        location: StagingXcmV4Location,
+        location: StagingXcmV5Location,
         version: number,
       ) => ChainSubmittableExtrinsic<
         {
           pallet: 'PolkadotXcm';
           palletCall: {
             name: 'ForceXcmVersion';
-            params: { location: StagingXcmV4Location; version: number };
+            params: { location: StagingXcmV5Location; version: number };
           };
         },
         ChainKnownTypes
@@ -12091,6 +12382,74 @@ export interface ChainTx<
       >
     >;
 
+    /**
+     * Authorize another `aliaser` location to alias into the local `origin` making this call.
+     * The `aliaser` is only authorized until the provided `expiry` block number.
+     * The call can also be used for a previously authorized alias in order to update its
+     * `expiry` block number.
+     *
+     * Usually useful to allow your local account to be aliased into from a remote location
+     * also under your control (like your account on another chain).
+     *
+     * WARNING: make sure the caller `origin` (you) trusts the `aliaser` location to act in
+     * their/your name. Once authorized using this call, the `aliaser` can freely impersonate
+     * `origin` in XCM programs executed on the local chain.
+     *
+     * @param {XcmVersionedLocation} aliaser
+     * @param {bigint | undefined} expires
+     **/
+    addAuthorizedAlias: GenericTxCall<
+      (
+        aliaser: XcmVersionedLocation,
+        expires: bigint | undefined,
+      ) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'PolkadotXcm';
+          palletCall: {
+            name: 'AddAuthorizedAlias';
+            params: { aliaser: XcmVersionedLocation; expires: bigint | undefined };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
+    /**
+     * Remove a previously authorized `aliaser` from the list of locations that can alias into
+     * the local `origin` making this call.
+     *
+     * @param {XcmVersionedLocation} aliaser
+     **/
+    removeAuthorizedAlias: GenericTxCall<
+      (aliaser: XcmVersionedLocation) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'PolkadotXcm';
+          palletCall: {
+            name: 'RemoveAuthorizedAlias';
+            params: { aliaser: XcmVersionedLocation };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
+    /**
+     * Remove all previously authorized `aliaser`s that can alias into the local `origin`
+     * making this call.
+     *
+     **/
+    removeAllAuthorizedAliases: GenericTxCall<
+      () => ChainSubmittableExtrinsic<
+        {
+          pallet: 'PolkadotXcm';
+          palletCall: {
+            name: 'RemoveAllAuthorizedAliases';
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
     /**
      * Generic pallet tx call
      **/
@@ -12179,6 +12538,107 @@ export interface ChainTx<
      **/
     [callName: string]: GenericTxCall<TxCall<ChainKnownTypes>>;
   };
+  /**
+   * 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<
+      (cursor: PalletMigrationsMigrationCursor | undefined) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'MultiBlockMigrations';
+          palletCall: {
+            name: 'ForceSetCursor';
+            params: { cursor: PalletMigrationsMigrationCursor | undefined };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
+    /**
+     * 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<
+      (
+        index: number,
+        innerCursor: BytesLike | undefined,
+        startedAt: number | undefined,
+      ) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'MultiBlockMigrations';
+          palletCall: {
+            name: 'ForceSetActiveCursor';
+            params: { index: number; innerCursor: BytesLike | undefined; startedAt: number | undefined };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
+    /**
+     * 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<
+      () => ChainSubmittableExtrinsic<
+        {
+          pallet: 'MultiBlockMigrations';
+          palletCall: {
+            name: 'ForceOnboardMbms';
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
+    /**
+     * 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<
+      (selector: PalletMigrationsHistoricCleanupSelector) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'MultiBlockMigrations';
+          palletCall: {
+            name: 'ClearHistoric';
+            params: { selector: PalletMigrationsHistoricCleanupSelector };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
+    /**
+     * Generic pallet tx call
+     **/
+    [callName: string]: GenericTxCall<TxCall<ChainKnownTypes>>;
+  };
   /**
    * Pallet `OrmlXcm`'s transaction calls
    **/
@@ -12775,279 +13235,6 @@ export interface ChainTx<
      **/
     [callName: string]: GenericTxCall<TxCall<ChainKnownTypes>>;
   };
-  /**
-   * Pallet `Ismp`'s transaction calls
-   **/
-  ismp: {
-    /**
-     * Execute the provided batch of ISMP messages, this will short-circuit and revert if any
-     * of the provided messages are invalid. This is an unsigned extrinsic that permits anyone
-     * execute ISMP messages for free, provided they have valid proofs and the messages have
-     * not been previously processed.
-     *
-     * The dispatch origin for this call must be an unsigned one.
-     *
-     * - `messages`: the messages to handle or process.
-     *
-     * Emits different message events based on the Message received if successful.
-     *
-     * @param {Array<IsmpMessagingMessage>} messages
-     **/
-    handleUnsigned: GenericTxCall<
-      (messages: Array<IsmpMessagingMessage>) => ChainSubmittableExtrinsic<
-        {
-          pallet: 'Ismp';
-          palletCall: {
-            name: 'HandleUnsigned';
-            params: { messages: Array<IsmpMessagingMessage> };
-          };
-        },
-        ChainKnownTypes
-      >
-    >;
-
-    /**
-     * Create a consensus client, using a subjectively chosen consensus state. This can also
-     * be used to overwrite an existing consensus state. The dispatch origin for this
-     * call must be `T::AdminOrigin`.
-     *
-     * - `message`: [`CreateConsensusState`] struct.
-     *
-     * Emits [`Event::ConsensusClientCreated`] if successful.
-     *
-     * @param {IsmpMessagingCreateConsensusState} message
-     **/
-    createConsensusClient: GenericTxCall<
-      (message: IsmpMessagingCreateConsensusState) => ChainSubmittableExtrinsic<
-        {
-          pallet: 'Ismp';
-          palletCall: {
-            name: 'CreateConsensusClient';
-            params: { message: IsmpMessagingCreateConsensusState };
-          };
-        },
-        ChainKnownTypes
-      >
-    >;
-
-    /**
-     * Modify the unbonding period and challenge period for a consensus state.
-     * The dispatch origin for this call must be `T::AdminOrigin`.
-     *
-     * - `message`: `UpdateConsensusState` struct.
-     *
-     * @param {PalletIsmpUtilsUpdateConsensusState} message
-     **/
-    updateConsensusState: GenericTxCall<
-      (message: PalletIsmpUtilsUpdateConsensusState) => ChainSubmittableExtrinsic<
-        {
-          pallet: 'Ismp';
-          palletCall: {
-            name: 'UpdateConsensusState';
-            params: { message: PalletIsmpUtilsUpdateConsensusState };
-          };
-        },
-        ChainKnownTypes
-      >
-    >;
-
-    /**
-     * Add more funds to a message (request or response) to be used for delivery and execution.
-     *
-     * Should not be called on a message that has been completed (delivered or timed-out) as
-     * those funds will be lost forever.
-     *
-     * @param {PalletIsmpUtilsFundMessageParams} message
-     **/
-    fundMessage: GenericTxCall<
-      (message: PalletIsmpUtilsFundMessageParams) => ChainSubmittableExtrinsic<
-        {
-          pallet: 'Ismp';
-          palletCall: {
-            name: 'FundMessage';
-            params: { message: PalletIsmpUtilsFundMessageParams };
-          };
-        },
-        ChainKnownTypes
-      >
-    >;
-
-    /**
-     * Generic pallet tx call
-     **/
-    [callName: string]: GenericTxCall<TxCall<ChainKnownTypes>>;
-  };
-  /**
-   * Pallet `IsmpParachain`'s transaction calls
-   **/
-  ismpParachain: {
-    /**
-     * This allows block builders submit parachain consensus proofs as inherents. If the
-     * provided [`ConsensusMessage`] is not for a parachain, this call will fail.
-     *
-     * @param {IsmpMessagingConsensusMessage} data
-     **/
-    updateParachainConsensus: GenericTxCall<
-      (data: IsmpMessagingConsensusMessage) => ChainSubmittableExtrinsic<
-        {
-          pallet: 'IsmpParachain';
-          palletCall: {
-            name: 'UpdateParachainConsensus';
-            params: { data: IsmpMessagingConsensusMessage };
-          };
-        },
-        ChainKnownTypes
-      >
-    >;
-
-    /**
-     * Add some new parachains to the parachains whitelist
-     *
-     * @param {Array<IsmpParachainParachainData>} paraIds
-     **/
-    addParachain: GenericTxCall<
-      (paraIds: Array<IsmpParachainParachainData>) => ChainSubmittableExtrinsic<
-        {
-          pallet: 'IsmpParachain';
-          palletCall: {
-            name: 'AddParachain';
-            params: { paraIds: Array<IsmpParachainParachainData> };
-          };
-        },
-        ChainKnownTypes
-      >
-    >;
-
-    /**
-     * Removes some parachains from the parachains whitelist
-     *
-     * @param {Array<number>} paraIds
-     **/
-    removeParachain: GenericTxCall<
-      (paraIds: Array<number>) => ChainSubmittableExtrinsic<
-        {
-          pallet: 'IsmpParachain';
-          palletCall: {
-            name: 'RemoveParachain';
-            params: { paraIds: Array<number> };
-          };
-        },
-        ChainKnownTypes
-      >
-    >;
-
-    /**
-     * Generic pallet tx call
-     **/
-    [callName: string]: GenericTxCall<TxCall<ChainKnownTypes>>;
-  };
-  /**
-   * Pallet `TokenGateway`'s transaction calls
-   **/
-  tokenGateway: {
-    /**
-     * Teleports a registered asset
-     * locks the asset and dispatches a request to token gateway on the destination
-     *
-     * @param {PalletTokenGatewayTeleportParams} params
-     **/
-    teleport: GenericTxCall<
-      (params: PalletTokenGatewayTeleportParams) => ChainSubmittableExtrinsic<
-        {
-          pallet: 'TokenGateway';
-          palletCall: {
-            name: 'Teleport';
-            params: { params: PalletTokenGatewayTeleportParams };
-          };
-        },
-        ChainKnownTypes
-      >
-    >;
-
-    /**
-     * Set the token gateway address for specified chains
-     *
-     * @param {Array<[IsmpHostStateMachine, BytesLike]>} addresses
-     **/
-    setTokenGatewayAddresses: GenericTxCall<
-      (addresses: Array<[IsmpHostStateMachine, BytesLike]>) => ChainSubmittableExtrinsic<
-        {
-          pallet: 'TokenGateway';
-          palletCall: {
-            name: 'SetTokenGatewayAddresses';
-            params: { addresses: Array<[IsmpHostStateMachine, BytesLike]> };
-          };
-        },
-        ChainKnownTypes
-      >
-    >;
-
-    /**
-     * Registers a multi-chain ERC6160 asset. The asset should not already exist.
-     *
-     * This works by dispatching a request to the TokenGateway module on each requested chain
-     * to create the asset.
-     * `native` should be true if this asset originates from this chain
-     *
-     * @param {PalletTokenGatewayAssetRegistration} asset
-     **/
-    createErc6160Asset: GenericTxCall<
-      (asset: PalletTokenGatewayAssetRegistration) => ChainSubmittableExtrinsic<
-        {
-          pallet: 'TokenGateway';
-          palletCall: {
-            name: 'CreateErc6160Asset';
-            params: { asset: PalletTokenGatewayAssetRegistration };
-          };
-        },
-        ChainKnownTypes
-      >
-    >;
-
-    /**
-     * Registers a multi-chain ERC6160 asset. The asset should not already exist.
-     *
-     * This works by dispatching a request to the TokenGateway module on each requested chain
-     * to create the asset.
-     *
-     * @param {TokenGatewayPrimitivesGatewayAssetUpdate} asset
-     **/
-    updateErc6160Asset: GenericTxCall<
-      (asset: TokenGatewayPrimitivesGatewayAssetUpdate) => ChainSubmittableExtrinsic<
-        {
-          pallet: 'TokenGateway';
-          palletCall: {
-            name: 'UpdateErc6160Asset';
-            params: { asset: TokenGatewayPrimitivesGatewayAssetUpdate };
-          };
-        },
-        ChainKnownTypes
-      >
-    >;
-
-    /**
-     * Update the precision for an existing asset
-     *
-     * @param {PalletTokenGatewayPrecisionUpdate} update
-     **/
-    updateAssetPrecision: GenericTxCall<
-      (update: PalletTokenGatewayPrecisionUpdate) => ChainSubmittableExtrinsic<
-        {
-          pallet: 'TokenGateway';
-          palletCall: {
-            name: 'UpdateAssetPrecision';
-            params: { update: PalletTokenGatewayPrecisionUpdate };
-          };
-        },
-        ChainKnownTypes
-      >
-    >;
-
-    /**
-     * Generic pallet tx call
-     **/
-    [callName: string]: GenericTxCall<TxCall<ChainKnownTypes>>;
-  };
   /**
    * Pallet `EmaOracle`'s transaction calls
    **/