@moonbeam-network/xcm-builder 1.0.0-dev.288 → 1.0.0-dev.289

package/build/index.d.ts

@@ -1733,7 +1733,7 @@ declare enum Provider {
 }
 type MrlTransferConfig = ContractConfig | ExtrinsicConfig | WormholeConfig | SnowbridgeConfig;
 type MrlConfigBuilder = ConfigBuilder<MrlTransferConfig, MrlBuilderParams> & {
-    provider?: Provider;
+    provider: Provider;
 };
 type MrlExecuteConfigBuilder = ConfigBuilder<ContractConfig, MrlExecuteBuilderParams>;
 interface MrlBuilderParams extends BuilderParams<AnyChain> {
@@ -1796,7 +1796,12 @@ declare function snowbridge(): {
 };
 
 declare function Batch(): {
-    transferAssetsAndMessage: () => MrlConfigBuilder;
+    /**
+     * Transfers assets and XCM message using XTokens contract for multi-currency transfer.
+     * Uses parents: 1 for multilocation derivation.
+     */
+    transferAssetsAndMessageViaXTokens: () => MrlConfigBuilder;
+    transferAssetsAndMessageViaXcmPrecompile: () => MrlConfigBuilder;
 };
 
 declare function Gmp(): {
@@ -1823,7 +1828,7 @@ declare function ethereumXcm(): {
 };
 
 declare function polkadotXcm(): {
-    send: () => MrlConfigBuilder;
+    send: (transferAssetsPallet?: "polkadotXcm" | "xTokens") => MrlConfigBuilder;
 };
 
 declare function extrinsic(): {

package/build/index.mjs

@@ -1114,6 +1114,7 @@ function XcmPrecompile() {
       }),
       foreignErc20: () => ({
         build: (params) => {
+          console.log("params", params);
           return buildTransferAssetsLocation({
             ...params,
             assetsMultilocations: [
@@ -5161,6 +5162,7 @@ function snowbridge() {
 
 // src/mrl/providers/wormhole/contract/Batch/Batch.ts
 import {
+  AssetAmount as AssetAmount2,
   EvmParachain as EvmParachain5
 } from "@moonbeam-network/xcm-types";
 import { getMultilocationDerivedAddresses as getMultilocationDerivedAddresses2 } from "@moonbeam-network/xcm-utils";
@@ -5178,7 +5180,7 @@ var CROSS_CHAIN_FEE = 100000000000000000n;
 function polkadotXcm3() {
   const provider = "wormhole" /* Wormhole */;
   return {
-    send: () => ({
+    send: (transferAssetsPallet) => ({
       provider,
       build: ({
         asset,
@@ -5204,12 +5206,15 @@ function polkadotXcm3() {
         if (!Parachain2.is(source)) {
           throw new Error("Source chain needs to be a parachain");
         }
+        console.log("sourceAddress", sourceAddress);
         const { address20: computedOriginAccount } = getMultilocationDerivedAddresses({
           address: sourceAddress,
           paraId: source.parachainId,
-          isParents: true
+          parents: 1
         });
+        console.log("computedOriginAccount", computedOriginAccount);
         const assetTransferTxs = getAssetTransferTxs({
+          transferAssetsPallet,
           asset,
           computedOriginAccount,
           destination,
@@ -5248,7 +5253,28 @@ function polkadotXcm3() {
     })
   };
 }
+function getDestinationMultilocation2(source, bridgeChain) {
+  const isDifferentEcosystem = source.ecosystem !== bridgeChain.ecosystem;
+  if (isDifferentEcosystem) {
+    return {
+      parents: 2,
+      interior: {
+        X2: [
+          { GlobalConsensus: getGlobalConsensus(bridgeChain) },
+          { Parachain: bridgeChain.parachainId }
+        ]
+      }
+    };
+  }
+  return {
+    parents: 1,
+    interior: {
+      X1: { Parachain: bridgeChain.parachainId }
+    }
+  };
+}
 function buildSendExtrinsic({
+  source,
   computedOriginAccount,
   moonAsset,
   bridgeChain,
@@ -5259,14 +5285,13 @@ function buildSendExtrinsic({
     throw new Error("Transact params are required");
   }
   const version = getExtrinsicArgumentVersion(sourceApi.tx.polkadotXcm.send);
+  console.log("transact", transact);
   return sourceApi.tx.polkadotXcm.send(
     {
-      [version]: normalizeX1(version, {
-        parents: 1,
-        interior: {
-          X1: { Parachain: bridgeChain.parachainId }
-        }
-      })
+      [version]: normalizeX1(
+        version,
+        getDestinationMultilocation2(source, bridgeChain)
+      )
     },
     {
       [version]: [
@@ -5342,6 +5367,49 @@ function buildSendExtrinsic({
   );
 }
 function getAssetTransferTxs({
+  transferAssetsPallet = "xTokens",
+  ...params
+}) {
+  console.log("transferAssetsPallet", transferAssetsPallet);
+  if (transferAssetsPallet === "xTokens") {
+    return getAssetTransferTxsFromXtokens(params);
+  }
+  if (transferAssetsPallet === "polkadotXcm") {
+    return getAssetTransferTxsForPolkadotXcm(params);
+  }
+  throw new Error(
+    "Invalid transferAssetsPallet for polkadotXcm().send() function"
+  );
+}
+function getAssetTransferTxsForPolkadotXcm({
+  asset,
+  computedOriginAccount,
+  moonApi,
+  moonAsset,
+  bridgeChain,
+  source,
+  sourceAddress,
+  sourceApi
+}) {
+  const { transferAssets } = sourceApi.tx.polkadotXcm;
+  const polkadotXcmBuilder = ExtrinsicBuilder().polkadotXcm().transferAssetsToEcosystem().X4();
+  const transferAssetsTx = transferAssets(
+    ...polkadotXcmBuilder.build({
+      asset,
+      destination: bridgeChain,
+      destinationAddress: computedOriginAccount,
+      destinationApi: moonApi,
+      fee: AssetAmount.fromChainAsset(source.getChainAsset(moonAsset), {
+        amount: CROSS_CHAIN_FEE + BUY_EXECUTION_FEE
+      }),
+      source,
+      sourceAddress,
+      sourceApi
+    }).getArgs(transferAssets)
+  );
+  return [transferAssetsTx];
+}
+function getAssetTransferTxsFromXtokens({
   asset,
   computedOriginAccount,
   fee,
@@ -5352,9 +5420,9 @@ function getAssetTransferTxs({
   sourceAddress,
   sourceApi
 }) {
-  const { transfer, transferMulticurrencies } = sourceApi.tx.xTokens;
   const transferBuilder = ExtrinsicBuilder().xTokens().transfer();
   const transferMulticurrenciesBuilder = ExtrinsicBuilder().xTokens().transferMultiCurrencies();
+  const { transfer, transferMulticurrencies } = sourceApi.tx.xTokens;
   if (asset.isSame(fee)) {
     const assetTransferTx = transfer(
       ...transferBuilder.build({
@@ -5405,8 +5473,8 @@ function getAssetTransferTxs({
   return [multiCurrenciesTransferTx];
 }
 
-// src/mrl/providers/wormhole/contract/Batch/abi/peaq/PeaqBatchContractAbi.ts
-var PEAQ_BATCH_ABI = [
+// src/mrl/providers/wormhole/contract/Batch/abi/BatchContractAbi.ts
+var BATCH_ABI = [
   {
     anonymous: false,
     inputs: [
@@ -5519,8 +5587,8 @@ var PEAQ_BATCH_ABI = [
   }
 ];
 
-// src/mrl/providers/wormhole/contract/Batch/abi/peaq/PeaqXcmUtilsContractAbi.ts
-var PEAQ_XCM_UTILS_ABI = [
+// src/mrl/providers/wormhole/contract/Batch/abi/XcmUtilsContractAbi.ts
+var XCM_UTILS_ABI = [
   {
     inputs: [
       {
@@ -5621,8 +5689,8 @@ var PEAQ_XCM_UTILS_ABI = [
   }
 ];
 
-// src/mrl/providers/wormhole/contract/Batch/abi/peaq/PeaqXtokensContractAbi.ts
-var PEAQ_XTOKENS_ABI = [
+// src/mrl/providers/wormhole/contract/Batch/abi/XtokensContractAbi.ts
+var XTOKENS_ABI2 = [
   {
     inputs: [
       {
@@ -5938,9 +6006,9 @@ var PEAQ_XTOKENS_ABI = [
 // src/mrl/providers/wormhole/contract/Batch/abi/abi.helpers.ts
 function getAbisForChain(_) {
   return {
-    BatchAbi: PEAQ_BATCH_ABI,
-    XcmUtilsAbi: PEAQ_XCM_UTILS_ABI,
-    XtokensAbi: PEAQ_XTOKENS_ABI
+    BatchAbi: BATCH_ABI,
+    XcmUtilsAbi: XCM_UTILS_ABI,
+    XtokensAbi: XTOKENS_ABI2
   };
 }
 
@@ -5949,22 +6017,14 @@ var module = "Batch";
 function Batch() {
   const provider = "wormhole" /* Wormhole */;
   return {
-    transferAssetsAndMessage: () => ({
+    /**
+     * Transfers assets and XCM message using XTokens contract for multi-currency transfer.
+     * Uses parents: 1 for multilocation derivation.
+     */
+    transferAssetsAndMessageViaXTokens: () => ({
       provider,
-      build: ({
-        asset,
-        destination,
-        destinationAddress,
-        fee,
-        isAutomatic,
-        moonAsset,
-        bridgeChain,
-        moonApi,
-        source,
-        sourceAddress,
-        sourceApi,
-        transact
-      }) => {
+      build: (params) => {
+        const { source, sourceAddress, sourceApi } = params;
         if (!EvmParachain5.is(source)) {
           throw new Error("Source chain needs to be an EVMParachain");
         }
@@ -5977,44 +6037,53 @@ function Batch() {
           );
         }
         const subMappedAddress = evmToAddress3(sourceAddress);
-        const { BatchAbi, XcmUtilsAbi, XtokensAbi } = getAbisForChain(source);
         const { address20: computedOriginAccount } = getMultilocationDerivedAddresses2({
           address: subMappedAddress,
           paraId: source.parachainId,
-          isParents: true
+          parents: 1
         });
-        const send = buildSendExtrinsic({
-          asset,
-          destination,
-          destinationAddress,
+        const encodedXcmMessage = buildXcmMessage2({
+          asset: params.asset,
+          destination: params.destination,
+          destinationAddress: params.destinationAddress,
           computedOriginAccount,
-          fee,
-          isAutomatic,
-          moonAsset,
-          bridgeChain,
-          moonApi,
+          fee: params.fee,
+          isAutomatic: params.isAutomatic,
+          moonAsset: params.moonAsset,
+          bridgeChain: params.bridgeChain,
+          moonApi: params.moonApi,
           source,
           sourceAddress,
           sourceApi,
-          transact
+          transact: params.transact
         });
-        const encodedXcmMessage = send.args[1].toHex();
-        const { destinationParachain, destinationParachainAndAddress } = getDestinationInHex(bridgeChain, computedOriginAccount);
+        const { BatchAbi, XcmUtilsAbi, XtokensAbi } = getAbisForChain(source);
+        const { destinationParachainAndAddress } = getDestinationInHex(
+          params.bridgeChain,
+          computedOriginAccount
+        );
         const { currencies, feeItem } = getCurrencies({
           source,
-          moonAsset,
-          asset
+          moonAsset: params.moonAsset,
+          asset: params.asset
         });
-        const weight = maxUint64;
         const multiTransferTxData = encodeFunctionData2({
           abi: XtokensAbi,
           functionName: "transferMultiCurrencies",
-          args: [currencies, feeItem, destinationParachainAndAddress, weight]
+          args: [
+            currencies,
+            feeItem,
+            destinationParachainAndAddress,
+            maxUint64
+          ]
         });
-        const xcmSendTxData = encodeFunctionData2({
+        const xcmSendTxData = buildXcmSendTxData({
           abi: XcmUtilsAbi,
-          functionName: "xcmSend",
-          args: [destinationParachain, encodedXcmMessage]
+          destination: getDestinationInHex(
+            params.bridgeChain,
+            computedOriginAccount
+          ).destinationParachain,
+          encodedXcmMessage
         });
         return new ContractConfig({
           address: source.contracts.Batch,
@@ -6029,9 +6098,101 @@ function Batch() {
           module
         });
       }
+    }),
+    transferAssetsAndMessageViaXcmPrecompile: () => ({
+      provider,
+      build: (params) => {
+        const { source, sourceAddress, sourceApi } = params;
+        if (!EvmParachain5.is(source)) {
+          throw new Error("Source chain needs to be an EVMParachain");
+        }
+        if (!sourceApi) {
+          throw new Error("Source API needs to be defined");
+        }
+        if (!source.contracts?.XcmUtils || !source.contracts?.Batch || !source.contracts?.XcmPrecompile) {
+          throw new Error(
+            "Source chain needs to have the XcmUtils and Batch contract addresses configured"
+          );
+        }
+        const { address20: computedOriginAccount } = getMultilocationDerivedAddresses2({
+          address: sourceAddress,
+          paraId: source.parachainId,
+          parents: 2
+          // this function is only used for global consensus currently
+        });
+        console.log("computedOriginAccount", computedOriginAccount);
+        const encodedXcmMessage = buildXcmMessage2({
+          asset: params.asset,
+          destination: params.destination,
+          destinationAddress: params.destinationAddress,
+          computedOriginAccount,
+          fee: params.fee,
+          isAutomatic: params.isAutomatic,
+          moonAsset: params.moonAsset,
+          bridgeChain: params.bridgeChain,
+          moonApi: params.moonApi,
+          source,
+          sourceAddress,
+          sourceApi,
+          transact: params.transact
+        });
+        const { BatchAbi, XcmUtilsAbi } = getAbisForChain(source);
+        const bridgeChainFee = AssetAmount2.fromChainAsset(
+          params.bridgeChain.getChainAsset(params.moonAsset),
+          {
+            // TODO mjm get from the config, after merging the changes from Tanssi Demo, which brings bridgeChainFee to the params of this function
+            amount: 0.03
+          }
+        );
+        const transferAssetsCall = ContractBuilder().XcmPrecompile().transferAssetsLocation().foreignErc20().build({
+          sourceApi,
+          asset: params.asset,
+          fee: bridgeChainFee,
+          destination: params.bridgeChain,
+          destinationAddress: computedOriginAccount,
+          source,
+          sourceAddress
+        });
+        const transferAssetsCallData = transferAssetsCall.encodeFunctionData();
+        const globalConsensusDestination = getGlobalConsensusDestination(
+          sourceApi,
+          params.bridgeChain
+        );
+        const xcmSendTxData = buildXcmSendTxData({
+          abi: XcmUtilsAbi,
+          destination: {
+            parents: globalConsensusDestination[0],
+            interior: globalConsensusDestination[1]
+          },
+          encodedXcmMessage
+        });
+        return new ContractConfig({
+          address: source.contracts.Batch,
+          abi: BatchAbi,
+          args: [
+            [source.contracts.XcmPrecompile, source.contracts.XcmUtils],
+            [],
+            [transferAssetsCallData, xcmSendTxData],
+            []
+          ],
+          func: "batchAll",
+          module
+        });
+      }
     })
   };
 }
+function buildXcmMessage2(params) {
+  const send = buildSendExtrinsic(params);
+  return send.args[1].toHex();
+}
+function buildXcmSendTxData(params) {
+  return encodeFunctionData2({
+    abi: params.abi,
+    functionName: "xcmSend",
+    args: [params.destination, params.encodedXcmMessage]
+  });
+}
 function getDestinationInHex(bridgeChain, computedOriginAccount) {
   const destinationParachain = {
     parents: 1,
@@ -6163,28 +6324,28 @@ function wormhole() {
         destinationAddress,
         isAutomatic,
         moonApi,
-        bridgeChain: moonChain,
+        bridgeChain,
         source,
         sourceAddress
       }) => {
         const isSourceParachain = Parachain3.is(source);
-        const isDestinationMoonChain = destination.isEqual(moonChain);
+        const isDestinationMoonChain = destination.isEqual(bridgeChain);
         const isDestinationEvmChain = EvmChain4.is(destination);
         const isNativeAsset = asset.isSame(
-          isDestinationEvmChain ? moonChain.nativeAsset : source.nativeAsset
+          isDestinationEvmChain ? bridgeChain.nativeAsset : source.nativeAsset
         );
-        const tokenAddress = isNativeAsset ? "native" : isDestinationEvmChain ? moonChain.getChainAsset(asset).address : asset.address;
+        const tokenAddress = isNativeAsset ? "native" : isDestinationEvmChain ? bridgeChain.getChainAsset(asset).address : asset.address;
         const { address20: computedOriginAccount } = getMultilocationDerivedAddresses3({
           address: sourceAddress,
           paraId: isSourceParachain ? source.parachainId : void 0,
-          isParents: true
+          parents: 1
         });
         if (!tokenAddress) {
           throw new Error(`Asset ${asset.key} has no address`);
         }
         const wh = wormholeFactory(source);
-        const whSource = isDestinationEvmChain ? wh.getChain(moonChain.getWormholeName()) : wh.getChain(source.getWormholeName());
-        const whDestination = isDestinationEvmChain ? wh.getChain(destination.getWormholeName()) : wh.getChain(moonChain.getWormholeName());
+        const whSource = isDestinationEvmChain ? wh.getChain(bridgeChain.getWormholeName()) : wh.getChain(source.getWormholeName());
+        const whDestination = isDestinationEvmChain ? wh.getChain(destination.getWormholeName()) : wh.getChain(bridgeChain.getWormholeName());
         const whAsset = Wormhole2.tokenId(whSource.chain, tokenAddress);
         const whSourceAddress = Wormhole2.chainAddress(
           whSource.chain,
@@ -6201,7 +6362,12 @@ function wormhole() {
             from: whSourceAddress,
             to: whDestinationAddress,
             protocol: isAutomatic ? "AutomaticTokenBridge" /* AutomaticTokenBridge */ : "TokenBridge" /* TokenBridge */,
-            payload: isDestinationMoonChain || isDestinationEvmChain ? void 0 : getPayload({ destination, destinationAddress, moonApi })
+            payload: isDestinationMoonChain || isDestinationEvmChain ? void 0 : getPayload({
+              destination,
+              destinationAddress,
+              moonApi,
+              bridgeChain
+            })
           },
           func: "tokenTransfer"
         });
@@ -6212,16 +6378,57 @@ function wormhole() {
 function getPayload({
   moonApi,
   destination,
-  destinationAddress
+  destinationAddress,
+  bridgeChain
+}) {
+  const destinationMultilocation = getDestinationMultilocation3({
+    destination,
+    destinationAddress,
+    moonApi,
+    bridgeChain
+  });
+  console.log("destinationMultilocation", destinationMultilocation.toHuman());
+  const action = moonApi.createType("XcmRoutingUserAction", {
+    destination: destinationMultilocation
+  });
+  const versioned = moonApi.createType("VersionedUserAction", {
+    V1: action
+  });
+  return versioned.toU8a();
+}
+function getDestinationMultilocation3({
+  moonApi,
+  destination,
+  destinationAddress,
+  bridgeChain
 }) {
   if (!EvmParachain7.isAnyParachain(destination)) {
     throw new Error(
       `Destination ${destination.name} is not a Parachain or EvmParachain`
     );
   }
-  const isEvmDestination = EvmParachain7.is(destination);
   const version = getExtrinsicArgumentVersion(moonApi.tx.polkadotXcm.send);
-  const multilocation = moonApi.createType("XcmVersionedLocation", {
+  const isDifferentEcosystem = destination.ecosystem !== bridgeChain.ecosystem;
+  const isEvmDestination = EvmParachain7.is(destination);
+  if (isDifferentEcosystem) {
+    return moonApi.createType("XcmVersionedLocation", {
+      [version]: {
+        parents: 2,
+        interior: {
+          X3: [
+            {
+              GlobalConsensus: getGlobalConsensus(destination)
+            },
+            {
+              Parachain: destination.parachainId
+            },
+            getExtrinsicAccount(destinationAddress)
+          ]
+        }
+      }
+    });
+  }
+  return moonApi.createType("XcmVersionedLocation", {
     [version]: {
       parents: 1,
       interior: {
@@ -6236,13 +6443,6 @@ function getPayload({
       }
     }
   });
-  const action = moonApi.createType("XcmRoutingUserAction", {
-    destination: multilocation
-  });
-  const versioned = moonApi.createType("VersionedUserAction", {
-    V1: action
-  });
-  return versioned.toU8a();
 }
 
 // src/mrl/providers/wormhole/contract/TokenBridge/TokenBridgeAbi.ts
@@ -7787,6 +7987,7 @@ function ethereumXcm() {
           functionName: "approve",
           args: [contract3.address, tokenAmountOnBridgeChain]
         });
+        console.log("transact contract ", contract3);
         const batchAll = encodeFunctionData3({
           abi: BATCH_CONTRACT_ABI,
           functionName: "batchAll",