@moonbeam-network/xcm-builder 1.0.0-dev.16 → 1.0.0-dev.160

package/build/index.mjs

@@ -1,2 +1,4481 @@
-import"@polkadot/api-augment";var p=(t=>(t.Evm="Evm",t.Substrate="Substrate",t))(p||{});var u=class{module;func;type;constructor({module:r,func:t,type:n}){this.module=r,this.func=t,this.type=n}};var c=class extends u{args;transform;constructor({args:r=[],transform:t,type:n="Substrate",...i}){super({...i,type:n}),this.args=r,this.transform=t}};function Z(){return{assetRegistry:F,assets:O}}function F(){let e="assetRegistry";return{assetMetadatas:()=>({build:({asset:r})=>new c({module:e,func:"assetMetadatas",args:[r],transform:async t=>t.unwrapOrDefault().minimalBalance.toBigInt()})}),currencyMetadatas:()=>({build:({asset:r})=>new c({module:e,func:"currencyMetadatas",args:[r],transform:async t=>t.unwrapOrDefault().minimalBalance.toBigInt()})})}}function O(){return{asset:()=>({build:({asset:e})=>new c({module:"assets",func:"asset",args:[e],transform:async r=>r.unwrapOrDefault().minBalance.toBigInt()})})}}import{isString as W}from"@polkadot/util";import{formatAssetIdToERC20 as C}from"@moonbeam-network/xcm-utils";import{isString as b,u8aToHex as M}from"@polkadot/util";import{decodeAddress as D}from"@polkadot/util-crypto";var m=class extends u{args;address;constructor({args:r,address:t,...n}){super({...n,type:"Evm"}),this.args=r,this.address=t}};function E(){return{transfer:(e=4e9)=>({build:({address:r,amount:t,asset:n,destination:i})=>new m({args:[b(n)?C(n):n,t,h(r,i),e],func:"transfer",module:"Xtokens"})}),transferMultiCurrencies:(e=4e9)=>({build:({address:r,amount:t,asset:n,destination:i,fee:o,feeAsset:s})=>new m({args:[[[b(n)?C(n):n,t],[b(s)?C(s):s,o]],1,h(r,i),e],func:"transferMultiCurrencies",module:"Xtokens"})})}}function h(e,r){let n=`0x${r.isEvmParachain()?"03":"01"}${M(D(e),-1,!1)}00`;return[1,r.parachainId?[`0x0000000${r.parachainId.toString(16)}`,n]:[n]]}function xr(){return{Xtokens:E}}function wr(){return{evm:_,substrate:K}}function _(){return{erc20:R}}function K(){return{assets:q,system:V,tokens:U}}function R(){return{build:({address:e,asset:r})=>{if(!r||!W(r))throw new Error(`Invalid contract address: ${r}`);return new m({address:r,args:[e],func:"balanceOf",module:"Erc20"})}}}function q(){return{account:()=>({build:({address:e,asset:r})=>new c({module:"assets",func:"account",args:[r,e],transform:async t=>t.unwrapOrDefault().balance.toBigInt()})})}}function V(){return{account:()=>({build:({address:e})=>new c({module:"system",func:"account",args:[e],transform:async r=>{let t=r.data,n=t.miscFrozen??t.frozen;return BigInt(t.free.sub(n).toString())}})}),accountEquilibrium:()=>({build:({address:e,asset:r})=>new c({module:"system",func:"account",args:[e],transform:async t=>{var s;if(t.data.isEmpty)return 0n;let n=t.data.toJSON(),i;if(Array.isArray(n)&&(i=n),Array.isArray((s=n==null?void 0:n.v0)==null?void 0:s.balance)&&(i=n.v0.balance),!i)throw new Error("Can't get balance from Equilibrium chain");let o=i.find(([d])=>d===r);return o?BigInt(o[1].positive):0n}})})}}function U(){return{accounts:()=>({build:({address:e,asset:r})=>new c({module:"tokens",func:"accounts",args:[e,r],transform:async({free:t,frozen:n})=>BigInt(t.sub(n).toString())})})}}var a=class extends u{getArgs;constructor({getArgs:r,...t}){super({...t,type:"Substrate"}),this.getArgs=r}};var w="eqBalances";function I(){return{xcmTransfer:()=>({build:({address:e,amount:r,asset:t,destination:n})=>new a({module:w,func:"xcmTransfer",getArgs:()=>[t,r,{parents:1,interior:{X2:[{Parachain:n.parachainId},{AccountKey20:{network:"Any",key:e}}]}},"ThisAccWillPay"]})}),transferXcm:()=>({build:({address:e,amount:r,asset:t,destination:n,fee:i,feeAsset:o})=>new a({module:w,func:"transferXcm",getArgs:()=>{let s=r-i>0n?r-i:0n;return[[t,t===o?s:r],[o,i],{parents:1,interior:{X2:[{Parachain:n.parachainId},{AccountKey20:{network:"Any",key:e}}]}}]}})})}}import{getTypeDef as z}from"@polkadot/types";var A=(n=>(n.v1="V1",n.v2="V2",n.v3="V3",n))(A||{});function f(e,r=0){if(!e)return"V1";let{type:t}=e.meta.args[r],n=e.meta.registry.createType(t.toString()),i=z(n==null?void 0:n.toRawType());if(!i.sub)return"V1";let o=Array.isArray(i.sub)?i.sub.map(s=>s.name):[i.sub.name];if(o.includes("V1"))return"V1";if(o.includes("V2"))return"V2";if(o.includes("V3"))return"V3";throw new Error("Can't find Xcm version")}function l({asset:e,address:r,destination:t,func:n,parents:i=1}){let o=f(n);return[{[o]:{parents:i,interior:{X1:{Parachain:t.parachainId}}}},{[o]:{parents:0,interior:{X1:{AccountKey20:{network:"Any",key:r}}}}},{[o]:e},0,"Unlimited"]}var g="polkadotXcm";function T(){return{limitedReserveTransferAssets:()=>{let e="limitedReserveTransferAssets";return{here:()=>({build:r=>new a({module:g,func:e,getArgs:t=>l({...r,func:t,asset:[{id:{Concrete:{parents:0,interior:"Here"}},fun:{Fungible:r.amount}}]})})}),X1:()=>({build:r=>new a({module:g,func:e,getArgs:t=>l({...r,func:t,asset:[{id:{Concrete:{parents:0,interior:{X1:{PalletInstance:r.palletInstance}}}},fun:{Fungible:r.amount}}]})})}),X2:()=>({build:r=>new a({module:g,func:e,getArgs:t=>l({...r,func:t,asset:[{id:{Concrete:{parents:0,interior:{X2:[{PalletInstance:r.palletInstance},{GeneralIndex:r.asset}]}}},fun:{Fungible:r.amount}}]})})})}},limitedReserveWithdrawAssets:()=>{let e="limitedReserveWithdrawAssets";return{X2:()=>({build:r=>new a({module:g,func:e,getArgs:t=>l({...r,func:t,asset:[{id:{Concrete:{parents:1,interior:{X2:[{Parachain:r.destination.parachainId},{PalletInstance:r.palletInstance}]}}},fun:{Fungible:r.amount}}]})})})}}}}function P(e,r){var n;let t=(n=r==null?void 0:r.meta.args.at(-1))==null?void 0:n.type;return t?t.eq("XcmV2WeightLimit")?{Limited:e}:t.eq("XcmV3WeightLimit")?"Unlimited":e:e}var x="xTokens";function X(){return{transfer:()=>({build:({address:e,amount:r,asset:t,destination:n,source:i})=>new a({module:x,func:"transfer",getArgs:o=>{let s=f(o,2);return[t,r,{[s]:{parents:1,interior:{X2:[{Parachain:n.parachainId},{AccountKey20:{network:"Any",key:e}}]}}},P(i.weight,o)]}})}),transferMultiAsset:e=>{let r="transferMultiasset";return{X1:()=>({build:({address:t,amount:n,destination:i})=>new a({module:x,func:r,getArgs:o=>{let s=f(o,1);return[{[s]:{id:{Concrete:{parents:1,interior:{X1:{Parachain:e}}}},fun:{Fungible:n}}},{[s]:{parents:1,interior:{X2:[{Parachain:i.parachainId},{AccountKey20:{network:"Any",key:t}}]}}},"Unlimited"]}})}),X2:()=>({build:({address:t,amount:n,asset:i,destination:o,source:s})=>new a({module:x,func:r,getArgs:d=>{let B=f(d,1);return[{[B]:{id:{Concrete:{parents:1,interior:{X2:[{Parachain:e},{GeneralKey:i}]}}},fun:{Fungible:n}}},{[B]:{parents:1,interior:{X2:[{Parachain:o.parachainId},{AccountKey20:{network:"Any",key:t}}]}}},P(s.weight,d)]}})})}},transferMultiCurrencies:()=>({build:({address:e,amount:r,asset:t,destination:n,fee:i,feeAsset:o})=>new a({module:x,func:"transferMulticurrencies",getArgs:()=>[[[t,r],[o,i]],1,{["V3"]:{parents:1,interior:{X2:[{Parachain:n.parachainId},{AccountKey20:{key:e}}]}}},"Unlimited"]})})}}var k="xTransfer";function S(){return{transfer:()=>{let e="transfer";return{here:()=>({build:({address:r,amount:t,destination:n})=>new a({module:k,func:e,getArgs:()=>[{id:{Concrete:{parents:0,interior:"Here"}},fun:{Fungible:t}},{parents:1,interior:{X2:[{Parachain:n.parachainId},{AccountKey20:{key:r}}]}},{refTime:5e9,proofSize:0}]})}),X2:()=>({build:({address:r,amount:t,destination:n,palletInstance:i})=>new a({module:k,func:e,getArgs:()=>[{id:{Concrete:{parents:1,interior:{X2:[{Parachain:n.parachainId},{PalletInstance:i}]}}},fun:{Fungible:t||1n}},{parents:1,interior:{X2:[{Parachain:n.parachainId},{AccountKey20:{key:r}}]}},{refTime:5e9,proofSize:0}]})})}}}}var L="xcmPallet";function v(){return{limitedReserveTransferAssets:(e=1)=>{let r="limitedReserveTransferAssets";return{here:()=>({build:t=>new a({module:L,func:r,getArgs:n=>l({...t,parents:e,func:n,asset:[{id:{Concrete:{parents:0,interior:"Here"}},fun:{Fungible:t.amount}}]})})})}}}}function At(){return{eqBalances:I,xTokens:X,xTransfer:S,polkadotXcm:T,xcmPallet:v}}var y=class{api;call;type="Substrate";constructor({api:r,call:t}){this.api=r,this.call=t}};function kt(){return{assetManager:$}}function $(){return{assetTypeUnitsPerSecond:(e=1e9)=>({build:({api:r,asset:t})=>new y({api:r,call:async()=>{let n=await r.query.assetManager.assetIdType(t);if(n.isNone)throw new Error(`No asset type found for asset ${t}`);let i=n.unwrap(),s=(await r.query.assetManager.assetTypeUnitsPerSecond(i)).unwrapOrDefault().toBigInt();return BigInt(e)*s/BigInt(10**12)}})})}}export{Z as AssetMinBuilder,wr as BalanceBuilder,u as BaseConfig,p as CallType,xr as ContractBuilder,m as ContractConfig,At as ExtrinsicBuilder,a as ExtrinsicConfig,kt as FeeBuilder,c as SubstrateQueryConfig,A as XcmVersion,_ as evm,K as substrate};
+// src/index.ts
+import "@polkadot/api-augment";
+
+// src/extrinsic/ExtrinsicBuilder.utils.ts
+import { getTypeDef } from "@polkadot/types";
+import { u8aToHex } from "@polkadot/util";
+import { decodeAddress } from "@polkadot/util-crypto";
+
+// src/extrinsic/ExtrinsicBuilder.interfaces.ts
+var XcmVersion = /* @__PURE__ */ ((XcmVersion2) => {
+  XcmVersion2["v1"] = "V1";
+  XcmVersion2["v2"] = "V2";
+  XcmVersion2["v3"] = "V3";
+  XcmVersion2["v4"] = "V4";
+  XcmVersion2["v5"] = "V5";
+  return XcmVersion2;
+})(XcmVersion || {});
+
+// src/extrinsic/ExtrinsicBuilder.utils.ts
+function getExtrinsicArgumentVersion(func, index = 0) {
+  if (!func) return "V1" /* v1 */;
+  const { type } = func.meta.args[index];
+  const instance = func.meta.registry.createType(type.toString());
+  const raw = getTypeDef(instance?.toRawType());
+  if (!raw.sub) {
+    return "V1" /* v1 */;
+  }
+  const versions = Array.isArray(raw.sub) ? raw.sub.map((x) => x.name) : [raw.sub.name];
+  if (versions.includes("V5" /* v5 */)) {
+    return "V5" /* v5 */;
+  }
+  if (versions.includes("V4" /* v4 */)) {
+    return "V4" /* v4 */;
+  }
+  if (versions.includes("V3" /* v3 */)) {
+    return "V3" /* v3 */;
+  }
+  if (versions.includes("V2" /* v2 */)) {
+    return "V2" /* v2 */;
+  }
+  if (versions.includes("V1" /* v1 */)) {
+    return "V1" /* v1 */;
+  }
+  throw new Error("Can't find XCM version");
+}
+function getExtrinsicAccount(address) {
+  const isEthAddress = address.length === 42 && address.startsWith("0x");
+  return isEthAddress ? {
+    AccountKey20: {
+      key: address
+    }
+  } : {
+    AccountId32: {
+      id: u8aToHex(decodeAddress(address)),
+      network: null
+    }
+  };
+}
+function isXcmV4(xcmVersion) {
+  return xcmVersion >= "V4" /* v4 */;
+}
+function normalizeX1(xcmVersion, versionedObject) {
+  if (!isXcmV4(xcmVersion)) return versionedObject;
+  const normalizedObject = { ...versionedObject };
+  const interior = normalizedObject.interior;
+  if ("X1" in interior && interior?.X1 && !Array.isArray(interior.X1)) {
+    interior.X1 = [interior.X1];
+  } else if ("x1" in interior && interior?.x1 && !Array.isArray(interior.x1)) {
+    interior.x1 = [interior.x1];
+  }
+  return normalizedObject;
+}
+function normalizeConcrete(xcmVersion, versionedObject) {
+  return isXcmV4(xcmVersion) ? versionedObject : applyConcreteWrapper(versionedObject);
+}
+function applyConcreteWrapper(versionedObject) {
+  return {
+    Concrete: { ...versionedObject }
+  };
+}
+
+// src/types/BaseConfig.ts
+var BaseConfig = class {
+  module;
+  func;
+  constructor({ module: module5, func }) {
+    this.module = module5;
+    this.func = func;
+  }
+};
+
+// src/types/substrate/SubstrateQueryConfig.ts
+var SubstrateQueryConfig = class _SubstrateQueryConfig extends BaseConfig {
+  args;
+  transform;
+  static is(obj) {
+    return obj instanceof _SubstrateQueryConfig;
+  }
+  constructor({
+    args = [],
+    transform,
+    ...other
+  }) {
+    super({ ...other });
+    this.args = args;
+    this.transform = transform;
+  }
+};
+
+// src/asset-min/AssetMinBuilder.ts
+function AssetMinBuilder() {
+  return {
+    assetRegistry,
+    assets,
+    foreignAssets
+  };
+}
+function assetRegistry() {
+  const pallet6 = "assetRegistry";
+  return {
+    assetMetadatas: () => ({
+      build: ({ asset }) => new SubstrateQueryConfig({
+        module: pallet6,
+        func: "assetMetadatas",
+        args: [asset],
+        // biome-ignore lint/suspicious/noExplicitAny: not sure how to fix this
+        transform: async (response) => response.unwrapOrDefault().minimalBalance.toBigInt()
+      })
+    }),
+    currencyMetadatas: () => ({
+      build: ({ asset }) => new SubstrateQueryConfig({
+        module: pallet6,
+        func: "currencyMetadatas",
+        args: [asset],
+        // biome-ignore lint/suspicious/noExplicitAny: not sure how to fix this
+        transform: async (response) => response.unwrapOrDefault().minimalBalance.toBigInt()
+      })
+    })
+  };
+}
+function assets() {
+  return {
+    asset: () => ({
+      build: ({ asset }) => new SubstrateQueryConfig({
+        module: "assets",
+        func: "asset",
+        args: [asset],
+        transform: async (response) => response.unwrapOrDefault().minBalance.toBigInt()
+      })
+    })
+  };
+}
+function foreignAssets() {
+  return {
+    asset: () => ({
+      build: ({ address }) => {
+        if (!address) {
+          throw new Error(
+            "Asset address is missing for foreignAssets.asset min calculation"
+          );
+        }
+        const multilocation = {
+          parents: 2,
+          interior: {
+            X2: [
+              {
+                globalconsensus: {
+                  ethereum: {
+                    chainId: 1
+                  }
+                }
+              },
+              getExtrinsicAccount(address)
+            ]
+          }
+        };
+        return new SubstrateQueryConfig({
+          module: "foreignAssets",
+          func: "asset",
+          args: [multilocation],
+          transform: async (response) => response.unwrapOrDefault().minBalance.toBigInt()
+        });
+      }
+    })
+  };
+}
+
+// src/balance/BalanceBuilder.ts
+import { evmToAddress as evmToAddress2 } from "@polkadot/util-crypto";
+
+// src/types/evm/ContractConfig.ts
+import { encodeFunctionData } from "viem";
+var ContractConfig = class _ContractConfig extends BaseConfig {
+  address;
+  abi;
+  // biome-ignore lint/suspicious/noExplicitAny: not sure how to fix this
+  args;
+  static is(obj) {
+    return obj instanceof _ContractConfig;
+  }
+  constructor({
+    address,
+    abi,
+    args,
+    ...other
+  }) {
+    super({ ...other });
+    this.address = address;
+    this.abi = abi;
+    this.args = args;
+  }
+  encodeFunctionData() {
+    return encodeFunctionData({
+      abi: this.abi,
+      functionName: this.func,
+      args: this.args
+    });
+  }
+};
+
+// src/contract/contracts/Xtokens/Xtokens.ts
+import { formatAssetIdToERC20 } from "@moonbeam-network/xcm-utils";
+import { u8aToHex as u8aToHex3 } from "@polkadot/util";
+import { decodeAddress as decodeAddress3, evmToAddress } from "@polkadot/util-crypto";
+
+// src/builder.utils.ts
+import { EvmParachain } from "@moonbeam-network/xcm-types";
+import { u8aToHex as u8aToHex2 } from "@polkadot/util";
+import { decodeAddress as decodeAddress2 } from "@polkadot/util-crypto";
+function getPrecompileDestinationInterior(destination, address) {
+  if (!address) {
+    return [`0x0000000${destination.parachainId.toString(16)}`];
+  }
+  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];
+}
+
+// src/contract/contracts/Xtokens/XtokensABI.ts
+var XTOKENS_ABI = [
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "currencyAddress",
+        type: "address"
+      },
+      {
+        internalType: "uint256",
+        name: "amount",
+        type: "uint256"
+      },
+      {
+        components: [
+          {
+            internalType: "uint8",
+            name: "parents",
+            type: "uint8"
+          },
+          {
+            internalType: "bytes[]",
+            name: "interior",
+            type: "bytes[]"
+          }
+        ],
+        internalType: "struct Xtokens.Multilocation",
+        name: "destination",
+        type: "tuple"
+      },
+      {
+        internalType: "uint64",
+        name: "weight",
+        type: "uint64"
+      }
+    ],
+    name: "transfer",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        components: [
+          {
+            internalType: "address",
+            name: "currencyAddress",
+            type: "address"
+          },
+          {
+            internalType: "uint256",
+            name: "amount",
+            type: "uint256"
+          }
+        ],
+        internalType: "struct Xtokens.Currency[]",
+        name: "currencies",
+        type: "tuple[]"
+      },
+      {
+        internalType: "uint32",
+        name: "feeItem",
+        type: "uint32"
+      },
+      {
+        components: [
+          {
+            internalType: "uint8",
+            name: "parents",
+            type: "uint8"
+          },
+          {
+            internalType: "bytes[]",
+            name: "interior",
+            type: "bytes[]"
+          }
+        ],
+        internalType: "struct Xtokens.Multilocation",
+        name: "destination",
+        type: "tuple"
+      },
+      {
+        internalType: "uint64",
+        name: "weight",
+        type: "uint64"
+      }
+    ],
+    name: "transferMultiCurrencies",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
+
+// src/contract/contracts/Xtokens/Xtokens.ts
+var U_64_MAX = 18446744073709551615n;
+var XTOKENS_CONTRACT_ADDRESS = "0x0000000000000000000000000000000000000804";
+function Xtokens() {
+  return {
+    transfer: (weight = U_64_MAX) => ({
+      build: ({ destinationAddress, asset, destination }) => new ContractConfig({
+        address: XTOKENS_CONTRACT_ADDRESS,
+        abi: XTOKENS_ABI,
+        args: [
+          asset.address ? formatAssetIdToERC20(asset.address) : asset.getAssetId(),
+          asset.amount,
+          getDestinationMultilocation(destinationAddress, destination),
+          weight
+        ],
+        func: "transfer",
+        module: "Xtokens"
+      })
+    }),
+    transferMultiCurrencies: (weight = U_64_MAX) => ({
+      build: ({ asset, destination, destinationAddress, fee }) => new ContractConfig({
+        address: XTOKENS_CONTRACT_ADDRESS,
+        abi: XTOKENS_ABI,
+        args: [
+          [
+            [
+              asset.address ? formatAssetIdToERC20(asset.address) : asset.getAssetId(),
+              asset.amount
+            ],
+            [
+              fee.address ? formatAssetIdToERC20(fee.address) : fee.getAssetId(),
+              fee.amount
+            ]
+          ],
+          1,
+          // index of the fee asset
+          getDestinationMultilocation(destinationAddress, destination),
+          weight
+        ],
+        func: "transferMultiCurrencies",
+        module: "Xtokens"
+      })
+    }),
+    transferWithEvmTo32: (weight = U_64_MAX) => ({
+      build: ({ destinationAddress, asset, destination }) => {
+        const multilocation = getDestinationMultilocationForPrecompileDestination(
+          destinationAddress,
+          destination
+        );
+        return new ContractConfig({
+          address: XTOKENS_CONTRACT_ADDRESS,
+          abi: XTOKENS_ABI,
+          args: [
+            asset.address ? formatAssetIdToERC20(asset.address) : asset.getAssetId(),
+            asset.amount,
+            multilocation,
+            weight
+          ],
+          func: "transfer",
+          module: "Xtokens"
+        });
+      }
+    })
+  };
+}
+function getDestinationMultilocationForPrecompileDestination(address, destination) {
+  const accountType = "01";
+  const substrateAddress = evmToAddress(address);
+  const acc = `0x${accountType}${u8aToHex3(
+    decodeAddress3(substrateAddress),
+    -1,
+    false
+  )}00`;
+  return [
+    1,
+    destination.parachainId ? [`0x0000000${destination.parachainId.toString(16)}`, acc] : [acc]
+  ];
+}
+function getDestinationMultilocation(address, destination) {
+  const interior = getPrecompileDestinationInterior(destination, address);
+  return [1, interior];
+}
+
+// src/contract/ContractBuilder.ts
+function ContractBuilder() {
+  return {
+    Xtokens
+  };
+}
+
+// src/types/evm/EvmQueryConfig.ts
+var EvmQueryConfig = class _EvmQueryConfig {
+  args;
+  func;
+  static is(obj) {
+    return obj instanceof _EvmQueryConfig;
+  }
+  constructor({ args, func }) {
+    this.args = args;
+    this.func = func;
+  }
+};
+
+// src/balance/Erc20Abi.ts
+var ERC20_ABI = [
+  {
+    constant: true,
+    inputs: [],
+    name: "name",
+    outputs: [
+      {
+        name: "",
+        type: "string"
+      }
+    ],
+    payable: false,
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    constant: false,
+    inputs: [
+      {
+        name: "_spender",
+        type: "address"
+      },
+      {
+        name: "_value",
+        type: "uint256"
+      }
+    ],
+    name: "approve",
+    outputs: [
+      {
+        name: "",
+        type: "bool"
+      }
+    ],
+    payable: false,
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: "totalSupply",
+    outputs: [
+      {
+        name: "",
+        type: "uint256"
+      }
+    ],
+    payable: false,
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    constant: false,
+    inputs: [
+      {
+        name: "_from",
+        type: "address"
+      },
+      {
+        name: "_to",
+        type: "address"
+      },
+      {
+        name: "_value",
+        type: "uint256"
+      }
+    ],
+    name: "transferFrom",
+    outputs: [
+      {
+        name: "",
+        type: "bool"
+      }
+    ],
+    payable: false,
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: "decimals",
+    outputs: [
+      {
+        name: "",
+        type: "uint8"
+      }
+    ],
+    payable: false,
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    constant: true,
+    inputs: [
+      {
+        name: "_owner",
+        type: "address"
+      }
+    ],
+    name: "balanceOf",
+    outputs: [
+      {
+        name: "balance",
+        type: "uint256"
+      }
+    ],
+    payable: false,
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: "symbol",
+    outputs: [
+      {
+        name: "",
+        type: "string"
+      }
+    ],
+    payable: false,
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    constant: false,
+    inputs: [
+      {
+        name: "_to",
+        type: "address"
+      },
+      {
+        name: "_value",
+        type: "uint256"
+      }
+    ],
+    name: "transfer",
+    outputs: [
+      {
+        name: "",
+        type: "bool"
+      }
+    ],
+    payable: false,
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    constant: true,
+    inputs: [
+      {
+        name: "_owner",
+        type: "address"
+      },
+      {
+        name: "_spender",
+        type: "address"
+      }
+    ],
+    name: "allowance",
+    outputs: [
+      {
+        name: "",
+        type: "uint256"
+      }
+    ],
+    payable: false,
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    payable: true,
+    stateMutability: "payable",
+    type: "fallback"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        name: "owner",
+        type: "address"
+      },
+      {
+        indexed: true,
+        name: "spender",
+        type: "address"
+      },
+      {
+        indexed: false,
+        name: "value",
+        type: "uint256"
+      }
+    ],
+    name: "Approval",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        name: "from",
+        type: "address"
+      },
+      {
+        indexed: true,
+        name: "to",
+        type: "address"
+      },
+      {
+        indexed: false,
+        name: "value",
+        type: "uint256"
+      }
+    ],
+    name: "Transfer",
+    type: "event"
+  }
+];
+
+// src/balance/BalanceBuilder.ts
+function BalanceBuilder() {
+  return {
+    evm,
+    substrate
+  };
+}
+function evm() {
+  return {
+    erc20,
+    native
+  };
+}
+function erc20() {
+  return {
+    build: ({ asset, address }) => {
+      if (!asset.address) {
+        throw new Error(`Asset ${asset.key} has no address`);
+      }
+      return new ContractConfig({
+        address: asset.address,
+        abi: ERC20_ABI,
+        args: [address],
+        func: "balanceOf",
+        module: "Erc20"
+      });
+    }
+  };
+}
+function native() {
+  return {
+    build: ({ address }) => {
+      return new EvmQueryConfig({
+        func: "getBalance",
+        args: [{ address }]
+      });
+    }
+  };
+}
+function substrate() {
+  return {
+    assets: assets2,
+    foreignAssets: foreignAssets2,
+    system,
+    tokens
+  };
+}
+function assets2() {
+  return {
+    account: () => ({
+      build: ({ address, asset }) => new SubstrateQueryConfig({
+        module: "assets",
+        func: "account",
+        args: [asset.getBalanceAssetId(), address],
+        transform: async (response) => response.unwrapOrDefault().balance.toBigInt()
+      })
+    })
+  };
+}
+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)
+            ]
+          }
+        };
+        return new SubstrateQueryConfig({
+          module: "foreignAssets",
+          func: "account",
+          args: [multilocation, address],
+          transform: async (response) => response.unwrapOrDefault().balance.toBigInt()
+        });
+      }
+    })
+  };
+}
+function system() {
+  return {
+    account: () => ({
+      build: ({ address }) => new SubstrateQueryConfig({
+        module: "system",
+        func: "account",
+        args: [address],
+        transform: async (response) => calculateSystemAccountBalance(response)
+      })
+    }),
+    accountEquilibrium: () => ({
+      build: ({ address, asset }) => new SubstrateQueryConfig({
+        module: "system",
+        func: "account",
+        args: [address],
+        transform: async (response) => {
+          if (response.data.isEmpty) {
+            return 0n;
+          }
+          const res = response.data.toJSON();
+          let balances;
+          if (Array.isArray(res)) {
+            balances = res;
+          }
+          if (Array.isArray(res?.v0?.balance)) {
+            balances = res.v0.balance;
+          }
+          if (!balances) {
+            throw new Error("Can't get balance from Equilibrium chain");
+          }
+          const balance = balances.find(
+            ([assetId]) => assetId === asset.getBalanceAssetId()
+          );
+          if (!balance) {
+            return 0n;
+          }
+          return BigInt(balance[1].positive);
+        }
+      })
+    }),
+    accountEvmTo32: () => ({
+      build: ({ address }) => {
+        const substrateAddress = evmToAddress2(address);
+        return new SubstrateQueryConfig({
+          module: "system",
+          func: "account",
+          args: [substrateAddress],
+          transform: async (response) => calculateSystemAccountBalance(response)
+        });
+      }
+    })
+  };
+}
+function tokens() {
+  return {
+    accounts: () => ({
+      build: ({ address, asset }) => new SubstrateQueryConfig({
+        module: "tokens",
+        func: "accounts",
+        args: [address, asset.getBalanceAssetId()],
+        transform: async ({
+          free,
+          frozen
+        }) => BigInt(free.sub(frozen).toString())
+      })
+    })
+  };
+}
+async function calculateSystemAccountBalance(response) {
+  const balance = response.data;
+  const free = BigInt(balance.free.toString());
+  const frozen = balance.miscFrozen ?? balance.frozen;
+  const frozenMinusReserved = BigInt(frozen.sub(balance.reserved).toString());
+  const locked = frozenMinusReserved < 0n ? 0n : frozenMinusReserved;
+  return free - locked;
+}
+
+// src/types/substrate/ExtrinsicConfig.ts
+var ExtrinsicConfig = class _ExtrinsicConfig extends BaseConfig {
+  // biome-ignore lint/suspicious/noExplicitAny: not sure how to fix this
+  getArgs;
+  static is(obj) {
+    return obj instanceof _ExtrinsicConfig;
+  }
+  constructor({ getArgs, ...other }) {
+    super({ ...other });
+    this.getArgs = getArgs;
+  }
+};
+
+// src/extrinsic/pallets/eqBalances/eqBalances.ts
+var pallet = "eqBalances";
+function eqBalances() {
+  return {
+    xcmTransfer: () => ({
+      build: ({ destinationAddress, asset, destination }) => new ExtrinsicConfig({
+        module: pallet,
+        func: "xcmTransfer",
+        getArgs: () => [
+          asset.getAssetId(),
+          asset.amount,
+          {
+            parents: 1,
+            interior: {
+              X2: [
+                {
+                  Parachain: destination.parachainId
+                },
+                getExtrinsicAccount(destinationAddress)
+              ]
+            }
+          },
+          "ThisAccWillPay" /* ThisAccWillPay */
+        ]
+      })
+    }),
+    transferXcm: () => ({
+      build: ({ destinationAddress: address, asset, destination, fee }) => new ExtrinsicConfig({
+        module: pallet,
+        func: "transferXcm",
+        getArgs: () => {
+          const amountWithoutFee = asset.amount - fee.amount > 0n ? asset.amount - fee.amount : 0n;
+          return [
+            [
+              asset.getAssetId(),
+              asset.isSame(fee) ? amountWithoutFee : asset.amount
+            ],
+            [fee.getAssetId(), fee.amount],
+            {
+              parents: 1,
+              interior: {
+                X2: [
+                  {
+                    Parachain: destination.parachainId
+                  },
+                  getExtrinsicAccount(address)
+                ]
+              }
+            }
+          ];
+        }
+      })
+    })
+  };
+}
+
+// src/extrinsic/pallets/polkadotXcm/polkadotXcm.util.ts
+function getPolkadotXcmExtrinsicArgs({
+  asset,
+  destinationAddress,
+  destination,
+  func,
+  parents = 1,
+  feeIndex = 0
+  // biome-ignore lint/suspicious/noExplicitAny: not sure how to fix this
+}) {
+  const version = getExtrinsicArgumentVersion(func);
+  return [
+    {
+      [version]: normalizeX1(version, {
+        parents,
+        interior: {
+          X1: {
+            Parachain: destination.parachainId
+          }
+        }
+      })
+    },
+    {
+      [version]: normalizeX1(version, {
+        parents: 0,
+        interior: {
+          X1: getExtrinsicAccount(destinationAddress)
+        }
+      })
+    },
+    {
+      [version]: asset
+    },
+    feeIndex,
+    "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() {
+  return {
+    limitedReserveTransferAssets: () => {
+      const func = "limitedReserveTransferAssets";
+      return {
+        here: () => ({
+          build: (params) => new ExtrinsicConfig({
+            module: pallet2,
+            func,
+            getArgs: (extrinsicFunction) => {
+              const version = getExtrinsicArgumentVersion(extrinsicFunction);
+              return getPolkadotXcmExtrinsicArgs({
+                ...params,
+                func: extrinsicFunction,
+                asset: [
+                  {
+                    id: normalizeConcrete(version, {
+                      parents: 0,
+                      interior: "Here"
+                    }),
+                    fun: {
+                      Fungible: params.asset.amount
+                    }
+                  }
+                ]
+              });
+            }
+          })
+        }),
+        X1: () => ({
+          build: (params) => new ExtrinsicConfig({
+            module: pallet2,
+            func,
+            getArgs: (extrinsicFunction) => {
+              const version = getExtrinsicArgumentVersion(extrinsicFunction);
+              return getPolkadotXcmExtrinsicArgs({
+                ...params,
+                func: extrinsicFunction,
+                asset: [
+                  {
+                    id: normalizeConcrete(
+                      version,
+                      normalizeX1(version, {
+                        parents: 0,
+                        interior: {
+                          X1: {
+                            PalletInstance: params.asset.getAssetPalletInstance()
+                          }
+                        }
+                      })
+                    ),
+                    fun: {
+                      Fungible: params.asset.amount
+                    }
+                  }
+                ]
+              });
+            }
+          })
+        }),
+        X2: () => ({
+          build: (params) => new ExtrinsicConfig({
+            module: pallet2,
+            func,
+            getArgs: (extrinsicFunction) => {
+              const isAssetDifferent = !params.asset.isSame(params.fee);
+              const version = getExtrinsicArgumentVersion(extrinsicFunction);
+              const assets3 = [
+                {
+                  id: normalizeConcrete(version, {
+                    parents: 0,
+                    interior: {
+                      X2: [
+                        {
+                          PalletInstance: params.asset.getAssetPalletInstance()
+                        },
+                        {
+                          GeneralIndex: params.asset.getAssetId()
+                        }
+                      ]
+                    }
+                  }),
+                  fun: {
+                    Fungible: params.asset.amount
+                  }
+                }
+              ];
+              const shouldFeeAssetPrecede = shouldFeeAssetPrecedeAsset(params);
+              if (isAssetDifferent) {
+                const feeAsset = {
+                  id: normalizeConcrete(version, {
+                    parents: 0,
+                    interior: {
+                      X2: [
+                        {
+                          PalletInstance: params.fee.getAssetPalletInstance()
+                        },
+                        {
+                          GeneralIndex: params.fee.getAssetId()
+                        }
+                      ]
+                    }
+                  }),
+                  fun: {
+                    Fungible: params.fee.amount
+                  }
+                };
+                if (shouldFeeAssetPrecede) {
+                  assets3.unshift(feeAsset);
+                } else {
+                  assets3.push(feeAsset);
+                }
+              }
+              return getPolkadotXcmExtrinsicArgs({
+                ...params,
+                func: extrinsicFunction,
+                asset: assets3,
+                feeIndex: isAssetDifferent && !shouldFeeAssetPrecede ? 1 : 0
+              });
+            }
+          })
+        })
+      };
+    },
+    limitedReserveWithdrawAssets: () => {
+      const func = "limitedReserveWithdrawAssets";
+      return {
+        X2: () => ({
+          build: (params) => new ExtrinsicConfig({
+            module: pallet2,
+            func,
+            getArgs: (extrinsicFunction) => {
+              const version = getExtrinsicArgumentVersion(extrinsicFunction);
+              return getPolkadotXcmExtrinsicArgs({
+                ...params,
+                func: extrinsicFunction,
+                asset: [
+                  {
+                    id: normalizeConcrete(version, {
+                      parents: 1,
+                      interior: {
+                        X2: [
+                          {
+                            Parachain: params.destination.parachainId
+                          },
+                          {
+                            PalletInstance: params.asset.getAssetPalletInstance()
+                          }
+                        ]
+                      }
+                    }),
+                    fun: {
+                      Fungible: params.asset.amount
+                    }
+                  }
+                ]
+              });
+            }
+          })
+        })
+      };
+    },
+    transferAssets: () => {
+      const func = "transferAssets";
+      return {
+        here: () => ({
+          build: (params) => new ExtrinsicConfig({
+            module: pallet2,
+            func,
+            getArgs: (extrinsicFunction) => {
+              const version = getExtrinsicArgumentVersion(extrinsicFunction);
+              return getPolkadotXcmExtrinsicArgs({
+                ...params,
+                func: extrinsicFunction,
+                asset: [
+                  {
+                    id: normalizeConcrete(version, {
+                      parents: 1,
+                      interior: "Here"
+                    }),
+                    fun: {
+                      Fungible: params.asset.amount
+                    }
+                  }
+                ]
+              });
+            }
+          })
+        })
+      };
+    },
+    transferAssetsUsingTypeAndThen: () => {
+      const func = "transferAssetsUsingTypeAndThen";
+      return {
+        // TODO we could pass a parameter globalConsensus in the chain asset if we need a different one
+        globalConsensusEthereum: () => ({
+          build: (params) => new ExtrinsicConfig({
+            module: pallet2,
+            func,
+            getArgs: (extrinsicFunction) => {
+              if (!params.asset.address) {
+                throw new Error(
+                  "Asset address is needed for transferAssetsUsingTypeAndThen.globalConsensus function"
+                );
+              }
+              const version = getExtrinsicArgumentVersion(extrinsicFunction);
+              return [
+                {
+                  [version]: {
+                    parents: 1,
+                    interior: {
+                      X1: [
+                        {
+                          Parachain: params.destination.parachainId
+                        }
+                      ]
+                    }
+                  }
+                },
+                {
+                  [version]: [
+                    {
+                      id: normalizeConcrete(version, {
+                        parents: 2,
+                        interior: {
+                          X2: [
+                            { globalConsensus: { Ethereum: { ChainId: 1 } } },
+                            getExtrinsicAccount(params.asset.address)
+                          ]
+                        }
+                      }),
+                      fun: { fungible: params.asset.amount }
+                    }
+                  ]
+                },
+                "LocalReserve",
+                {
+                  [version]: normalizeConcrete(version, {
+                    parents: 2,
+                    interior: {
+                      X2: [
+                        { globalConsensus: { Ethereum: { ChainId: 1 } } },
+                        getExtrinsicAccount(params.asset.address)
+                      ]
+                    }
+                  })
+                },
+                "LocalReserve",
+                {
+                  [version]: [
+                    {
+                      DepositAsset: {
+                        assets: {
+                          Wild: { AllCounted: 1 }
+                        },
+                        beneficiary: normalizeX1(version, {
+                          parents: 0,
+                          interior: {
+                            X1: getExtrinsicAccount(
+                              params.destinationAddress
+                            )
+                          }
+                        })
+                      }
+                    }
+                  ]
+                },
+                "Unlimited"
+              ];
+            }
+          })
+        })
+      };
+    }
+  };
+}
+
+// src/extrinsic/pallets/xTokens/xTokens.utils.ts
+function getWeight() {
+  return "Unlimited";
+}
+function getDestination(version, address, destination) {
+  return {
+    [version]: {
+      parents: 1,
+      interior: {
+        X2: [
+          {
+            Parachain: destination.parachainId
+          },
+          getExtrinsicAccount(address)
+        ]
+      }
+    }
+  };
+}
+
+// src/extrinsic/pallets/xTokens/xTokens.ts
+var pallet3 = "xTokens";
+function xTokens() {
+  return {
+    transfer: () => ({
+      build: ({ destinationAddress, asset, destination }) => new ExtrinsicConfig({
+        module: pallet3,
+        func: "transfer",
+        getArgs: (func) => {
+          const destIndex = 2;
+          const version = getExtrinsicArgumentVersion(func, destIndex);
+          return [
+            asset.getAssetId(),
+            asset.amount,
+            getDestination(version, destinationAddress, destination),
+            getWeight()
+          ];
+        }
+      })
+    }),
+    transferMultiAsset: (originParachainId) => {
+      const funcName = "transferMultiasset";
+      const destIndex = 1;
+      return {
+        here: () => ({
+          build: ({ destinationAddress: address, asset, destination }) => new ExtrinsicConfig({
+            module: pallet3,
+            func: funcName,
+            getArgs: (func) => {
+              const version = getExtrinsicArgumentVersion(func, destIndex);
+              return [
+                {
+                  [version]: {
+                    id: normalizeConcrete(version, {
+                      parents: 0,
+                      interior: "Here"
+                    }),
+                    fun: {
+                      Fungible: asset.amount
+                    }
+                  }
+                },
+                getDestination(version, address, destination),
+                getWeight()
+              ];
+            }
+          })
+        }),
+        X1: () => ({
+          build: ({ destinationAddress: address, asset, destination }) => new ExtrinsicConfig({
+            module: pallet3,
+            func: funcName,
+            getArgs: (func) => {
+              const version = getExtrinsicArgumentVersion(func, destIndex);
+              return [
+                {
+                  [version]: {
+                    id: normalizeConcrete(
+                      version,
+                      normalizeX1(version, {
+                        parents: 1,
+                        interior: {
+                          X1: {
+                            Parachain: originParachainId
+                          }
+                        }
+                      })
+                    ),
+                    fun: {
+                      Fungible: asset.amount
+                    }
+                  }
+                },
+                getDestination(version, address, destination),
+                getWeight()
+              ];
+            }
+          })
+        }),
+        X2: () => ({
+          build: ({ destinationAddress: address, asset, destination }) => new ExtrinsicConfig({
+            module: pallet3,
+            func: funcName,
+            getArgs: (func) => {
+              const version = getExtrinsicArgumentVersion(func, destIndex);
+              return [
+                {
+                  [version]: {
+                    id: normalizeConcrete(version, {
+                      parents: 1,
+                      interior: {
+                        X2: [
+                          {
+                            Parachain: originParachainId
+                          },
+                          {
+                            GeneralKey: asset.getAssetId()
+                          }
+                        ]
+                      }
+                    }),
+                    fun: {
+                      Fungible: asset.amount
+                    }
+                  }
+                },
+                getDestination(version, address, destination),
+                getWeight()
+              ];
+            }
+          })
+        })
+      };
+    },
+    transferMultiCurrencies: () => ({
+      build: ({ destinationAddress: address, asset, destination, fee }) => new ExtrinsicConfig({
+        module: pallet3,
+        func: "transferMulticurrencies",
+        getArgs: () => [
+          [
+            [asset.getAssetId(), asset.amount],
+            [fee.getAssetId(), fee.amount]
+          ],
+          1,
+          getDestination("V3" /* v3 */, address, destination),
+          getWeight()
+        ]
+      })
+    })
+  };
+}
+
+// src/extrinsic/pallets/xTransfer/xTransfer.ts
+var pallet4 = "xTransfer";
+function xTransfer() {
+  return {
+    transfer: () => {
+      const method = "transfer";
+      return {
+        here: () => ({
+          build: ({ destinationAddress: address, asset, destination }) => new ExtrinsicConfig({
+            module: pallet4,
+            func: method,
+            getArgs: () => [
+              {
+                id: {
+                  Concrete: {
+                    parents: 0,
+                    interior: "Here"
+                  }
+                },
+                fun: {
+                  Fungible: asset.amount
+                }
+              },
+              {
+                parents: 1,
+                interior: {
+                  X2: [
+                    {
+                      Parachain: destination.parachainId
+                    },
+                    getExtrinsicAccount(address)
+                  ]
+                }
+              },
+              {
+                refTime: 5e9,
+                proofSize: 0
+              }
+            ]
+          })
+        }),
+        X2: () => ({
+          build: ({ destinationAddress, asset, destination }) => new ExtrinsicConfig({
+            module: pallet4,
+            func: method,
+            getArgs: () => [
+              {
+                id: {
+                  Concrete: {
+                    parents: 1,
+                    interior: {
+                      X2: [
+                        {
+                          Parachain: destination.parachainId
+                        },
+                        {
+                          PalletInstance: asset.getAssetPalletInstance()
+                        }
+                      ]
+                    }
+                  }
+                },
+                fun: {
+                  Fungible: asset.amount || 1n
+                }
+              },
+              {
+                parents: 1,
+                interior: {
+                  X2: [
+                    {
+                      Parachain: destination.parachainId
+                    },
+                    getExtrinsicAccount(destinationAddress)
+                  ]
+                }
+              },
+              {
+                refTime: 5e9,
+                proofSize: 0
+              }
+            ]
+          })
+        })
+      };
+    }
+  };
+}
+
+// src/extrinsic/pallets/xcmPallet/xcmPallet.ts
+var pallet5 = "xcmPallet";
+function xcmPallet() {
+  return {
+    limitedReserveTransferAssets: (parents = 1) => {
+      const func = "limitedReserveTransferAssets";
+      return {
+        here: () => ({
+          build: (params) => new ExtrinsicConfig({
+            module: pallet5,
+            func,
+            getArgs: (extrinsicFunction) => {
+              const version = getExtrinsicArgumentVersion(extrinsicFunction);
+              return getPolkadotXcmExtrinsicArgs({
+                ...params,
+                parents,
+                func: extrinsicFunction,
+                asset: [
+                  {
+                    id: normalizeConcrete(version, {
+                      parents: 0,
+                      interior: "Here"
+                    }),
+                    fun: {
+                      Fungible: params.asset.amount
+                    }
+                  }
+                ]
+              });
+            }
+          })
+        })
+      };
+    },
+    transferAssetsUsingTypeAndThen: () => {
+      const func = "transferAssetsUsingTypeAndThen";
+      return {
+        here: () => ({
+          build: (params) => new ExtrinsicConfig({
+            module: pallet5,
+            func,
+            getArgs: () => {
+              const version = "V4" /* v4 */;
+              return [
+                {
+                  [version]: {
+                    parents: 0,
+                    interior: {
+                      X1: [
+                        {
+                          Parachain: params.destination.parachainId
+                        }
+                      ]
+                    }
+                  }
+                },
+                {
+                  [version]: [
+                    {
+                      id: {
+                        parents: 0,
+                        interior: "Here"
+                      },
+                      fun: {
+                        Fungible: params.asset.amount
+                      }
+                    }
+                  ]
+                },
+                "LocalReserve",
+                {
+                  [version]: {
+                    parents: 0,
+                    interior: "Here"
+                  }
+                },
+                "LocalReserve",
+                {
+                  [version]: [
+                    {
+                      DepositAsset: {
+                        assets: {
+                          Wild: { AllCounted: 1 }
+                        },
+                        beneficiary: {
+                          parents: 0,
+                          interior: {
+                            X1: [
+                              getExtrinsicAccount(params.destinationAddress)
+                            ]
+                          }
+                        }
+                      }
+                    }
+                  ]
+                },
+                "Unlimited"
+              ];
+            }
+          })
+        })
+      };
+    }
+  };
+}
+
+// src/extrinsic/ExtrinsicBuilder.ts
+function ExtrinsicBuilder() {
+  return {
+    eqBalances,
+    xTokens,
+    xTransfer,
+    polkadotXcm,
+    xcmPallet
+  };
+}
+
+// src/types/substrate/SubstrateCallConfig.ts
+var SubstrateCallConfig = class _SubstrateCallConfig {
+  api;
+  // biome-ignore lint/suspicious/noExplicitAny: not sure how to fix this
+  call;
+  static is(obj) {
+    return obj instanceof _SubstrateCallConfig;
+  }
+  constructor({ api, call }) {
+    this.api = api;
+    this.call = call;
+  }
+};
+
+// src/fee/FeeBuilder.utils.ts
+var DEFAULT_AMOUNT = 10 ** 6;
+var DEFAULT_HEX_STRING = "0xabcdef1234567890fedcba0987654321abcdef1234567890fedcba0987654321";
+var XCM_VERSION = "V4" /* v4 */;
+function isXcmV42() {
+  return XCM_VERSION === "V4" /* v4 */;
+}
+function getWithdrawAssetInstruction(assetTypes) {
+  return {
+    WithdrawAsset: assetTypes.map((assetType) => ({
+      id: { ...assetType },
+      fun: {
+        Fungible: DEFAULT_AMOUNT
+      }
+    }))
+  };
+}
+function getReserveAssetDepositedInstruction(assetTypes) {
+  return {
+    ReserveAssetDeposited: assetTypes.map((assetType) => ({
+      id: { ...assetType },
+      fun: {
+        Fungible: DEFAULT_AMOUNT
+      }
+    }))
+  };
+}
+function getClearOriginInstruction() {
+  return {
+    ClearOrigin: "NULL"
+  };
+}
+function getBuyExecutionInstruction(assetType) {
+  return {
+    BuyExecution: {
+      fees: {
+        id: {
+          ...assetType
+        },
+        fun: {
+          Fungible: DEFAULT_AMOUNT
+        }
+      },
+      weight_limit: {
+        Unlimited: "NULL"
+      }
+    }
+  };
+}
+function getDepositAssetInstruction(address, assets3) {
+  const accountKey = {
+    AccountKey20: {
+      key: address,
+      network: null
+    }
+  };
+  return {
+    DepositAsset: {
+      assets: {
+        Wild: {
+          AllCounted: assets3.length
+        }
+      },
+      beneficiary: {
+        interior: {
+          X1: isXcmV42() ? [accountKey] : accountKey
+        },
+        parents: 0
+      },
+      max_assets: 0
+    }
+  };
+}
+function getSetTopicInstruction() {
+  return {
+    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
+  });
+  if (!xcmToWeightResult.isOk) {
+    throw new Error(
+      "There was an error trying to get the weight for the xcm instructions (queryXcmWeight)"
+    );
+  }
+  const xcmToWeight = xcmToWeightResult.asOk;
+  const weightToForeignAssets = await api.call.xcmPaymentApi.queryWeightToAssetFee(xcmToWeight, {
+    [XCM_VERSION]: {
+      ...versionedAssetId
+    }
+  });
+  if (!weightToForeignAssets.isOk) {
+    throw new Error(
+      "There was an error trying to get the fee with the weight and asset (weightToForeignAssets)"
+    );
+  }
+  return weightToForeignAssets.asOk.toBigInt();
+}
+
+// src/fee/FeeBuilder.ts
+function FeeBuilder() {
+  return {
+    xcmPaymentApi
+  };
+}
+function xcmPaymentApi() {
+  return {
+    xcmPaymentFee: ({
+      isAssetReserveChain,
+      shouldTransferAssetPrecedeFeeAsset = false
+    }) => ({
+      build: ({
+        address,
+        api,
+        asset,
+        destination,
+        feeAsset
+      }) => new SubstrateCallConfig({
+        api,
+        call: async () => {
+          const versionedFeeAssetId = await getVersionedAssetId(
+            api,
+            feeAsset,
+            destination
+          );
+          const versionedTransferAssetId = await getVersionedAssetId(
+            api,
+            asset,
+            destination
+          );
+          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
+          );
+        }
+      })
+    })
+  };
+}
+
+// src/mrl/providers/wormhole/contract/Batch/Batch.ts
+import {
+  EvmParachain as EvmParachain2
+} from "@moonbeam-network/xcm-types";
+import { getMultilocationDerivedAddresses as getMultilocationDerivedAddresses2 } from "@moonbeam-network/xcm-utils";
+import { evmToAddress as evmToAddress3 } from "@polkadot/util-crypto";
+import { encodeFunctionData as encodeFunctionData2, maxUint64 } from "viem";
+
+// src/mrl/providers/wormhole/extrinsic/polkadotXcm/polkadotXcm.ts
+import {
+  AssetAmount,
+  Parachain
+} from "@moonbeam-network/xcm-types";
+import { getMultilocationDerivedAddresses } from "@moonbeam-network/xcm-utils";
+var BUY_EXECUTION_FEE = 100000000000000000n;
+var CROSS_CHAIN_FEE = 100000000000000000n;
+function polkadotXcm2() {
+  return {
+    send: () => ({
+      build: ({
+        asset,
+        destination,
+        destinationAddress,
+        fee,
+        isAutomatic,
+        moonAsset,
+        moonChain,
+        moonApi,
+        sendOnlyRemoteExecution,
+        source,
+        sourceAddress,
+        sourceApi,
+        transact
+      }) => {
+        if (!destination.wh?.name) {
+          throw new Error("Destination chain does not have a wormhole name");
+        }
+        if (!sourceApi) {
+          throw new Error("Source API needs to be defined");
+        }
+        if (!Parachain.is(source)) {
+          throw new Error("Source chain needs to be a parachain");
+        }
+        const { address20: computedOriginAccount } = getMultilocationDerivedAddresses({
+          address: sourceAddress,
+          paraId: source.parachainId,
+          isParents: true
+        });
+        const assetTransferTxs = getAssetTransferTxs({
+          asset,
+          computedOriginAccount,
+          destination,
+          destinationAddress,
+          fee,
+          isAutomatic,
+          moonApi,
+          moonAsset,
+          moonChain,
+          source,
+          sourceAddress,
+          sourceApi
+        });
+        const send = buildSendExtrinsic({
+          asset,
+          destination,
+          destinationAddress,
+          computedOriginAccount,
+          fee,
+          isAutomatic,
+          moonAsset,
+          moonChain,
+          moonApi,
+          source,
+          sourceAddress,
+          sourceApi,
+          transact
+        });
+        const transactionsToSend = sendOnlyRemoteExecution ? [send] : [...assetTransferTxs, send];
+        return new ExtrinsicConfig({
+          module: "utility",
+          func: "batchAll",
+          getArgs: () => [transactionsToSend]
+        });
+      }
+    })
+  };
+}
+function buildSendExtrinsic({
+  computedOriginAccount,
+  moonAsset,
+  moonChain,
+  sourceApi,
+  transact
+}) {
+  if (!transact) {
+    throw new Error("Transact params are required");
+  }
+  return sourceApi.tx.polkadotXcm.send(
+    {
+      // TODO apply XCM versioning
+      V3: {
+        parents: 1,
+        interior: { X1: { Parachain: moonChain.parachainId } }
+      }
+    },
+    {
+      V3: [
+        {
+          WithdrawAsset: [
+            {
+              id: {
+                Concrete: {
+                  parents: 0,
+                  interior: {
+                    X1: {
+                      PalletInstance: moonAsset.getAssetPalletInstance()
+                    }
+                  }
+                }
+              },
+              fun: { Fungible: BUY_EXECUTION_FEE }
+            }
+          ]
+        },
+        {
+          BuyExecution: {
+            fees: {
+              id: {
+                Concrete: {
+                  parents: 0,
+                  interior: {
+                    X1: {
+                      PalletInstance: moonAsset.getAssetPalletInstance()
+                    }
+                  }
+                }
+              },
+              fun: { Fungible: BUY_EXECUTION_FEE }
+            },
+            weightLimit: "Unlimited"
+          }
+        },
+        {
+          Transact: {
+            originKind: "SovereignAccount",
+            requireWeightAtMost: {
+              refTime: transact.txWeight.refTime,
+              proofSize: transact.txWeight.proofSize
+            },
+            call: {
+              encoded: transact.call
+            }
+          }
+        },
+        {
+          SetAppendix: [
+            { RefundSurplus: {} },
+            {
+              DepositAsset: {
+                assets: { Wild: { AllCounted: 1 } },
+                beneficiary: {
+                  parents: 0,
+                  interior: {
+                    X1: { AccountKey20: { key: computedOriginAccount } }
+                  }
+                }
+              }
+            }
+          ]
+        }
+      ]
+    }
+  );
+}
+function getAssetTransferTxs({
+  asset,
+  computedOriginAccount,
+  fee,
+  moonApi,
+  moonAsset,
+  moonChain,
+  source,
+  sourceAddress,
+  sourceApi
+}) {
+  const { transfer, transferMulticurrencies } = sourceApi.tx.xTokens;
+  const transferBuilder = ExtrinsicBuilder().xTokens().transfer();
+  const transferMulticurrenciesBuilder = ExtrinsicBuilder().xTokens().transferMultiCurrencies();
+  if (asset.isSame(fee)) {
+    const assetTransferTx = transfer(
+      ...transferBuilder.build({
+        asset: asset.copyWith({
+          // TODO for the moment this is only applicable to peaq, AGNG pays for fees and we have to include the cross chain fee
+          // for this we have to add a new concept in the config (Cross Chain Fee), and get the value from there
+          amount: asset.amount + 10n * CROSS_CHAIN_FEE
+        }),
+        destination: moonChain,
+        destinationAddress: computedOriginAccount,
+        destinationApi: moonApi,
+        fee,
+        source,
+        sourceAddress,
+        sourceApi
+      }).getArgs(transfer)
+    );
+    const feeAssetTransferTx = transfer(
+      ...transferBuilder.build({
+        asset: AssetAmount.fromChainAsset(source.getChainAsset(moonAsset), {
+          amount: CROSS_CHAIN_FEE + BUY_EXECUTION_FEE
+        }),
+        destination: moonChain,
+        destinationAddress: computedOriginAccount,
+        destinationApi: moonApi,
+        fee,
+        source,
+        sourceAddress,
+        sourceApi
+      }).getArgs(transfer)
+    );
+    return [assetTransferTx, feeAssetTransferTx];
+  }
+  const multiCurrenciesTransferTx = transferMulticurrencies(
+    ...transferMulticurrenciesBuilder.build({
+      asset,
+      destination: moonChain,
+      destinationAddress: computedOriginAccount,
+      destinationApi: moonApi,
+      fee: AssetAmount.fromChainAsset(source.getChainAsset(moonAsset), {
+        amount: CROSS_CHAIN_FEE + BUY_EXECUTION_FEE
+      }),
+      source,
+      sourceAddress,
+      sourceApi
+    }).getArgs(transferMulticurrencies)
+  );
+  return [multiCurrenciesTransferTx];
+}
+
+// src/mrl/providers/wormhole/contract/Batch/abi/peaq/PeaqBatchContractAbi.ts
+var PEAQ_BATCH_ABI = [
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "index",
+        type: "uint256"
+      }
+    ],
+    name: "SubcallFailed",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "index",
+        type: "uint256"
+      }
+    ],
+    name: "SubcallSucceeded",
+    type: "event"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address[]",
+        name: "to",
+        type: "address[]"
+      },
+      {
+        internalType: "uint256[]",
+        name: "value",
+        type: "uint256[]"
+      },
+      {
+        internalType: "bytes[]",
+        name: "callData",
+        type: "bytes[]"
+      },
+      {
+        internalType: "uint64[]",
+        name: "gasLimit",
+        type: "uint64[]"
+      }
+    ],
+    name: "batchAll",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address[]",
+        name: "to",
+        type: "address[]"
+      },
+      {
+        internalType: "uint256[]",
+        name: "value",
+        type: "uint256[]"
+      },
+      {
+        internalType: "bytes[]",
+        name: "callData",
+        type: "bytes[]"
+      },
+      {
+        internalType: "uint64[]",
+        name: "gasLimit",
+        type: "uint64[]"
+      }
+    ],
+    name: "batchSome",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address[]",
+        name: "to",
+        type: "address[]"
+      },
+      {
+        internalType: "uint256[]",
+        name: "value",
+        type: "uint256[]"
+      },
+      {
+        internalType: "bytes[]",
+        name: "callData",
+        type: "bytes[]"
+      },
+      {
+        internalType: "uint64[]",
+        name: "gasLimit",
+        type: "uint64[]"
+      }
+    ],
+    name: "batchSomeUntilFailure",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
+
+// src/mrl/providers/wormhole/contract/Batch/abi/peaq/PeaqXcmUtilsContractAbi.ts
+var PEAQ_XCM_UTILS_ABI = [
+  {
+    inputs: [
+      {
+        components: [
+          {
+            internalType: "uint8",
+            name: "parents",
+            type: "uint8"
+          },
+          {
+            internalType: "bytes[]",
+            name: "interior",
+            type: "bytes[]"
+          }
+        ],
+        internalType: "struct XcmUtils.Multilocation",
+        name: "multilocation",
+        type: "tuple"
+      }
+    ],
+    name: "getUnitsPerSecond",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "unitsPerSecond",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "message",
+        type: "bytes"
+      }
+    ],
+    name: "weightMessage",
+    outputs: [
+      {
+        internalType: "uint64",
+        name: "weight",
+        type: "uint64"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "message",
+        type: "bytes"
+      },
+      {
+        internalType: "uint64",
+        name: "maxWeight",
+        type: "uint64"
+      }
+    ],
+    name: "xcmExecute",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        components: [
+          {
+            internalType: "uint8",
+            name: "parents",
+            type: "uint8"
+          },
+          {
+            internalType: "bytes[]",
+            name: "interior",
+            type: "bytes[]"
+          }
+        ],
+        internalType: "struct XcmUtils.Multilocation",
+        name: "dest",
+        type: "tuple"
+      },
+      {
+        internalType: "bytes",
+        name: "message",
+        type: "bytes"
+      }
+    ],
+    name: "xcmSend",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
+
+// src/mrl/providers/wormhole/contract/Batch/abi/peaq/PeaqXtokensContractAbi.ts
+var PEAQ_XTOKENS_ABI = [
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "currencyAddress",
+        type: "address"
+      },
+      {
+        internalType: "uint256",
+        name: "amount",
+        type: "uint256"
+      },
+      {
+        components: [
+          {
+            internalType: "uint8",
+            name: "parents",
+            type: "uint8"
+          },
+          {
+            internalType: "bytes[]",
+            name: "interior",
+            type: "bytes[]"
+          }
+        ],
+        internalType: "struct Xtokens.Multilocation",
+        name: "destination",
+        type: "tuple"
+      },
+      {
+        internalType: "uint64",
+        name: "weight",
+        type: "uint64"
+      }
+    ],
+    name: "transfer",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        components: [
+          {
+            components: [
+              {
+                internalType: "uint8",
+                name: "parents",
+                type: "uint8"
+              },
+              {
+                internalType: "bytes[]",
+                name: "interior",
+                type: "bytes[]"
+              }
+            ],
+            internalType: "struct Xtokens.Multilocation",
+            name: "location",
+            type: "tuple"
+          },
+          {
+            internalType: "uint256",
+            name: "amount",
+            type: "uint256"
+          }
+        ],
+        internalType: "struct Xtokens.MultiAsset[]",
+        name: "assets",
+        type: "tuple[]"
+      },
+      {
+        internalType: "uint32",
+        name: "feeItem",
+        type: "uint32"
+      },
+      {
+        components: [
+          {
+            internalType: "uint8",
+            name: "parents",
+            type: "uint8"
+          },
+          {
+            internalType: "bytes[]",
+            name: "interior",
+            type: "bytes[]"
+          }
+        ],
+        internalType: "struct Xtokens.Multilocation",
+        name: "destination",
+        type: "tuple"
+      },
+      {
+        internalType: "uint64",
+        name: "weight",
+        type: "uint64"
+      }
+    ],
+    name: "transferMultiAssets",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        components: [
+          {
+            internalType: "address",
+            name: "currencyAddress",
+            type: "address"
+          },
+          {
+            internalType: "uint256",
+            name: "amount",
+            type: "uint256"
+          }
+        ],
+        internalType: "struct Xtokens.Currency[]",
+        name: "currencies",
+        type: "tuple[]"
+      },
+      {
+        internalType: "uint32",
+        name: "feeItem",
+        type: "uint32"
+      },
+      {
+        components: [
+          {
+            internalType: "uint8",
+            name: "parents",
+            type: "uint8"
+          },
+          {
+            internalType: "bytes[]",
+            name: "interior",
+            type: "bytes[]"
+          }
+        ],
+        internalType: "struct Xtokens.Multilocation",
+        name: "destination",
+        type: "tuple"
+      },
+      {
+        internalType: "uint64",
+        name: "weight",
+        type: "uint64"
+      }
+    ],
+    name: "transferMultiCurrencies",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        components: [
+          {
+            internalType: "uint8",
+            name: "parents",
+            type: "uint8"
+          },
+          {
+            internalType: "bytes[]",
+            name: "interior",
+            type: "bytes[]"
+          }
+        ],
+        internalType: "struct Xtokens.Multilocation",
+        name: "asset",
+        type: "tuple"
+      },
+      {
+        internalType: "uint256",
+        name: "amount",
+        type: "uint256"
+      },
+      {
+        components: [
+          {
+            internalType: "uint8",
+            name: "parents",
+            type: "uint8"
+          },
+          {
+            internalType: "bytes[]",
+            name: "interior",
+            type: "bytes[]"
+          }
+        ],
+        internalType: "struct Xtokens.Multilocation",
+        name: "destination",
+        type: "tuple"
+      },
+      {
+        internalType: "uint64",
+        name: "weight",
+        type: "uint64"
+      }
+    ],
+    name: "transferMultiasset",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        components: [
+          {
+            internalType: "uint8",
+            name: "parents",
+            type: "uint8"
+          },
+          {
+            internalType: "bytes[]",
+            name: "interior",
+            type: "bytes[]"
+          }
+        ],
+        internalType: "struct Xtokens.Multilocation",
+        name: "asset",
+        type: "tuple"
+      },
+      {
+        internalType: "uint256",
+        name: "amount",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "fee",
+        type: "uint256"
+      },
+      {
+        components: [
+          {
+            internalType: "uint8",
+            name: "parents",
+            type: "uint8"
+          },
+          {
+            internalType: "bytes[]",
+            name: "interior",
+            type: "bytes[]"
+          }
+        ],
+        internalType: "struct Xtokens.Multilocation",
+        name: "destination",
+        type: "tuple"
+      },
+      {
+        internalType: "uint64",
+        name: "weight",
+        type: "uint64"
+      }
+    ],
+    name: "transferMultiassetWithFee",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "currencyAddress",
+        type: "address"
+      },
+      {
+        internalType: "uint256",
+        name: "amount",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "fee",
+        type: "uint256"
+      },
+      {
+        components: [
+          {
+            internalType: "uint8",
+            name: "parents",
+            type: "uint8"
+          },
+          {
+            internalType: "bytes[]",
+            name: "interior",
+            type: "bytes[]"
+          }
+        ],
+        internalType: "struct Xtokens.Multilocation",
+        name: "destination",
+        type: "tuple"
+      },
+      {
+        internalType: "uint64",
+        name: "weight",
+        type: "uint64"
+      }
+    ],
+    name: "transferWithFee",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
+
+// src/mrl/providers/wormhole/contract/Batch/abi/abi.helpers.ts
+function getAbisForChain(chain) {
+  return {
+    BatchAbi: PEAQ_BATCH_ABI,
+    XcmUtilsAbi: PEAQ_XCM_UTILS_ABI,
+    XtokensAbi: PEAQ_XTOKENS_ABI
+  };
+}
+
+// src/mrl/providers/wormhole/contract/Batch/Batch.ts
+var module = "Batch";
+function Batch() {
+  return {
+    transferAssetsAndMessage: () => ({
+      build: ({
+        asset,
+        destination,
+        destinationAddress,
+        fee,
+        isAutomatic,
+        moonAsset,
+        moonChain,
+        moonApi,
+        source,
+        sourceAddress,
+        sourceApi,
+        transact
+      }) => {
+        if (!EvmParachain2.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?.Xtokens || !source.contracts?.XcmUtils || !source.contracts?.Batch) {
+          throw new Error(
+            "Source chain needs to have the Xtokens, XcmUtils and Batch contract addresses configured"
+          );
+        }
+        const subMappedAddress = evmToAddress3(sourceAddress);
+        const { BatchAbi, XcmUtilsAbi, XtokensAbi } = getAbisForChain(source);
+        const { address20: computedOriginAccount } = getMultilocationDerivedAddresses2({
+          address: subMappedAddress,
+          paraId: source.parachainId,
+          isParents: true
+        });
+        const send = buildSendExtrinsic({
+          asset,
+          destination,
+          destinationAddress,
+          computedOriginAccount,
+          fee,
+          isAutomatic,
+          moonAsset,
+          moonChain,
+          moonApi,
+          source,
+          sourceAddress,
+          sourceApi,
+          transact
+        });
+        const encodedXcmMessage = send.args[1].toHex();
+        const { destinationParachain, destinationParachainAndAddress } = getDestinationInHex(moonChain, computedOriginAccount);
+        const { currencies, feeItem } = getCurrencies({
+          source,
+          moonAsset,
+          asset
+        });
+        const weight = maxUint64;
+        const multiTransferTxData = encodeFunctionData2({
+          abi: XtokensAbi,
+          functionName: "transferMultiCurrencies",
+          args: [currencies, feeItem, destinationParachainAndAddress, weight]
+        });
+        const xcmSendTxData = encodeFunctionData2({
+          abi: XcmUtilsAbi,
+          functionName: "xcmSend",
+          args: [destinationParachain, encodedXcmMessage]
+        });
+        return new ContractConfig({
+          address: source.contracts.Batch,
+          abi: BatchAbi,
+          args: [
+            [source.contracts.Xtokens, source.contracts.XcmUtils],
+            [],
+            [multiTransferTxData, xcmSendTxData],
+            []
+          ],
+          func: "batchAll",
+          module
+        });
+      }
+    })
+  };
+}
+function getDestinationInHex(moonChain, computedOriginAccount) {
+  const destinationParachain = {
+    parents: 1,
+    interior: getPrecompileDestinationInterior(moonChain)
+  };
+  const destinationParachainAndAddress = {
+    parents: 1,
+    interior: getPrecompileDestinationInterior(
+      moonChain,
+      computedOriginAccount
+    )
+  };
+  return {
+    destinationParachain,
+    destinationParachainAndAddress
+  };
+}
+function getCurrencies({ source, moonAsset, asset }) {
+  const currencies = [
+    {
+      currencyAddress: source.getChainAsset(moonAsset).address,
+      amount: CROSS_CHAIN_FEE
+    },
+    {
+      currencyAddress: asset.address,
+      amount: asset.amount
+    }
+  ];
+  const feeItem = 0;
+  return { currencies, feeItem };
+}
+
+// src/mrl/providers/wormhole/contract/Gmp/Gmp.ts
+import { u8aToHex as u8aToHex4 } from "@polkadot/util";
+
+// src/mrl/providers/wormhole/contract/Gmp/GmpAbi.ts
+var GMP_ABI = [
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "vaa",
+        type: "bytes"
+      }
+    ],
+    name: "wormholeTransferERC20",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
+
+// src/mrl/providers/wormhole/contract/Gmp/Gmp.ts
+var module2 = "GMP";
+var GMP_CONTRACT_ADDRESS = "0x0000000000000000000000000000000000000816";
+function Gmp() {
+  return {
+    wormholeTransferERC20: () => ({
+      build: ({ bytes }) => {
+        const hex = u8aToHex4(bytes);
+        return new ContractConfig({
+          address: GMP_CONTRACT_ADDRESS,
+          abi: GMP_ABI,
+          args: [hex],
+          func: "wormholeTransferERC20",
+          module: module2
+        });
+      }
+    })
+  };
+}
+
+// src/mrl/providers/wormhole/contract/TokenBridge/TokenBridge.ts
+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 { 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";
+
+// src/mrl/providers/wormhole/wormhole/WormholeConfig.ts
+var WormholeConfig = class _WormholeConfig {
+  args;
+  func;
+  static is(obj) {
+    return obj instanceof _WormholeConfig;
+  }
+  constructor({ args, func }) {
+    this.args = args;
+    this.func = func;
+  }
+};
+
+// src/mrl/providers/wormhole/wormhole/wormholeFactory.ts
+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]);
+}
+
+// src/mrl/providers/wormhole/wormhole/wormhole.ts
+function wormhole() {
+  return {
+    tokenTransfer: () => ({
+      build: ({
+        asset,
+        destination,
+        destinationAddress,
+        isAutomatic,
+        moonApi,
+        moonChain,
+        source,
+        sourceAddress
+      }) => {
+        const isSourceParachain = Parachain2.is(source);
+        const isDestinationMoonChain = destination.isEqual(moonChain);
+        const isDestinationEvmChain = EvmChain.is(destination);
+        const isNativeAsset = asset.isSame(
+          isDestinationEvmChain ? moonChain.nativeAsset : source.nativeAsset
+        );
+        const tokenAddress = isNativeAsset ? "native" : isDestinationEvmChain ? moonChain.getChainAsset(asset).address : asset.address;
+        const { address20: computedOriginAccount } = getMultilocationDerivedAddresses3({
+          address: sourceAddress,
+          paraId: isSourceParachain ? source.parachainId : void 0,
+          isParents: true
+        });
+        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 whAsset = Wormhole2.tokenId(whSource.chain, tokenAddress);
+        const whSourceAddress = Wormhole2.chainAddress(
+          whSource.chain,
+          isDestinationEvmChain ? computedOriginAccount : sourceAddress
+        );
+        const whDestinationAddress = Wormhole2.chainAddress(
+          whDestination.chain,
+          isDestinationMoonChain || isDestinationEvmChain ? destinationAddress : GMP_CONTRACT_ADDRESS
+        );
+        return new WormholeConfig({
+          args: [
+            whAsset,
+            asset.amount,
+            whSourceAddress,
+            whDestinationAddress,
+            isAutomatic,
+            isDestinationMoonChain || isDestinationEvmChain ? void 0 : getPayload({ destination, destinationAddress, moonApi })
+          ],
+          func: "tokenTransfer"
+        });
+      }
+    })
+  };
+}
+function getPayload({
+  moonApi,
+  destination,
+  destinationAddress
+}) {
+  if (!EvmParachain3.isAnyParachain(destination)) {
+    throw new Error(
+      `Destination ${destination.name} is not a Parachain or EvmParachain`
+    );
+  }
+  const isPeaqEvm = destination.key === "peaq-evm-Alphanet" || destination.key === "peaq-evm";
+  const multilocation = moonApi.createType("XcmVersionedLocation", {
+    V3: {
+      parents: 1,
+      interior: {
+        X2: [
+          {
+            Parachain: destination.parachainId
+          },
+          getExtrinsicAccount(
+            isPeaqEvm ? evmToAddress4(destinationAddress) : destinationAddress
+          )
+        ]
+      }
+    }
+  });
+  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
+var TOKEN_BRIDGE_ABI = [
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "address",
+        name: "previousAdmin",
+        type: "address"
+      },
+      {
+        indexed: false,
+        internalType: "address",
+        name: "newAdmin",
+        type: "address"
+      }
+    ],
+    name: "AdminChanged",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "beacon",
+        type: "address"
+      }
+    ],
+    name: "BeaconUpgraded",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "oldContract",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "newContract",
+        type: "address"
+      }
+    ],
+    name: "ContractUpgraded",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "implementation",
+        type: "address"
+      }
+    ],
+    name: "Upgraded",
+    type: "event"
+  },
+  {
+    inputs: [],
+    name: "WETH",
+    outputs: [
+      {
+        internalType: "contract IWETH",
+        name: "",
+        type: "address"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint16",
+        name: "chainId_",
+        type: "uint16"
+      }
+    ],
+    name: "bridgeContracts",
+    outputs: [
+      {
+        internalType: "bytes32",
+        name: "",
+        type: "bytes32"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "chainId",
+    outputs: [
+      {
+        internalType: "uint16",
+        name: "",
+        type: "uint16"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "evmChainId",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "finality",
+    outputs: [
+      {
+        internalType: "uint8",
+        name: "",
+        type: "uint8"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "hash",
+        type: "bytes32"
+      }
+    ],
+    name: "governanceActionIsConsumed",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "governanceChainId",
+    outputs: [
+      {
+        internalType: "uint16",
+        name: "",
+        type: "uint16"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "governanceContract",
+    outputs: [
+      {
+        internalType: "bytes32",
+        name: "",
+        type: "bytes32"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "isFork",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "impl",
+        type: "address"
+      }
+    ],
+    name: "isInitialized",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "hash",
+        type: "bytes32"
+      }
+    ],
+    name: "isTransferCompleted",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "token",
+        type: "address"
+      }
+    ],
+    name: "isWrappedAsset",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "token",
+        type: "address"
+      }
+    ],
+    name: "outstandingBridged",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "encodedRecoverChainId",
+        type: "bytes"
+      }
+    ],
+    name: "parseRecoverChainId",
+    outputs: [
+      {
+        components: [
+          {
+            internalType: "bytes32",
+            name: "module",
+            type: "bytes32"
+          },
+          {
+            internalType: "uint8",
+            name: "action",
+            type: "uint8"
+          },
+          {
+            internalType: "uint256",
+            name: "evmChainId",
+            type: "uint256"
+          },
+          {
+            internalType: "uint16",
+            name: "newChainId",
+            type: "uint16"
+          }
+        ],
+        internalType: "struct BridgeStructs.RecoverChainId",
+        name: "rci",
+        type: "tuple"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "encoded",
+        type: "bytes"
+      }
+    ],
+    name: "parseRegisterChain",
+    outputs: [
+      {
+        components: [
+          {
+            internalType: "bytes32",
+            name: "module",
+            type: "bytes32"
+          },
+          {
+            internalType: "uint8",
+            name: "action",
+            type: "uint8"
+          },
+          {
+            internalType: "uint16",
+            name: "chainId",
+            type: "uint16"
+          },
+          {
+            internalType: "uint16",
+            name: "emitterChainID",
+            type: "uint16"
+          },
+          {
+            internalType: "bytes32",
+            name: "emitterAddress",
+            type: "bytes32"
+          }
+        ],
+        internalType: "struct BridgeStructs.RegisterChain",
+        name: "chain",
+        type: "tuple"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "encoded",
+        type: "bytes"
+      }
+    ],
+    name: "parseUpgrade",
+    outputs: [
+      {
+        components: [
+          {
+            internalType: "bytes32",
+            name: "module",
+            type: "bytes32"
+          },
+          {
+            internalType: "uint8",
+            name: "action",
+            type: "uint8"
+          },
+          {
+            internalType: "uint16",
+            name: "chainId",
+            type: "uint16"
+          },
+          {
+            internalType: "bytes32",
+            name: "newContract",
+            type: "bytes32"
+          }
+        ],
+        internalType: "struct BridgeStructs.UpgradeContract",
+        name: "chain",
+        type: "tuple"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "encodedVM",
+        type: "bytes"
+      }
+    ],
+    name: "registerChain",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "encodedVM",
+        type: "bytes"
+      }
+    ],
+    name: "submitRecoverChainId",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "tokenImplementation",
+    outputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "encodedVM",
+        type: "bytes"
+      }
+    ],
+    name: "upgrade",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "wormhole",
+    outputs: [
+      {
+        internalType: "contract IWormhole",
+        name: "",
+        type: "address"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint16",
+        name: "tokenChainId",
+        type: "uint16"
+      },
+      {
+        internalType: "bytes32",
+        name: "tokenAddress",
+        type: "bytes32"
+      }
+    ],
+    name: "wrappedAsset",
+    outputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    stateMutability: "payable",
+    type: "receive"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "tokenAddress",
+        type: "address"
+      },
+      {
+        internalType: "uint32",
+        name: "nonce",
+        type: "uint32"
+      }
+    ],
+    name: "attestToken",
+    outputs: [
+      {
+        internalType: "uint64",
+        name: "sequence",
+        type: "uint64"
+      }
+    ],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint16",
+        name: "recipientChain",
+        type: "uint16"
+      },
+      {
+        internalType: "bytes32",
+        name: "recipient",
+        type: "bytes32"
+      },
+      {
+        internalType: "uint256",
+        name: "arbiterFee",
+        type: "uint256"
+      },
+      {
+        internalType: "uint32",
+        name: "nonce",
+        type: "uint32"
+      }
+    ],
+    name: "wrapAndTransferETH",
+    outputs: [
+      {
+        internalType: "uint64",
+        name: "sequence",
+        type: "uint64"
+      }
+    ],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint16",
+        name: "recipientChain",
+        type: "uint16"
+      },
+      {
+        internalType: "bytes32",
+        name: "recipient",
+        type: "bytes32"
+      },
+      {
+        internalType: "uint32",
+        name: "nonce",
+        type: "uint32"
+      },
+      {
+        internalType: "bytes",
+        name: "payload",
+        type: "bytes"
+      }
+    ],
+    name: "wrapAndTransferETHWithPayload",
+    outputs: [
+      {
+        internalType: "uint64",
+        name: "sequence",
+        type: "uint64"
+      }
+    ],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "token",
+        type: "address"
+      },
+      {
+        internalType: "uint256",
+        name: "amount",
+        type: "uint256"
+      },
+      {
+        internalType: "uint16",
+        name: "recipientChain",
+        type: "uint16"
+      },
+      {
+        internalType: "bytes32",
+        name: "recipient",
+        type: "bytes32"
+      },
+      {
+        internalType: "uint256",
+        name: "arbiterFee",
+        type: "uint256"
+      },
+      {
+        internalType: "uint32",
+        name: "nonce",
+        type: "uint32"
+      }
+    ],
+    name: "transferTokens",
+    outputs: [
+      {
+        internalType: "uint64",
+        name: "sequence",
+        type: "uint64"
+      }
+    ],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "token",
+        type: "address"
+      },
+      {
+        internalType: "uint256",
+        name: "amount",
+        type: "uint256"
+      },
+      {
+        internalType: "uint16",
+        name: "recipientChain",
+        type: "uint16"
+      },
+      {
+        internalType: "bytes32",
+        name: "recipient",
+        type: "bytes32"
+      },
+      {
+        internalType: "uint32",
+        name: "nonce",
+        type: "uint32"
+      },
+      {
+        internalType: "bytes",
+        name: "payload",
+        type: "bytes"
+      }
+    ],
+    name: "transferTokensWithPayload",
+    outputs: [
+      {
+        internalType: "uint64",
+        name: "sequence",
+        type: "uint64"
+      }
+    ],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "encodedVm",
+        type: "bytes"
+      }
+    ],
+    name: "updateWrapped",
+    outputs: [
+      {
+        internalType: "address",
+        name: "token",
+        type: "address"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "encodedVm",
+        type: "bytes"
+      }
+    ],
+    name: "createWrapped",
+    outputs: [
+      {
+        internalType: "address",
+        name: "token",
+        type: "address"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "encodedVm",
+        type: "bytes"
+      }
+    ],
+    name: "completeTransferWithPayload",
+    outputs: [
+      {
+        internalType: "bytes",
+        name: "",
+        type: "bytes"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "encodedVm",
+        type: "bytes"
+      }
+    ],
+    name: "completeTransferAndUnwrapETHWithPayload",
+    outputs: [
+      {
+        internalType: "bytes",
+        name: "",
+        type: "bytes"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "encodedVm",
+        type: "bytes"
+      }
+    ],
+    name: "completeTransfer",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "encodedVm",
+        type: "bytes"
+      }
+    ],
+    name: "completeTransferAndUnwrapETH",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        components: [
+          {
+            internalType: "uint8",
+            name: "payloadID",
+            type: "uint8"
+          },
+          {
+            internalType: "bytes32",
+            name: "tokenAddress",
+            type: "bytes32"
+          },
+          {
+            internalType: "uint16",
+            name: "tokenChain",
+            type: "uint16"
+          },
+          {
+            internalType: "uint8",
+            name: "decimals",
+            type: "uint8"
+          },
+          {
+            internalType: "bytes32",
+            name: "symbol",
+            type: "bytes32"
+          },
+          {
+            internalType: "bytes32",
+            name: "name",
+            type: "bytes32"
+          }
+        ],
+        internalType: "struct BridgeStructs.AssetMeta",
+        name: "meta",
+        type: "tuple"
+      }
+    ],
+    name: "encodeAssetMeta",
+    outputs: [
+      {
+        internalType: "bytes",
+        name: "encoded",
+        type: "bytes"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        components: [
+          {
+            internalType: "uint8",
+            name: "payloadID",
+            type: "uint8"
+          },
+          {
+            internalType: "uint256",
+            name: "amount",
+            type: "uint256"
+          },
+          {
+            internalType: "bytes32",
+            name: "tokenAddress",
+            type: "bytes32"
+          },
+          {
+            internalType: "uint16",
+            name: "tokenChain",
+            type: "uint16"
+          },
+          {
+            internalType: "bytes32",
+            name: "to",
+            type: "bytes32"
+          },
+          {
+            internalType: "uint16",
+            name: "toChain",
+            type: "uint16"
+          },
+          {
+            internalType: "uint256",
+            name: "fee",
+            type: "uint256"
+          }
+        ],
+        internalType: "struct BridgeStructs.Transfer",
+        name: "transfer",
+        type: "tuple"
+      }
+    ],
+    name: "encodeTransfer",
+    outputs: [
+      {
+        internalType: "bytes",
+        name: "encoded",
+        type: "bytes"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        components: [
+          {
+            internalType: "uint8",
+            name: "payloadID",
+            type: "uint8"
+          },
+          {
+            internalType: "uint256",
+            name: "amount",
+            type: "uint256"
+          },
+          {
+            internalType: "bytes32",
+            name: "tokenAddress",
+            type: "bytes32"
+          },
+          {
+            internalType: "uint16",
+            name: "tokenChain",
+            type: "uint16"
+          },
+          {
+            internalType: "bytes32",
+            name: "to",
+            type: "bytes32"
+          },
+          {
+            internalType: "uint16",
+            name: "toChain",
+            type: "uint16"
+          },
+          {
+            internalType: "bytes32",
+            name: "fromAddress",
+            type: "bytes32"
+          },
+          {
+            internalType: "bytes",
+            name: "payload",
+            type: "bytes"
+          }
+        ],
+        internalType: "struct BridgeStructs.TransferWithPayload",
+        name: "transfer",
+        type: "tuple"
+      }
+    ],
+    name: "encodeTransferWithPayload",
+    outputs: [
+      {
+        internalType: "bytes",
+        name: "encoded",
+        type: "bytes"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "encoded",
+        type: "bytes"
+      }
+    ],
+    name: "parsePayloadID",
+    outputs: [
+      {
+        internalType: "uint8",
+        name: "payloadID",
+        type: "uint8"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "encoded",
+        type: "bytes"
+      }
+    ],
+    name: "parseAssetMeta",
+    outputs: [
+      {
+        components: [
+          {
+            internalType: "uint8",
+            name: "payloadID",
+            type: "uint8"
+          },
+          {
+            internalType: "bytes32",
+            name: "tokenAddress",
+            type: "bytes32"
+          },
+          {
+            internalType: "uint16",
+            name: "tokenChain",
+            type: "uint16"
+          },
+          {
+            internalType: "uint8",
+            name: "decimals",
+            type: "uint8"
+          },
+          {
+            internalType: "bytes32",
+            name: "symbol",
+            type: "bytes32"
+          },
+          {
+            internalType: "bytes32",
+            name: "name",
+            type: "bytes32"
+          }
+        ],
+        internalType: "struct BridgeStructs.AssetMeta",
+        name: "meta",
+        type: "tuple"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "encoded",
+        type: "bytes"
+      }
+    ],
+    name: "parseTransfer",
+    outputs: [
+      {
+        components: [
+          {
+            internalType: "uint8",
+            name: "payloadID",
+            type: "uint8"
+          },
+          {
+            internalType: "uint256",
+            name: "amount",
+            type: "uint256"
+          },
+          {
+            internalType: "bytes32",
+            name: "tokenAddress",
+            type: "bytes32"
+          },
+          {
+            internalType: "uint16",
+            name: "tokenChain",
+            type: "uint16"
+          },
+          {
+            internalType: "bytes32",
+            name: "to",
+            type: "bytes32"
+          },
+          {
+            internalType: "uint16",
+            name: "toChain",
+            type: "uint16"
+          },
+          {
+            internalType: "uint256",
+            name: "fee",
+            type: "uint256"
+          }
+        ],
+        internalType: "struct BridgeStructs.Transfer",
+        name: "transfer",
+        type: "tuple"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "encoded",
+        type: "bytes"
+      }
+    ],
+    name: "parseTransferWithPayload",
+    outputs: [
+      {
+        components: [
+          {
+            internalType: "uint8",
+            name: "payloadID",
+            type: "uint8"
+          },
+          {
+            internalType: "uint256",
+            name: "amount",
+            type: "uint256"
+          },
+          {
+            internalType: "bytes32",
+            name: "tokenAddress",
+            type: "bytes32"
+          },
+          {
+            internalType: "uint16",
+            name: "tokenChain",
+            type: "uint16"
+          },
+          {
+            internalType: "bytes32",
+            name: "to",
+            type: "bytes32"
+          },
+          {
+            internalType: "uint16",
+            name: "toChain",
+            type: "uint16"
+          },
+          {
+            internalType: "bytes32",
+            name: "fromAddress",
+            type: "bytes32"
+          },
+          {
+            internalType: "bytes",
+            name: "payload",
+            type: "bytes"
+          }
+        ],
+        internalType: "struct BridgeStructs.TransferWithPayload",
+        name: "transfer",
+        type: "tuple"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "encoded",
+        type: "bytes"
+      }
+    ],
+    name: "_parseTransferCommon",
+    outputs: [
+      {
+        components: [
+          {
+            internalType: "uint8",
+            name: "payloadID",
+            type: "uint8"
+          },
+          {
+            internalType: "uint256",
+            name: "amount",
+            type: "uint256"
+          },
+          {
+            internalType: "bytes32",
+            name: "tokenAddress",
+            type: "bytes32"
+          },
+          {
+            internalType: "uint16",
+            name: "tokenChain",
+            type: "uint16"
+          },
+          {
+            internalType: "bytes32",
+            name: "to",
+            type: "bytes32"
+          },
+          {
+            internalType: "uint16",
+            name: "toChain",
+            type: "uint16"
+          },
+          {
+            internalType: "uint256",
+            name: "fee",
+            type: "uint256"
+          }
+        ],
+        internalType: "struct BridgeStructs.Transfer",
+        name: "transfer",
+        type: "tuple"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  }
+];
+
+// src/mrl/providers/wormhole/contract/TokenBridge/TokenBridge.ts
+var module3 = "TokenBridge";
+function TokenBridge() {
+  return {
+    transferTokens: () => ({
+      build: ({ asset, destination, destinationAddress, moonChain }) => {
+        const wh = wormholeFactory(moonChain);
+        const whDestination = wh.getChain(destination.getWormholeName()).config.chainId;
+        const tokenAddressOnMoonChain = moonChain.getChainAsset(asset).address;
+        if (!tokenAddressOnMoonChain) {
+          throw new Error(
+            `Asset ${asset.symbol} does not have a token address on chain ${moonChain.name}`
+          );
+        }
+        const destinationAddress32bytes = convertAddressTo32Bytes(
+          destinationAddress
+        );
+        const tokenAmountOnMoonChain = asset.convertDecimals(
+          moonChain.getChainAsset(asset).decimals
+        ).amount;
+        const contractAddress = wh.getChain("Moonbeam").config.contracts.tokenBridge;
+        if (!contractAddress) {
+          throw new Error(`Wormhole address not found for ${moonChain.name}`);
+        }
+        return new ContractConfig({
+          address: contractAddress,
+          abi: TOKEN_BRIDGE_ABI,
+          args: [
+            tokenAddressOnMoonChain,
+            tokenAmountOnMoonChain,
+            whDestination,
+            destinationAddress32bytes,
+            0n,
+            0
+          ],
+          func: "transferTokens",
+          module: module3
+        });
+      }
+    })
+  };
+}
+
+// src/mrl/providers/wormhole/contract/TokenBridgeRelayer/TokenBridgeRelayer.ts
+import { convertAddressTo32Bytes as convertAddressTo32Bytes2 } from "@moonbeam-network/xcm-utils";
+
+// src/mrl/providers/wormhole/contract/TokenBridgeRelayer/TokenBridgeRelayerAbi.ts
+var TOKEN_BRIDGE_RELAYER_ABI = [
+  {
+    inputs: [
+      {
+        internalType: "uint16",
+        name: "targetChainId",
+        type: "uint16"
+      },
+      {
+        internalType: "address",
+        name: "token",
+        type: "address"
+      },
+      {
+        internalType: "uint8",
+        name: "decimals",
+        type: "uint8"
+      }
+    ],
+    name: "calculateRelayerFee",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "feeInTokenDenomination",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "token",
+        type: "address"
+      },
+      {
+        internalType: "uint256",
+        name: "amount",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "toNativeTokenAmount",
+        type: "uint256"
+      },
+      {
+        internalType: "uint16",
+        name: "targetChain",
+        type: "uint16"
+      },
+      {
+        internalType: "bytes32",
+        name: "targetRecipient",
+        type: "bytes32"
+      },
+      {
+        internalType: "uint32",
+        name: "batchId",
+        type: "uint32"
+      }
+    ],
+    name: "transferTokensWithRelay",
+    outputs: [
+      {
+        internalType: "uint64",
+        name: "messageSequence",
+        type: "uint64"
+      }
+    ],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "toNativeTokenAmount",
+        type: "uint256"
+      },
+      {
+        internalType: "uint16",
+        name: "targetChain",
+        type: "uint16"
+      },
+      {
+        internalType: "bytes32",
+        name: "targetRecipient",
+        type: "bytes32"
+      },
+      {
+        internalType: "uint32",
+        name: "batchId",
+        type: "uint32"
+      }
+    ],
+    name: "wrapAndTransferEthWithRelay",
+    outputs: [
+      {
+        internalType: "uint64",
+        name: "messageSequence",
+        type: "uint64"
+      }
+    ],
+    stateMutability: "payable",
+    type: "function"
+  }
+];
+
+// src/mrl/providers/wormhole/contract/TokenBridgeRelayer/TokenBridgeRelayer.ts
+var module4 = "TokenBridgeRelayer";
+function TokenBridgeRelayer() {
+  return {
+    transferTokensWithRelay: () => ({
+      build: ({ asset, destination, destinationAddress, moonChain }) => {
+        const wh = wormholeFactory(moonChain);
+        const whDestination = wh.getChain(destination.getWormholeName()).config.chainId;
+        const tokenAddressOnMoonChain = moonChain.getChainAsset(asset).address;
+        if (!tokenAddressOnMoonChain) {
+          throw new Error(
+            `Asset ${asset.symbol} does not have a token address on chain ${moonChain.name}`
+          );
+        }
+        const destinationAddress32bytes = convertAddressTo32Bytes2(
+          destinationAddress
+        );
+        const tokenAmountOnMoonChain = asset.convertDecimals(
+          moonChain.getChainAsset(asset).decimals
+        ).amount;
+        const contractAddress = wh.getChain("Moonbeam").config.contracts.tokenBridgeRelayer;
+        if (!contractAddress) {
+          throw new Error(`Wormhole address not found for ${moonChain.name}`);
+        }
+        return new ContractConfig({
+          address: contractAddress,
+          abi: TOKEN_BRIDGE_RELAYER_ABI,
+          args: [
+            tokenAddressOnMoonChain,
+            tokenAmountOnMoonChain,
+            0,
+            whDestination,
+            destinationAddress32bytes,
+            0
+          ],
+          func: "transferTokensWithRelay",
+          module: module4
+        });
+      }
+    })
+  };
+}
+
+// src/mrl/providers/wormhole/contract/index.ts
+function contract() {
+  return { Batch, Gmp, TokenBridge, TokenBridgeRelayer };
+}
+
+// src/mrl/providers/wormhole/extrinsic/ethereumXcm/ethereumXcm.ts
+import { encodeFunctionData as encodeFunctionData3 } from "viem";
+
+// src/mrl/MrlBuilder.constants.ts
+var BATCH_CONTRACT_ADDRESS = "0x0000000000000000000000000000000000000808";
+
+// src/mrl/providers/wormhole/extrinsic/ethereumXcm/BatchContractAbi.ts
+var BATCH_CONTRACT_ABI = [
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "index",
+        type: "uint256"
+      }
+    ],
+    name: "SubcallFailed",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "index",
+        type: "uint256"
+      }
+    ],
+    name: "SubcallSucceeded",
+    type: "event"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address[]",
+        name: "to",
+        type: "address[]"
+      },
+      {
+        internalType: "uint256[]",
+        name: "value",
+        type: "uint256[]"
+      },
+      {
+        internalType: "bytes[]",
+        name: "callData",
+        type: "bytes[]"
+      },
+      {
+        internalType: "uint64[]",
+        name: "gasLimit",
+        type: "uint64[]"
+      }
+    ],
+    name: "batchAll",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address[]",
+        name: "to",
+        type: "address[]"
+      },
+      {
+        internalType: "uint256[]",
+        name: "value",
+        type: "uint256[]"
+      },
+      {
+        internalType: "bytes[]",
+        name: "callData",
+        type: "bytes[]"
+      },
+      {
+        internalType: "uint64[]",
+        name: "gasLimit",
+        type: "uint64[]"
+      }
+    ],
+    name: "batchSome",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address[]",
+        name: "to",
+        type: "address[]"
+      },
+      {
+        internalType: "uint256[]",
+        name: "value",
+        type: "uint256[]"
+      },
+      {
+        internalType: "bytes[]",
+        name: "callData",
+        type: "bytes[]"
+      },
+      {
+        internalType: "uint64[]",
+        name: "gasLimit",
+        type: "uint64[]"
+      }
+    ],
+    name: "batchSomeUntilFailure",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
+
+// src/mrl/providers/wormhole/extrinsic/ethereumXcm/ethereumXcm.ts
+function ethereumXcm() {
+  return {
+    transact: () => ({
+      build: (params) => {
+        const { asset, isAutomatic, moonChain, moonGasLimit } = params;
+        if (!moonGasLimit) {
+          throw new Error("moonGasLimit must be defined");
+        }
+        const tokenAddressOnMoonChain = moonChain.getChainAsset(asset).address;
+        if (!tokenAddressOnMoonChain) {
+          throw new Error(
+            `Asset ${asset.symbol} does not have a token address on chain ${moonChain.name}`
+          );
+        }
+        const tokenAmountOnMoonChain = asset.convertDecimals(
+          moonChain.getChainAsset(asset).decimals
+        ).amount;
+        const contract2 = isAutomatic ? contract().TokenBridgeRelayer().transferTokensWithRelay().build(params) : contract().TokenBridge().transferTokens().build(params);
+        const approveTx = encodeFunctionData3({
+          abi: ERC20_ABI,
+          functionName: "approve",
+          args: [contract2.address, tokenAmountOnMoonChain]
+        });
+        const batchAll = encodeFunctionData3({
+          abi: BATCH_CONTRACT_ABI,
+          functionName: "batchAll",
+          args: [
+            [tokenAddressOnMoonChain, contract2.address],
+            [0n, 0n],
+            // Value to send for each call
+            [approveTx, contract2.encodeFunctionData()],
+            // Call data for each call
+            []
+            // Gas limit for each call
+          ]
+        });
+        return new ExtrinsicConfig({
+          module: "ethereumXcm",
+          func: "transact",
+          getArgs: () => [
+            {
+              V2: {
+                gasLimit: moonGasLimit,
+                action: {
+                  Call: BATCH_CONTRACT_ADDRESS
+                },
+                value: 0,
+                input: batchAll
+              }
+            }
+          ]
+        });
+      }
+    })
+  };
+}
+
+// src/mrl/providers/wormhole/extrinsic/index.ts
+function extrinsic() {
+  return { ethereumXcm, polkadotXcm: polkadotXcm2 };
+}
+
+// src/mrl/providers/wormhole/index.ts
+function wormhole2() {
+  return {
+    contract,
+    extrinsic,
+    wormhole
+  };
+}
+
+// src/mrl/MrlBuilder.ts
+function MrlBuilder() {
+  return {
+    wormhole: wormhole2
+  };
+}
+export {
+  AssetMinBuilder,
+  BATCH_CONTRACT_ABI,
+  BATCH_CONTRACT_ADDRESS,
+  BalanceBuilder,
+  ContractBuilder,
+  ContractConfig,
+  ERC20_ABI,
+  EvmQueryConfig,
+  ExtrinsicBuilder,
+  ExtrinsicConfig,
+  FeeBuilder,
+  MrlBuilder,
+  SubstrateCallConfig,
+  SubstrateQueryConfig,
+  WormholeConfig,
+  XcmVersion,
+  calculateSystemAccountBalance,
+  evm,
+  substrate,
+  wormhole2 as wormhole,
+  wormholeFactory
+};
 //# sourceMappingURL=index.mjs.map