@moonbeam-network/xcm-builder 3.1.1 → 3.2.0

package/build/index.d.ts

@@ -429,23 +429,38 @@ interface FeeConfigBuilderParams {
     asset: ChainAsset;
     destination: AnyParachain;
     feeAsset: ChainAsset;
+    source: AnyChain;
 }
 interface XcmPaymentFeeProps {
     isAssetReserveChain: boolean;
     shouldTransferAssetPrecedeFeeAsset?: boolean;
+    parents?: number;
 }
 interface MoonbeamRuntimeXcmConfigAssetType extends Enum {
     readonly isXcm: boolean;
     readonly asXcm: StagingXcmV3MultiLocation;
     readonly type: 'Xcm';
 }
+type GetVersionedAssetId = (params: FeeConfigBuilderParams) => Promise<object> | object;
+
+declare function xcmPaymentApi(): {
+    fromCurrencyIdToLocations: (options: XcmPaymentFeeProps) => FeeConfigBuilder;
+    fromAssetIdQuery: (options: XcmPaymentFeeProps) => FeeConfigBuilder;
+    fromSourceAccountKey20: (options: XcmPaymentFeeProps) => FeeConfigBuilder;
+    fromSourcePalletInstance: (options: XcmPaymentFeeProps) => FeeConfigBuilder;
+    fromHere: (options: XcmPaymentFeeProps) => FeeConfigBuilder;
+    fromHereAndGeneralIndex: (options: XcmPaymentFeeProps) => FeeConfigBuilder;
+    fromPalletInstanceAndGeneralIndex: (options: XcmPaymentFeeProps) => FeeConfigBuilder;
+    fromHereAndSourceGeneralIndex: (options: XcmPaymentFeeProps) => FeeConfigBuilder;
+    fromGeneralIndex: (options: XcmPaymentFeeProps) => FeeConfigBuilder;
+    fromPalletInstance: (options: XcmPaymentFeeProps) => FeeConfigBuilder;
+    fromPalletInstanceAndAccountKey20: (options: XcmPaymentFeeProps) => FeeConfigBuilder;
+    fromGlobalConsensus: (options: XcmPaymentFeeProps) => FeeConfigBuilder;
+};
 
 declare function FeeBuilder(): {
     xcmPaymentApi: typeof xcmPaymentApi;
 };
