@dedot/chaintypes 0.231.0 → 0.233.0

package/paseo/tx.d.ts

@@ -45,11 +45,10 @@ import type {
   FrameSupportPreimagesBounded,
   FrameSupportScheduleDispatchTime,
   SpWeightsWeightV2Weight,
-  PaseoRuntimeRuntimeParameters,
   PolkadotRuntimeCommonClaimsEcdsaSignature,
   PolkadotRuntimeCommonClaimsStatementKind,
   PalletVestingVestingInfo,
-  PaseoRuntimeProxyType,
+  PaseoRuntimeConstantsProxyProxyType,
   PalletMultisigTimepoint,
   PalletElectionProviderMultiPhaseRawSolution,
   PalletElectionProviderMultiPhaseSolutionOrSnapshotSize,
@@ -60,23 +59,25 @@ import type {
   PalletNominationPoolsConfigOp,
   PalletNominationPoolsConfigOpU32,
   PalletNominationPoolsConfigOpPerbill,
-  PalletNominationPoolsConfigOp004,
+  PalletNominationPoolsConfigOpAccountId32,
   PalletNominationPoolsClaimPermission,
   PalletNominationPoolsCommissionChangeRate,
   PalletNominationPoolsCommissionClaimPermission,
-  PolkadotPrimitivesV7AsyncBackingAsyncBackingParams,
-  PolkadotPrimitivesV7ExecutorParams,
-  PolkadotPrimitivesV7ApprovalVotingParams,
-  PolkadotPrimitivesVstagingSchedulerParams,
-  PolkadotPrimitivesV7InherentData,
+  PalletStakingAsyncRcClientValidatorSetReport,
+  PalletStakingAsyncAhClientOperatingMode,
+  PolkadotPrimitivesV8AsyncBackingAsyncBackingParams,
+  PolkadotPrimitivesV8ExecutorParams,
+  PolkadotPrimitivesV8ApprovalVotingParams,
+  PolkadotPrimitivesV8SchedulerParams,
+  PolkadotPrimitivesVstagingInherentData,
   PolkadotParachainPrimitivesPrimitivesId,
   PolkadotParachainPrimitivesPrimitivesValidationCode,
   PolkadotParachainPrimitivesPrimitivesHeadData,
   PolkadotParachainPrimitivesPrimitivesValidationCodeHash,
-  PolkadotPrimitivesV7PvfCheckStatement,
-  PolkadotPrimitivesV7ValidatorAppSignature,
+  PolkadotPrimitivesV8PvfCheckStatement,
+  PolkadotPrimitivesV8ValidatorAppSignature,
   PolkadotParachainPrimitivesPrimitivesHrmpChannelId,
-  PolkadotPrimitivesV7SlashingDisputeProof,
+  PolkadotPrimitivesVstagingDisputeProof,
   SpRuntimeMultiSigner,
   PalletBrokerCoretimeInterfaceCoreAssignment,
   PolkadotRuntimeParachainsAssignerCoretimePartsOf57600,
@@ -85,13 +86,20 @@ import type {
   PalletStateTrieMigrationProgress,
   XcmVersionedXcm,
   XcmVersionedAssets,
-  StagingXcmV4Location,
+  StagingXcmV5Location,
   XcmV3WeightLimit,
   StagingXcmExecutorAssetTransferTransferType,
   XcmVersionedAssetId,
   PolkadotRuntimeParachainsInclusionAggregateMessageOrigin,
   SpConsensusBeefyDoubleVotingProof,
+  SpConsensusBeefyForkVotingProof,
+  SpConsensusBeefyFutureBlockVotingProof,
   PolkadotRuntimeParachainsParasParaGenesisArgs,
+  PalletRcMigratorMigrationStage,
+  StagingXcmV5Response,
+  PalletRcMigratorQueuePriority,
+  PalletRcMigratorManagerMultisigVote,
+  PalletRcMigratorMigrationSettings,
 } from './types.js';
 
 export type ChainSubmittableExtrinsic<
@@ -719,7 +727,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.
      *
@@ -1032,6 +1040,33 @@ export interface ChainTx<
       >
     >;
 
+    /**
+     * Poke the deposit reserved for an index.
+     *
+     * The dispatch origin for this call must be _Signed_ and the signing account must have a
+     * non-frozen account `index`.
+     *
+     * The transaction fees is waived if the deposit is changed after poking/reconsideration.
+     *
+     * - `index`: the index whose deposit is to be poked/reconsidered.
+     *
+     * Emits `DepositPoked` if successful.
+     *
+     * @param {number} index
+     **/
+    pokeDeposit: GenericTxCall<
+      (index: number) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'Indices';
+          palletCall: {
+            name: 'PokeDeposit';
+            params: { index: number };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
     /**
      * Generic pallet tx call
      **/
@@ -1364,7 +1399,9 @@ export interface ChainTx<
     /**
      * Schedule a portion of the stash to be unlocked ready for transfer out after the bond
      * period ends. If this leaves an amount actively bonded less than
-     * T::Currency::minimum_balance(), then it is increased to the full amount.
+     * [`asset::existential_deposit`], then it is increased to the full amount.
+     *
+     * The stash may be chilled if the ledger total amount falls to 0 after unbonding.
      *
      * The dispatch origin for this call must be _Signed_ by the controller, not the stash.
      *
@@ -1776,6 +1813,7 @@ export interface ChainTx<
      * Can be called by the `T::AdminOrigin`.
      *
      * Parameters: era and indices of the slashes for that era to kill.
+     * They **must** be sorted in ascending order, *and* unique.
      *
      * @param {number} era
      * @param {Array<number>} slashIndices
@@ -2189,6 +2227,74 @@ export interface ChainTx<
       >
     >;
 
+    /**
+     * Removes the legacy Staking locks if they exist.
+     *
+     * This removes the legacy lock on the stake with [`Config::OldCurrency`] and creates a
+     * hold on it if needed. If all stake cannot be held, the best effort is made to hold as
+     * much as possible. The remaining stake is forced withdrawn from the ledger.
+     *
+     * The fee is waived if the migration is successful.
+     *
+     * @param {AccountId32Like} stash
+     **/
+    migrateCurrency: GenericTxCall<
+      (stash: AccountId32Like) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'Staking';
+          palletCall: {
+            name: 'MigrateCurrency';
+            params: { stash: AccountId32Like };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
+    /**
+     * This function allows governance to manually slash a validator and is a
+     * **fallback mechanism**.
+     *
+     * The dispatch origin must be `T::AdminOrigin`.
+     *
+     * ## Parameters
+     * - `validator_stash` - The stash account of the validator to slash.
+     * - `era` - The era in which the validator was in the active set.
+     * - `slash_fraction` - The percentage of the stake to slash, expressed as a Perbill.
+     *
+     * ## Behavior
+     *
+     * The slash will be applied using the standard slashing mechanics, respecting the
+     * configured `SlashDeferDuration`.
+     *
+     * This means:
+     * - If the validator was already slashed by a higher percentage for the same era, this
+     * slash will have no additional effect.
+     * - If the validator was previously slashed by a lower percentage, only the difference
+     * will be applied.
+     * - The slash will be deferred by `SlashDeferDuration` eras before being enacted.
+     *
+     * @param {AccountId32Like} validatorStash
+     * @param {number} era
+     * @param {Perbill} slashFraction
+     **/
+    manualSlash: GenericTxCall<
+      (
+        validatorStash: AccountId32Like,
+        era: number,
+        slashFraction: Perbill,
+      ) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'Staking';
+          palletCall: {
+            name: 'ManualSlash';
+            params: { validatorStash: AccountId32Like; era: number; slashFraction: Perbill };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
     /**
      * Generic pallet tx call
      **/
@@ -2515,6 +2621,8 @@ export interface ChainTx<
      * Emits [`Event::Paid`] if successful.
      *
      * @param {number} index
+     *
+     * @deprecated The `spend_local` call will be removed by May 2025. Migrate to the new flow and use the `spend` call.
      **/
     payout: GenericTxCall<
       (index: number) => ChainSubmittableExtrinsic<
@@ -2551,6 +2659,8 @@ export interface ChainTx<
      * Emits [`Event::SpendProcessed`] if the spend payout has succeed.
      *
      * @param {number} index
+     *
+     * @deprecated The `remove_approval` call will be removed by May 2025. It associated with the deprecated `spend_local` call.
      **/
     checkStatus: GenericTxCall<
       (index: number) => ChainSubmittableExtrinsic<
@@ -3167,36 +3277,6 @@ export interface ChainTx<
      **/
     [callName: string]: GenericTxCall<TxCall<ChainKnownTypes>>;
   };
-  /**
-   * Pallet `Parameters`'s transaction calls
-   **/
-  parameters: {
-    /**
-     * Set the value of a parameter.
-     *
-     * The dispatch origin of this call must be `AdminOrigin` for the given `key`. Values be
-     * deleted by setting them to `None`.
-     *
-     * @param {PaseoRuntimeRuntimeParameters} keyValue
-     **/
-    setParameter: GenericTxCall<
-      (keyValue: PaseoRuntimeRuntimeParameters) => ChainSubmittableExtrinsic<
-        {
-          pallet: 'Parameters';
-          palletCall: {
-            name: 'SetParameter';
-            params: { keyValue: PaseoRuntimeRuntimeParameters };
-          };
-        },
-        ChainKnownTypes
-      >
-    >;
-
-    /**
-     * Generic pallet tx call
-     **/
-    [callName: string]: GenericTxCall<TxCall<ChainKnownTypes>>;
-  };
   /**
    * Pallet `Claims`'s transaction calls
    **/
@@ -3349,7 +3429,7 @@ export interface ChainTx<
      * Attest to a statement, needed to finalize the claims process.
      *
      * WARNING: Insecure unless your chain includes `PrevalidateAttests` as a
-     * `SignedExtension`.
+     * `TransactionExtension`.
      *
      * Unsigned Validation:
      * A call to attest is deemed valid if the sender has a `Preclaim` registered
@@ -3797,6 +3877,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 {PaseoRuntimeRuntimeCallLike} main
+     * @param {PaseoRuntimeRuntimeCallLike} fallback
+     **/
+    ifElse: GenericTxCall<
+      (
+        main: PaseoRuntimeRuntimeCallLike,
+        fallback: PaseoRuntimeRuntimeCallLike,
+      ) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'Utility';
+          palletCall: {
+            name: 'IfElse';
+            params: { main: PaseoRuntimeRuntimeCallLike; fallback: PaseoRuntimeRuntimeCallLike };
+          };
+        },
+        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 {PaseoRuntimeOriginCaller} asOrigin
+     * @param {PaseoRuntimeRuntimeCallLike} call
+     **/
+    dispatchAsFallible: GenericTxCall<
+      (
+        asOrigin: PaseoRuntimeOriginCaller,
+        call: PaseoRuntimeRuntimeCallLike,
+      ) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'Utility';
+          palletCall: {
+            name: 'DispatchAsFallible';
+            params: { asOrigin: PaseoRuntimeOriginCaller; call: PaseoRuntimeRuntimeCallLike };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
     /**
      * Generic pallet tx call
      **/
@@ -3818,13 +3968,13 @@ export interface ChainTx<
      * - `call`: The call to be made by the `real` account.
      *
      * @param {MultiAddressLike} real
-     * @param {PaseoRuntimeProxyType | undefined} forceProxyType
+     * @param {PaseoRuntimeConstantsProxyProxyType | undefined} forceProxyType
      * @param {PaseoRuntimeRuntimeCallLike} call
      **/
     proxy: GenericTxCall<
       (
         real: MultiAddressLike,
-        forceProxyType: PaseoRuntimeProxyType | undefined,
+        forceProxyType: PaseoRuntimeConstantsProxyProxyType | undefined,
         call: PaseoRuntimeRuntimeCallLike,
       ) => ChainSubmittableExtrinsic<
         {
@@ -3833,7 +3983,7 @@ export interface ChainTx<
             name: 'Proxy';
             params: {
               real: MultiAddressLike;
-              forceProxyType: PaseoRuntimeProxyType | undefined;
+              forceProxyType: PaseoRuntimeConstantsProxyProxyType | undefined;
               call: PaseoRuntimeRuntimeCallLike;
             };
           };
@@ -3854,20 +4004,20 @@ export interface ChainTx<
      * zero.
      *
      * @param {MultiAddressLike} delegate
-     * @param {PaseoRuntimeProxyType} proxyType
+     * @param {PaseoRuntimeConstantsProxyProxyType} proxyType
      * @param {number} delay
      **/
     addProxy: GenericTxCall<
       (
         delegate: MultiAddressLike,
-        proxyType: PaseoRuntimeProxyType,
+        proxyType: PaseoRuntimeConstantsProxyProxyType,
         delay: number,
       ) => ChainSubmittableExtrinsic<
         {
           pallet: 'Proxy';
           palletCall: {
             name: 'AddProxy';
-            params: { delegate: MultiAddressLike; proxyType: PaseoRuntimeProxyType; delay: number };
+            params: { delegate: MultiAddressLike; proxyType: PaseoRuntimeConstantsProxyProxyType; delay: number };
           };
         },
         ChainKnownTypes
@@ -3884,20 +4034,20 @@ export interface ChainTx<
      * - `proxy_type`: The permissions currently enabled for the removed proxy account.
      *
      * @param {MultiAddressLike} delegate
-     * @param {PaseoRuntimeProxyType} proxyType
+     * @param {PaseoRuntimeConstantsProxyProxyType} proxyType
      * @param {number} delay
      **/
     removeProxy: GenericTxCall<
       (
         delegate: MultiAddressLike,
-        proxyType: PaseoRuntimeProxyType,
+        proxyType: PaseoRuntimeConstantsProxyProxyType,
         delay: number,
       ) => ChainSubmittableExtrinsic<
         {
           pallet: 'Proxy';
           palletCall: {
             name: 'RemoveProxy';
-            params: { delegate: MultiAddressLike; proxyType: PaseoRuntimeProxyType; delay: number };
+            params: { delegate: MultiAddressLike; proxyType: PaseoRuntimeConstantsProxyProxyType; delay: number };
           };
         },
         ChainKnownTypes
@@ -3909,7 +4059,7 @@ export interface ChainTx<
      *
      * The dispatch origin for this call must be _Signed_.
      *
-     * WARNING: This may be called on accounts created by `pure`, however if done, then
+     * WARNING: This may be called on accounts created by `create_pure`, however if done, then
      * the unreserved fees will be inaccessible. **All access to this account will be lost.**
      *
      **/
@@ -3945,13 +4095,13 @@ export interface ChainTx<
      *
      * Fails if there are insufficient funds to pay for deposit.
      *
-     * @param {PaseoRuntimeProxyType} proxyType
+     * @param {PaseoRuntimeConstantsProxyProxyType} proxyType
      * @param {number} delay
      * @param {number} index
      **/
     createPure: GenericTxCall<
       (
-        proxyType: PaseoRuntimeProxyType,
+        proxyType: PaseoRuntimeConstantsProxyProxyType,
         delay: number,
         index: number,
       ) => ChainSubmittableExtrinsic<
@@ -3959,7 +4109,7 @@ export interface ChainTx<
           pallet: 'Proxy';
           palletCall: {
             name: 'CreatePure';
-            params: { proxyType: PaseoRuntimeProxyType; delay: number; index: number };
+            params: { proxyType: PaseoRuntimeConstantsProxyProxyType; delay: number; index: number };
           };
         },
         ChainKnownTypes
@@ -3973,19 +4123,19 @@ export interface ChainTx<
      * inaccessible.
      *
      * Requires a `Signed` origin, and the sender account must have been created by a call to
-     * `pure` with corresponding parameters.
+     * `create_pure` with corresponding parameters.
      *
-     * - `spawner`: The account that originally called `pure` to create this account.
-     * - `index`: The disambiguation index originally passed to `pure`. Probably `0`.
-     * - `proxy_type`: The proxy type originally passed to `pure`.
-     * - `height`: The height of the chain when the call to `pure` was processed.
-     * - `ext_index`: The extrinsic index in which the call to `pure` was processed.
+     * - `spawner`: The account that originally called `create_pure` to create this account.
+     * - `index`: The disambiguation index originally passed to `create_pure`. Probably `0`.
+     * - `proxy_type`: The proxy type originally passed to `create_pure`.
+     * - `height`: The height of the chain when the call to `create_pure` was processed.
+     * - `ext_index`: The extrinsic index in which the call to `create_pure` was processed.
      *
      * Fails with `NoPermission` in case the caller is not a previously created pure
-     * account whose `pure` call has corresponding parameters.
+     * account whose `create_pure` call has corresponding parameters.
      *
      * @param {MultiAddressLike} spawner
-     * @param {PaseoRuntimeProxyType} proxyType
+     * @param {PaseoRuntimeConstantsProxyProxyType} proxyType
      * @param {number} index
      * @param {number} height
      * @param {number} extIndex
@@ -3993,7 +4143,7 @@ export interface ChainTx<
     killPure: GenericTxCall<
       (
         spawner: MultiAddressLike,
-        proxyType: PaseoRuntimeProxyType,
+        proxyType: PaseoRuntimeConstantsProxyProxyType,
         index: number,
         height: number,
         extIndex: number,
@@ -4004,7 +4154,7 @@ export interface ChainTx<
             name: 'KillPure';
             params: {
               spawner: MultiAddressLike;
-              proxyType: PaseoRuntimeProxyType;
+              proxyType: PaseoRuntimeConstantsProxyProxyType;
               index: number;
               height: number;
               extIndex: number;
@@ -4128,14 +4278,14 @@ export interface ChainTx<
      *
      * @param {MultiAddressLike} delegate
      * @param {MultiAddressLike} real
-     * @param {PaseoRuntimeProxyType | undefined} forceProxyType
+     * @param {PaseoRuntimeConstantsProxyProxyType | undefined} forceProxyType
      * @param {PaseoRuntimeRuntimeCallLike} call
      **/
     proxyAnnounced: GenericTxCall<
       (
         delegate: MultiAddressLike,
         real: MultiAddressLike,
-        forceProxyType: PaseoRuntimeProxyType | undefined,
+        forceProxyType: PaseoRuntimeConstantsProxyProxyType | undefined,
         call: PaseoRuntimeRuntimeCallLike,
       ) => ChainSubmittableExtrinsic<
         {
@@ -4145,7 +4295,7 @@ export interface ChainTx<
             params: {
               delegate: MultiAddressLike;
               real: MultiAddressLike;
-              forceProxyType: PaseoRuntimeProxyType | undefined;
+              forceProxyType: PaseoRuntimeConstantsProxyProxyType | undefined;
               call: PaseoRuntimeRuntimeCallLike;
             };
           };
@@ -4154,6 +4304,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
      **/
@@ -4382,6 +4555,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
      **/
@@ -4647,6 +4856,72 @@ export interface ChainTx<
       >
     >;
 
+    /**
+     * Approve bountry and propose a curator simultaneously.
+     * This call is a shortcut to calling `approve_bounty` and `propose_curator` separately.
+     *
+     * May only be called from `T::SpendOrigin`.
+     *
+     * - `bounty_id`: Bounty ID to approve.
+     * - `curator`: The curator account whom will manage this bounty.
+     * - `fee`: The curator fee.
+     *
+     * ## Complexity
+     * - O(1).
+     *
+     * @param {number} bountyId
+     * @param {MultiAddressLike} curator
+     * @param {bigint} fee
+     **/
+    approveBountyWithCurator: GenericTxCall<
+      (
+        bountyId: number,
+        curator: MultiAddressLike,
+        fee: bigint,
+      ) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'Bounties';
+          palletCall: {
+            name: 'ApproveBountyWithCurator';
+            params: { bountyId: number; curator: MultiAddressLike; fee: bigint };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
+    /**
+     * Poke the deposit reserved for creating a bounty proposal.
+     *
+     * This can be used by accounts to update their reserved amount.
+     *
+     * The dispatch origin for this call must be _Signed_.
+     *
+     * Parameters:
+     * - `bounty_id`: The bounty id for which to adjust the deposit.
+     *
+     * If the deposit is updated, the difference will be reserved/unreserved from the
+     * proposer's account.
+     *
+     * The transaction is made free if the deposit is updated and paid otherwise.
+     *
+     * Emits `DepositPoked` if the deposit is updated.
+     *
+     * @param {number} bountyId
+     **/
+    pokeDeposit: GenericTxCall<
+      (bountyId: number) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'Bounties';
+          palletCall: {
+            name: 'PokeDeposit';
+            params: { bountyId: number };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
     /**
      * Generic pallet tx call
      **/
@@ -5079,19 +5354,13 @@ export interface ChainTx<
      * This can only be called when [`Phase::Emergency`] is enabled, as an alternative to
      * calling [`Call::set_emergency_election_result`].
      *
-     * @param {number | undefined} maybeMaxVoters
-     * @param {number | undefined} maybeMaxTargets
      **/
     governanceFallback: GenericTxCall<
-      (
-        maybeMaxVoters: number | undefined,
-        maybeMaxTargets: number | undefined,
-      ) => ChainSubmittableExtrinsic<
+      () => ChainSubmittableExtrinsic<
         {
           pallet: 'ElectionProviderMultiPhase';
           palletCall: {
             name: 'GovernanceFallback';
-            params: { maybeMaxVoters: number | undefined; maybeMaxTargets: number | undefined };
           };
         },
         ChainKnownTypes
@@ -5195,8 +5464,14 @@ export interface ChainTx<
    **/
   nominationPools: {
     /**
-     * Stake funds with a pool. The amount to bond is transferred from the member to the
-     * pools account and immediately increases the pools bond.
+     * Stake funds with a pool. The amount to bond is delegated (or transferred based on
+     * [`adapter::StakeStrategyType`]) from the member to the pool account and immediately
+     * increases the pool's bond.
+     *
+     * The method of transferring the amount to the pool account is determined by
+     * [`adapter::StakeStrategyType`]. If the pool is configured to use
+     * [`adapter::StakeStrategyType::Delegate`], the funds remain in the account of
+     * the `origin`, while the pool gains the right to use these funds for staking.
      *
      * # Note
      *
@@ -5481,13 +5756,13 @@ export interface ChainTx<
      * The dispatch origin of this call must be signed by the pool nominator or the pool
      * root role.
      *
-     * This directly forward the call to the staking pallet, on behalf of the pool bonded
-     * account.
+     * This directly forwards the call to an implementation of `StakingInterface` (e.g.,
+     * `pallet-staking`) through [`Config::StakeAdapter`], on behalf of the bonded pool.
      *
      * # Note
      *
-     * In addition to a `root` or `nominator` role of `origin`, pool's depositor needs to have
-     * at least `depositor_min_bond` in the pool to start nominating.
+     * In addition to a `root` or `nominator` role of `origin`, the pool's depositor needs to
+     * have at least `depositor_min_bond` in the pool to start nominating.
      *
      * @param {number} poolId
      * @param {Array<AccountId32Like>} validators
@@ -5621,16 +5896,16 @@ export interface ChainTx<
      * most pool members and they should be informed of changes to pool roles.
      *
      * @param {number} poolId
-     * @param {PalletNominationPoolsConfigOp004} newRoot
-     * @param {PalletNominationPoolsConfigOp004} newNominator
-     * @param {PalletNominationPoolsConfigOp004} newBouncer
+     * @param {PalletNominationPoolsConfigOpAccountId32} newRoot
+     * @param {PalletNominationPoolsConfigOpAccountId32} newNominator
+     * @param {PalletNominationPoolsConfigOpAccountId32} newBouncer
      **/
     updateRoles: GenericTxCall<
       (
         poolId: number,
-        newRoot: PalletNominationPoolsConfigOp004,
-        newNominator: PalletNominationPoolsConfigOp004,
-        newBouncer: PalletNominationPoolsConfigOp004,
+        newRoot: PalletNominationPoolsConfigOpAccountId32,
+        newNominator: PalletNominationPoolsConfigOpAccountId32,
+        newBouncer: PalletNominationPoolsConfigOpAccountId32,
       ) => ChainSubmittableExtrinsic<
         {
           pallet: 'NominationPools';
@@ -5638,9 +5913,9 @@ export interface ChainTx<
             name: 'UpdateRoles';
             params: {
               poolId: number;
-              newRoot: PalletNominationPoolsConfigOp004;
-              newNominator: PalletNominationPoolsConfigOp004;
-              newBouncer: PalletNominationPoolsConfigOp004;
+              newRoot: PalletNominationPoolsConfigOpAccountId32;
+              newNominator: PalletNominationPoolsConfigOpAccountId32;
+              newBouncer: PalletNominationPoolsConfigOpAccountId32;
             };
           };
         },
@@ -5654,6 +5929,9 @@ export interface ChainTx<
      * The dispatch origin of this call can be signed by the pool nominator or the pool
      * root role, same as [`Pallet::nominate`].
      *
+     * This directly forwards the call to an implementation of `StakingInterface` (e.g.,
+     * `pallet-staking`) through [`Config::StakeAdapter`], on behalf of the bonded pool.
+     *
      * Under certain conditions, this call can be dispatched permissionlessly (i.e. by any
      * account).
      *
@@ -5662,9 +5940,7 @@ export interface ChainTx<
      * are unable to unbond.
      *
      * # Conditions for permissioned dispatch:
-     * * The caller has a nominator or root role of the pool.
-     * This directly forward the call to the staking pallet, on behalf of the pool bonded
-     * account.
+     * * The caller is the pool's nominator or root.
      *
      * @param {number} poolId
      **/
@@ -5836,9 +6112,20 @@ export interface ChainTx<
     /**
      * Claim pending commission.
      *
-     * The dispatch origin of this call must be signed by the `root` role of the pool. Pending
-     * commission is paid out and added to total claimed commission`. Total pending commission
-     * is reset to zero. the current.
+     * The `root` role of the pool is _always_ allowed to claim the pool's commission.
+     *
+     * If the pool has set `CommissionClaimPermission::Permissionless`, then any account can
+     * trigger the process of claiming the pool's commission.
+     *
+     * If the pool has set its `CommissionClaimPermission` to `Account(acc)`, then only
+     * accounts
+     * * `acc`, and
+     * * the pool's root account
+     *
+     * may call this extrinsic on behalf of the pool.
+     *
+     * Pending commissions are paid out and added to the total claimed commission.
+     * The total pending commission is reset to zero.
      *
      * @param {number} poolId
      **/
@@ -5910,8 +6197,10 @@ export interface ChainTx<
      * Fails unless [`crate::pallet::Config::StakeAdapter`] is of strategy type:
      * [`adapter::StakeStrategyType::Delegate`].
      *
-     * This call can be dispatched permissionlessly (i.e. by any account). If the member has
-     * slash to be applied, caller may be rewarded with the part of the slash.
+     * The pending slash amount of the member must be equal or more than `ExistentialDeposit`.
+     * This call can be dispatched permissionlessly (i.e. by any account). If the execution
+     * is successful, fee is refunded and caller may be rewarded with a part of the slash
+     * based on the [`crate::pallet::Config::StakeAdapter`] configuration.
      *
      * @param {MultiAddressLike} memberAccount
      **/
@@ -6099,21 +6388,20 @@ export interface ChainTx<
     [callName: string]: GenericTxCall<TxCall<ChainKnownTypes>>;
   };
   /**
-   * Pallet `Configuration`'s transaction calls
+   * Pallet `StakingAhClient`'s transaction calls
    **/
-  configuration: {
+  stakingAhClient: {
     /**
-     * Set the validation upgrade cooldown.
      *
-     * @param {number} new_
+     * @param {PalletStakingAsyncRcClientValidatorSetReport} report
      **/
-    setValidationUpgradeCooldown: GenericTxCall<
-      (new_: number) => ChainSubmittableExtrinsic<
+    validatorSet: GenericTxCall<
+      (report: PalletStakingAsyncRcClientValidatorSetReport) => ChainSubmittableExtrinsic<
         {
-          pallet: 'Configuration';
+          pallet: 'StakingAhClient';
           palletCall: {
-            name: 'SetValidationUpgradeCooldown';
-            params: { new: number };
+            name: 'ValidatorSet';
+            params: { report: PalletStakingAsyncRcClientValidatorSetReport };
           };
         },
         ChainKnownTypes
@@ -6121,17 +6409,17 @@ export interface ChainTx<
     >;
 
     /**
-     * Set the validation upgrade delay.
+     * Allows governance to force set the operating mode of the pallet.
      *
-     * @param {number} new_
+     * @param {PalletStakingAsyncAhClientOperatingMode} mode
      **/
-    setValidationUpgradeDelay: GenericTxCall<
-      (new_: number) => ChainSubmittableExtrinsic<
+    setMode: GenericTxCall<
+      (mode: PalletStakingAsyncAhClientOperatingMode) => ChainSubmittableExtrinsic<
         {
-          pallet: 'Configuration';
+          pallet: 'StakingAhClient';
           palletCall: {
-            name: 'SetValidationUpgradeDelay';
-            params: { new: number };
+            name: 'SetMode';
+            params: { mode: PalletStakingAsyncAhClientOperatingMode };
           };
         },
         ChainKnownTypes
@@ -6139,16 +6427,41 @@ export interface ChainTx<
     >;
 
     /**
-     * Set the acceptance period for an included candidate.
+     * manually do what this pallet was meant to do at the end of the migration.
      *
-     * @param {number} new_
      **/
-    setCodeRetentionPeriod: GenericTxCall<
-      (new_: number) => ChainSubmittableExtrinsic<
+    forceOnMigrationEnd: GenericTxCall<
+      () => ChainSubmittableExtrinsic<
         {
-          pallet: 'Configuration';
+          pallet: 'StakingAhClient';
           palletCall: {
-            name: 'SetCodeRetentionPeriod';
+            name: 'ForceOnMigrationEnd';
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
+    /**
+     * Generic pallet tx call
+     **/
+    [callName: string]: GenericTxCall<TxCall<ChainKnownTypes>>;
+  };
+  /**
+   * Pallet `Configuration`'s transaction calls
+   **/
+  configuration: {
+    /**
+     * Set the validation upgrade cooldown.
+     *
+     * @param {number} new_
+     **/
+    setValidationUpgradeCooldown: GenericTxCall<
+      (new_: number) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'Configuration';
+          palletCall: {
+            name: 'SetValidationUpgradeCooldown';
             params: { new: number };
           };
         },
@@ -6157,16 +6470,16 @@ export interface ChainTx<
     >;
 
     /**
-     * Set the max validation code size for incoming upgrades.
+     * Set the validation upgrade delay.
      *
      * @param {number} new_
      **/
-    setMaxCodeSize: GenericTxCall<
+    setValidationUpgradeDelay: GenericTxCall<
       (new_: number) => ChainSubmittableExtrinsic<
         {
           pallet: 'Configuration';
           palletCall: {
-            name: 'SetMaxCodeSize';
+            name: 'SetValidationUpgradeDelay';
             params: { new: number };
           };
         },
@@ -6175,16 +6488,16 @@ export interface ChainTx<
     >;
 
     /**
-     * Set the max POV block size for incoming upgrades.
+     * Set the acceptance period for an included candidate.
      *
      * @param {number} new_
      **/
-    setMaxPovSize: GenericTxCall<
+    setCodeRetentionPeriod: GenericTxCall<
       (new_: number) => ChainSubmittableExtrinsic<
         {
           pallet: 'Configuration';
           palletCall: {
-            name: 'SetMaxPovSize';
+            name: 'SetCodeRetentionPeriod';
             params: { new: number };
           };
         },
@@ -6193,16 +6506,16 @@ export interface ChainTx<
     >;
 
     /**
-     * Set the max head data size for paras.
+     * Set the max validation code size for incoming upgrades.
      *
      * @param {number} new_
      **/
-    setMaxHeadDataSize: GenericTxCall<
+    setMaxCodeSize: GenericTxCall<
       (new_: number) => ChainSubmittableExtrinsic<
         {
           pallet: 'Configuration';
           palletCall: {
-            name: 'SetMaxHeadDataSize';
+            name: 'SetMaxCodeSize';
             params: { new: number };
           };
         },
@@ -6211,19 +6524,34 @@ export interface ChainTx<
     >;
 
     /**
-     * Set the number of coretime execution cores.
+     * Set the max POV block size for incoming upgrades.
      *
-     * NOTE: that this configuration is managed by the coretime chain. Only manually change
-     * this, if you really know what you are doing!
+     * @param {number} new_
+     **/
+    setMaxPovSize: GenericTxCall<
+      (new_: number) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'Configuration';
+          palletCall: {
+            name: 'SetMaxPovSize';
+            params: { new: number };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
+    /**
+     * Set the max head data size for paras.
      *
      * @param {number} new_
      **/
-    setCoretimeCores: GenericTxCall<
+    setMaxHeadDataSize: GenericTxCall<
       (new_: number) => ChainSubmittableExtrinsic<
         {
           pallet: 'Configuration';
           palletCall: {
-            name: 'SetCoretimeCores';
+            name: 'SetMaxHeadDataSize';
             params: { new: number };
           };
         },
@@ -6232,16 +6560,19 @@ export interface ChainTx<
     >;
 
     /**
-     * Set the max number of times a claim may timeout on a core before it is abandoned
+     * Set the number of coretime execution cores.
+     *
+     * NOTE: that this configuration is managed by the coretime chain. Only manually change
+     * this, if you really know what you are doing!
      *
      * @param {number} new_
      **/
-    setMaxAvailabilityTimeouts: GenericTxCall<
+    setCoretimeCores: GenericTxCall<
       (new_: number) => ChainSubmittableExtrinsic<
         {
           pallet: 'Configuration';
           palletCall: {
-            name: 'SetMaxAvailabilityTimeouts';
+            name: 'SetCoretimeCores';
             params: { new: number };
           };
         },
@@ -6781,15 +7112,15 @@ export interface ChainTx<
     /**
      * Set the asynchronous backing parameters.
      *
-     * @param {PolkadotPrimitivesV7AsyncBackingAsyncBackingParams} new_
+     * @param {PolkadotPrimitivesV8AsyncBackingAsyncBackingParams} new_
      **/
     setAsyncBackingParams: GenericTxCall<
-      (new_: PolkadotPrimitivesV7AsyncBackingAsyncBackingParams) => ChainSubmittableExtrinsic<
+      (new_: PolkadotPrimitivesV8AsyncBackingAsyncBackingParams) => ChainSubmittableExtrinsic<
         {
           pallet: 'Configuration';
           palletCall: {
             name: 'SetAsyncBackingParams';
-            params: { new: PolkadotPrimitivesV7AsyncBackingAsyncBackingParams };
+            params: { new: PolkadotPrimitivesV8AsyncBackingAsyncBackingParams };
           };
         },
         ChainKnownTypes
@@ -6799,15 +7130,15 @@ export interface ChainTx<
     /**
      * Set PVF executor parameters.
      *
-     * @param {PolkadotPrimitivesV7ExecutorParams} new_
+     * @param {PolkadotPrimitivesV8ExecutorParams} new_
      **/
     setExecutorParams: GenericTxCall<
-      (new_: PolkadotPrimitivesV7ExecutorParams) => ChainSubmittableExtrinsic<
+      (new_: PolkadotPrimitivesV8ExecutorParams) => ChainSubmittableExtrinsic<
         {
           pallet: 'Configuration';
           palletCall: {
             name: 'SetExecutorParams';
-            params: { new: PolkadotPrimitivesV7ExecutorParams };
+            params: { new: PolkadotPrimitivesV8ExecutorParams };
           };
         },
         ChainKnownTypes
@@ -6886,24 +7217,6 @@ export interface ChainTx<
       >
     >;
 
-    /**
-     * Set the on demand (parathreads) ttl in the claimqueue.
-     *
-     * @param {number} new_
-     **/
-    setOnDemandTtl: GenericTxCall<
-      (new_: number) => ChainSubmittableExtrinsic<
-        {
-          pallet: 'Configuration';
-          palletCall: {
-            name: 'SetOnDemandTtl';
-            params: { new: number };
-          };
-        },
-        ChainKnownTypes
-      >
-    >;
-
     /**
      * Set the minimum backing votes threshold.
      *
@@ -6947,15 +7260,15 @@ export interface ChainTx<
     /**
      * Set approval-voting-params.
      *
-     * @param {PolkadotPrimitivesV7ApprovalVotingParams} new_
+     * @param {PolkadotPrimitivesV8ApprovalVotingParams} new_
      **/
     setApprovalVotingParams: GenericTxCall<
-      (new_: PolkadotPrimitivesV7ApprovalVotingParams) => ChainSubmittableExtrinsic<
+      (new_: PolkadotPrimitivesV8ApprovalVotingParams) => ChainSubmittableExtrinsic<
         {
           pallet: 'Configuration';
           palletCall: {
             name: 'SetApprovalVotingParams';
-            params: { new: PolkadotPrimitivesV7ApprovalVotingParams };
+            params: { new: PolkadotPrimitivesV8ApprovalVotingParams };
           };
         },
         ChainKnownTypes
@@ -6965,15 +7278,15 @@ export interface ChainTx<
     /**
      * Set scheduler-params.
      *
-     * @param {PolkadotPrimitivesVstagingSchedulerParams} new_
+     * @param {PolkadotPrimitivesV8SchedulerParams} new_
      **/
     setSchedulerParams: GenericTxCall<
-      (new_: PolkadotPrimitivesVstagingSchedulerParams) => ChainSubmittableExtrinsic<
+      (new_: PolkadotPrimitivesV8SchedulerParams) => ChainSubmittableExtrinsic<
         {
           pallet: 'Configuration';
           palletCall: {
             name: 'SetSchedulerParams';
-            params: { new: PolkadotPrimitivesVstagingSchedulerParams };
+            params: { new: PolkadotPrimitivesV8SchedulerParams };
           };
         },
         ChainKnownTypes
@@ -7010,15 +7323,15 @@ export interface ChainTx<
     /**
      * Enter the paras inherent. This will process bitfields and backed candidates.
      *
-     * @param {PolkadotPrimitivesV7InherentData} data
+     * @param {PolkadotPrimitivesVstagingInherentData} data
      **/
     enter: GenericTxCall<
-      (data: PolkadotPrimitivesV7InherentData) => ChainSubmittableExtrinsic<
+      (data: PolkadotPrimitivesVstagingInherentData) => ChainSubmittableExtrinsic<
         {
           pallet: 'ParaInherent';
           palletCall: {
             name: 'Enter';
-            params: { data: PolkadotPrimitivesV7InherentData };
+            params: { data: PolkadotPrimitivesVstagingInherentData };
           };
         },
         ChainKnownTypes
@@ -7214,21 +7527,21 @@ export interface ChainTx<
      * Includes a statement for a PVF pre-checking vote. Potentially, finalizes the vote and
      * enacts the results if that was the last vote before achieving the supermajority.
      *
-     * @param {PolkadotPrimitivesV7PvfCheckStatement} stmt
-     * @param {PolkadotPrimitivesV7ValidatorAppSignature} signature
+     * @param {PolkadotPrimitivesV8PvfCheckStatement} stmt
+     * @param {PolkadotPrimitivesV8ValidatorAppSignature} signature
      **/
     includePvfCheckStatement: GenericTxCall<
       (
-        stmt: PolkadotPrimitivesV7PvfCheckStatement,
-        signature: PolkadotPrimitivesV7ValidatorAppSignature,
+        stmt: PolkadotPrimitivesV8PvfCheckStatement,
+        signature: PolkadotPrimitivesV8ValidatorAppSignature,
       ) => ChainSubmittableExtrinsic<
         {
           pallet: 'Paras';
           palletCall: {
             name: 'IncludePvfCheckStatement';
             params: {
-              stmt: PolkadotPrimitivesV7PvfCheckStatement;
-              signature: PolkadotPrimitivesV7ValidatorAppSignature;
+              stmt: PolkadotPrimitivesV8PvfCheckStatement;
+              signature: PolkadotPrimitivesV8ValidatorAppSignature;
             };
           };
         },
@@ -7258,6 +7571,91 @@ export interface ChainTx<
       >
     >;
 
+    /**
+     * Remove an upgrade cooldown for a parachain.
+     *
+     * The cost for removing the cooldown earlier depends on the time left for the cooldown
+     * multiplied by [`Config::CooldownRemovalMultiplier`]. The paid tokens are burned.
+     *
+     * @param {PolkadotParachainPrimitivesPrimitivesId} para
+     **/
+    removeUpgradeCooldown: GenericTxCall<
+      (para: PolkadotParachainPrimitivesPrimitivesId) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'Paras';
+          palletCall: {
+            name: 'RemoveUpgradeCooldown';
+            params: { para: PolkadotParachainPrimitivesPrimitivesId };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
+    /**
+     * Sets the storage for the authorized current code hash of the parachain.
+     * If not applied, it will be removed at the `System::block_number() + valid_period` block.
+     *
+     * This can be useful, when triggering `Paras::force_set_current_code(para, code)`
+     * from a different chain than the one where the `Paras` pallet is deployed.
+     *
+     * The main purpose is to avoid transferring the entire `code` Wasm blob between chains.
+     * Instead, we authorize `code_hash` with `root`, which can later be applied by
+     * `Paras::apply_authorized_force_set_current_code(para, code)` by anyone.
+     *
+     * Authorizations are stored in an **overwriting manner**.
+     *
+     * @param {PolkadotParachainPrimitivesPrimitivesId} para
+     * @param {PolkadotParachainPrimitivesPrimitivesValidationCodeHash} newCodeHash
+     * @param {number} validPeriod
+     **/
+    authorizeForceSetCurrentCodeHash: GenericTxCall<
+      (
+        para: PolkadotParachainPrimitivesPrimitivesId,
+        newCodeHash: PolkadotParachainPrimitivesPrimitivesValidationCodeHash,
+        validPeriod: number,
+      ) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'Paras';
+          palletCall: {
+            name: 'AuthorizeForceSetCurrentCodeHash';
+            params: {
+              para: PolkadotParachainPrimitivesPrimitivesId;
+              newCodeHash: PolkadotParachainPrimitivesPrimitivesValidationCodeHash;
+              validPeriod: number;
+            };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
+    /**
+     * Applies the already authorized current code for the parachain,
+     * triggering the same functionality as `force_set_current_code`.
+     *
+     * @param {PolkadotParachainPrimitivesPrimitivesId} para
+     * @param {PolkadotParachainPrimitivesPrimitivesValidationCode} newCode
+     **/
+    applyAuthorizedForceSetCurrentCode: GenericTxCall<
+      (
+        para: PolkadotParachainPrimitivesPrimitivesId,
+        newCode: PolkadotParachainPrimitivesPrimitivesValidationCode,
+      ) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'Paras';
+          palletCall: {
+            name: 'ApplyAuthorizedForceSetCurrentCode';
+            params: {
+              para: PolkadotParachainPrimitivesPrimitivesId;
+              newCode: PolkadotParachainPrimitivesPrimitivesValidationCode;
+            };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
     /**
      * Generic pallet tx call
      **/
@@ -7647,19 +8045,19 @@ export interface ChainTx<
   parasSlashing: {
     /**
      *
-     * @param {PolkadotPrimitivesV7SlashingDisputeProof} disputeProof
+     * @param {PolkadotPrimitivesVstagingDisputeProof} disputeProof
      * @param {SpSessionMembershipProof} keyOwnerProof
      **/
     reportDisputeLostUnsigned: GenericTxCall<
       (
-        disputeProof: PolkadotPrimitivesV7SlashingDisputeProof,
+        disputeProof: PolkadotPrimitivesVstagingDisputeProof,
         keyOwnerProof: SpSessionMembershipProof,
       ) => ChainSubmittableExtrinsic<
         {
           pallet: 'ParasSlashing';
           palletCall: {
             name: 'ReportDisputeLostUnsigned';
-            params: { disputeProof: PolkadotPrimitivesV7SlashingDisputeProof; keyOwnerProof: SpSessionMembershipProof };
+            params: { disputeProof: PolkadotPrimitivesVstagingDisputeProof; keyOwnerProof: SpSessionMembershipProof };
           };
         },
         ChainKnownTypes
@@ -7694,6 +8092,8 @@ export interface ChainTx<
      *
      * @param {bigint} maxAmount
      * @param {PolkadotParachainPrimitivesPrimitivesId} paraId
+     *
+     * @deprecated This will be removed in favor of using `place_order_with_credits`
      **/
     placeOrderAllowDeath: GenericTxCall<
       (
@@ -7730,6 +8130,8 @@ export interface ChainTx<
      *
      * @param {bigint} maxAmount
      * @param {PolkadotParachainPrimitivesPrimitivesId} paraId
+     *
+     * @deprecated This will be removed in favor of using `place_order_with_credits`
      **/
     placeOrderKeepAlive: GenericTxCall<
       (
@@ -7747,6 +8149,44 @@ export interface ChainTx<
       >
     >;
 
+    /**
+     * Create a single on demand core order with credits.
+     * Will charge the owner's on-demand credit account the spot price for the current block.
+     *
+     * Parameters:
+     * - `origin`: The sender of the call, on-demand credits will be withdrawn from this
+     * account.
+     * - `max_amount`: The maximum number of credits to spend from the origin to place an
+     * order.
+     * - `para_id`: A `ParaId` the origin wants to provide blockspace for.
+     *
+     * Errors:
+     * - `InsufficientCredits`
+     * - `QueueFull`
+     * - `SpotPriceHigherThanMaxAmount`
+     *
+     * Events:
+     * - `OnDemandOrderPlaced`
+     *
+     * @param {bigint} maxAmount
+     * @param {PolkadotParachainPrimitivesPrimitivesId} paraId
+     **/
+    placeOrderWithCredits: GenericTxCall<
+      (
+        maxAmount: bigint,
+        paraId: PolkadotParachainPrimitivesPrimitivesId,
+      ) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'OnDemand';
+          palletCall: {
+            name: 'PlaceOrderWithCredits';
+            params: { maxAmount: bigint; paraId: PolkadotParachainPrimitivesPrimitivesId };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
     /**
      * Generic pallet tx call
      **/
@@ -8543,6 +8983,27 @@ export interface ChainTx<
       >
     >;
 
+    /**
+     *
+     * @param {AccountId32Like} who
+     * @param {bigint} amount
+     **/
+    creditAccount: GenericTxCall<
+      (
+        who: AccountId32Like,
+        amount: bigint,
+      ) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'Coretime';
+          palletCall: {
+            name: 'CreditAccount';
+            params: { who: AccountId32Like; amount: bigint };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
     /**
      * Receive instructions from the `ExternalBrokerOrigin`, detailing how a specific core is
      * to be used.
@@ -8819,6 +9280,8 @@ export interface ChainTx<
      * @param {XcmVersionedLocation} beneficiary
      * @param {XcmVersionedAssets} assets
      * @param {number} feeAssetItem
+     *
+     * @deprecated This extrinsic uses `WeightLimit::Unlimited`, please migrate to `limited_teleport_assets` or `transfer_assets`
      **/
     teleportAssets: GenericTxCall<
       (
@@ -8879,6 +9342,8 @@ export interface ChainTx<
      * @param {XcmVersionedLocation} beneficiary
      * @param {XcmVersionedAssets} assets
      * @param {number} feeAssetItem
+     *
+     * @deprecated This extrinsic uses `WeightLimit::Unlimited`, please migrate to `limited_reserve_transfer_assets` or `transfer_assets`
      **/
     reserveTransferAssets: GenericTxCall<
       (
@@ -8940,19 +9405,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: 'XcmPallet';
           palletCall: {
             name: 'ForceXcmVersion';
-            params: { location: StagingXcmV4Location; version: number };
+            params: { location: StagingXcmV5Location; version: number };
           };
         },
         ChainKnownTypes
@@ -9340,6 +9805,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: 'XcmPallet';
+          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: 'XcmPallet';
+          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: 'XcmPallet';
+          palletCall: {
+            name: 'RemoveAllAuthorizedAliases';
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
     /**
      * Generic pallet tx call
      **/
@@ -9512,7 +10045,7 @@ export interface ChainTx<
      * @param {SpConsensusBeefyDoubleVotingProof} equivocationProof
      * @param {SpSessionMembershipProof} keyOwnerProof
      **/
-    reportEquivocation: GenericTxCall<
+    reportDoubleVoting: GenericTxCall<
       (
         equivocationProof: SpConsensusBeefyDoubleVotingProof,
         keyOwnerProof: SpSessionMembershipProof,
@@ -9520,7 +10053,7 @@ export interface ChainTx<
         {
           pallet: 'Beefy';
           palletCall: {
-            name: 'ReportEquivocation';
+            name: 'ReportDoubleVoting';
             params: { equivocationProof: SpConsensusBeefyDoubleVotingProof; keyOwnerProof: SpSessionMembershipProof };
           };
         },
@@ -9542,7 +10075,7 @@ export interface ChainTx<
      * @param {SpConsensusBeefyDoubleVotingProof} equivocationProof
      * @param {SpSessionMembershipProof} keyOwnerProof
      **/
-    reportEquivocationUnsigned: GenericTxCall<
+    reportDoubleVotingUnsigned: GenericTxCall<
       (
         equivocationProof: SpConsensusBeefyDoubleVotingProof,
         keyOwnerProof: SpSessionMembershipProof,
@@ -9550,7 +10083,7 @@ export interface ChainTx<
         {
           pallet: 'Beefy';
           palletCall: {
-            name: 'ReportEquivocationUnsigned';
+            name: 'ReportDoubleVotingUnsigned';
             params: { equivocationProof: SpConsensusBeefyDoubleVotingProof; keyOwnerProof: SpSessionMembershipProof };
           };
         },
@@ -9580,14 +10113,126 @@ export interface ChainTx<
     >;
 
     /**
-     * Generic pallet tx call
+     * Report fork voting equivocation. This method will verify the equivocation proof
+     * and validate the given key ownership proof against the extracted offender.
+     * If both are valid, the offence will be reported.
+     *
+     * @param {SpConsensusBeefyForkVotingProof} equivocationProof
+     * @param {SpSessionMembershipProof} keyOwnerProof
      **/
-    [callName: string]: GenericTxCall<TxCall<ChainKnownTypes>>;
-  };
-  /**
-   * Pallet `ParaSudoWrapper`'s transaction calls
-   **/
-  paraSudoWrapper: {
+    reportForkVoting: GenericTxCall<
+      (
+        equivocationProof: SpConsensusBeefyForkVotingProof,
+        keyOwnerProof: SpSessionMembershipProof,
+      ) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'Beefy';
+          palletCall: {
+            name: 'ReportForkVoting';
+            params: { equivocationProof: SpConsensusBeefyForkVotingProof; keyOwnerProof: SpSessionMembershipProof };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
+    /**
+     * Report fork voting equivocation. This method will verify the equivocation proof
+     * and validate the given key ownership proof against the extracted offender.
+     * If both are valid, the offence will be reported.
+     *
+     * This extrinsic must be called unsigned and it is expected that only
+     * block authors will call it (validated in `ValidateUnsigned`), as such
+     * if the block author is defined it will be defined as the equivocation
+     * reporter.
+     *
+     * @param {SpConsensusBeefyForkVotingProof} equivocationProof
+     * @param {SpSessionMembershipProof} keyOwnerProof
+     **/
+    reportForkVotingUnsigned: GenericTxCall<
+      (
+        equivocationProof: SpConsensusBeefyForkVotingProof,
+        keyOwnerProof: SpSessionMembershipProof,
+      ) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'Beefy';
+          palletCall: {
+            name: 'ReportForkVotingUnsigned';
+            params: { equivocationProof: SpConsensusBeefyForkVotingProof; keyOwnerProof: SpSessionMembershipProof };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
+    /**
+     * Report future block voting equivocation. This method will verify the equivocation proof
+     * and validate the given key ownership proof against the extracted offender.
+     * If both are valid, the offence will be reported.
+     *
+     * @param {SpConsensusBeefyFutureBlockVotingProof} equivocationProof
+     * @param {SpSessionMembershipProof} keyOwnerProof
+     **/
+    reportFutureBlockVoting: GenericTxCall<
+      (
+        equivocationProof: SpConsensusBeefyFutureBlockVotingProof,
+        keyOwnerProof: SpSessionMembershipProof,
+      ) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'Beefy';
+          palletCall: {
+            name: 'ReportFutureBlockVoting';
+            params: {
+              equivocationProof: SpConsensusBeefyFutureBlockVotingProof;
+              keyOwnerProof: SpSessionMembershipProof;
+            };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
+    /**
+     * Report future block voting equivocation. This method will verify the equivocation proof
+     * and validate the given key ownership proof against the extracted offender.
+     * If both are valid, the offence will be reported.
+     *
+     * This extrinsic must be called unsigned and it is expected that only
+     * block authors will call it (validated in `ValidateUnsigned`), as such
+     * if the block author is defined it will be defined as the equivocation
+     * reporter.
+     *
+     * @param {SpConsensusBeefyFutureBlockVotingProof} equivocationProof
+     * @param {SpSessionMembershipProof} keyOwnerProof
+     **/
+    reportFutureBlockVotingUnsigned: GenericTxCall<
+      (
+        equivocationProof: SpConsensusBeefyFutureBlockVotingProof,
+        keyOwnerProof: SpSessionMembershipProof,
+      ) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'Beefy';
+          palletCall: {
+            name: 'ReportFutureBlockVotingUnsigned';
+            params: {
+              equivocationProof: SpConsensusBeefyFutureBlockVotingProof;
+              keyOwnerProof: SpSessionMembershipProof;
+            };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
+    /**
+     * Generic pallet tx call
+     **/
+    [callName: string]: GenericTxCall<TxCall<ChainKnownTypes>>;
+  };
+  /**
+   * Pallet `ParaSudoWrapper`'s transaction calls
+   **/
+  paraSudoWrapper: {
     /**
      * Schedule a para to be initialized at the start of the next session.
      *
@@ -9845,6 +10490,353 @@ export interface ChainTx<
       >
     >;
 
+    /**
+     * Generic pallet tx call
+     **/
+    [callName: string]: GenericTxCall<TxCall<ChainKnownTypes>>;
+  };
+  /**
+   * Pallet `RcMigrator`'s transaction calls
+   **/
+  rcMigrator: {
+    /**
+     * Set the migration stage.
+     *
+     * This call is intended for emergency use only and is guarded by the
+     * [`Config::AdminOrigin`].
+     *
+     * @param {PalletRcMigratorMigrationStage} stage
+     **/
+    forceSetStage: GenericTxCall<
+      (stage: PalletRcMigratorMigrationStage) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'RcMigrator';
+          palletCall: {
+            name: 'ForceSetStage';
+            params: { stage: PalletRcMigratorMigrationStage };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
+    /**
+     * Schedule the migration to start at a given moment.
+     *
+     * ### Parameters:
+     * - `start`: The block number at which the migration will start. `DispatchTime` calculated
+     * at the moment of the extrinsic execution.
+     * - `warm_up`: Duration or timepoint that will be used to prepare for the migration. Calls
+     * are filtered during this period. It is intended to give enough time for UMP and DMP
+     * queues to empty. `DispatchTime` calculated at the moment of the transition to the
+     * warm-up stage.
+     * - `cool_off`: The block number at which the post migration cool-off period will end. The
+     * `DispatchTime` calculated at the moment of the transition to the cool-off stage.
+     * - `unsafe_ignore_staking_lock_check`: ONLY FOR TESTING. Ignore the check whether the
+     * scheduled time point is far enough in the future.
+     *
+     * Note: If the staking election for next era is already complete, and the next
+     * validator set is queued in `pallet-session`, we want to avoid starting the data
+     * migration at this point as it can lead to some missed validator rewards. To address
+     * this, we stop staking election at the start of migration and must wait atleast 1
+     * session (set via warm_up) before starting the data migration.
+     *
+     * Read [`MigrationStage::Scheduled`] documentation for more details.
+     *
+     * @param {FrameSupportScheduleDispatchTime} start
+     * @param {FrameSupportScheduleDispatchTime} warmUp
+     * @param {FrameSupportScheduleDispatchTime} coolOff
+     * @param {boolean} unsafeIgnoreStakingLockCheck
+     **/
+    scheduleMigration: GenericTxCall<
+      (
+        start: FrameSupportScheduleDispatchTime,
+        warmUp: FrameSupportScheduleDispatchTime,
+        coolOff: FrameSupportScheduleDispatchTime,
+        unsafeIgnoreStakingLockCheck: boolean,
+      ) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'RcMigrator';
+          palletCall: {
+            name: 'ScheduleMigration';
+            params: {
+              start: FrameSupportScheduleDispatchTime;
+              warmUp: FrameSupportScheduleDispatchTime;
+              coolOff: FrameSupportScheduleDispatchTime;
+              unsafeIgnoreStakingLockCheck: boolean;
+            };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
+    /**
+     * Start the data migration.
+     *
+     * This is typically called by the Asset Hub to indicate it's readiness to receive the
+     * migration data.
+     *
+     **/
+    startDataMigration: GenericTxCall<
+      () => ChainSubmittableExtrinsic<
+        {
+          pallet: 'RcMigrator';
+          palletCall: {
+            name: 'StartDataMigration';
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
+    /**
+     * Receive a query response from the Asset Hub for a previously sent xcm message.
+     *
+     * @param {bigint} queryId
+     * @param {StagingXcmV5Response} response
+     **/
+    receiveQueryResponse: GenericTxCall<
+      (
+        queryId: bigint,
+        response: StagingXcmV5Response,
+      ) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'RcMigrator';
+          palletCall: {
+            name: 'ReceiveQueryResponse';
+            params: { queryId: bigint; response: StagingXcmV5Response };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
+    /**
+     * Resend a previously sent and unconfirmed XCM message.
+     *
+     * @param {bigint} queryId
+     **/
+    resendXcm: GenericTxCall<
+      (queryId: bigint) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'RcMigrator';
+          palletCall: {
+            name: 'ResendXcm';
+            params: { queryId: bigint };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
+    /**
+     * Set the unprocessed message buffer size.
+     *
+     * `None` means to use the configuration value.
+     *
+     * @param {number | undefined} new_
+     **/
+    setUnprocessedMsgBuffer: GenericTxCall<
+      (new_: number | undefined) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'RcMigrator';
+          palletCall: {
+            name: 'SetUnprocessedMsgBuffer';
+            params: { new: number | undefined };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
+    /**
+     * Set the AH UMP queue priority configuration.
+     *
+     * Can only be called by the `AdminOrigin`.
+     *
+     * @param {PalletRcMigratorQueuePriority} new_
+     **/
+    setAhUmpQueuePriority: GenericTxCall<
+      (new_: PalletRcMigratorQueuePriority) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'RcMigrator';
+          palletCall: {
+            name: 'SetAhUmpQueuePriority';
+            params: { new: PalletRcMigratorQueuePriority };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
+    /**
+     * Set the manager account id.
+     *
+     * The manager has the similar to [`Config::AdminOrigin`] privileges except that it
+     * can not set the manager account id via `set_manager` call.
+     *
+     * @param {AccountId32Like | undefined} new_
+     **/
+    setManager: GenericTxCall<
+      (new_: AccountId32Like | undefined) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'RcMigrator';
+          palletCall: {
+            name: 'SetManager';
+            params: { new: AccountId32Like | undefined };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
+    /**
+     * XCM send call identical to the [`pallet_xcm::Pallet::send`] call but with the
+     * [Config::SendXcm] router which will be able to send messages to the Asset Hub during
+     * the migration.
+     *
+     * @param {XcmVersionedLocation} dest
+     * @param {XcmVersionedXcm} message
+     **/
+    sendXcmMessage: GenericTxCall<
+      (
+        dest: XcmVersionedLocation,
+        message: XcmVersionedXcm,
+      ) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'RcMigrator';
+          palletCall: {
+            name: 'SendXcmMessage';
+            params: { dest: XcmVersionedLocation; message: XcmVersionedXcm };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
+    /**
+     * Set the accounts to be preserved on Relay Chain during the migration.
+     *
+     * The accounts must have no consumers references.
+     *
+     * @param {Array<AccountId32Like>} accounts
+     **/
+    preserveAccounts: GenericTxCall<
+      (accounts: Array<AccountId32Like>) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'RcMigrator';
+          palletCall: {
+            name: 'PreserveAccounts';
+            params: { accounts: Array<AccountId32Like> };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
+    /**
+     * Set the canceller account id.
+     *
+     * The canceller can only stop scheduled migration.
+     *
+     * @param {AccountId32Like | undefined} new_
+     **/
+    setCanceller: GenericTxCall<
+      (new_: AccountId32Like | undefined) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'RcMigrator';
+          palletCall: {
+            name: 'SetCanceller';
+            params: { new: AccountId32Like | undefined };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
+    /**
+     * Pause the migration.
+     *
+     **/
+    pauseMigration: GenericTxCall<
+      () => ChainSubmittableExtrinsic<
+        {
+          pallet: 'RcMigrator';
+          palletCall: {
+            name: 'PauseMigration';
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
+    /**
+     * Cancel the migration.
+     *
+     * Migration can only be cancelled if it is in the [`MigrationStage::Scheduled`] state.
+     *
+     **/
+    cancelMigration: GenericTxCall<
+      () => ChainSubmittableExtrinsic<
+        {
+          pallet: 'RcMigrator';
+          palletCall: {
+            name: 'CancelMigration';
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
+    /**
+     * Vote on behalf of any of the members in `MultisigMembers`.
+     *
+     * Unsigned extrinsic, requiring the `payload` to be signed.
+     *
+     * Upon each call, a new entry is created in `ManagerMultisigs` map the `payload.call` to
+     * be dispatched. Once `MultisigThreshold` is reached, the entire map is deleted, and we
+     * move on to the next round.
+     *
+     * The round system ensures that signatures from older round cannot be reused.
+     *
+     * @param {PalletRcMigratorManagerMultisigVote} payload
+     * @param {SpRuntimeMultiSignature} sig
+     **/
+    voteManagerMultisig: GenericTxCall<
+      (
+        payload: PalletRcMigratorManagerMultisigVote,
+        sig: SpRuntimeMultiSignature,
+      ) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'RcMigrator';
+          palletCall: {
+            name: 'VoteManagerMultisig';
+            params: { payload: PalletRcMigratorManagerMultisigVote; sig: SpRuntimeMultiSignature };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
+    /**
+     * Set the migration settings. Can only be done by admin or manager.
+     *
+     * @param {PalletRcMigratorMigrationSettings | undefined} settings
+     **/
+    setSettings: GenericTxCall<
+      (settings: PalletRcMigratorMigrationSettings | undefined) => ChainSubmittableExtrinsic<
+        {
+          pallet: 'RcMigrator';
+          palletCall: {
+            name: 'SetSettings';
+            params: { settings: PalletRcMigratorMigrationSettings | undefined };
+          };
+        },
+        ChainKnownTypes
+      >
+    >;
+
     /**
      * Generic pallet tx call
      **/