@dedot/chaintypes 0.0.1-alpha.65 → 0.0.1-alpha.67

package/rococoAssetHub/events.d.ts

@@ -21,6 +21,8 @@ import type {
   PalletNftsAttributeNamespace,
   PalletNftsPriceWithDirection,
   PalletNftsPalletAttributes,
+  PalletStateTrieMigrationMigrationCompute,
+  PalletStateTrieMigrationError,
 } from './types';
 
 export interface ChainEvents extends GenericChainEvents {
@@ -2244,6 +2246,92 @@ export interface ChainEvents extends GenericChainEvents {
       }
     >;
 
+    /**
+     * Pool has been touched in order to fulfill operational requirements.
+     **/
+    Touched: GenericPalletEvent<
+      'AssetConversion',
+      'Touched',
+      {
+        /**
+         * The ID of the pool.
+         **/
+        poolId: [StagingXcmV3MultilocationMultiLocation, StagingXcmV3MultilocationMultiLocation];
+
+        /**
+         * The account initiating the touch.
+         **/
+        who: AccountId32;
+      }
+    >;
+
+    /**
+     * Generic pallet event
+     **/
+    [prop: string]: GenericPalletEvent;
+  };
+  /**
+   * Pallet `StateTrieMigration`'s events
+   **/
+  stateTrieMigration: {
+    /**
+     * Given number of `(top, child)` keys were migrated respectively, with the given
+     * `compute`.
+     **/
+    Migrated: GenericPalletEvent<
+      'StateTrieMigration',
+      'Migrated',
+      { top: number; child: number; compute: PalletStateTrieMigrationMigrationCompute }
+    >;
+
+    /**
+     * Some account got slashed by the given amount.
+     **/
+    Slashed: GenericPalletEvent<'StateTrieMigration', 'Slashed', { who: AccountId32; amount: bigint }>;
+
+    /**
+     * The auto migration task finished.
+     **/
+    AutoMigrationFinished: GenericPalletEvent<'StateTrieMigration', 'AutoMigrationFinished', null>;
+
+    /**
+     * Migration got halted due to an error or miss-configuration.
+     **/
+    Halted: GenericPalletEvent<'StateTrieMigration', 'Halted', { error: PalletStateTrieMigrationError }>;
+
+    /**
+     * Generic pallet event
+     **/
+    [prop: string]: GenericPalletEvent;
+  };
+  /**
+   * Pallet `AssetConversionMigration`'s events
+   **/
+  assetConversionMigration: {
+    /**
+     * Indicates that a pool has been migrated to the new account ID.
+     **/
+    MigratedToNewAccount: GenericPalletEvent<
+      'AssetConversionMigration',
+      'MigratedToNewAccount',
+      {
+        /**
+         * Pool's ID.
+         **/
+        poolId: [StagingXcmV3MultilocationMultiLocation, StagingXcmV3MultilocationMultiLocation];
+
+        /**
+         * Pool's prior account ID.
+         **/
+        priorAccount: AccountId32;
+
+        /**
+         * Pool's new account ID.
+         **/
+        newAccount: AccountId32;
+      }
+    >;
+
     /**
      * Generic pallet event
      **/

package/rococoAssetHub/query.d.ts

@@ -76,6 +76,8 @@ import type {
   StagingXcmV3MultilocationMultiLocation,
   PalletNftFractionalizationDetails,
   PalletAssetConversionPoolInfo,
+  PalletStateTrieMigrationMigrationTask,
+  PalletStateTrieMigrationMigrationLimits,
 } from './types';
 
 export interface ChainStorage extends GenericChainStorage {
@@ -1519,6 +1521,43 @@ export interface ChainStorage extends GenericChainStorage {
      **/
     nextPoolAssetId: GenericStorageQuery<() => number | undefined>;
 
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery;
+  };
+  /**
+   * Pallet `StateTrieMigration`'s storage queries
+   **/
+  stateTrieMigration: {
+    /**
+     * Migration progress.
+     *
+     * This stores the snapshot of the last migrated keys. It can be set into motion and move
+     * forward by any of the means provided by this pallet.
+     *
+     * @param {Callback<PalletStateTrieMigrationMigrationTask> =} callback
+     **/
+    migrationProcess: GenericStorageQuery<() => PalletStateTrieMigrationMigrationTask>;
+
+    /**
+     * The limits that are imposed on automatic migrations.
+     *
+     * If set to None, then no automatic migration happens.
+     *
+     * @param {Callback<PalletStateTrieMigrationMigrationLimits | undefined> =} callback
+     **/
+    autoLimits: GenericStorageQuery<() => PalletStateTrieMigrationMigrationLimits | undefined>;
+
+    /**
+     * The maximum limits that the signed migration could use.
+     *
+     * If not set, no signed submission is allowed.
+     *
+     * @param {Callback<PalletStateTrieMigrationMigrationLimits | undefined> =} callback
+     **/
+    signedMigrationMaxLimits: GenericStorageQuery<() => PalletStateTrieMigrationMigrationLimits | undefined>;
+
     /**
      * Generic pallet storage query
      **/

package/rococoAssetHub/runtime.d.ts

@@ -512,28 +512,51 @@ export interface RuntimeApis extends GenericRuntimeApis {
    **/
   genesisBuilder: {
     /**
-     * Creates the default `RuntimeGenesisConfig` and returns it as a JSON blob.
+     * Build `RuntimeGenesisConfig` from a JSON blob not using any defaults and store it in the
+     * storage.
      *
-     * This function instantiates the default `RuntimeGenesisConfig` struct for the runtime and serializes it into a JSON
-     * blob. It returns a `Vec<u8>` containing the JSON representation of the default `RuntimeGenesisConfig`.
+     * In the case of a FRAME-based runtime, this function deserializes the full `RuntimeGenesisConfig` from the given JSON blob and
+     * puts it into the storage. If the provided JSON blob is incorrect or incomplete or the
+     * deserialization fails, an error is returned.
      *
-     * @callname: GenesisBuilder_create_default_config
+     * Please note that provided JSON blob must contain all `RuntimeGenesisConfig` fields, no
+     * defaults will be used.
+     *
+     * @callname: GenesisBuilder_build_state
+     * @param {BytesLike} json
      **/
-    createDefaultConfig: GenericRuntimeApiMethod<() => Promise<Bytes>>;
+    buildState: GenericRuntimeApiMethod<(json: BytesLike) => Promise<Result<[], string>>>;
 
     /**
-     * Build `RuntimeGenesisConfig` from a JSON blob not using any defaults and store it in the storage.
+     * Returns a JSON blob representation of the built-in `RuntimeGenesisConfig` identified by
+     * `id`.
      *
-     * This function deserializes the full `RuntimeGenesisConfig` from the given JSON blob and puts it into the storage.
-     * If the provided JSON blob is incorrect or incomplete or the deserialization fails, an error is returned.
-     * It is recommended to log any errors encountered during the process.
+     * If `id` is `None` the function returns JSON blob representation of the default
+     * `RuntimeGenesisConfig` struct of the runtime. Implementation must provide default
+     * `RuntimeGenesisConfig`.
      *
-     * Please note that provided json blob must contain all `RuntimeGenesisConfig` fields, no defaults will be used.
+     * Otherwise function returns a JSON representation of the built-in, named
+     * `RuntimeGenesisConfig` preset identified by `id`, or `None` if such preset does not
+     * exists. Returned `Vec<u8>` contains bytes of JSON blob (patch) which comprises a list of
+     * (potentially nested) key-value pairs that are intended for customizing the default
+     * runtime genesis config. The patch shall be merged (rfc7386) with the JSON representation
+     * of the default `RuntimeGenesisConfig` to create a comprehensive genesis config that can
+     * be used in `build_state` method.
      *
-     * @callname: GenesisBuilder_build_config
-     * @param {BytesLike} json
+     * @callname: GenesisBuilder_get_preset
+     * @param {string | undefined} id
+     **/
+    getPreset: GenericRuntimeApiMethod<(id?: string | undefined) => Promise<Bytes | undefined>>;
+
+    /**
+     * Returns a list of identifiers for available builtin `RuntimeGenesisConfig` presets.
+     *
+     * The presets from the list can be queried with [`GenesisBuilder::get_preset`] method. If
+     * no named presets are provided by the runtime the list is empty.
+     *
+     * @callname: GenesisBuilder_preset_names
      **/
-    buildConfig: GenericRuntimeApiMethod<(json: BytesLike) => Promise<Result<[], string>>>;
+    presetNames: GenericRuntimeApiMethod<() => Promise<Array<string>>>;
 
     /**
      * Generic runtime api call

package/rococoAssetHub/tx.d.ts

@@ -21,6 +21,8 @@ import type {
   SpWeightsWeightV2Weight,
   StagingXcmV4Location,
   XcmV3WeightLimit,
+  StagingXcmExecutorAssetTransferTransferType,
+  XcmVersionedAssetId,
   CumulusPrimitivesCoreAggregateMessageOrigin,
   AssetHubRococoRuntimeOriginCaller,
   PalletMultisigTimepoint,
@@ -39,6 +41,9 @@ import type {
   PalletNftsPreSignedMint,
   PalletNftsPreSignedAttributes,
   StagingXcmV3MultilocationMultiLocation,
+  PalletStateTrieMigrationMigrationLimits,
+  PalletStateTrieMigrationMigrationTask,
+  PalletStateTrieMigrationProgress,
 } from './types';
 
 export type ChainSubmittableExtrinsic<T extends IRuntimeTxCall = AssetHubRococoRuntimeRuntimeCallLike> = Extrinsic<
@@ -956,7 +961,6 @@ export interface ChainTx extends GenericChainTx<TxCall> {
    **/
   polkadotXcm: {
     /**
-     * WARNING: DEPRECATED. `send` will be removed after June 2024. Use `send_blob` instead.
      *
      * @param {XcmVersionedLocation} dest
      * @param {XcmVersionedXcm} message
@@ -1086,9 +1090,6 @@ export interface ChainTx extends GenericChainTx<TxCall> {
      * the maximum amount of weight that the message could take to be executed, then no
      * execution attempt will be made.
      *
-     * WARNING: DEPRECATED. `execute` will be removed after June 2024. Use `execute_blob`
-     * instead.
-     *
      * @param {XcmVersionedXcm} message
      * @param {SpWeightsWeightV2Weight} maxWeight
      **/
@@ -1400,53 +1401,85 @@ export interface ChainTx extends GenericChainTx<TxCall> {
     >;
 
     /**
-     * Execute an XCM from a local, signed, origin.
+     * Transfer assets from the local chain to the destination chain using explicit transfer
+     * types for assets and fees.
      *
-     * An event is deposited indicating whether the message could be executed completely
-     * or only partially.
+     * `assets` must have same reserve location or may be teleportable to `dest`. Caller must
+     * provide the `assets_transfer_type` to be used for `assets`:
+     * - `TransferType::LocalReserve`: transfer assets to sovereign account of destination
+     * chain and forward a notification XCM to `dest` to mint and deposit reserve-based
+     * assets to `beneficiary`.
+     * - `TransferType::DestinationReserve`: burn local assets and forward a notification to
+     * `dest` chain to withdraw the reserve assets from this chain's sovereign account and
+     * deposit them to `beneficiary`.
+     * - `TransferType::RemoteReserve(reserve)`: burn local assets, forward XCM to `reserve`
+     * chain to move reserves from this chain's SA to `dest` chain's SA, and forward another
+     * XCM to `dest` to mint and deposit reserve-based assets to `beneficiary`. Typically
+     * the remote `reserve` is Asset Hub.
+     * - `TransferType::Teleport`: burn local assets and forward XCM to `dest` chain to
+     * mint/teleport assets and deposit them to `beneficiary`.
+     *
+     * On the destination chain, as well as any intermediary hops, `BuyExecution` is used to
+     * buy execution using transferred `assets` identified by `remote_fees_id`.
+     * Make sure enough of the specified `remote_fees_id` asset is included in the given list
+     * of `assets`. `remote_fees_id` should be enough to pay for `weight_limit`. If more weight
+     * is needed than `weight_limit`, then the operation will fail and the sent assets may be
+     * at risk.
      *
-     * No more than `max_weight` will be used in its attempted execution. If this is less than
-     * the maximum amount of weight that the message could take to be executed, then no
-     * execution attempt will be made.
+     * `remote_fees_id` may use different transfer type than rest of `assets` and can be
+     * specified through `fees_transfer_type`.
      *
-     * The message is passed in encoded. It needs to be decodable as a [`VersionedXcm`].
+     * The caller needs to specify what should happen to the transferred assets once they reach
+     * the `dest` chain. This is done through the `custom_xcm_on_dest` parameter, which
+     * contains the instructions to execute on `dest` as a final step.
+     * This is usually as simple as:
+     * `Xcm(vec![DepositAsset { assets: Wild(AllCounted(assets.len())), beneficiary }])`,
+     * but could be something more exotic like sending the `assets` even further.
      *
-     * @param {BytesLike} encodedMessage
-     * @param {SpWeightsWeightV2Weight} maxWeight
-     **/
-    executeBlob: GenericTxCall<
-      (
-        encodedMessage: BytesLike,
-        maxWeight: SpWeightsWeightV2Weight,
-      ) => ChainSubmittableExtrinsic<{
-        pallet: 'PolkadotXcm';
-        palletCall: {
-          name: 'ExecuteBlob';
-          params: { encodedMessage: BytesLike; maxWeight: SpWeightsWeightV2Weight };
-        };
-      }>
-    >;
-
-    /**
-     * Send an XCM from a local, signed, origin.
-     *
-     * The destination, `dest`, will receive this message with a `DescendOrigin` instruction
-     * that makes the origin of the message be the origin on this system.
-     *
-     * The message is passed in encoded. It needs to be decodable as a [`VersionedXcm`].
+     * - `origin`: Must be capable of withdrawing the `assets` and executing XCM.
+     * - `dest`: Destination context for the assets. Will typically be `[Parent,
+     * Parachain(..)]` to send from parachain to parachain, or `[Parachain(..)]` to send from
+     * relay to parachain, or `(parents: 2, (GlobalConsensus(..), ..))` to send from
+     * parachain across a bridge to another ecosystem destination.
+     * - `assets`: The assets to be withdrawn. This should include the assets used to pay the
+     * fee on the `dest` (and possibly reserve) chains.
+     * - `assets_transfer_type`: The XCM `TransferType` used to transfer the `assets`.
+     * - `remote_fees_id`: One of the included `assets` to be be used to pay fees.
+     * - `fees_transfer_type`: The XCM `TransferType` used to transfer the `fees` assets.
+     * - `custom_xcm_on_dest`: The XCM to be executed on `dest` chain as the last step of the
+     * transfer, which also determines what happens to the assets on the destination chain.
+     * - `weight_limit`: The remote-side weight limit, if any, for the XCM fee purchase.
      *
      * @param {XcmVersionedLocation} dest
-     * @param {BytesLike} encodedMessage
+     * @param {XcmVersionedAssets} assets
+     * @param {StagingXcmExecutorAssetTransferTransferType} assetsTransferType
+     * @param {XcmVersionedAssetId} remoteFeesId
+     * @param {StagingXcmExecutorAssetTransferTransferType} feesTransferType
+     * @param {XcmVersionedXcm} customXcmOnDest
+     * @param {XcmV3WeightLimit} weightLimit
      **/
-    sendBlob: GenericTxCall<
+    transferAssetsUsingTypeAndThen: GenericTxCall<
       (
         dest: XcmVersionedLocation,
-        encodedMessage: BytesLike,
+        assets: XcmVersionedAssets,
+        assetsTransferType: StagingXcmExecutorAssetTransferTransferType,
+        remoteFeesId: XcmVersionedAssetId,
+        feesTransferType: StagingXcmExecutorAssetTransferTransferType,
+        customXcmOnDest: XcmVersionedXcm,
+        weightLimit: XcmV3WeightLimit,
       ) => ChainSubmittableExtrinsic<{
         pallet: 'PolkadotXcm';
         palletCall: {
-          name: 'SendBlob';
-          params: { dest: XcmVersionedLocation; encodedMessage: BytesLike };
+          name: 'TransferAssetsUsingTypeAndThen';
+          params: {
+            dest: XcmVersionedLocation;
+            assets: XcmVersionedAssets;
+            assetsTransferType: StagingXcmExecutorAssetTransferTransferType;
+            remoteFeesId: XcmVersionedAssetId;
+            feesTransferType: StagingXcmExecutorAssetTransferTransferType;
+            customXcmOnDest: XcmVersionedXcm;
+            weightLimit: XcmV3WeightLimit;
+          };
         };
       }>
     >;
@@ -7879,6 +7912,227 @@ export interface ChainTx extends GenericChainTx<TxCall> {
       }>
     >;
 
+    /**
+     * Touch an existing pool to fulfill prerequisites before providing liquidity, such as
+     * ensuring that the pool's accounts are in place. It is typically useful when a pool
+     * creator removes the pool's accounts and does not provide a liquidity. This action may
+     * involve holding assets from the caller as a deposit for creating the pool's accounts.
+     *
+     * The origin must be Signed.
+     *
+     * - `asset1`: The asset ID of an existing pool with a pair (asset1, asset2).
+     * - `asset2`: The asset ID of an existing pool with a pair (asset1, asset2).
+     *
+     * Emits `Touched` event when successful.
+     *
+     * @param {StagingXcmV3MultilocationMultiLocation} asset1
+     * @param {StagingXcmV3MultilocationMultiLocation} asset2
+     **/
+    touch: GenericTxCall<
+      (
+        asset1: StagingXcmV3MultilocationMultiLocation,
+        asset2: StagingXcmV3MultilocationMultiLocation,
+      ) => ChainSubmittableExtrinsic<{
+        pallet: 'AssetConversion';
+        palletCall: {
+          name: 'Touch';
+          params: { asset1: StagingXcmV3MultilocationMultiLocation; asset2: StagingXcmV3MultilocationMultiLocation };
+        };
+      }>
+    >;
+
+    /**
+     * Generic pallet tx call
+     **/
+    [callName: string]: GenericTxCall<TxCall>;
+  };
+  /**
+   * Pallet `StateTrieMigration`'s transaction calls
+   **/
+  stateTrieMigration: {
+    /**
+     * Control the automatic migration.
+     *
+     * The dispatch origin of this call must be [`Config::ControlOrigin`].
+     *
+     * @param {PalletStateTrieMigrationMigrationLimits | undefined} maybeConfig
+     **/
+    controlAutoMigration: GenericTxCall<
+      (maybeConfig: PalletStateTrieMigrationMigrationLimits | undefined) => ChainSubmittableExtrinsic<{
+        pallet: 'StateTrieMigration';
+        palletCall: {
+          name: 'ControlAutoMigration';
+          params: { maybeConfig: PalletStateTrieMigrationMigrationLimits | undefined };
+        };
+      }>
+    >;
+
+    /**
+     * Continue the migration for the given `limits`.
+     *
+     * The dispatch origin of this call can be any signed account.
+     *
+     * This transaction has NO MONETARY INCENTIVES. calling it will not reward anyone. Albeit,
+     * Upon successful execution, the transaction fee is returned.
+     *
+     * The (potentially over-estimated) of the byte length of all the data read must be
+     * provided for up-front fee-payment and weighing. In essence, the caller is guaranteeing
+     * that executing the current `MigrationTask` with the given `limits` will not exceed
+     * `real_size_upper` bytes of read data.
+     *
+     * The `witness_task` is merely a helper to prevent the caller from being slashed or
+     * generally trigger a migration that they do not intend. This parameter is just a message
+     * from caller, saying that they believed `witness_task` was the last state of the
+     * migration, and they only wish for their transaction to do anything, if this assumption
+     * holds. In case `witness_task` does not match, the transaction fails.
+     *
+     * Based on the documentation of [`MigrationTask::migrate_until_exhaustion`], the
+     * recommended way of doing this is to pass a `limit` that only bounds `count`, as the
+     * `size` limit can always be overwritten.
+     *
+     * @param {PalletStateTrieMigrationMigrationLimits} limits
+     * @param {number} realSizeUpper
+     * @param {PalletStateTrieMigrationMigrationTask} witnessTask
+     **/
+    continueMigrate: GenericTxCall<
+      (
+        limits: PalletStateTrieMigrationMigrationLimits,
+        realSizeUpper: number,
+        witnessTask: PalletStateTrieMigrationMigrationTask,
+      ) => ChainSubmittableExtrinsic<{
+        pallet: 'StateTrieMigration';
+        palletCall: {
+          name: 'ContinueMigrate';
+          params: {
+            limits: PalletStateTrieMigrationMigrationLimits;
+            realSizeUpper: number;
+            witnessTask: PalletStateTrieMigrationMigrationTask;
+          };
+        };
+      }>
+    >;
+
+    /**
+     * Migrate the list of top keys by iterating each of them one by one.
+     *
+     * This does not affect the global migration process tracker ([`MigrationProcess`]), and
+     * should only be used in case any keys are leftover due to a bug.
+     *
+     * @param {Array<BytesLike>} keys
+     * @param {number} witnessSize
+     **/
+    migrateCustomTop: GenericTxCall<
+      (
+        keys: Array<BytesLike>,
+        witnessSize: number,
+      ) => ChainSubmittableExtrinsic<{
+        pallet: 'StateTrieMigration';
+        palletCall: {
+          name: 'MigrateCustomTop';
+          params: { keys: Array<BytesLike>; witnessSize: number };
+        };
+      }>
+    >;
+
+    /**
+     * Migrate the list of child keys by iterating each of them one by one.
+     *
+     * All of the given child keys must be present under one `child_root`.
+     *
+     * This does not affect the global migration process tracker ([`MigrationProcess`]), and
+     * should only be used in case any keys are leftover due to a bug.
+     *
+     * @param {BytesLike} root
+     * @param {Array<BytesLike>} childKeys
+     * @param {number} totalSize
+     **/
+    migrateCustomChild: GenericTxCall<
+      (
+        root: BytesLike,
+        childKeys: Array<BytesLike>,
+        totalSize: number,
+      ) => ChainSubmittableExtrinsic<{
+        pallet: 'StateTrieMigration';
+        palletCall: {
+          name: 'MigrateCustomChild';
+          params: { root: BytesLike; childKeys: Array<BytesLike>; totalSize: number };
+        };
+      }>
+    >;
+
+    /**
+     * Set the maximum limit of the signed migration.
+     *
+     * @param {PalletStateTrieMigrationMigrationLimits} limits
+     **/
+    setSignedMaxLimits: GenericTxCall<
+      (limits: PalletStateTrieMigrationMigrationLimits) => ChainSubmittableExtrinsic<{
+        pallet: 'StateTrieMigration';
+        palletCall: {
+          name: 'SetSignedMaxLimits';
+          params: { limits: PalletStateTrieMigrationMigrationLimits };
+        };
+      }>
+    >;
+
+    /**
+     * Forcefully set the progress the running migration.
+     *
+     * This is only useful in one case: the next key to migrate is too big to be migrated with
+     * a signed account, in a parachain context, and we simply want to skip it. A reasonable
+     * example of this would be `:code:`, which is both very expensive to migrate, and commonly
+     * used, so probably it is already migrated.
+     *
+     * In case you mess things up, you can also, in principle, use this to reset the migration
+     * process.
+     *
+     * @param {PalletStateTrieMigrationProgress} progressTop
+     * @param {PalletStateTrieMigrationProgress} progressChild
+     **/
+    forceSetProgress: GenericTxCall<
+      (
+        progressTop: PalletStateTrieMigrationProgress,
+        progressChild: PalletStateTrieMigrationProgress,
+      ) => ChainSubmittableExtrinsic<{
+        pallet: 'StateTrieMigration';
+        palletCall: {
+          name: 'ForceSetProgress';
+          params: { progressTop: PalletStateTrieMigrationProgress; progressChild: PalletStateTrieMigrationProgress };
+        };
+      }>
+    >;
+
+    /**
+     * Generic pallet tx call
+     **/
+    [callName: string]: GenericTxCall<TxCall>;
+  };
+  /**
+   * Pallet `AssetConversionMigration`'s transaction calls
+   **/
+  assetConversionMigration: {
+    /**
+     * Migrates an existing pool to a new account ID derivation method for a given asset pair.
+     * If the migration is successful, transaction fees are refunded to the caller.
+     *
+     * Must be signed.
+     *
+     * @param {StagingXcmV3MultilocationMultiLocation} asset1
+     * @param {StagingXcmV3MultilocationMultiLocation} asset2
+     **/
+    migrateToNewAccount: GenericTxCall<
+      (
+        asset1: StagingXcmV3MultilocationMultiLocation,
+        asset2: StagingXcmV3MultilocationMultiLocation,
+      ) => ChainSubmittableExtrinsic<{
+        pallet: 'AssetConversionMigration';
+        palletCall: {
+          name: 'MigrateToNewAccount';
+          params: { asset1: StagingXcmV3MultilocationMultiLocation; asset2: StagingXcmV3MultilocationMultiLocation };
+        };
+      }>
+    >;
+
     /**
      * Generic pallet tx call
      **/