-declare function xcmPaymentApi(): {
-    xcmPaymentFee: ({ isAssetReserveChain, shouldTransferAssetPrecedeFeeAsset, }: XcmPaymentFeeProps) => FeeConfigBuilder;
-};
 
 declare function wormhole$1(): {
     tokenTransfer: () => MrlConfigBuilder;
@@ -624,4 +639,4 @@ declare function MrlBuilder(): {
 
 declare const BATCH_CONTRACT_ADDRESS = "0x0000000000000000000000000000000000000808";
 
-export { 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, ERC20_ABI, type EquilibriumSystemBalanceData, type EvmFunctionArgs, EvmQueryConfig, type EvmQueryConfigParams, type EvmQueryFunctions, ExtrinsicBuilder, ExtrinsicConfig, type ExtrinsicConfigBuilder, type ExtrinsicConfigConstructorParams, FeeBuilder, type FeeConfigBuilder, type FeeConfigBuilderParams, type MoonbeamRuntimeXcmConfigAssetType, MrlBuilder, type MrlBuilderParams, type MrlConfigBuilder, type MrlExecuteBuilderParams, type MrlExecuteConfigBuilder, type PalletBalancesAccountDataOld, type Parents, type QueryConfigConstructorParams, SubstrateCallConfig, type SubstrateCallConfigConstructorParams, SubstrateQueryConfig, type TokensPalletAccountData, type Transact, WormholeConfig, type WormholeConfigConstructorParams, type WormholeFunctionArgs, type WormholeTransferFunctions, type XcmPaymentFeeProps, XcmVersion, calculateSystemAccountBalance, evm, substrate, wormhole, wormholeFactory };
+export { 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, ERC20_ABI, type EquilibriumSystemBalanceData, type EvmFunctionArgs, EvmQueryConfig, type EvmQueryConfigParams, type EvmQueryFunctions, ExtrinsicBuilder, ExtrinsicConfig, type ExtrinsicConfigBuilder, type ExtrinsicConfigConstructorParams, FeeBuilder, type FeeConfigBuilder, type FeeConfigBuilderParams, type GetVersionedAssetId, type MoonbeamRuntimeXcmConfigAssetType, MrlBuilder, type MrlBuilderParams, type MrlConfigBuilder, type MrlExecuteBuilderParams, type MrlExecuteConfigBuilder, type PalletBalancesAccountDataOld, type Parents, type QueryConfigConstructorParams, SubstrateCallConfig, type SubstrateCallConfigConstructorParams, SubstrateQueryConfig, type TokensPalletAccountData, type Transact, WormholeConfig, type WormholeConfigConstructorParams, type WormholeFunctionArgs, type WormholeTransferFunctions, type XcmPaymentFeeProps, XcmVersion, calculateSystemAccountBalance, evm, substrate, wormhole, wormholeFactory };

package/build/index.mjs

@@ -2,6 +2,7 @@
 import "@polkadot/api-augment";
 
 // src/extrinsic/ExtrinsicBuilder.utils.ts
+import { isEthAddress } from "@moonbeam-network/xcm-utils";
 import { getTypeDef } from "@polkadot/types";
 import { u8aToHex } from "@polkadot/util";
 import { decodeAddress } from "@polkadot/util-crypto";
@@ -44,8 +45,7 @@ function getExtrinsicArgumentVersion(func, index = 0) {
   throw new Error("Can't find XCM version");
 }
 function getExtrinsicAccount(address) {
-  const isEthAddress = address.length === 42 && address.startsWith("0x");
-  return isEthAddress ? {
+  return isEthAddress(address) ? {
     AccountKey20: {
       key: address
     }
@@ -2240,11 +2240,14 @@ function ExtrinsicBuilder() {
 }
 
 // src/fee/FeeBuilder.utils.ts
+import { isEthAddress as isEthAddress2 } from "@moonbeam-network/xcm-utils";
+import { u8aToHex as u8aToHex5 } from "@polkadot/util";
+import { decodeAddress as decodeAddress5 } from "@polkadot/util-crypto";
 var DEFAULT_AMOUNT = 10 ** 6;
 var DEFAULT_HEX_STRING = "0xabcdef1234567890fedcba0987654321abcdef1234567890fedcba0987654321";
-var XCM_VERSION = "V4" /* v4 */;
+var STABLE_XCM_VERSION = "V4" /* v4 */;
 function isXcmV42() {
-  return XCM_VERSION === "V4" /* v4 */;
+  return STABLE_XCM_VERSION === "V4" /* v4 */;
 }
 function getWithdrawAssetInstruction(assetTypes) {
   return {
@@ -2290,8 +2293,8 @@ function getBuyExecutionInstruction(assetType) {
 }
 function getDepositAssetInstruction(address, assets3) {
   const accountKey = {
-    AccountKey20: {
-      key: address,
+    [isEthAddress2(address) ? "AccountKey20" : "AccountId32"]: {
+      key: isEthAddress2(address) ? address : u8aToHex5(decodeAddress5(address)),
       network: null
     }
   };
@@ -2317,71 +2320,9 @@ function getSetTopicInstruction() {
     SetTopic: DEFAULT_HEX_STRING
   };
 }
-function getNativeAssetId(palletInstanceNumber) {
-  if (!palletInstanceNumber) {
-    throw new Error(
-      "No pallet instance configured for the native asset for XcmPaymentApi fee calculation"
-    );
-  }
-  const palletInstance = {
-    PalletInstance: palletInstanceNumber
-  };
-  const id = {
-    interior: {
-      X1: isXcmV42() ? [palletInstance] : palletInstance
-    },
-    parents: "0"
-  };
-  return normalizeConcrete(XCM_VERSION, id);
-}
-function getConcreteAssetIdWithAccountKey20(asset, palletInstance) {
-  if (!palletInstance) {
-    throw new Error(
-      `No pallet instance configured for the asset ${asset} for XcmPaymentApi fee calculation`
-    );
-  }
-  const id = {
-    interior: {
-      X2: [
-        {
-          PalletInstance: palletInstance
-        },
-        {
-          AccountKey20: {
-            key: asset,
-            network: null
-          }
-        }
-      ]
-    },
-    parents: "0"
-  };
-  return normalizeConcrete(XCM_VERSION, id);
-}
-async function getAssetIdType(api, asset) {
-  const type = await api.query.assetManager.assetIdType(asset);
-  if (type.isNone || !type.unwrap().isXcm) {
-    throw new Error(`No asset type found for asset ${asset}`);
-  }
-  return type;
-}
-async function getVersionedAssetId(api, asset, chain) {
-  const assetId = asset.getAssetId();
-  const palletInstance = asset.getAssetPalletInstance();
-  if (assetId === chain.nativeAsset.originSymbol) {
-    return getNativeAssetId(palletInstance);
-  }
-  if (asset.hasOnlyAddress()) {
-    return getConcreteAssetIdWithAccountKey20(asset.address, palletInstance);
-  }
-  const assetType = await getAssetIdType(api, assetId);
-  const assetTypeObject = assetType.unwrap().asXcm.toJSON();
-  const normalizedAssetTypeObject = normalizeX1(XCM_VERSION, assetTypeObject);
-  return normalizeConcrete(XCM_VERSION, normalizedAssetTypeObject);
-}
 async function getFeeForXcmInstructionsAndAsset(api, instructions, versionedAssetId) {
   const xcmToWeightResult = await api.call.xcmPaymentApi.queryXcmWeight({
-    [XCM_VERSION]: instructions
+    [STABLE_XCM_VERSION]: instructions
   });
   if (!xcmToWeightResult.isOk) {
     throw new Error(
@@ -2390,68 +2331,342 @@ async function getFeeForXcmInstructionsAndAsset(api, instructions, versionedAsse
   }
   const xcmToWeight = xcmToWeightResult.asOk;
   const weightToForeignAssets = await api.call.xcmPaymentApi.queryWeightToAssetFee(xcmToWeight, {
-    [XCM_VERSION]: {
+    [STABLE_XCM_VERSION]: {
       ...versionedAssetId
     }
   });
   if (!weightToForeignAssets.isOk) {
-    throw new Error(
-      "There was an error trying to get the fee with the weight and asset (weightToForeignAssets)"
+    console.error(
+      "Error trying to get the fee with the weight and asset (weightToForeignAssets) with V4, retrying with V5"
     );
+    const weightToForeignAssetsV5 = await api.call.xcmPaymentApi.queryWeightToAssetFee(xcmToWeight, {
+      ["V5" /* v5 */]: {
+        ...versionedAssetId
+      }
+    });
+    if (!weightToForeignAssetsV5.isOk) {
+      throw new Error(
+        "There was an error trying to get the fee with the weight and asset (weightToForeignAssets). Make sure the asset is supported by XcmPaymentApi."
+      );
+    }
+    return weightToForeignAssetsV5.asOk.toBigInt();
   }
   return weightToForeignAssets.asOk.toBigInt();
 }
 
-// src/fee/FeeBuilder.ts
-function FeeBuilder() {
-  return {
-    xcmPaymentApi
-  };
-}
-function xcmPaymentApi() {
+// src/fee/VersionedAssetBuilder.ts
+import { Parachain } from "@moonbeam-network/xcm-types";
+function BuildVersionedAsset() {
   return {
-    xcmPaymentFee: ({
-      isAssetReserveChain,
-      shouldTransferAssetPrecedeFeeAsset = false
-    }) => ({
-      build: ({
-        address,
-        api,
-        asset,
-        destination,
-        feeAsset
-      }) => new SubstrateCallConfig({
-        api,
-        call: async () => {
-          const versionedFeeAssetId = await getVersionedAssetId(
-            api,
-            feeAsset,
-            destination
+    fromHere: (parents = 1) => ({
+      parents,
+      interior: "Here"
+    }),
+    fromAccountKey20: (asset) => ({
+      interior: {
+        X2: [
+          {
+            PalletInstance: asset.getAssetPalletInstance()
+          },
+          {
+            AccountKey20: {
+              key: asset.address,
+              network: null
+            }
+          }
+        ]
+      },
+      parents: "0"
+    }),
+    fromGeneralIndex: (asset) => ({
+      interior: {
+        X1: [{ GeneralIndex: asset.getAssetId() }]
+      },
+      parents: "0"
+    }),
+    fromGlobalConsensus: (asset) => ({
+      interior: {
+        X2: [
+          { GlobalConsensus: { Ethereum: { chainId: 1 } } },
+          { AccountKey20: { key: asset.address, network: null } }
+        ]
+      },
+      parents: 2
+    }),
+    fromPalletInstance: (asset) => {
+      validatePalletInstance(asset);
+      return {
+        interior: {
+          X1: [
+            {
+              PalletInstance: asset.getAssetPalletInstance()
+            }
+          ]
+        },
+        parents: "0"
+      };
+    },
+    fromPalletInstanceAndGeneralIndex: (asset) => {
+      validatePalletInstance(asset);
+      return {
+        interior: {
+          X2: [
+            {
+              PalletInstance: asset.getAssetPalletInstance()
+            },
+            { GeneralIndex: asset.getAssetId() }
+          ]
+        },
+        parents: "0"
+      };
+    },
+    fromSource: () => ({
+      accountKey20: (source, asset) => {
+        if (!(source instanceof Parachain)) {
+          throw new Error(
+            `Chain ${source.name} must be a Parachain to build versioned asset id for XcmPaymentApi fee calculation`
           );
-          const versionedTransferAssetId = await getVersionedAssetId(
-            api,
-            asset,
-            destination
+        }
+        const sourceAsset = source.getChainAsset(asset);
+        validatePalletInstance(sourceAsset);
+        return {
+          interior: {
+            X3: [
+              { Parachain: source.parachainId },
+              { PalletInstance: sourceAsset.getAssetPalletInstance() },
+              { AccountKey20: { key: sourceAsset.address, network: null } }
+            ]
+          },
+          parents: 1
+        };
+      },
+      palletInstance: (source, asset) => {
+        if (!(source instanceof Parachain)) {
+          throw new Error(
+            `Chain ${source.name} must be a Parachain to build versioned asset id for XcmPaymentApi fee calculation`
           );
-          const versionedAssets = shouldTransferAssetPrecedeFeeAsset ? [versionedTransferAssetId, versionedFeeAssetId] : [versionedFeeAssetId, versionedTransferAssetId];
-          const assets3 = feeAsset === asset ? [versionedFeeAssetId] : versionedAssets;
-          const instructions = [
-            isAssetReserveChain ? getWithdrawAssetInstruction(assets3) : getReserveAssetDepositedInstruction(assets3),
-            getClearOriginInstruction(),
-            getBuyExecutionInstruction(versionedFeeAssetId),
-            getDepositAssetInstruction(address, assets3),
-            getSetTopicInstruction()
-          ];
-          return getFeeForXcmInstructionsAndAsset(
-            api,
-            instructions,
-            versionedFeeAssetId
+        }
+        const sourceAsset = source.getChainAsset(asset);
+        validatePalletInstance(sourceAsset);
+        return {
+          interior: {
+            X2: [
+              { Parachain: source.parachainId },
+              {
+                PalletInstance: sourceAsset.getAssetPalletInstance()
+              }
+            ]
+          },
+          parents: 1
+        };
+      },
+      palletInstanceAndGeneralIndex: (source, asset) => {
+        if (!(source instanceof Parachain)) {
+          throw new Error(
+            `Chain ${source.name} must be a Parachain to build versioned asset id for XcmPaymentApi fee calculation`
           );
         }
-      })
+        const sourceAsset = source.getChainAsset(asset);
+        validatePalletInstance(sourceAsset);
+        return {
+          interior: {
+            X3: [
+              { Parachain: source.parachainId },
+              { PalletInstance: sourceAsset.getAssetPalletInstance() },
+              { GeneralIndex: sourceAsset.getAssetId() }
+            ]
+          },
+          parents: 1
+        };
+      }
     })
   };
 }
+function QueryVersionedAsset() {
+  return {
+    fromCurrencyIdToLocations: async (asset, api) => {
+      const result = await api.query.assetRegistry.currencyIdToLocations(
+        asset.getAssetRegisteredId()
+      );
+      if (!result || result.isEmpty) {
+        throw new Error(`No location found for asset ${asset.getSymbol()}`);
+      }
+      return result.toJSON();
+    },
+    fromAssetId: async (asset, api) => {
+      if (!asset.getAssetRegisteredId()) {
+        throw new Error(
+          `No asset registered id found for asset ${asset.getSymbol()}`
+        );
+      }
+      const assetManagerResult = await api.query.assetManager.assetIdType(asset.getAssetRegisteredId());
+      if (assetManagerResult.isNone || assetManagerResult.isEmpty || !assetManagerResult.unwrap().isXcm) {
+        const evmForeignAssetsResult = await api.query.evmForeignAssets.assetsById(asset.getAssetRegisteredId());
+        if (!evmForeignAssetsResult || evmForeignAssetsResult.isEmpty || evmForeignAssetsResult.isNone) {
+          throw new Error(`No asset type found for asset ${asset.getSymbol()}`);
+        }
+        return evmForeignAssetsResult.unwrapOrDefault().toJSON();
+      }
+      return normalizeX1(
+        STABLE_XCM_VERSION,
+        assetManagerResult.unwrapOrDefault().asXcm.toJSON()
+      );
+    }
+  };
+}
+var validatePalletInstance = (asset) => {
+  if (!asset.getAssetPalletInstance()) {
+    throw new Error(
+      `No pallet instance configured for the asset ${asset.key} for XcmPaymentApi fee calculation`
+    );
+  }
+};
+
+// src/fee/xcmPaymentApi/xcmPaymentApi.utils.ts
+async function getVersionedAssets({
+  getVersionedFeeAsset,
+  getVersionedTransferAsset,
+  options,
+  params
+}) {
+  const { asset: transferAsset, feeAsset } = params;
+  const versionedFeeAssetId = await getVersionedFeeAsset(params);
+  const assets3 = [versionedFeeAssetId];
+  if (feeAsset !== transferAsset && getVersionedTransferAsset) {
+    const versionedTransferAssetId = await getVersionedTransferAsset(params);
+    if (options.shouldTransferAssetPrecedeFeeAsset) {
+      assets3.unshift(versionedTransferAssetId);
+    } else {
+      assets3.push(versionedTransferAssetId);
+    }
+  }
+  return [assets3, versionedFeeAssetId];
+}
+function getInstructions({
+  isAssetReserveChain,
+  assets: assets3,
+  versionedFeeAssetId,
+  address
+}) {
+  return [
+    isAssetReserveChain ? getWithdrawAssetInstruction(assets3) : getReserveAssetDepositedInstruction(assets3),
+    getClearOriginInstruction(),
+    getBuyExecutionInstruction(versionedFeeAssetId),
+    getDepositAssetInstruction(address, assets3),
+    getSetTopicInstruction()
+  ];
+}
+
+// src/fee/xcmPaymentApi/xcmPaymentApi.ts
+function xcmPaymentApi() {
+  const localMethods = {
+    fromHere: (options) => createXcmFeeBuilder({
+      getVersionedFeeAsset: () => BuildVersionedAsset().fromHere(options.parents),
+      options
+    }),
+    fromHereAndGeneralIndex: (options) => createXcmFeeBuilder({
+      getVersionedFeeAsset: () => BuildVersionedAsset().fromHere(),
+      getVersionedTransferAsset: ({ asset }) => BuildVersionedAsset().fromPalletInstanceAndGeneralIndex(asset),
+      options
+    }),
+    fromPalletInstanceAndGeneralIndex: (options) => createXcmFeeBuilder({
+      getVersionedFeeAsset: ({ feeAsset }) => BuildVersionedAsset().fromPalletInstanceAndGeneralIndex(feeAsset),
+      options
+    }),
+    fromHereAndSourceGeneralIndex: (options) => createXcmFeeBuilder({
+      getVersionedFeeAsset: () => BuildVersionedAsset().fromHere(),
+      getVersionedTransferAsset: ({ source, asset }) => BuildVersionedAsset().fromSource().palletInstanceAndGeneralIndex(source, asset),
+      options
+    }),
+    fromGeneralIndex: (options) => createXcmFeeBuilder({
+      getVersionedFeeAsset: ({ feeAsset }) => BuildVersionedAsset().fromGeneralIndex(feeAsset),
+      options
+    }),
+    fromPalletInstance: (options) => createXcmFeeBuilder({
+      getVersionedFeeAsset: ({ feeAsset }) => BuildVersionedAsset().fromPalletInstance(feeAsset),
+      options
+    }),
+    fromPalletInstanceAndAccountKey20: (options) => createXcmFeeBuilder({
+      getVersionedFeeAsset: ({ feeAsset }) => BuildVersionedAsset().fromPalletInstance(feeAsset),
+      getVersionedTransferAsset: ({ asset }) => BuildVersionedAsset().fromAccountKey20(asset),
+      options
+    }),
+    fromGlobalConsensus: (options) => createXcmFeeBuilder({
+      getVersionedFeeAsset: ({ feeAsset }) => BuildVersionedAsset().fromGlobalConsensus(feeAsset),
+      options
+    })
+  };
+  const sourceMethods = {
+    fromSourceAccountKey20: (options) => createXcmFeeBuilder({
+      getVersionedFeeAsset: ({ source, asset }) => BuildVersionedAsset().fromSource().accountKey20(source, asset),
+      options
+    }),
+    fromSourcePalletInstance: (options) => createXcmFeeBuilder({
+      getVersionedFeeAsset: ({ source, feeAsset }) => BuildVersionedAsset().fromSource().palletInstance(source, feeAsset),
+      options
+    })
+  };
+  const queryMethods = {
+    fromCurrencyIdToLocations: (options) => createXcmFeeBuilder({
+      getVersionedFeeAsset: async ({ feeAsset, api }) => {
+        return await QueryVersionedAsset().fromCurrencyIdToLocations(
+          feeAsset,
+          api
+        );
+      },
+      options
+    }),
+    fromAssetIdQuery: (options) => createXcmFeeBuilder({
+      getVersionedFeeAsset: async ({ feeAsset, api }) => {
+        return await QueryVersionedAsset().fromAssetId(feeAsset, api);
+      },
+      getVersionedTransferAsset: async ({ asset, api }) => {
+        return await QueryVersionedAsset().fromAssetId(asset, api);
+      },
+      options
+    })
+  };
+  return {
+    ...localMethods,
+    ...sourceMethods,
+    ...queryMethods
+  };
+}
+var createXcmFeeBuilder = ({
+  getVersionedFeeAsset,
+  getVersionedTransferAsset,
+  options
+}) => ({
+  build: (params) => new SubstrateCallConfig({
+    api: params.api,
+    call: async () => {
+      const [assets3, versionedFeeAssetId] = await getVersionedAssets({
+        getVersionedFeeAsset,
+        getVersionedTransferAsset,
+        options,
+        params
+      });
+      const instructions = getInstructions({
+        isAssetReserveChain: options.isAssetReserveChain,
+        assets: assets3,
+        versionedFeeAssetId,
+        address: params.address
+      });
+      return getFeeForXcmInstructionsAndAsset(
+        params.api,
+        instructions,
+        versionedFeeAssetId
+      );
+    }
+  })
+});
+
+// src/fee/FeeBuilder.ts
+function FeeBuilder() {
+  return {
+    xcmPaymentApi
+  };
+}
 
 // src/mrl/providers/wormhole/contract/Batch/Batch.ts
 import {
@@ -2464,7 +2679,7 @@ import { encodeFunctionData as encodeFunctionData2, maxUint64 } from "viem";
 // src/mrl/providers/wormhole/extrinsic/polkadotXcm/polkadotXcm.ts
 import {
   AssetAmount,
-  Parachain
+  Parachain as Parachain2
 } from "@moonbeam-network/xcm-types";
 import { getMultilocationDerivedAddresses } from "@moonbeam-network/xcm-utils";
 var BUY_EXECUTION_FEE = 100000000000000000n;
@@ -2493,7 +2708,7 @@ function polkadotXcm2() {
         if (!sourceApi) {
           throw new Error("Source API needs to be defined");
         }
-        if (!Parachain.is(source)) {
+        if (!Parachain2.is(source)) {
           throw new Error("Source chain needs to be a parachain");
         }
         const { address20: computedOriginAccount } = getMultilocationDerivedAddresses({
@@ -3349,7 +3564,7 @@ function getCurrencies({ source, moonAsset, asset }) {
 }
 
 // src/mrl/providers/wormhole/contract/Gmp/Gmp.ts
-import { u8aToHex as u8aToHex5 } from "@polkadot/util";
+import { u8aToHex as u8aToHex6 } from "@polkadot/util";
 
 // src/mrl/providers/wormhole/contract/Gmp/GmpAbi.ts
 var GMP_ABI = [
@@ -3375,7 +3590,7 @@ function Gmp() {
   return {
     wormholeTransferERC20: () => ({
       build: ({ bytes }) => {
-        const hex = u8aToHex5(bytes);
+        const hex = u8aToHex6(bytes);
         return new ContractConfig({
           address: GMP_CONTRACT_ADDRESS,
           abi: GMP_ABI,
@@ -3392,7 +3607,7 @@ function Gmp() {
 import { convertAddressTo32Bytes } from "@moonbeam-network/xcm-utils";
 
 // src/mrl/providers/wormhole/wormhole/wormhole.ts
-import { EvmChain, EvmParachain as EvmParachain3, Parachain as Parachain2 } from "@moonbeam-network/xcm-types";
+import { EvmChain, EvmParachain as EvmParachain3, Parachain as Parachain3 } from "@moonbeam-network/xcm-types";
 import { getMultilocationDerivedAddresses as getMultilocationDerivedAddresses3 } from "@moonbeam-network/xcm-utils";
 import { evmToAddress as evmToAddress4 } from "@polkadot/util-crypto/address";
 import { Wormhole as Wormhole2 } from "@wormhole-foundation/sdk-connect";
@@ -3414,7 +3629,20 @@ var WormholeConfig = class _WormholeConfig {
 import { Wormhole } from "@wormhole-foundation/sdk-connect";
 import { EvmPlatform } from "@wormhole-foundation/sdk-evm";
 function wormholeFactory(chain) {
-  return new Wormhole(chain.isTestChain ? "Testnet" : "Mainnet", [EvmPlatform]);
+  return new Wormhole(
+    chain.isTestChain ? "Testnet" : "Mainnet",
+    [EvmPlatform],
+    {
+      chains: {
+        Ethereum: {
+          rpc: "https://eth.llamarpc.com"
+        },
+        Moonbeam: {
+          rpc: "https://rpc.api.moonbeam.network"
+        }
+      }
+    }
+  );
 }
 
 // src/mrl/providers/wormhole/wormhole/wormhole.ts
@@ -3431,7 +3659,7 @@ function wormhole() {
         source,
         sourceAddress
       }) => {
-        const isSourceParachain = Parachain2.is(source);
+        const isSourceParachain = Parachain3.is(source);
         const isDestinationMoonChain = destination.isEqual(moonChain);
         const isDestinationEvmChain = EvmChain.is(destination);
         const isNativeAsset = asset.isSame(