@moonbeam-network/xcm-builder 1.0.0-dev.154 → 1.0.0-dev.155

package/build/index.mjs

@@ -1,2 +1,4479 @@
-import"@polkadot/api-augment";import{getTypeDef as tt}from"@polkadot/types";import{u8aToHex as et}from"@polkadot/util";import{decodeAddress as rt}from"@polkadot/util-crypto";var p=(i=>(i.v1="V1",i.v2="V2",i.v3="V3",i.v4="V4",i))(p||{});function d(r,t=0){if(!r)return"V1";let{type:e}=r.meta.args[t],n=r.meta.registry.createType(e.toString()),i=tt(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 c(r){return r.length===42&&r.startsWith("0x")?{AccountKey20:{key:r}}:{AccountId32:{id:et(rt(r)),network:null}}}var b=(e=>(e.Evm="Evm",e.Substrate="Substrate",e))(b||{});var l=class{module;func;type;constructor({module:t,func:e,type:n}){this.module=t,this.func=e,this.type=n}};var u=class extends l{args;transform;constructor({args:t=[],transform:e,type:n="Substrate",...i}){super({...i,type:n}),this.args=t,this.transform=e}};function Ut(){return{assetRegistry:nt,assets:it,foreignAssets:ot}}function nt(){let r="assetRegistry";return{assetMetadatas:()=>({build:({asset:t})=>new u({module:r,func:"assetMetadatas",args:[t],transform:async e=>e.unwrapOrDefault().minimalBalance.toBigInt()})}),currencyMetadatas:()=>({build:({asset:t})=>new u({module:r,func:"currencyMetadatas",args:[t],transform:async e=>e.unwrapOrDefault().minimalBalance.toBigInt()})})}}function it(){return{asset:()=>({build:({asset:r})=>new u({module:"assets",func:"asset",args:[r],transform:async t=>t.unwrapOrDefault().minBalance.toBigInt()})})}}function ot(){return{asset:()=>({build:({asset:r})=>{let t={parents:2,interior:{X2:[{globalconsensus:{ethereum:{chainId:1}}},c(r)]}};return new u({module:"foreignAssets",func:"asset",args:[t],transform:async e=>e.unwrapOrDefault().minBalance.toBigInt()})}})}}import{isString as ct}from"@polkadot/util";import{evmToAddress as ut}from"@polkadot/util-crypto";import{formatAssetIdToERC20 as P}from"@moonbeam-network/xcm-utils";import{isString as E,u8aToHex as D}from"@polkadot/util";import{decodeAddress as k,evmToAddress as st}from"@polkadot/util-crypto";var f=class extends l{args;address;constructor({args:t,address:e,...n}){super({...n,type:"Evm"}),this.args=t,this.address=e}};var T=18446744073709551615n;function N(){return{transfer:(r=T)=>({build:({address:t,amount:e,asset:n,destination:i})=>new f({args:[E(n)?P(n):n,e,O(t,i),r],func:"transfer",module:"Xtokens"})}),transferMultiCurrencies:(r=T)=>({build:({address:t,amount:e,asset:n,destination:i,fee:o,feeAsset:s})=>new f({args:[[[E(n)?P(n):n,e],[E(s)?P(s):s,o]],1,O(t,i),r],func:"transferMultiCurrencies",module:"Xtokens"})}),transferWithEvmTo32:(r=T)=>({build:({address:t,amount:e,asset:n,destination:i})=>{let o=at(t,i);return new f({args:[E(n)?P(n):n,e,o,r],func:"transfer",module:"Xtokens"})}})}}function at(r,t){let e="01",n=st(r),i=`0x${e}${D(k(n),-1,!1)}00`;return[1,t.parachainId?[`0x0000000${t.parachainId.toString(16)}`,i]:[i]]}function O(r,t){let n=`0x${t.isEvmParachain()?"03":"01"}${D(k(r),-1,!1)}00`;return[1,t.parachainId?[`0x0000000${t.parachainId.toString(16)}`,n]:[n]]}function oe(){return{Xtokens:N}}function Ae(){return{evm:mt,substrate:lt}}function mt(){return{erc20:ft}}function lt(){return{assets:gt,foreignAssets:dt,system:pt,tokens:At}}function ft(){return{build:({address:r,asset:t})=>{if(!t||!ct(t))throw new Error(`Invalid contract address: ${t}`);return new f({address:t,args:[r],func:"balanceOf",module:"Erc20"})}}}function gt(){return{account:()=>({build:({address:r,asset:t})=>new u({module:"assets",func:"account",args:[t,r],transform:async e=>e.unwrapOrDefault().balance.toBigInt()})})}}function dt(){return{account:()=>({build:({address:r,asset:t})=>{let e={parents:2,interior:{X2:[{GlobalConsensus:{ethereum:{chainId:1}}},c(t)]}};return new u({module:"foreignAssets",func:"account",args:[e,r],transform:async n=>n.unwrapOrDefault().balance.toBigInt()})}})}}function pt(){return{account:()=>({build:({address:r})=>new u({module:"system",func:"account",args:[r],transform:async t=>M(t)})}),accountEquilibrium:()=>({build:({address:r,asset:t})=>new u({module:"system",func:"account",args:[r],transform:async e=>{var s;if(e.data.isEmpty)return 0n;let n=e.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(([m])=>m===t);return o?BigInt(o[1].positive):0n}})}),accountEvmTo32:()=>({build:({address:r})=>{let t=ut(r);return new u({module:"system",func:"account",args:[t],transform:async e=>M(e)})}})}}function At(){return{accounts:()=>({build:({address:r,asset:t})=>new u({module:"tokens",func:"accounts",args:[r,t],transform:async({free:e,frozen:n})=>BigInt(e.sub(n).toString())})})}}async function M(r){let t=r.data,e=BigInt(t.free.toString()),n=t.miscFrozen??t.frozen,i=BigInt(n.sub(t.reserved).toString()),o=i<0n?0n:i;return e-o}var a=class extends l{getArgs;constructor({getArgs:t,...e}){super({...e,type:"Substrate"}),this.getArgs=t}};var R="eqBalances";function W(){return{xcmTransfer:()=>({build:({address:r,amount:t,asset:e,destination:n})=>new a({module:R,func:"xcmTransfer",getArgs:()=>[e,t,{parents:1,interior:{X2:[{Parachain:n.parachainId},c(r)]}},"ThisAccWillPay"]})}),transferXcm:()=>({build:({address:r,amount:t,asset:e,destination:n,fee:i,feeAsset:o})=>new a({module:R,func:"transferXcm",getArgs:()=>{let s=t-i>0n?t-i:0n;return[[e,e===o?s:t],[o,i],{parents:1,interior:{X2:[{Parachain:n.parachainId},c(r)]}}]}})})}}function g({asset:r,address:t,destination:e,func:n,parents:i=1,feeIndex:o=0}){let s=d(n);return[{[s]:{parents:i,interior:{X1:{Parachain:e.parachainId}}}},{[s]:{parents:0,interior:{X1:c(t)}}},{[s]:r},o,"Unlimited"]}function _({asset:r,feeAsset:t}){let e=Number(r),n=Number(t);return Number.isNaN(e)||Number.isNaN(n)?!1:e>n}var A="polkadotXcm";function L(){return{limitedReserveTransferAssets:()=>{let r="limitedReserveTransferAssets";return{here:()=>({build:t=>new a({module:A,func:r,getArgs:e=>g({...t,func:e,asset:[{id:{Concrete:{parents:0,interior:"Here"}},fun:{Fungible:t.amount}}]})})}),X1:()=>({build:t=>new a({module:A,func:r,getArgs:e=>g({...t,func:e,asset:[{id:{Concrete:{parents:0,interior:{X1:{PalletInstance:t.palletInstance}}}},fun:{Fungible:t.amount}}]})})}),X2:()=>({build:t=>new a({module:A,func:r,getArgs:e=>{let n=!!t.feeAsset&&t.asset!==t.feeAsset,i=[{id:{Concrete:{parents:0,interior:{X2:[{PalletInstance:t.palletInstance},{GeneralIndex:t.asset}]}}},fun:{Fungible:t.amount}}],o=_(t);if(n){let s={id:{Concrete:{parents:0,interior:{X2:[{PalletInstance:t.palletInstance},{GeneralIndex:t.feeAsset}]}}},fun:{Fungible:t.fee}};o?i.unshift(s):i.push(s)}return g({...t,func:e,asset:i,feeIndex:n&&!o?1:0})}})})}},limitedReserveWithdrawAssets:()=>{let r="limitedReserveWithdrawAssets";return{X2:()=>({build:t=>new a({module:A,func:r,getArgs:e=>g({...t,func:e,asset:[{id:{Concrete:{parents:1,interior:{X2:[{Parachain:t.destination.parachainId},{PalletInstance:t.palletInstance}]}}},fun:{Fungible:t.amount}}]})})})}},trasferAssets:()=>{let r="transferAssets";return{here:()=>({build:t=>new a({module:A,func:r,getArgs:e=>g({...t,func:e,asset:[{id:{Concrete:{parents:1,interior:"Here"}},fun:{Fungible:t.amount}}]})})})}},transferAssetsUsingTypeAndThen:()=>{let r="transferAssetsUsingTypeAndThen";return{globalConcensusEthereum:()=>({build:({destination:t,address:e,amount:n,asset:i})=>{let o="V4";return new a({module:A,func:r,getArgs:()=>[{[o]:{parents:1,interior:{X1:[{Parachain:t.parachainId}]}}},{[o]:[{id:{parents:2,interior:{X2:[{globalConsensus:{Ethereum:{ChainId:1}}},c(i)]}},fun:{fungible:n}}]},"LocalReserve",{[o]:{parents:2,interior:{X2:[{globalConsensus:{Ethereum:{ChainId:1}}},c(i)]}}},"LocalReserve",{[o]:[{DepositAsset:{assets:{Wild:{AllCounted:1}},beneficiary:{parents:0,interior:{X1:[c(e)]}}}}]},"Unlimited"]})}})}}}}function x(){return"Unlimited"}function C(r,t,e){return{[r]:{parents:1,interior:{X2:[{Parachain:e.parachainId},c(t)]}}}}var h="xTokens";function V(){return{transfer:()=>({build:({address:r,amount:t,asset:e,destination:n})=>new a({module:h,func:"transfer",getArgs:i=>{let o=d(i,2);return[e,t,C(o,r,n),x()]}})}),transferMultiAsset:r=>{let t="transferMultiasset";return{here:()=>({build:({address:e,amount:n,destination:i})=>new a({module:h,func:t,getArgs:o=>{let s=d(o,1);return[{[s]:{id:{Concrete:{parents:0,interior:"Here"}},fun:{Fungible:n}}},C(s,e,i),x()]}})}),X1:()=>({build:({address:e,amount:n,destination:i})=>new a({module:h,func:t,getArgs:o=>{let s=d(o,1);return[{[s]:{id:{Concrete:{parents:1,interior:{X1:{Parachain:r}}}},fun:{Fungible:n}}},C(s,e,i),x()]}})}),X2:()=>({build:({address:e,amount:n,asset:i,destination:o})=>new a({module:h,func:t,getArgs:s=>{let m=d(s,1);return[{[m]:{id:{Concrete:{parents:1,interior:{X2:[{Parachain:r},{GeneralKey:i}]}}},fun:{Fungible:n}}},C(m,e,o),x()]}})})}},transferMultiCurrencies:()=>({build:({address:r,amount:t,asset:e,destination:n,fee:i,feeAsset:o})=>new a({module:h,func:"transferMulticurrencies",getArgs:()=>[[[e,t],[o,i]],1,C("V3",r,n),x()]})})}}var U="xTransfer";function H(){return{transfer:()=>{let r="transfer";return{here:()=>({build:({address:t,amount:e,destination:n})=>new a({module:U,func:r,getArgs:()=>[{id:{Concrete:{parents:0,interior:"Here"}},fun:{Fungible:e}},{parents:1,interior:{X2:[{Parachain:n.parachainId},c(t)]}},{refTime:5e9,proofSize:0}]})}),X2:()=>({build:({address:t,amount:e,destination:n,palletInstance:i})=>new a({module:U,func:r,getArgs:()=>[{id:{Concrete:{parents:1,interior:{X2:[{Parachain:n.parachainId},{PalletInstance:i}]}}},fun:{Fungible:e||1n}},{parents:1,interior:{X2:[{Parachain:n.parachainId},c(t)]}},{refTime:5e9,proofSize:0}]})})}}}}var j="xcmPallet";function q(){return{limitedReserveTransferAssets:(r=1)=>{let t="limitedReserveTransferAssets";return{here:()=>({build:e=>new a({module:j,func:t,getArgs:n=>g({...e,parents:r,func:n,asset:[{id:{Concrete:{parents:0,interior:"Here"}},fun:{Fungible:e.amount}}]})})})}},transferAssetsUsingTypeAndThen:()=>{let r="transferAssetsUsingTypeAndThen";return{here:()=>({build:t=>new a({module:j,func:r,getArgs:()=>{let e="V4";return[{[e]:{parents:0,interior:{X1:[{Parachain:t.destination.parachainId}]}}},{[e]:[{id:{parents:0,interior:"Here"},fun:{Fungible:t.amount}}]},"LocalReserve",{[e]:{parents:0,interior:"Here"}},"LocalReserve",{[e]:[{DepositAsset:{assets:{Wild:{AllCounted:1}},beneficiary:{parents:0,interior:{X1:[c(t.address)]}}}}]},"Unlimited"]}})})}}}}function xr(){return{eqBalances:W,xTokens:V,xTransfer:H,polkadotXcm:L,xcmPallet:q}}var B=class{api;call;type="Substrate";constructor({api:t,call:e}){this.api=t,this.call=e}};import{isHexString as xt}from"@moonbeam-network/xcm-utils";var X=10**6,Ct="0xabcdef1234567890fedcba0987654321abcdef1234567890fedcba0987654321",yt="0x0000000000000000000000000000000000000802",bt={moonbeam:"10",moonriver:"10","moonbase-alpha":"3"},ht={moonbeam:"110",moonriver:"110","moonbase-alpha":"48"},w="V4";function y(){return w==="V4"}function Pt(r){if(!y())return r;let t={...r};return t.interior&&typeof t.interior=="object"&&"x1"in t.interior&&(Array.isArray(t.interior.x1)||(t.interior.x1=[t.interior.x1])),t}function z(r){return{WithdrawAsset:r.map(t=>({id:{...t},fun:{Fungible:X}}))}}function $(r){return{ReserveAssetDeposited:r.map(t=>({id:{...t},fun:{Fungible:X}}))}}function G(){return{ClearOrigin:"NULL"}}function K(r){return{BuyExecution:{fees:{id:{...r},fun:{Fungible:X}},weight_limit:{Unlimited:"NULL"}}}}function J(r,t){let e={AccountKey20:{key:r,network:null}};return{DepositAsset:{assets:{Wild:{AllCounted:t.length}},beneficiary:{interior:{X1:y()?[e]:e},parents:0},max_assets:0}}}function Q(){return{SetTopic:Ct}}function v(r){return{Concrete:{...r}}}function Et(r){let t={PalletInstance:bt[r]},e={interior:{X1:y()?[t]:t},parents:"0"};return y()?e:v(e)}function Bt(r,t){let e={interior:{X2:[{PalletInstance:ht[t]},{AccountKey20:{key:r,network:null}}]},parents:"0"};return y()?e:v(e)}async function It(r,t){let e=await r.query.assetManager.assetIdType(t);if(e.isNone||!e.unwrap().isXcm)throw new Error(`No asset type found for asset ${t}`);return e}async function S(r,t,e){if(t===yt)return Et(e.key);if(xt(t))return Bt(t,e.key);let i=(await It(r,t)).unwrap().asXcm.toJSON(),o=Pt(i);return y()?o:v(o)}async function Y(r,t,e){let n=await r.call.xcmPaymentApi.queryXcmWeight({[w]:t});if(!n.isOk)throw new Error("There was an error trying to get the weight for the xcm instructions (queryXcmWeight)");let i=n.asOk,o=await r.call.xcmPaymentApi.queryWeightToAssetFee(i,{[w]:{...e}});if(!o.isOk)throw new Error("There was an error trying to get the fee with the weight and asset (weightToForeingAssets)");return o.asOk.toBigInt()}function Sr(){return{xcmPaymentApi:Tt}}function Tt(){return{xcmPaymentFee:({isAssetReserveChain:r,shouldTransferAssetPrecedeAsset:t=!1})=>({build:({address:e,api:n,feeAsset:i,chain:o,transferAsset:s})=>new B({api:n,call:async()=>{let m=await S(n,i,o),F=await S(n,s,o),I=i===s?[m]:t?[F,m]:[m,F],Z=[r?z(I):$(I),G(),K(m),J(e,I),Q()];return Y(n,Z,m)}})})}}export{Ut as AssetMinBuilder,Ae as BalanceBuilder,l as BaseConfig,b as CallType,oe as ContractBuilder,f as ContractConfig,xr as ExtrinsicBuilder,a as ExtrinsicConfig,Sr as FeeBuilder,u as SubstrateQueryConfig,p as XcmVersion,M as calculateSystemAccountBalance,mt as evm,lt 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,
+        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
+        });
+        return new ExtrinsicConfig({
+          module: "utility",
+          func: "batchAll",
+          getArgs: () => [[...assetTransferTxs, send]]
+        });
+      }
+    })
+  };
+}
+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