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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dedot/chaintypes",
-  "version": "0.0.1-alpha.66",
+  "version": "0.0.1-alpha.67",
   "description": "Types for substrate-based chains",
   "author": "Thang X. Vu <thang@coongcrafts.io>",
   "main": "",
@@ -20,7 +20,7 @@
     "directory": "dist"
   },
   "license": "Apache-2.0",
-  "gitHead": "496e067e850866bccf0f901e759c43486cf09c30",
+  "gitHead": "d4d37014615c2e4ceab107c709d3b1e062c40313",
   "module": "./index.js",
   "types": "./index.d.ts"
 }

package/westendAssetHub/consts.d.ts

@@ -775,4 +775,13 @@ export interface ChainConsts extends GenericChainConsts {
      **/
     [name: string]: any;
   };
+  /**
+   * Pallet `AssetConversionMigration`'s constants
+   **/
+  assetConversionMigration: {
+    /**
+     * Generic pallet constant
+     **/
+    [name: string]: any;
+  };
 }

package/westendAssetHub/errors.d.ts

@@ -439,11 +439,6 @@ export interface ChainErrors extends GenericChainErrors {
      **/
     InUse: GenericPalletError;
 
-    /**
-     * Invalid non-concrete asset.
-     **/
-    InvalidAssetNotConcrete: GenericPalletError;
-
     /**
      * Invalid asset, reserve chain could not be determined for it.
      **/
@@ -464,17 +459,6 @@ export interface ChainErrors extends GenericChainErrors {
      **/
     LocalExecutionIncomplete: GenericPalletError;
 
-    /**
-     * Could not decode XCM.
-     **/
-    UnableToDecode: GenericPalletError;
-
-    /**
-     * XCM encoded length is too large.
-     * Returned when an XCM encoded length is larger than `MaxXcmEncodedSize`.
-     **/
-    XcmTooLarge: GenericPalletError;
-
     /**
      * Generic pallet error
      **/
@@ -1502,6 +1486,35 @@ export interface ChainErrors extends GenericChainErrors {
      **/
     BelowMinimum: GenericPalletError;
 
+    /**
+     * Generic pallet error
+     **/
+    [error: string]: GenericPalletError;
+  };
+  /**
+   * Pallet `AssetConversionMigration`'s errors
+   **/
+  assetConversionMigration: {
+    /**
+     * Provided asset pair is not supported for pool.
+     **/
+    InvalidAssetPair: GenericPalletError;
+
+    /**
+     * The pool doesn't exist.
+     **/
+    PoolNotFound: GenericPalletError;
+
+    /**
+     * Pool's balance cannot be zero.
+     **/
+    ZeroBalance: GenericPalletError;
+
+    /**
+     * Indicates a partial transfer of balance to the new account during a migration.
+     **/
+    PartialTransfer: GenericPalletError;
+
     /**
      * Generic pallet error
      **/

package/westendAssetHub/events.d.ts

@@ -2244,6 +2244,58 @@ 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 `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/westendAssetHub/runtime.d.ts

@@ -579,28 +579,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/westendAssetHub/tx.d.ts

@@ -21,6 +21,8 @@ import type {
   SpWeightsWeightV2Weight,
   StagingXcmV4Location,
   XcmV3WeightLimit,
+  StagingXcmExecutorAssetTransferTransferType,
+  XcmVersionedAssetId,
   CumulusPrimitivesCoreAggregateMessageOrigin,
   AssetHubWestendRuntimeOriginCaller,
   PalletMultisigTimepoint,
@@ -956,7 +958,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 +1087,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 +1398,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 +7909,66 @@ 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 `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
      **/

package/westendAssetHub/types.d.ts

@@ -69,7 +69,8 @@ export type AssetHubWestendRuntimeRuntimeEvent =
   | { pallet: 'ForeignAssets'; palletEvent: PalletAssetsEvent002 }
   | { pallet: 'NftFractionalization'; palletEvent: PalletNftFractionalizationEvent }
   | { pallet: 'PoolAssets'; palletEvent: PalletAssetsEvent }
-  | { pallet: 'AssetConversion'; palletEvent: PalletAssetConversionEvent };
+  | { pallet: 'AssetConversion'; palletEvent: PalletAssetConversionEvent }
+  | { pallet: 'AssetConversionMigration'; palletEvent: PalletAssetConversionOpsEvent };
 
 /**
  * Event for the System pallet.
@@ -2039,8 +2040,52 @@ export type PalletAssetConversionEvent =
          **/
         path: Array<[StagingXcmV3MultilocationMultiLocation, bigint]>;
       };
+    }
+  /**
+   * Pool has been touched in order to fulfill operational requirements.
+   **/
+  | {
+      name: 'Touched';
+      data: {
+        /**
+         * The ID of the pool.
+         **/
+        poolId: [StagingXcmV3MultilocationMultiLocation, StagingXcmV3MultilocationMultiLocation];
+
+        /**
+         * The account initiating the touch.
+         **/
+        who: AccountId32;
+      };
     };
 
+/**
+ * The `Event` enum of this pallet
+ **/
+export type PalletAssetConversionOpsEvent =
+  /**
+   * Indicates that a pool has been migrated to the new account ID.
+   **/
+  {
+    name: 'MigratedToNewAccount';
+    data: {
+      /**
+       * Pool's ID.
+       **/
+      poolId: [StagingXcmV3MultilocationMultiLocation, StagingXcmV3MultilocationMultiLocation];
+
+      /**
+       * Pool's prior account ID.
+       **/
+      priorAccount: AccountId32;
+
+      /**
+       * Pool's new account ID.
+       **/
+      newAccount: AccountId32;
+    };
+  };
+
 export type FrameSystemLastRuntimeUpgradeInfo = { specVersion: number; specName: string };
 
 export type FrameSystemCodeUpgradeAuthorization = { codeHash: H256; checkVersion: boolean };
@@ -3306,9 +3351,6 @@ export type PalletXcmRemoteLockedFungibleRecord = {
  * Contains a variant per dispatchable extrinsic that this pallet has.
  **/
 export type PalletXcmCall =
-  /**
-   * WARNING: DEPRECATED. `send` will be removed after June 2024. Use `send_blob` instead.
-   **/
   | { name: 'Send'; params: { dest: XcmVersionedLocation; message: XcmVersionedXcm } }
   /**
    * Teleport some assets from the local chain to some destination chain.
@@ -3389,9 +3431,6 @@ export type PalletXcmCall =
    * 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.
-   *
-   * WARNING: DEPRECATED. `execute` will be removed after June 2024. Use `execute_blob`
-   * instead.
    **/
   | { name: 'Execute'; params: { message: XcmVersionedXcm; maxWeight: SpWeightsWeightV2Weight } }
   /**
@@ -3561,32 +3600,69 @@ export type PalletXcmCall =
    **/
   | { name: 'ClaimAssets'; params: { assets: XcmVersionedAssets; beneficiary: XcmVersionedLocation } }
   /**
-   * 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`].
-   **/
-  | { name: 'ExecuteBlob'; params: { encodedMessage: Bytes; maxWeight: SpWeightsWeightV2Weight } }
-  /**
-   * Send an XCM from a local, signed, origin.
+   * 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.
    *
-   * 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.
    **/
-  | { name: 'SendBlob'; params: { dest: XcmVersionedLocation; encodedMessage: Bytes } };
+  | {
+      name: 'TransferAssetsUsingTypeAndThen';
+      params: {
+        dest: XcmVersionedLocation;
+        assets: XcmVersionedAssets;
+        assetsTransferType: StagingXcmExecutorAssetTransferTransferType;
+        remoteFeesId: XcmVersionedAssetId;
+        feesTransferType: StagingXcmExecutorAssetTransferTransferType;
+        customXcmOnDest: XcmVersionedXcm;
+        weightLimit: XcmV3WeightLimit;
+      };
+    };
 
 export type PalletXcmCallLike =
-  /**
-   * WARNING: DEPRECATED. `send` will be removed after June 2024. Use `send_blob` instead.
-   **/
   | { name: 'Send'; params: { dest: XcmVersionedLocation; message: XcmVersionedXcm } }
   /**
    * Teleport some assets from the local chain to some destination chain.
@@ -3667,9 +3743,6 @@ export type PalletXcmCallLike =
    * 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.
-   *
-   * WARNING: DEPRECATED. `execute` will be removed after June 2024. Use `execute_blob`
-   * instead.
    **/
   | { name: 'Execute'; params: { message: XcmVersionedXcm; maxWeight: SpWeightsWeightV2Weight } }
   /**
@@ -3839,27 +3912,67 @@ export type PalletXcmCallLike =
    **/
   | { name: 'ClaimAssets'; params: { assets: XcmVersionedAssets; beneficiary: XcmVersionedLocation } }
   /**
-   * Execute an XCM from a local, signed, origin.
-   *
-   * An event is deposited indicating whether the message could be executed completely
-   * or only partially.
+   * Transfer assets from the local chain to the destination chain using explicit transfer
+   * types for assets and fees.
    *
-   * 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.
+   * `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.
    *
-   * The message is passed in encoded. It needs to be decodable as a [`VersionedXcm`].
-   **/
-  | { name: 'ExecuteBlob'; params: { encodedMessage: BytesLike; maxWeight: SpWeightsWeightV2Weight } }
-  /**
-   * Send an XCM from a local, signed, origin.
+   * `remote_fees_id` may use different transfer type than rest of `assets` and can be
+   * specified through `fees_transfer_type`.
    *
-   * 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 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.
    *
-   * 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.
    **/
-  | { name: 'SendBlob'; params: { dest: XcmVersionedLocation; encodedMessage: BytesLike } };
+  | {
+      name: 'TransferAssetsUsingTypeAndThen';
+      params: {
+        dest: XcmVersionedLocation;
+        assets: XcmVersionedAssets;
+        assetsTransferType: StagingXcmExecutorAssetTransferTransferType;
+        remoteFeesId: XcmVersionedAssetId;
+        feesTransferType: StagingXcmExecutorAssetTransferTransferType;
+        customXcmOnDest: XcmVersionedXcm;
+        weightLimit: XcmV3WeightLimit;
+      };
+    };
 
 export type XcmVersionedXcm =
   | { tag: 'V2'; value: XcmV2Xcm }
@@ -4063,6 +4176,12 @@ export type XcmV3MultiassetWildMultiAsset =
 
 export type XcmV3MultiassetWildFungibility = 'Fungible' | 'NonFungible';
 
+export type StagingXcmExecutorAssetTransferTransferType =
+  | { tag: 'Teleport' }
+  | { tag: 'LocalReserve' }
+  | { tag: 'DestinationReserve' }
+  | { tag: 'RemoteReserve'; value: XcmVersionedLocation };
+
 /**
  * The `Error` enum of this pallet.
  **/
@@ -4150,10 +4269,6 @@ export type PalletXcmError =
    * The unlock operation cannot succeed because there are still consumers of the lock.
    **/
   | 'InUse'
-  /**
-   * Invalid non-concrete asset.
-   **/
-  | 'InvalidAssetNotConcrete'
   /**
    * Invalid asset, reserve chain could not be determined for it.
    **/
@@ -4169,16 +4284,7 @@ export type PalletXcmError =
   /**
    * Local XCM execution incomplete.
    **/
-  | 'LocalExecutionIncomplete'
-  /**
-   * Could not decode XCM.
-   **/
-  | 'UnableToDecode'
-  /**
-   * XCM encoded length is too large.
-   * Returned when an XCM encoded length is larger than `MaxXcmEncodedSize`.
-   **/
-  | 'XcmTooLarge';
+  | 'LocalExecutionIncomplete';
 
 /**
  * Contains a variant per dispatchable extrinsic that this pallet has.
@@ -4546,7 +4652,8 @@ export type AssetHubWestendRuntimeRuntimeCall =
   | { pallet: 'ForeignAssets'; palletCall: PalletAssetsCall002 }
   | { pallet: 'NftFractionalization'; palletCall: PalletNftFractionalizationCall }
   | { pallet: 'PoolAssets'; palletCall: PalletAssetsCall003 }
-  | { pallet: 'AssetConversion'; palletCall: PalletAssetConversionCall };
+  | { pallet: 'AssetConversion'; palletCall: PalletAssetConversionCall }
+  | { pallet: 'AssetConversionMigration'; palletCall: PalletAssetConversionOpsCall };
 
 export type AssetHubWestendRuntimeRuntimeCallLike =
   | { pallet: 'System'; palletCall: FrameSystemCallLike }
@@ -4570,7 +4677,8 @@ export type AssetHubWestendRuntimeRuntimeCallLike =
   | { pallet: 'ForeignAssets'; palletCall: PalletAssetsCallLike002 }
   | { pallet: 'NftFractionalization'; palletCall: PalletNftFractionalizationCallLike }
   | { pallet: 'PoolAssets'; palletCall: PalletAssetsCallLike003 }
-  | { pallet: 'AssetConversion'; palletCall: PalletAssetConversionCallLike };
+  | { pallet: 'AssetConversion'; palletCall: PalletAssetConversionCallLike }
+  | { pallet: 'AssetConversionMigration'; palletCall: PalletAssetConversionOpsCallLike };
 
 /**
  * Contains a variant per dispatchable extrinsic that this pallet has.
@@ -11164,6 +11272,23 @@ export type PalletAssetConversionCall =
         sendTo: AccountId32;
         keepAlive: boolean;
       };
+    }
+  /**
+   * 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.
+   **/
+  | {
+      name: 'Touch';
+      params: { asset1: StagingXcmV3MultilocationMultiLocation; asset2: StagingXcmV3MultilocationMultiLocation };
     };
 
 export type PalletAssetConversionCallLike =
@@ -11256,8 +11381,52 @@ export type PalletAssetConversionCallLike =
         sendTo: AccountId32Like;
         keepAlive: boolean;
       };
+    }
+  /**
+   * 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.
+   **/
+  | {
+      name: 'Touch';
+      params: { asset1: StagingXcmV3MultilocationMultiLocation; asset2: StagingXcmV3MultilocationMultiLocation };
     };
 
