@moonbeam-network/xcm-builder 4.2.5 → 4.3.0

package/build/index.d.ts

@@ -83,9 +83,11 @@ declare class ContractConfig extends BaseConfig {
 type ContractConfigBuilder = ConfigBuilder<ContractConfig>;
 type DestinationMultilocation = [
     /**
+     * 0 - if destination is referring to a location in the same chain
      * 1 - if transaction is going through or to a relay chain
+     * 2 - if transaction is going to a parachain in another ecosystem
      */
-    1,
+    0 | 1 | 2,
     ([
         /**
          * example '0x00000007DC'
@@ -120,11 +122,18 @@ declare enum TransferType {
     LocalReserve = 1,
     DestinationReserve = 2
 }
+type AssetMultilocation = [[number, string[]], bigint];
 
 declare function XcmPrecompile(): {
     transferAssetsToPara20: (shouldTransferAssetPrecedeFeeAsset?: boolean) => ContractConfigBuilder;
     transferAssetsToPara32: (shouldTransferAssetPrecedeFeeAsset?: boolean) => ContractConfigBuilder;
     transferAssetsToRelay: () => ContractConfigBuilder;
+    transferAssetsLocation: () => {
+        nativeAsset: () => ContractConfigBuilder;
+        localErc20: () => ContractConfigBuilder;
+        foreignAsset: () => ContractConfigBuilder;
+        foreignErc20: () => ContractConfigBuilder;
+    };
     transferAssetsUsingTypeAndThenAddress: (shouldTransferAssetPrecedeFeeAsset?: boolean) => ContractConfigBuilder;
 };
 
@@ -195,7 +204,10 @@ declare function assets(): {
     account: () => BalanceConfigBuilder;
 };
 declare function foreignAssets(): {
-    account: () => BalanceConfigBuilder;
+    account: () => {
+        globalConsensus: () => BalanceConfigBuilder;
+        id: () => BalanceConfigBuilder;
+    };
 };
 declare function system(): {
     account: () => BalanceConfigBuilder;
@@ -752,4 +764,4 @@ declare function MrlBuilder(): {
 
 declare const BATCH_CONTRACT_ADDRESS = "0x0000000000000000000000000000000000000808";
 
-export { type AssetAddressFormat, AssetMinBuilder, type AssetMinConfigBuilder, type AssetMinConfigBuilderParams, BATCH_CONTRACT_ABI, BATCH_CONTRACT_ADDRESS, BalanceBuilder, type BalanceBuilderParams, type BalanceConfigBuilder, type BuilderParams, type ConfigBuilder, ContractBuilder, ContractConfig, type ContractConfigBuilder, type ContractConfigConstructorParams, type DestinationMultilocation, ERC20_ABI, type EquilibriumSystemBalanceData, type EventMonitoringConfig, type EvmFunctionArgs, EvmQueryConfig, type EvmQueryConfigParams, type EvmQueryFunctions, ExtrinsicBuilder, ExtrinsicConfig, type ExtrinsicConfigBuilder, type ExtrinsicConfigConstructorParams, FeeBuilder, type FeeConfigBuilder, type FeeConfigBuilderParams, type GetVersionedAssetId, MonitoringBuilder, type MonitoringBuilderConfig, type MoonbeamRuntimeXcmConfigAssetType, MrlBuilder, type MrlBuilderParams, type MrlConfigBuilder, type MrlExecuteBuilderParams, type MrlExecuteConfigBuilder, type PalletBalancesAccountDataOld, type Parents, Protocols, type QueryConfigConstructorParams, SubstrateCallConfig, type SubstrateCallConfigConstructorParams, SubstrateQueryConfig, type TokensPalletAccountData, type Transact, TransferType, WormholeConfig, type WormholeConfigConstructorParams, type WormholeFunctionArgs, type WormholeTransferFunctions, type XcmPaymentFeeProps, XcmVersion, calculateSystemAccountBalance, evm, substrate, wormhole, wormholeFactory };
+export { type AssetAddressFormat, AssetMinBuilder, type AssetMinConfigBuilder, type AssetMinConfigBuilderParams, type AssetMultilocation, BATCH_CONTRACT_ABI, BATCH_CONTRACT_ADDRESS, BalanceBuilder, type BalanceBuilderParams, type BalanceConfigBuilder, type BuilderParams, type ConfigBuilder, ContractBuilder, ContractConfig, type ContractConfigBuilder, type ContractConfigConstructorParams, type DestinationMultilocation, ERC20_ABI, type EquilibriumSystemBalanceData, type EventMonitoringConfig, type EvmFunctionArgs, EvmQueryConfig, type EvmQueryConfigParams, type EvmQueryFunctions, ExtrinsicBuilder, ExtrinsicConfig, type ExtrinsicConfigBuilder, type ExtrinsicConfigConstructorParams, FeeBuilder, type FeeConfigBuilder, type FeeConfigBuilderParams, type GetVersionedAssetId, MonitoringBuilder, type MonitoringBuilderConfig, type MoonbeamRuntimeXcmConfigAssetType, MrlBuilder, type MrlBuilderParams, type MrlConfigBuilder, type MrlExecuteBuilderParams, type MrlExecuteConfigBuilder, type PalletBalancesAccountDataOld, type Parents, Protocols, type QueryConfigConstructorParams, SubstrateCallConfig, type SubstrateCallConfigConstructorParams, SubstrateQueryConfig, type TokensPalletAccountData, type Transact, TransferType, WormholeConfig, type WormholeConfigConstructorParams, type WormholeFunctionArgs, type WormholeTransferFunctions, type XcmPaymentFeeProps, XcmVersion, calculateSystemAccountBalance, evm, substrate, wormhole, wormholeFactory };

package/build/index.mjs

@@ -280,20 +280,136 @@ var TransferType = /* @__PURE__ */ ((TransferType2) => {
 })(TransferType || {});
 
 // src/contract/ContractBuilder.utils.ts
-import { EvmParachain } from "@moonbeam-network/xcm-types";
+import {
+  EvmParachain
+} from "@moonbeam-network/xcm-types";
 import { u8aToHex as u8aToHex2 } from "@polkadot/util";
 import { decodeAddress as decodeAddress2 } from "@polkadot/util-crypto";
+
+// src/extrinsic/pallets/polkadotXcm/polkadotXcm.util.ts
+import { Ecosystem } from "@moonbeam-network/xcm-types";
+function getPolkadotXcmExtrinsicArgs({
+  assets: assets3,
+  destinationAddress,
+  destination,
+  func,
+  parents = 1,
+  feeIndex = 0
+}) {
+  const version = getExtrinsicArgumentVersion(func);
+  return [
+    // dest
+    {
+      [version]: normalizeX1(version, {
+        parents,
+        interior: {
+          X1: {
+            Parachain: destination.parachainId
+          }
+        }
+      })
+    },
+    // beneficiary
+    {
+      [version]: normalizeX1(version, {
+        parents: 0,
+        interior: {
+          X1: getExtrinsicAccount(destinationAddress)
+        }
+      })
+    },
+    // assets
+    {
+      [version]: assets3
+    },
+    // feeAssetItem
+    feeIndex,
+    // weightLimit
+    "Unlimited"
+  ];
+}
+function isKusamaDestination(destination) {
+  return destination.ecosystem === Ecosystem.Kusama || destination.ecosystem === Ecosystem.MoonsamaRelay;
+}
+function isPolkadotDestination(destination) {
+  return destination.ecosystem === Ecosystem.Polkadot || destination.ecosystem === Ecosystem.MoonlamaRelay;
+}
+function getGlobalConsensus(destination) {
+  if (isKusamaDestination(destination)) {
+    return "Kusama";
+  }
+  if (isPolkadotDestination(destination)) {
+    return "Polkadot";
+  }
+  return {
+    ByGenesis: destination.relayGenesisHash
+  };
+}
+function getEcosystemTransferExtrinsicArgs({
+  assets: assets3,
+  destinationAddress,
+  destination,
+  func,
+  feeIndex = 0
+}) {
+  const version = getExtrinsicArgumentVersion(func);
+  const globalConsensus = getGlobalConsensus(destination);
+  return [
+    // dest
+    {
+      [version]: normalizeX1(version, {
+        parents: 2,
+        interior: {
+          X2: [
+            { GlobalConsensus: globalConsensus },
+            {
+              Parachain: destination.parachainId
+            }
+          ]
+        }
+      })
+    },
+    // beneficiary
+    {
+      [version]: normalizeX1(version, {
+        parents: 0,
+        interior: {
+          X1: getExtrinsicAccount(destinationAddress)
+        }
+      })
+    },
+    // assets
+    {
+      [version]: assets3
+    },
+    // feeAssetItem
+    feeIndex,
+    // weightLimit
+    "Unlimited"
+  ];
+}
+function shouldFeeAssetPrecedeAsset({
+  asset,
+  fee
+}) {
+  const assetIdNumber = Number(asset.getAssetId());
+  const feeAssetIdNumber = Number(fee.getAssetId());
+  if (Number.isNaN(assetIdNumber) || Number.isNaN(feeAssetIdNumber)) {
+    return false;
+  }
+  return assetIdNumber > feeAssetIdNumber;
+}
+
+// src/contract/ContractBuilder.utils.ts
 function getPrecompileDestinationInterior(destination, address) {
   if (!address) {
-    return [`0x0000000${destination.parachainId.toString(16)}`];
+    return [encodeParachain(destination.parachainId)];
   }
-  const accountType = EvmParachain.is(destination) ? "03" : "01";
-  const acc = `0x${accountType}${u8aToHex2(
-    decodeAddress2(address),
-    -1,
-    false
-  )}00`;
-  return destination.parachainId ? [`0x0000000${destination.parachainId.toString(16)}`, acc] : [acc];
+  const acc = encodeAddress(destination, address);
+  return destination.parachainId ? [encodeParachain(destination.parachainId), acc] : [acc];
+}
+function getBeneficiaryMultilocation(address, destination) {
+  return [0, [encodeAddress(destination, address)]];
 }
 function getDestinationMultilocation(address, destination) {
   const interior = getPrecompileDestinationInterior(destination, address);
@@ -303,7 +419,75 @@ function getDestinationParachainMultilocation(destination) {
   if (destination.isRelay) {
     return [1, []];
   }
-  return [1, [`0x00${destination.parachainId.toString(16).padStart(8, "0")}`]];
+  return [1, [encodeParachain(destination.parachainId)]];
+}
+function getGlobalConsensusDestination(sourceApi, destination) {
+  return [
+    2,
+    [
+      encodeGlobalConsensus(sourceApi, destination),
+      encodeParachain(destination.parachainId)
+    ]
+  ];
+}
+function getPalletInstanceMultilocation(sourceApi, asset) {
+  return [
+    [0, [encodePalletInstance(sourceApi, asset.getAssetPalletInstance())]],
+    asset.amount
+  ];
+}
+function getAssetAddressMultilocation(sourceApi, asset, destination) {
+  if (!asset.address) {
+    throw new Error(`Asset address is required for ${asset.key}`);
+  }
+  return [
+    [
+      0,
+      [
+        encodePalletInstance(sourceApi, asset.getAssetPalletInstance()),
+        encodeAddress(destination, asset.address)
+      ]
+    ],
+    asset.amount
+  ];
+}
+function getGlobalConsensusAssetMultilocation(sourceApi, asset, destination) {
+  const assetInDestination = destination.getChainAsset(asset);
+  return [
+    [
+      2,
+      [
+        encodeGlobalConsensus(sourceApi, destination),
+        encodeParachain(destination.parachainId),
+        encodePalletInstance(
+          sourceApi,
+          assetInDestination.getAssetPalletInstance()
+        )
+      ]
+    ],
+    asset.amount
+  ];
+}
+function getAddressGlobalConsensusAssetMultilocation(sourceApi, asset, destination) {
+  const assetInDestination = destination.getChainAsset(asset);
+  if (!assetInDestination.address) {
+    throw new Error(`Asset address is required for ${assetInDestination.key}`);
+  }
+  return [
+    [
+      2,
+      [
+        encodeGlobalConsensus(sourceApi, destination),
+        encodeParachain(destination.parachainId),
+        encodePalletInstance(
+          sourceApi,
+          assetInDestination.getAssetPalletInstance()
+        ),
+        encodeAddress(destination, assetInDestination.address)
+      ]
+    ],
+    asset.amount
+  ];
 }
 function encodeXcmMessageToBytes(xcmMessage, api) {
   if (!api) {
@@ -317,6 +501,35 @@ function encodeXcmMessageToBytes(xcmMessage, api) {
     throw error;
   }
 }
+function encodeParachain(paraId) {
+  return `0x00${paraId.toString(16).padStart(8, "0")}`;
+}
+function encodeGlobalConsensus(api, destination) {
+  const globalConsensus = getGlobalConsensus(destination);
+  return encodeXcmJunction(api, {
+    GlobalConsensus: globalConsensus
+  });
+}
+function encodePalletInstance(api, palletInstance) {
+  return encodeXcmJunction(api, {
+    PalletInstance: palletInstance
+  });
+}
+function encodeXcmJunction(api, junction) {
+  if (!api) {
+    throw new Error("API is required to encode XCM junction");
+  }
+  const junctionType = api.createType("XcmV3Junction", junction);
+  return junctionType.toHex();
+}
+function encodeAddress(destination, address) {
+  const accountType = EvmParachain.is(destination) ? "03" : "01";
+  return `0x${accountType}${u8aToHex2(
+    decodeAddress2(address),
+    -1,
+    false
+  )}00`;
+}
 
 // src/contract/contracts/XcmPrecompile/XcmPrecompileAbi.ts
 var XCM_ABI = [
@@ -855,6 +1068,67 @@ function XcmPrecompile() {
         });
       }
     }),
+    transferAssetsLocation: () => ({
+      nativeAsset: () => ({
+        build: (params) => {
+          return buildTransferAssetsLocation({
+            ...params,
+            assetsMultilocations: [
+              getPalletInstanceMultilocation(params.sourceApi, params.asset)
+            ]
+          });
+        }
+      }),
+      localErc20: () => ({
+        build: (params) => {
+          return buildTransferAssetsLocation({
+            ...params,
+            assetsMultilocations: [
+              getAssetAddressMultilocation(
+                params.sourceApi,
+                params.asset,
+                params.destination
+              )
+            ]
+          });
+        }
+      }),
+      foreignAsset: () => ({
+        build: (params) => {
+          return buildTransferAssetsLocation({
+            ...params,
+            assetsMultilocations: [
+              getGlobalConsensusAssetMultilocation(
+                params.sourceApi,
+                params.asset,
+                params.destination
+              )
+            ]
+          });
+        }
+      }),
+      foreignErc20: () => ({
+        build: (params) => {
+          return buildTransferAssetsLocation({
+            ...params,
+            assetsMultilocations: [
+              // fee asset
+              getGlobalConsensusAssetMultilocation(
+                params.sourceApi,
+                params.fee,
+                params.destination
+              ),
+              // transfer asset
+              getAddressGlobalConsensusAssetMultilocation(
+                params.sourceApi,
+                params.asset,
+                params.destination
+              )
+            ]
+          });
+        }
+      })
+    }),
     transferAssetsUsingTypeAndThenAddress: (shouldTransferAssetPrecedeFeeAsset = false) => ({
       build: ({
         destinationAddress,
@@ -869,7 +1143,6 @@ function XcmPrecompile() {
           fee,
           shouldTransferAssetPrecedeFeeAsset
         );
-        const destLocation = getDestinationParachainMultilocation(destination);
         const xcmMessage = buildXcmMessage(
           assets3,
           destinationAddress,
@@ -884,7 +1157,7 @@ function XcmPrecompile() {
           address: XCM_PRECOMPILE_ADDRESS,
           abi: XCM_ABI,
           args: [
-            destLocation,
+            getDestinationParachainMultilocation(destination),
             assets3,
             2 /* DestinationReserve */,
             feeIndex,
@@ -936,6 +1209,26 @@ function buildXcmMessage(assets3, destinationAddress, sourceApi) {
     [xcmVersion]: [instruction]
   };
 }
+function buildTransferAssetsLocation({
+  assetsMultilocations,
+  feeAssetItem = 0,
+  destinationAddress,
+  destination,
+  sourceApi
+}) {
+  return new ContractConfig({
+    address: XCM_PRECOMPILE_ADDRESS,
+    abi: XCM_ABI,
+    args: [
+      getGlobalConsensusDestination(sourceApi, destination),
+      getBeneficiaryMultilocation(destinationAddress, destination),
+      assetsMultilocations,
+      feeAssetItem
+    ],
+    func: "transferAssetsLocation",
+    module: "Xcm"
+  });
+}
 
 // src/contract/contracts/Xtokens/Xtokens.ts
 import { formatAssetIdToERC20 } from "@moonbeam-network/xcm-utils";
@@ -1413,28 +1706,40 @@ function assets2() {
 function foreignAssets2() {
   return {
     account: () => ({
-      build: ({ address, asset }) => {
-        if (!asset.address) {
-          throw new Error(
-            "Asset address is needed to calculate balance with foreignAssets.account function"
-          );
-        }
-        const multilocation = {
-          parents: 2,
-          interior: {
-            X2: [
-              { GlobalConsensus: { ethereum: { chainId: 1 } } },
-              getExtrinsicAccount(asset.address)
-            ]
+      globalConsensus: () => ({
+        build: ({ address, asset }) => {
+          if (!asset.address) {
+            throw new Error(
+              "Asset address is needed to calculate balance with foreignAssets.account function"
+            );
           }
-        };
-        return new SubstrateQueryConfig({
-          module: "foreignAssets",
-          func: "account",
-          args: [multilocation, address],
-          transform: async (response) => response.unwrapOrDefault().balance.toBigInt()
-        });
-      }
+          const multilocation = {
+            parents: 2,
+            interior: {
+              X2: [
+                { GlobalConsensus: { ethereum: { chainId: 1 } } },
+                getExtrinsicAccount(asset.address)
+              ]
+            }
+          };
+          return new SubstrateQueryConfig({
+            module: "foreignAssets",
+            func: "account",
+            args: [multilocation, address],
+            transform: async (response) => response.unwrapOrDefault().balance.toBigInt()
+          });
+        }
+      }),
+      id: () => ({
+        build: ({ address, asset }) => {
+          return new SubstrateQueryConfig({
+            module: "foreignAssets",
+            func: "account",
+            args: [asset.getBalanceAssetId(), address],
+            transform: async (response) => response.unwrapOrDefault().balance.toBigInt()
+          });
+        }
+      })
     })
   };
 }
@@ -1571,120 +1876,6 @@ function eqBalances() {
   };
 }
 
-// src/extrinsic/pallets/polkadotXcm/polkadotXcm.util.ts
-import { Ecosystem } from "@moonbeam-network/xcm-types";
-function getPolkadotXcmExtrinsicArgs({
-  assets: assets3,
-  destinationAddress,
-  destination,
-  func,
-  parents = 1,
-  feeIndex = 0
-}) {
-  const version = getExtrinsicArgumentVersion(func);
-  return [
-    // dest
-    {
-      [version]: normalizeX1(version, {
-        parents,
-        interior: {
-          X1: {
-            Parachain: destination.parachainId
-          }
-        }
-      })
-    },
-    // beneficiary
-    {
-      [version]: normalizeX1(version, {
-        parents: 0,
-        interior: {
-          X1: getExtrinsicAccount(destinationAddress)
-        }
-      })
-    },
-    // assets
-    {
-      [version]: assets3
-    },
-    // feeAssetItem
-    feeIndex,
-    // weightLimit
-    "Unlimited"
-  ];
-}
-function isKusamaDestination(destination) {
-  return destination.ecosystem === Ecosystem.Kusama || destination.ecosystem === Ecosystem.MoonsamaRelay;
-}
-function isPolkadotDestination(destination) {
-  return destination.ecosystem === Ecosystem.Polkadot || destination.ecosystem === Ecosystem.MoonlamaRelay;
-}
-function getGlobalConsensus(destination) {
-  if (isKusamaDestination(destination)) {
-    return "Kusama";
-  }
-  if (isPolkadotDestination(destination)) {
-    return "Polkadot";
-  }
-  return {
-    ByGenesis: destination.relayGenesisHash
-  };
-}
-function getEcosystemTransferExtrinsicArgs({
-  assets: assets3,
-  destinationAddress,
-  destination,
-  func,
-  feeIndex = 0
-}) {
-  const version = getExtrinsicArgumentVersion(func);
-  const globalConsensus = getGlobalConsensus(destination);
-  return [
-    // dest
-    {
-      [version]: normalizeX1(version, {
-        parents: 2,
-        interior: {
-          X2: [
-            { GlobalConsensus: globalConsensus },
-            {
-              Parachain: destination.parachainId
-            }
-          ]
-        }
-      })
-    },
-    // beneficiary
-    {
-      [version]: normalizeX1(version, {
-        parents: 0,
-        interior: {
-          X1: getExtrinsicAccount(destinationAddress)
-        }
-      })
-    },
-    // assets
-    {
-      [version]: assets3
-    },
-    // feeAssetItem
-    feeIndex,
-    // weightLimit
-    "Unlimited"
-  ];
-}
-function shouldFeeAssetPrecedeAsset({
-  asset,
-  fee
-}) {
-  const assetIdNumber = Number(asset.getAssetId());
-  const feeAssetIdNumber = Number(fee.getAssetId());
-  if (Number.isNaN(assetIdNumber) || Number.isNaN(feeAssetIdNumber)) {
-    return false;
-  }
-  return assetIdNumber > feeAssetIdNumber;
-}
-
 // src/extrinsic/pallets/polkadotXcm/polkadotXcm.ts
 var pallet2 = "polkadotXcm";
 function polkadotXcm() {