+/**
+ * Pallet's callable functions.
+ **/
+export type PalletAssetConversionOpsCall =
+  /**
+   * 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.
+   **/
+  {
+    name: 'MigrateToNewAccount';
+    params: { asset1: StagingXcmV3MultilocationMultiLocation; asset2: StagingXcmV3MultilocationMultiLocation };
+  };
+
+export type PalletAssetConversionOpsCallLike =
+  /**
+   * 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.
+   **/
+  {
+    name: 'MigrateToNewAccount';
+    params: { asset1: StagingXcmV3MultilocationMultiLocation; asset2: StagingXcmV3MultilocationMultiLocation };
+  };
+
 export type AssetHubWestendRuntimeOriginCaller =
   | { tag: 'System'; value: FrameSupportDispatchRawOrigin }
   | { tag: 'PolkadotXcm'; value: PalletXcmOrigin }
@@ -11987,6 +12156,27 @@ export type PalletAssetConversionError =
    **/
   | 'BelowMinimum';
 
+/**
+ * The `Error` enum of this pallet.
+ **/
+export type PalletAssetConversionOpsError =
+  /**
+   * Provided asset pair is not supported for pool.
+   **/
+  | 'InvalidAssetPair'
+  /**
+   * The pool doesn't exist.
+   **/
+  | 'PoolNotFound'
+  /**
+   * Pool's balance cannot be zero.
+   **/
+  | 'ZeroBalance'
+  /**
+   * Indicates a partial transfer of balance to the new account during a migration.
+   **/
+  | 'PartialTransfer';
+
 export type FrameSystemExtensionsCheckNonZeroSender = {};
 
 export type FrameSystemExtensionsCheckSpecVersion = {};
@@ -12098,4 +12288,5 @@ export type AssetHubWestendRuntimeRuntimeError =
   | { tag: 'ForeignAssets'; value: PalletAssetsError }
   | { tag: 'NftFractionalization'; value: PalletNftFractionalizationError }
   | { tag: 'PoolAssets'; value: PalletAssetsError }
-  | { tag: 'AssetConversion'; value: PalletAssetConversionError };
+  | { tag: 'AssetConversion'; value: PalletAssetConversionError }
+  | { tag: 'AssetConversionMigration'; value: PalletAssetConversionOpsError };