@moonbeam-network/xcm-builder 1.0.0-dev.268 → 1.0.0-dev.269

package/build/index.mjs

@@ -92,7 +92,6 @@ var BaseConfig = class {
 // src/types/substrate/SubstrateQueryConfig.ts
 var SubstrateQueryConfig = class _SubstrateQueryConfig extends BaseConfig {
   args;
-  queryType;
   transform;
   static is(obj) {
     return obj instanceof _SubstrateQueryConfig;
@@ -100,12 +99,10 @@ var SubstrateQueryConfig = class _SubstrateQueryConfig extends BaseConfig {
   constructor({
     args = [],
     transform,
-    queryType = "query",
     ...other
   }) {
     super({ ...other });
     this.args = args;
-    this.queryType = queryType;
     this.transform = transform;
   }
 };
@@ -119,11 +116,11 @@ function AssetMinBuilder() {
   };
 }
 function assetRegistry() {
-  const pallet8 = "assetRegistry";
+  const pallet6 = "assetRegistry";
   return {
     assetMetadatas: () => ({
       build: ({ asset }) => new SubstrateQueryConfig({
-        module: pallet8,
+        module: pallet6,
         func: "assetMetadatas",
         args: [asset],
         // biome-ignore lint/suspicious/noExplicitAny: not sure how to fix this
@@ -132,7 +129,7 @@ function assetRegistry() {
     }),
     currencyMetadatas: () => ({
       build: ({ asset }) => new SubstrateQueryConfig({
-        module: pallet8,
+        module: pallet6,
         func: "currencyMetadatas",
         args: [asset],
         // biome-ignore lint/suspicious/noExplicitAny: not sure how to fix this
@@ -141,7 +138,7 @@ function assetRegistry() {
     }),
     metadata: () => ({
       build: ({ asset }) => new SubstrateQueryConfig({
-        module: pallet8,
+        module: pallet6,
         func: "metadata",
         args: [asset],
         // biome-ignore lint/suspicious/noExplicitAny: not sure how to fix this
@@ -205,8 +202,8 @@ import { encodeFunctionData } from "viem";
 var ContractConfig = class _ContractConfig extends BaseConfig {
   address;
   abi;
+  // biome-ignore lint/suspicious/noExplicitAny: not sure how to fix this
   args;
-  value;
   static is(obj) {
     return obj instanceof _ContractConfig;
   }
@@ -214,14 +211,12 @@ var ContractConfig = class _ContractConfig extends BaseConfig {
     address,
     abi,
     args,
-    value,
     ...other
   }) {
     super({ ...other });
     this.address = address;
     this.abi = abi;
     this.args = args;
-    this.value = value;
   }
   encodeFunctionData() {
     return encodeFunctionData({
@@ -3074,902 +3069,55 @@ function xTransfer() {
                     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/ExtrinsicBuilder.ts
-function ExtrinsicBuilder() {
-  return {
-    eqBalances,
-    xTokens,
-    xTransfer,
-    polkadotXcm,
-    xcmPallet
-  };
-}
-
-// src/fee/gateway/gateway.ts
-import { EvmChain, EvmParachain as EvmParachain2 } from "@moonbeam-network/xcm-types";
-
-// src/mrl/providers/snowbridge/contract/Gateway/GatewayAbi.ts
-var GATEWAY_ABI = [
-  {
-    inputs: [
-      { internalType: "address", name: "beefyClient", type: "address" },
-      { internalType: "address", name: "agentExecutor", type: "address" },
-      { internalType: "ParaID", name: "bridgeHubParaID", type: "uint32" },
-      { internalType: "bytes32", name: "bridgeHubAgentID", type: "bytes32" },
-      { internalType: "uint8", name: "foreignTokenDecimals", type: "uint8" },
-      { internalType: "uint128", name: "maxDestinationFee", type: "uint128" }
-    ],
-    stateMutability: "nonpayable",
-    type: "constructor"
-  },
-  { inputs: [], name: "AgentAlreadyCreated", type: "error" },
-  { inputs: [], name: "AgentDoesNotExist", type: "error" },
-  { inputs: [], name: "CantSetMiddlewareToSameAddress", type: "error" },
-  { inputs: [], name: "CantSetMiddlewareToZeroAddress", type: "error" },
-  { inputs: [], name: "ChannelAlreadyCreated", type: "error" },
-  { inputs: [], name: "ChannelDoesNotExist", type: "error" },
-  { inputs: [], name: "Disabled", type: "error" },
-  {
-    inputs: [
-      { internalType: "uint256", name: "epoch", type: "uint256" },
-      { internalType: "uint256", name: "eraIndex", type: "uint256" },
-      { internalType: "address", name: "tokenAddress", type: "address" },
-      { internalType: "uint256", name: "totalPointsToken", type: "uint256" },
-      { internalType: "uint256", name: "totalTokensInflated", type: "uint256" },
-      { internalType: "bytes32", name: "rewardsRoot", type: "bytes32" },
-      { internalType: "bytes", name: "errorBytes", type: "bytes" }
-    ],
-    name: "EUnableToProcessRewardsB",
-    type: "error"
-  },
-  {
-    inputs: [
-      { internalType: "uint256", name: "epoch", type: "uint256" },
-      { internalType: "uint256", name: "eraIndex", type: "uint256" },
-      { internalType: "address", name: "tokenAddress", type: "address" },
-      { internalType: "uint256", name: "totalPointsToken", type: "uint256" },
-      { internalType: "uint256", name: "totalTokensInflated", type: "uint256" },
-      { internalType: "bytes32", name: "rewardsRoot", type: "bytes32" },
-      { internalType: "string", name: "errorString", type: "string" }
-    ],
-    name: "EUnableToProcessRewardsS",
-    type: "error"
-  },
-  { inputs: [], name: "FeePaymentToLow", type: "error" },
-  { inputs: [], name: "InvalidAgentExecutionPayload", type: "error" },
-  { inputs: [], name: "InvalidChannelUpdate", type: "error" },
-  { inputs: [], name: "InvalidCodeHash", type: "error" },
-  { inputs: [], name: "InvalidConstructorParams", type: "error" },
-  { inputs: [], name: "InvalidContract", type: "error" },
-  { inputs: [], name: "InvalidNonce", type: "error" },
-  { inputs: [], name: "InvalidProof", type: "error" },
-  { inputs: [], name: "MiddlewareNotSet", type: "error" },
-  { inputs: [], name: "NativeTransferFailed", type: "error" },
-  { inputs: [], name: "NotEnoughGas", type: "error" },
-  { inputs: [], name: "Operators__OperatorsKeysCannotBeEmpty", type: "error" },
-  { inputs: [], name: "Operators__OperatorsLengthTooLong", type: "error" },
-  {
-    inputs: [
-      { internalType: "uint256", name: "x", type: "uint256" },
-      { internalType: "uint256", name: "y", type: "uint256" }
-    ],
-    name: "PRBMath_MulDiv18_Overflow",
-    type: "error"
-  },
-  {
-    inputs: [
-      { internalType: "uint256", name: "x", type: "uint256" },
-      { internalType: "uint256", name: "y", type: "uint256" },
-      { internalType: "uint256", name: "denominator", type: "uint256" }
-    ],
-    name: "PRBMath_MulDiv_Overflow",
-    type: "error"
-  },
-  {
-    inputs: [{ internalType: "uint256", name: "x", type: "uint256" }],
-    name: "PRBMath_UD60x18_Convert_Overflow",
-    type: "error"
-  },
-  {
-    inputs: [{ internalType: "UD60x18", name: "x", type: "uint256" }],
-    name: "PRBMath_UD60x18_Exp2_InputTooBig",
-    type: "error"
-  },
-  {
-    inputs: [{ internalType: "UD60x18", name: "x", type: "uint256" }],
-    name: "PRBMath_UD60x18_Log_InputTooSmall",
-    type: "error"
-  },
-  { inputs: [], name: "TokenNotRegistered", type: "error" },
-  { inputs: [], name: "Unauthorized", type: "error" },
-  {
-    anonymous: false,
-    inputs: [
-      {
-        indexed: false,
-        internalType: "bytes32",
-        name: "agentID",
-        type: "bytes32"
-      },
-      {
-        indexed: false,
-        internalType: "address",
-        name: "agent",
-        type: "address"
-      }
-    ],
-    name: "AgentCreated",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      {
-        indexed: true,
-        internalType: "bytes32",
-        name: "agentID",
-        type: "bytes32"
-      },
-      {
-        indexed: true,
-        internalType: "address",
-        name: "recipient",
-        type: "address"
-      },
-      {
-        indexed: false,
-        internalType: "uint256",
-        name: "amount",
-        type: "uint256"
-      }
-    ],
-    name: "AgentFundsWithdrawn",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      {
-        indexed: true,
-        internalType: "ChannelID",
-        name: "channelID",
-        type: "bytes32"
-      }
-    ],
-    name: "ChannelCreated",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      {
-        indexed: true,
-        internalType: "ChannelID",
-        name: "channelID",
-        type: "bytes32"
-      }
-    ],
-    name: "ChannelUpdated",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      {
-        indexed: true,
-        internalType: "bytes32",
-        name: "tokenID",
-        type: "bytes32"
-      },
-      {
-        indexed: false,
-        internalType: "address",
-        name: "token",
-        type: "address"
-      }
-    ],
-    name: "ForeignTokenRegistered",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      {
-        indexed: true,
-        internalType: "ChannelID",
-        name: "channelID",
-        type: "bytes32"
-      },
-      { indexed: false, internalType: "uint64", name: "nonce", type: "uint64" },
-      {
-        indexed: true,
-        internalType: "bytes32",
-        name: "messageID",
-        type: "bytes32"
-      },
-      { indexed: false, internalType: "bool", name: "success", type: "bool" }
-    ],
-    name: "InboundMessageDispatched",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      {
-        indexed: true,
-        internalType: "address",
-        name: "previousMiddleware",
-        type: "address"
-      },
-      {
-        indexed: true,
-        internalType: "address",
-        name: "newMiddleware",
-        type: "address"
-      }
-    ],
-    name: "MiddlewareChanged",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      {
-        indexed: false,
-        internalType: "enum OperatingMode",
-        name: "mode",
-        type: "uint8"
-      }
-    ],
-    name: "OperatingModeChanged",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      {
-        indexed: true,
-        internalType: "uint256",
-        name: "validatorsCount",
-        type: "uint256"
-      },
-      { indexed: false, internalType: "bytes", name: "payload", type: "bytes" }
-    ],
-    name: "OperatorsDataCreated",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      {
-        indexed: true,
-        internalType: "ChannelID",
-        name: "channelID",
-        type: "bytes32"
-      },
-      { indexed: false, internalType: "uint64", name: "nonce", type: "uint64" },
-      {
-        indexed: true,
-        internalType: "bytes32",
-        name: "messageID",
-        type: "bytes32"
-      },
-      { indexed: false, internalType: "bytes", name: "payload", type: "bytes" }
-    ],
-    name: "OutboundMessageAccepted",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      {
-        indexed: true,
-        internalType: "address",
-        name: "previousOwner",
-        type: "address"
-      },
-      {
-        indexed: true,
-        internalType: "address",
-        name: "newOwner",
-        type: "address"
-      }
-    ],
-    name: "OwnershipTransferred",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [],
-    name: "PricingParametersChanged",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      {
-        indexed: false,
-        internalType: "address",
-        name: "token",
-        type: "address"
-      }
-    ],
-    name: "TokenRegistrationSent",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      {
-        indexed: true,
-        internalType: "address",
-        name: "token",
-        type: "address"
-      },
-      {
-        indexed: true,
-        internalType: "address",
-        name: "sender",
-        type: "address"
-      },
-      {
-        indexed: true,
-        internalType: "ParaID",
-        name: "destinationChain",
-        type: "uint32"
-      },
-      {
-        components: [
-          { internalType: "enum Kind", name: "kind", type: "uint8" },
-          { internalType: "bytes", name: "data", type: "bytes" }
-        ],
-        indexed: false,
-        internalType: "struct MultiAddress",
-        name: "destinationAddress",
-        type: "tuple"
-      },
-      {
-        indexed: false,
-        internalType: "uint128",
-        name: "amount",
-        type: "uint128"
-      }
-    ],
-    name: "TokenSent",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [],
-    name: "TokenTransferFeesChanged",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      {
-        indexed: true,
-        internalType: "bytes32",
-        name: "operatorKey",
-        type: "bytes32"
-      },
-      {
-        indexed: false,
-        internalType: "uint256",
-        name: "slashFranction",
-        type: "uint256"
-      },
-      {
-        indexed: true,
-        internalType: "uint256",
-        name: "epoch",
-        type: "uint256"
-      },
-      { indexed: false, internalType: "bytes", name: "error", type: "bytes" }
-    ],
-    name: "UnableToProcessIndividualSlashB",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      {
-        indexed: true,
-        internalType: "bytes32",
-        name: "operatorKey",
-        type: "bytes32"
-      },
-      {
-        indexed: false,
-        internalType: "uint256",
-        name: "slashFranction",
-        type: "uint256"
-      },
-      {
-        indexed: true,
-        internalType: "uint256",
-        name: "epoch",
-        type: "uint256"
-      },
-      { indexed: false, internalType: "string", name: "error", type: "string" }
-    ],
-    name: "UnableToProcessIndividualSlashS",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      { indexed: false, internalType: "bytes", name: "error", type: "bytes" }
-    ],
-    name: "UnableToProcessRewardsMessageB",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      { indexed: false, internalType: "string", name: "error", type: "string" }
-    ],
-    name: "UnableToProcessRewardsMessageS",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      { indexed: false, internalType: "bytes", name: "error", type: "bytes" }
-    ],
-    name: "UnableToProcessSlashMessageB",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      { indexed: false, internalType: "string", name: "error", type: "string" }
-    ],
-    name: "UnableToProcessSlashMessageS",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      {
-        indexed: true,
-        internalType: "address",
-        name: "implementation",
-        type: "address"
-      }
-    ],
-    name: "Upgraded",
-    type: "event"
-  },
-  {
-    inputs: [],
-    name: "AGENT_EXECUTOR",
-    outputs: [{ internalType: "address", name: "", type: "address" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [],
-    name: "BEEFY_CLIENT",
-    outputs: [{ internalType: "address", name: "", type: "address" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [{ internalType: "bytes", name: "data", type: "bytes" }],
-    name: "agentExecute",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [{ internalType: "bytes32", name: "agentID", type: "bytes32" }],
-    name: "agentOf",
-    outputs: [{ internalType: "address", name: "", type: "address" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [{ internalType: "ChannelID", name: "channelID", type: "bytes32" }],
-    name: "channelNoncesOf",
-    outputs: [
-      { internalType: "uint64", name: "", type: "uint64" },
-      { internalType: "uint64", name: "", type: "uint64" }
-    ],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [{ internalType: "ChannelID", name: "channelID", type: "bytes32" }],
-    name: "channelOperatingModeOf",
-    outputs: [{ internalType: "enum OperatingMode", name: "", type: "uint8" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [{ internalType: "bytes", name: "data", type: "bytes" }],
-    name: "createAgent",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [{ internalType: "bytes", name: "data", type: "bytes" }],
-    name: "createChannel",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [],
-    name: "implementation",
-    outputs: [{ internalType: "address", name: "", type: "address" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [{ internalType: "bytes", name: "data", type: "bytes" }],
-    name: "initialize",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [{ internalType: "address", name: "token", type: "address" }],
-    name: "isTokenRegistered",
-    outputs: [{ internalType: "bool", name: "", type: "bool" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [{ internalType: "bytes", name: "data", type: "bytes" }],
-    name: "mintForeignToken",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [],
-    name: "operatingMode",
-    outputs: [{ internalType: "enum OperatingMode", name: "", type: "uint8" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [],
-    name: "pricingParameters",
-    outputs: [
-      { internalType: "UD60x18", name: "", type: "uint256" },
-      { internalType: "uint128", name: "", type: "uint128" }
-    ],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [{ internalType: "address", name: "token", type: "address" }],
-    name: "queryForeignTokenID",
-    outputs: [{ internalType: "bytes32", name: "", type: "bytes32" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [],
-    name: "quoteRegisterTokenFee",
-    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [
-      { internalType: "address", name: "token", type: "address" },
-      { internalType: "ParaID", name: "destinationChain", type: "uint32" },
-      { internalType: "uint128", name: "destinationFee", type: "uint128" }
-    ],
-    name: "quoteSendTokenFee",
-    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [{ internalType: "bytes", name: "data", type: "bytes" }],
-    name: "registerForeignToken",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [{ internalType: "address", name: "token", type: "address" }],
-    name: "registerToken",
-    outputs: [],
-    stateMutability: "payable",
-    type: "function"
-  },
-  {
-    inputs: [{ internalType: "bytes", name: "data", type: "bytes" }],
-    name: "reportSlashes",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [],
-    name: "s_middleware",
-    outputs: [{ internalType: "address", name: "", type: "address" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [
-      { internalType: "bytes32[]", name: "data", type: "bytes32[]" },
-      { internalType: "uint48", name: "epoch", type: "uint48" }
-    ],
-    name: "sendOperatorsData",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [{ internalType: "bytes", name: "data", type: "bytes" }],
-    name: "sendRewards",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [
-      { internalType: "address", name: "token", type: "address" },
-      { internalType: "ParaID", name: "destinationChain", type: "uint32" },
-      {
-        components: [
-          { internalType: "enum Kind", name: "kind", type: "uint8" },
-          { internalType: "bytes", name: "data", type: "bytes" }
-        ],
-        internalType: "struct MultiAddress",
-        name: "destinationAddress",
-        type: "tuple"
-      },
-      { internalType: "uint128", name: "destinationFee", type: "uint128" },
-      { internalType: "uint128", name: "amount", type: "uint128" }
-    ],
-    name: "sendToken",
-    outputs: [],
-    stateMutability: "payable",
-    type: "function"
-  },
-  {
-    inputs: [{ internalType: "address", name: "middleware", type: "address" }],
-    name: "setMiddleware",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [{ internalType: "bytes", name: "data", type: "bytes" }],
-    name: "setOperatingMode",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [{ internalType: "bytes", name: "data", type: "bytes" }],
-    name: "setPricingParameters",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [{ internalType: "bytes", name: "data", type: "bytes" }],
-    name: "setTokenTransferFees",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [
-      {
-        components: [
-          { internalType: "ChannelID", name: "channelID", type: "bytes32" },
-          { internalType: "uint64", name: "nonce", type: "uint64" },
-          { internalType: "enum Command", name: "command", type: "uint8" },
-          { internalType: "bytes", name: "params", type: "bytes" },
-          { internalType: "uint64", name: "maxDispatchGas", type: "uint64" },
-          { internalType: "uint256", name: "maxFeePerGas", type: "uint256" },
-          { internalType: "uint256", name: "reward", type: "uint256" },
-          { internalType: "bytes32", name: "id", type: "bytes32" }
-        ],
-        internalType: "struct InboundMessage",
-        name: "message",
-        type: "tuple"
-      },
-      { internalType: "bytes32[]", name: "leafProof", type: "bytes32[]" },
-      {
-        components: [
-          {
-            components: [
-              { internalType: "uint8", name: "version", type: "uint8" },
-              { internalType: "uint32", name: "parentNumber", type: "uint32" },
-              { internalType: "bytes32", name: "parentHash", type: "bytes32" },
-              {
-                internalType: "uint64",
-                name: "nextAuthoritySetID",
-                type: "uint64"
-              },
-              {
-                internalType: "uint32",
-                name: "nextAuthoritySetLen",
-                type: "uint32"
-              },
-              {
-                internalType: "bytes32",
-                name: "nextAuthoritySetRoot",
-                type: "bytes32"
-              }
-            ],
-            internalType: "struct Verification.MMRLeafPartial",
-            name: "leafPartial",
-            type: "tuple"
-          },
-          { internalType: "bytes32[]", name: "leafProof", type: "bytes32[]" },
-          {
-            internalType: "bytes32",
-            name: "parachainHeadsRoot",
-            type: "bytes32"
-          },
-          { internalType: "uint256", name: "leafProofOrder", type: "uint256" }
-        ],
-        internalType: "struct Verification.Proof",
-        name: "headerProof",
-        type: "tuple"
-      }
-    ],
-    name: "submitV1",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [{ internalType: "bytes32", name: "tokenID", type: "bytes32" }],
-    name: "tokenAddressOf",
-    outputs: [{ internalType: "address", name: "", type: "address" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [{ internalType: "bytes", name: "data", type: "bytes" }],
-    name: "transferNativeFromAgent",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [{ internalType: "bytes", name: "data", type: "bytes" }],
-    name: "transferNativeToken",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [{ internalType: "address", name: "newOwner", type: "address" }],
-    name: "transferOwnership",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [{ internalType: "bytes", name: "data", type: "bytes" }],
-    name: "updateChannel",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [{ internalType: "bytes", name: "data", type: "bytes" }],
-    name: "upgrade",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  }
-];
-
-// src/fee/gateway/gateway.ts
-function gateway() {
-  return {
-    quoteSendTokenFee() {
-      return {
-        build: ({ asset, destination, source }) => {
-          if (!asset.address) {
-            throw new Error(`Asset ${asset.key} has no address`);
-          }
-          if (!EvmChain.is(source) || !source.contracts?.Gateway) {
-            throw new Error(
-              "Source must be an EVMChain with the Gateway contract address configured for getting the quote send token fee for Gateway module"
-            );
-          }
-          if (!EvmParachain2.isAnyParachain(destination)) {
-            throw new Error(
-              "Destination must be a Parachain or EvmParachain for getting the quote send token fee for Gateway module"
-            );
-          }
-          return new ContractConfig({
-            address: source.contracts.Gateway,
-            abi: GATEWAY_ABI,
-            args: [asset.address, destination.parachainId, 0n],
-            func: "quoteSendTokenFee",
-            module: "Gateway"
-          });
-        }
+                          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/fee/outboundQueueApi/outboundQueueApi.ts
-function outboundQueueApi() {
+// src/extrinsic/ExtrinsicBuilder.ts
+function ExtrinsicBuilder() {
   return {
-    calculateFee: () => {
-      return {
-        build: ({ address, asset, balance }) => {
-          const args = [
-            {
-              MintForeignToken: {
-                tokenId: asset.getAssetId(),
-                recipient: address,
-                amount: balance?.amount
-              }
-            },
-            null
-          ];
-          return new SubstrateQueryConfig({
-            module: "outboundQueueApi",
-            func: "calculateFee",
-            args,
-            queryType: "call",
-            transform: async (data) => data.local.toBigInt() + data.remote.toBigInt()
-          });
-        }
-      };
-    }
+    eqBalances,
+    xTokens,
+    xTransfer,
+    polkadotXcm,
+    xcmPallet
   };
 }
 
 // src/fee/FeeBuilder.utils.ts
-import { EvmParachain as EvmParachain3 } from "@moonbeam-network/xcm-types";
+import { EvmParachain as EvmParachain2 } from "@moonbeam-network/xcm-types";
 import { isEthAddress as isEthAddress2 } from "@moonbeam-network/xcm-utils";
 import { u8aToHex as u8aToHex5 } from "@polkadot/util";
 import { decodeAddress as decodeAddress5 } from "@polkadot/util-crypto";
@@ -3990,7 +3138,7 @@ function getWithdrawAssetInstruction(assetTypes) {
   };
 }
 function getUniversalOriginInstruction(source) {
-  if (!EvmParachain3.isAnyParachain(source)) {
+  if (!EvmParachain2.isAnyParachain(source)) {
     throw new Error("Source is not a parachain");
   }
   return {
@@ -4000,7 +3148,7 @@ function getUniversalOriginInstruction(source) {
   };
 }
 function getDescendOriginInstruction(source) {
-  if (!EvmParachain3.isAnyParachain(source)) {
+  if (!EvmParachain2.isAnyParachain(source)) {
     throw new Error("Source is not a parachain");
   }
   return {
@@ -4389,39 +3537,35 @@ var createXcmFeeBuilder = ({
   getVersionedTransferAsset,
   options
 }) => ({
-  build: (params) => {
-    return new SubstrateCallConfig({
-      api: params.api,
-      call: async () => {
-        const [assets3, versionedFeeAssetId] = await getVersionedAssets({
-          getVersionedFeeAsset,
-          getVersionedTransferAsset,
-          options,
-          params
-        });
-        const instructions = getInstructions({
-          isAssetReserveChain: options.isAssetReserveChain,
-          assets: assets3,
-          versionedFeeAssetId,
-          address: params.address,
-          source: params.source,
-          isEcosystemBridge: options.isEcosystemBridge
-        });
-        return getFeeForXcmInstructionsAndAsset(
-          params.api,
-          instructions,
-          versionedFeeAssetId
-        );
-      }
-    });
-  }
+  build: (params) => new SubstrateCallConfig({
+    api: params.api,
+    call: async () => {
+      const [assets3, versionedFeeAssetId] = await getVersionedAssets({
+        getVersionedFeeAsset,
+        getVersionedTransferAsset,
+        options,
+        params
+      });
+      const instructions = getInstructions({
+        isAssetReserveChain: options.isAssetReserveChain,
+        assets: assets3,
+        versionedFeeAssetId,
+        address: params.address,
+        source: params.source,
+        isEcosystemBridge: options.isEcosystemBridge
+      });
+      return getFeeForXcmInstructionsAndAsset(
+        params.api,
+        instructions,
+        versionedFeeAssetId
+      );
+    }
+  })
 });
 
 // src/fee/FeeBuilder.ts
 function FeeBuilder() {
   return {
-    gateway,
-    outboundQueueApi,
     xcmPaymentApi
   };
 }
@@ -4683,265 +3827,9 @@ function MonitoringBuilder() {
   };
 }
 
-// src/mrl/providers/snowbridge/contract/Gateway/Gateway.ts
-import {
-  EvmParachain as EvmParachain4
-} from "@moonbeam-network/xcm-types";
-
-// src/mrl/providers/snowbridge/snowbridge/SnowbridgeConfig.ts
-var SnowbridgeConfig = class _SnowbridgeConfig {
-  args;
-  func;
-  provider = "snowbridge";
-  static is(obj) {
-    return obj instanceof _SnowbridgeConfig;
-  }
-  constructor({ args, func }) {
-    this.args = args;
-    this.func = func;
-  }
-};
-
-// src/mrl/providers/snowbridge/contract/Gateway/Gateway.ts
-function Gateway() {
-  const provider = "snowbridge";
-  return {
-    sendToken: () => ({
-      provider,
-      build: ({ asset, destinationAddress, protocolFee, destination }) => callSendToken(asset, protocolFee, destination, destinationAddress)
-    }),
-    approveAndSendToken: () => ({
-      provider,
-      build: ({ asset, destinationAddress, protocolFee, destination }) => {
-        const requiresApproval = protocolFee && !protocolFee.isSame(asset);
-        return callSendToken(
-          asset,
-          protocolFee,
-          destination,
-          destinationAddress,
-          requiresApproval
-        );
-      }
-    })
-  };
-}
-function callSendToken(asset, protocolFee, destination, destinationAddress, requiresApproval = false) {
-  if (!protocolFee) {
-    throw new Error("Protocol fee is required for Gateway module");
-  }
-  if (!EvmParachain4.isAnyParachain(destination)) {
-    throw new Error(
-      "Destination must be a Parachain or EvmParachain for sending token with Gateway module"
-    );
-  }
-  return new SnowbridgeConfig({
-    args: {
-      tokenAddress: asset.address,
-      destinationAddress,
-      destinationParaId: destination.parachainId,
-      amount: asset.amount,
-      bridgeFeeAmount: protocolFee.amount,
-      requiresApproval
-    },
-    func: "sendToken"
-  });
-}
-
-// src/mrl/providers/snowbridge/contract/index.ts
-function contract() {
-  return { Gateway };
-}
-
-// src/mrl/providers/snowbridge/extrinsic/ethereumTokenTransfer/ethereumTokenTransfers.ts
-var pallet6 = "ethereumTokenTransfers";
-function ethereumTokenTransfers() {
-  return {
-    transferNativeToken: () => {
-      const func = "transferNativeToken";
-      const provider = "snowbridge";
-      return {
-        provider,
-        build: ({ asset, destinationAddress }) => {
-          return new ExtrinsicConfig({
-            module: pallet6,
-            func,
-            getArgs: () => [asset.amount, destinationAddress]
-          });
-        }
-      };
-    }
-  };
-}
-
-// src/mrl/providers/snowbridge/extrinsic/xcmPallet/xcmPallet.ts
-import { EvmChain as EvmChain2 } from "@moonbeam-network/xcm-types";
-
-// src/mrl/providers/snowbridge/extrinsic/xcmPallet/xcmPallet.utils.ts
-function getGlobalConsensusArgs({
-  assets: assets3,
-  destination,
-  destinationAddress,
-  func
-}) {
-  const version = getExtrinsicArgumentVersion(func);
-  const dest = {
-    [version]: {
-      parents: 1,
-      interior: {
-        X1: [
-          {
-            GlobalConsensus: {
-              Ethereum: { chainId: destination.id }
-            }
-          }
-        ]
-      }
-    }
-  };
-  const beneficiary = {
-    [version]: {
-      parents: 0,
-      interior: {
-        X1: [
-          {
-            AccountKey20: {
-              network: { Ethereum: { chainId: destination.id } },
-              key: destinationAddress
-            }
-          }
-        ]
-      }
-    }
-  };
-  const assetsArg = {
-    [version]: assets3
-  };
-  return [
-    dest,
-    beneficiary,
-    assetsArg,
-    0,
-    // feeAssetItem
-    "Unlimited"
-  ];
-}
-
-// src/mrl/providers/snowbridge/extrinsic/xcmPallet/xcmPallet.ts
-var pallet7 = "xcmPallet";
-function xcmPallet2() {
-  return {
-    transferAssets: () => {
-      const func = "transferAssets";
-      const provider = "snowbridge";
-      return {
-        globalConsensus: () => ({
-          provider,
-          build: ({ asset, destination, destinationAddress }) => {
-            if (!EvmChain2.is(destination)) {
-              throw new Error(
-                "Destination must be an EVM chain for globalConsensus function"
-              );
-            }
-            return new ExtrinsicConfig({
-              module: pallet7,
-              func,
-              getArgs: (extrinsicFunction) => {
-                const assets3 = [
-                  {
-                    id: {
-                      parents: 1,
-                      interior: {
-                        X1: [
-                          {
-                            GlobalConsensus: {
-                              Ethereum: { chainId: destination.id }
-                            }
-                          }
-                        ]
-                      }
-                    },
-                    fun: { Fungible: asset.amount }
-                  }
-                ];
-                return getGlobalConsensusArgs({
-                  assets: assets3,
-                  destination,
-                  destinationAddress,
-                  func: extrinsicFunction
-                });
-              }
-            });
-          }
-        }),
-        globalConsensusErc20: () => ({
-          provider,
-          build: ({ asset, destination, destinationAddress }) => {
-            if (!EvmChain2.is(destination)) {
-              throw new Error(
-                "Destination must be an EVM chain for globalConsensusErc20 function"
-              );
-            }
-            const assetInDestination = destination.getChainAsset(asset);
-            return new ExtrinsicConfig({
-              module: pallet7,
-              func,
-              getArgs: (extrinsicFunction) => {
-                const assets3 = [
-                  {
-                    id: {
-                      parents: 1,
-                      interior: {
-                        X2: [
-                          {
-                            GlobalConsensus: {
-                              Ethereum: { chainId: destination.id }
-                            }
-                          },
-                          {
-                            AccountKey20: {
-                              network: {
-                                Ethereum: { chainId: destination.id }
-                              },
-                              key: assetInDestination.address
-                            }
-                          }
-                        ]
-                      }
-                    },
-                    fun: { Fungible: asset.amount }
-                  }
-                ];
-                return getGlobalConsensusArgs({
-                  assets: assets3,
-                  destination,
-                  destinationAddress,
-                  func: extrinsicFunction
-                });
-              }
-            });
-          }
-        })
-      };
-    }
-  };
-}
-
-// src/mrl/providers/snowbridge/extrinsic/index.ts
-function extrinsic() {
-  return { ethereumTokenTransfers, xcmPallet: xcmPallet2 };
-}
-
-// src/mrl/providers/snowbridge/index.ts
-function snowbridge() {
-  return {
-    contract,
-    extrinsic
-  };
-}
-
 // src/mrl/providers/wormhole/contract/Batch/Batch.ts
 import {
-  EvmParachain as EvmParachain5
+  EvmParachain as EvmParachain3
 } from "@moonbeam-network/xcm-types";
 import { getMultilocationDerivedAddresses as getMultilocationDerivedAddresses2 } from "@moonbeam-network/xcm-utils";
 import { evmToAddress as evmToAddress3 } from "@polkadot/util-crypto";
@@ -4953,13 +3841,12 @@ import {
   Parachain as Parachain2
 } from "@moonbeam-network/xcm-types";
 import { getMultilocationDerivedAddresses } from "@moonbeam-network/xcm-utils";
+import { moonriver } from "viem/chains";
 var BUY_EXECUTION_FEE = 100000000000000000n;
 var CROSS_CHAIN_FEE = 100000000000000000n;
 function polkadotXcm2() {
-  const provider = "wormhole";
   return {
     send: () => ({
-      provider,
       build: ({
         asset,
         destination,
@@ -4967,7 +3854,7 @@ function polkadotXcm2() {
         fee,
         isAutomatic,
         moonAsset,
-        bridgeChain,
+        moonChain,
         moonApi,
         sendOnlyRemoteExecution,
         source,
@@ -4998,7 +3885,7 @@ function polkadotXcm2() {
           isAutomatic,
           moonApi,
           moonAsset,
-          bridgeChain,
+          moonChain,
           source,
           sourceAddress,
           sourceApi
@@ -5011,7 +3898,7 @@ function polkadotXcm2() {
           fee,
           isAutomatic,
           moonAsset,
-          bridgeChain,
+          moonChain,
           moonApi,
           source,
           sourceAddress,
@@ -5019,6 +3906,16 @@ function polkadotXcm2() {
           transact
         });
         const transactionsToSend = sendOnlyRemoteExecution ? [send] : [...assetTransferTxs, send];
+        console.log("send", send.toHuman());
+        console.log(
+          "assetTransferTxs",
+          assetTransferTxs.map((tx) => tx.toHuman())
+        );
+        console.log("transact", transact);
+        console.log(
+          "transactionsToSend",
+          transactionsToSend.map((tx) => tx.toHuman())
+        );
         return new ExtrinsicConfig({
           module: "utility",
           func: "batchAll",
@@ -5031,7 +3928,7 @@ function polkadotXcm2() {
 function buildSendExtrinsic({
   computedOriginAccount,
   moonAsset,
-  bridgeChain,
+  moonChain,
   sourceApi,
   transact
 }) {
@@ -5042,9 +3939,12 @@ function buildSendExtrinsic({
   return sourceApi.tx.polkadotXcm.send(
     {
       [version]: normalizeX1(version, {
-        parents: 1,
+        parents: 2,
         interior: {
-          X1: { Parachain: bridgeChain.parachainId }
+          X2: [
+            { GlobalConsensus: "Polkadot" },
+            { Parachain: moonChain.parachainId }
+          ]
         }
       })
     },
@@ -5127,14 +4027,36 @@ function getAssetTransferTxs({
   fee,
   moonApi,
   moonAsset,
-  bridgeChain,
+  moonChain,
   source,
   sourceAddress,
   sourceApi
 }) {
-  const { transfer, transferMulticurrencies } = sourceApi.tx.xTokens;
+  const { transferAssets } = sourceApi.tx.polkadotXcm;
   const transferBuilder = ExtrinsicBuilder().xTokens().transfer();
+  const polkadotXcmBuilder = ExtrinsicBuilder().polkadotXcm().transferAssetsToEcosystem().X4();
   const transferMulticurrenciesBuilder = ExtrinsicBuilder().xTokens().transferMultiCurrencies();
+  const testMoonriver = source.name === moonriver.name;
+  console.log("testMoonriver", testMoonriver);
+  if (testMoonriver) {
+    const transferAssetsTx = transferAssets(
+      ...polkadotXcmBuilder.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(transferAssets)
+    );
+    console.log("transferAssetsTx", transferAssetsTx.toHuman());
+    return [transferAssetsTx];
+  }
+  const { transfer, transferMulticurrencies } = sourceApi.tx.xTokens;
   if (asset.isSame(fee)) {
     const assetTransferTx = transfer(
       ...transferBuilder.build({
@@ -5143,7 +4065,7 @@ function getAssetTransferTxs({
           // 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: bridgeChain,
+        destination: moonChain,
         destinationAddress: computedOriginAccount,
         destinationApi: moonApi,
         fee,
@@ -5157,7 +4079,7 @@ function getAssetTransferTxs({
         asset: AssetAmount.fromChainAsset(source.getChainAsset(moonAsset), {
           amount: CROSS_CHAIN_FEE + BUY_EXECUTION_FEE
         }),
-        destination: bridgeChain,
+        destination: moonChain,
         destinationAddress: computedOriginAccount,
         destinationApi: moonApi,
         fee,
@@ -5171,7 +4093,7 @@ function getAssetTransferTxs({
   const multiCurrenciesTransferTx = transferMulticurrencies(
     ...transferMulticurrenciesBuilder.build({
       asset,
-      destination: bridgeChain,
+      destination: moonChain,
       destinationAddress: computedOriginAccount,
       destinationApi: moonApi,
       fee: AssetAmount.fromChainAsset(source.getChainAsset(moonAsset), {
@@ -5727,10 +4649,8 @@ function getAbisForChain(_) {
 // src/mrl/providers/wormhole/contract/Batch/Batch.ts
 var module = "Batch";
 function Batch() {
-  const provider = "wormhole";
   return {
     transferAssetsAndMessage: () => ({
-      provider,
       build: ({
         asset,
         destination,
@@ -5738,14 +4658,14 @@ function Batch() {
         fee,
         isAutomatic,
         moonAsset,
-        bridgeChain,
+        moonChain,
         moonApi,
         source,
         sourceAddress,
         sourceApi,
         transact
       }) => {
-        if (!EvmParachain5.is(source)) {
+        if (!EvmParachain3.is(source)) {
           throw new Error("Source chain needs to be an EVMParachain");
         }
         if (!sourceApi) {
@@ -5771,7 +4691,7 @@ function Batch() {
           fee,
           isAutomatic,
           moonAsset,
-          bridgeChain,
+          moonChain,
           moonApi,
           source,
           sourceAddress,
@@ -5779,7 +4699,7 @@ function Batch() {
           transact
         });
         const encodedXcmMessage = send.args[1].toHex();
-        const { destinationParachain, destinationParachainAndAddress } = getDestinationInHex(bridgeChain, computedOriginAccount);
+        const { destinationParachain, destinationParachainAndAddress } = getDestinationInHex(moonChain, computedOriginAccount);
         const { currencies, feeItem } = getCurrencies({
           source,
           moonAsset,
@@ -5812,15 +4732,15 @@ function Batch() {
     })
   };
 }
-function getDestinationInHex(bridgeChain, computedOriginAccount) {
+function getDestinationInHex(moonChain, computedOriginAccount) {
   const destinationParachain = {
     parents: 1,
-    interior: getPrecompileDestinationInterior(bridgeChain)
+    interior: getPrecompileDestinationInterior(moonChain)
   };
   const destinationParachainAndAddress = {
     parents: 1,
     interior: getPrecompileDestinationInterior(
-      bridgeChain,
+      moonChain,
       computedOriginAccount
     )
   };
@@ -5897,7 +4817,6 @@ var Protocols = /* @__PURE__ */ ((Protocols2) => {
 var WormholeConfig = class _WormholeConfig {
   args;
   func;
-  provider = "wormhole";
   static is(obj) {
     return obj instanceof _WormholeConfig;
   }
@@ -5908,20 +4827,20 @@ var WormholeConfig = class _WormholeConfig {
 };
 
 // src/mrl/providers/wormhole/wormhole/wormhole.ts
-import { EvmChain as EvmChain3, EvmParachain as EvmParachain7, Parachain as Parachain3 } from "@moonbeam-network/xcm-types";
+import { EvmChain, EvmParachain as EvmParachain5, Parachain as Parachain3 } from "@moonbeam-network/xcm-types";
 import { getMultilocationDerivedAddresses as getMultilocationDerivedAddresses3 } from "@moonbeam-network/xcm-utils";
 import { evmToAddress as evmToAddress4 } from "@polkadot/util-crypto/address";
 import { Wormhole as Wormhole2 } from "@wormhole-foundation/sdk-connect";
 
 // src/mrl/providers/wormhole/wormhole/wormholeFactory.ts
-import { EvmParachain as EvmParachain6 } from "@moonbeam-network/xcm-types";
+import { EvmParachain as EvmParachain4 } from "@moonbeam-network/xcm-types";
 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],
-    EvmParachain6.isAnyEvmChain(chain) && chain.wh ? {
+    EvmParachain4.isAnyEvmChain(chain) && chain.wh ? {
       chains: {
         [chain.wh.name]: {
           rpc: chain.rpc
@@ -5933,23 +4852,21 @@ function wormholeFactory(chain) {
 
 // src/mrl/providers/wormhole/wormhole/wormhole.ts
 function wormhole() {
-  const provider = "wormhole";
   return {
     tokenTransfer: () => ({
-      provider,
       build: ({
         asset,
         destination,
         destinationAddress,
         isAutomatic,
         moonApi,
-        bridgeChain: moonChain,
+        moonChain,
         source,
         sourceAddress
       }) => {
         const isSourceParachain = Parachain3.is(source);
         const isDestinationMoonChain = destination.isEqual(moonChain);
-        const isDestinationEvmChain = EvmChain3.is(destination);
+        const isDestinationEvmChain = EvmChain.is(destination);
         const isNativeAsset = asset.isSame(
           isDestinationEvmChain ? moonChain.nativeAsset : source.nativeAsset
         );
@@ -5981,7 +4898,12 @@ function wormhole() {
             from: whSourceAddress,
             to: whDestinationAddress,
             protocol: isAutomatic ? "AutomaticTokenBridge" /* AutomaticTokenBridge */ : "TokenBridge" /* TokenBridge */,
-            payload: isDestinationMoonChain || isDestinationEvmChain ? void 0 : getPayload({ destination, destinationAddress, moonApi })
+            payload: isDestinationMoonChain || isDestinationEvmChain ? void 0 : getPayload({
+              destination,
+              destinationAddress,
+              moonApi,
+              moonChain
+            })
           },
           func: "tokenTransfer"
         });
@@ -5992,16 +4914,60 @@ function wormhole() {
 function getPayload({
   moonApi,
   destination,
-  destinationAddress
+  destinationAddress,
+  moonChain
+}) {
+  const multilocation = getMultilocation({
+    destination,
+    destinationAddress,
+    moonApi,
+    moonChain
+  });
+  console.log("multilocation", multilocation.toHuman());
+  const action = moonApi.createType("XcmRoutingUserAction", {
+    destination: multilocation
+  });
+  const versioned = moonApi.createType("VersionedUserAction", {
+    V1: action
+  });
+  return versioned.toU8a();
+}
+function getMultilocation({
+  moonApi,
+  destination,
+  destinationAddress,
+  moonChain
 }) {
-  if (!EvmParachain7.isAnyParachain(destination)) {
+  if (!EvmParachain5.isAnyParachain(destination)) {
     throw new Error(
       `Destination ${destination.name} is not a Parachain or EvmParachain`
     );
   }
-  const isEvmDestination = EvmParachain7.is(destination);
   const version = getExtrinsicArgumentVersion(moonApi.tx.polkadotXcm.send);
-  const multilocation = moonApi.createType("XcmVersionedLocation", {
+  const isDifferentEcosystem = destination.ecosystem !== moonChain.ecosystem;
+  const isEvmDestination = EvmParachain5.is(destination);
+  if (isDifferentEcosystem) {
+    return moonApi.createType("XcmVersionedLocation", {
+      [version]: {
+        parents: 2,
+        interior: {
+          X3: [
+            {
+              GlobalConsensus: getGlobalConsensus(destination)
+            },
+            {
+              Parachain: destination.parachainId
+            },
+            // wrong
+            getExtrinsicAccount(
+              isEvmDestination ? evmToAddress4(destinationAddress) : destinationAddress
+            )
+          ]
+        }
+      }
+    });
+  }
+  return moonApi.createType("XcmVersionedLocation", {
     [version]: {
       parents: 1,
       interior: {
@@ -6016,13 +4982,6 @@ function getPayload({
       }
     }
   });
-  const action = moonApi.createType("XcmRoutingUserAction", {
-    destination: multilocation
-  });
-  const versioned = moonApi.createType("VersionedUserAction", {
-    V1: action
-  });
-  return versioned.toU8a();
 }
 
 // src/mrl/providers/wormhole/contract/TokenBridge/TokenBridgeAbi.ts
@@ -7215,28 +6174,26 @@ var TOKEN_BRIDGE_ABI = [
 // src/mrl/providers/wormhole/contract/TokenBridge/TokenBridge.ts
 var module3 = "TokenBridge";
 function TokenBridge() {
-  const provider = "wormhole";
   return {
     transferTokens: () => ({
-      provider,
-      build: ({ asset, destination, destinationAddress, bridgeChain }) => {
-        const wh = wormholeFactory(bridgeChain);
+      build: ({ asset, destination, destinationAddress, moonChain }) => {
+        const wh = wormholeFactory(moonChain);
         const whDestination = wh.getChain(destination.getWormholeName()).config.chainId;
-        const tokenAddressOnMoonChain = bridgeChain.getChainAsset(asset).address;
+        const tokenAddressOnMoonChain = moonChain.getChainAsset(asset).address;
         if (!tokenAddressOnMoonChain) {
           throw new Error(
-            `Asset ${asset.symbol} does not have a token address on chain ${bridgeChain.name}`
+            `Asset ${asset.symbol} does not have a token address on chain ${moonChain.name}`
           );
         }
         const destinationAddress32bytes = convertAddressTo32Bytes(
           destinationAddress
         );
         const tokenAmountOnMoonChain = asset.convertDecimals(
-          bridgeChain.getChainAsset(asset).decimals
+          moonChain.getChainAsset(asset).decimals
         ).amount;
         const contractAddress = wh.getChain("Moonbeam").config.contracts.tokenBridge;
         if (!contractAddress) {
-          throw new Error(`Wormhole address not found for ${bridgeChain.name}`);
+          throw new Error(`Wormhole address not found for ${moonChain.name}`);
         }
         return new ContractConfig({
           address: contractAddress,
@@ -7374,28 +6331,26 @@ var TOKEN_BRIDGE_RELAYER_ABI = [
 // src/mrl/providers/wormhole/contract/TokenBridgeRelayer/TokenBridgeRelayer.ts
 var module4 = "TokenBridgeRelayer";
 function TokenBridgeRelayer() {
-  const provider = "wormhole";
   return {
     transferTokensWithRelay: () => ({
-      provider,
-      build: ({ asset, destination, destinationAddress, bridgeChain }) => {
-        const wh = wormholeFactory(bridgeChain);
+      build: ({ asset, destination, destinationAddress, moonChain }) => {
+        const wh = wormholeFactory(moonChain);
         const whDestination = wh.getChain(destination.getWormholeName()).config.chainId;
-        const tokenAddressOnMoonChain = bridgeChain.getChainAsset(asset).address;
+        const tokenAddressOnMoonChain = moonChain.getChainAsset(asset).address;
         if (!tokenAddressOnMoonChain) {
           throw new Error(
-            `Asset ${asset.symbol} does not have a token address on chain ${bridgeChain.name}`
+            `Asset ${asset.symbol} does not have a token address on chain ${moonChain.name}`
           );
         }
         const destinationAddress32bytes = convertAddressTo32Bytes2(
           destinationAddress
         );
         const tokenAmountOnMoonChain = asset.convertDecimals(
-          bridgeChain.getChainAsset(asset).decimals
+          moonChain.getChainAsset(asset).decimals
         ).amount;
         const contractAddress = wh.getChain("Moonbeam").config.contracts.tokenBridgeRelayer;
         if (!contractAddress) {
-          throw new Error(`Wormhole address not found for ${bridgeChain.name}`);
+          throw new Error(`Wormhole address not found for ${moonChain.name}`);
         }
         return new ContractConfig({
           address: contractAddress,
@@ -7417,7 +6372,7 @@ function TokenBridgeRelayer() {
 }
 
 // src/mrl/providers/wormhole/contract/index.ts
-function contract2() {
+function contract() {
   return { Batch, Gmp, TokenBridge, TokenBridgeRelayer };
 }
 
@@ -7543,38 +6498,36 @@ var BATCH_CONTRACT_ABI = [
 
 // src/mrl/providers/wormhole/extrinsic/ethereumXcm/ethereumXcm.ts
 function ethereumXcm() {
-  const provider = "wormhole";
   return {
     transact: () => ({
-      provider,
       build: (params) => {
-        const { asset, isAutomatic, bridgeChain, bridgeChainGasLimit } = params;
-        if (!bridgeChainGasLimit) {
-          throw new Error("bridgeChainGasLimit must be defined");
+        const { asset, isAutomatic, moonChain, moonGasLimit } = params;
+        if (!moonGasLimit) {
+          throw new Error("moonGasLimit must be defined");
         }
-        const tokenAddressOnMoonChain = bridgeChain.getChainAsset(asset).address;
+        const tokenAddressOnMoonChain = moonChain.getChainAsset(asset).address;
         if (!tokenAddressOnMoonChain) {
           throw new Error(
-            `Asset ${asset.symbol} does not have a token address on chain ${bridgeChain.name}`
+            `Asset ${asset.symbol} does not have a token address on chain ${moonChain.name}`
           );
         }
         const tokenAmountOnMoonChain = asset.convertDecimals(
-          bridgeChain.getChainAsset(asset).decimals
+          moonChain.getChainAsset(asset).decimals
         ).amount;
-        const contract3 = isAutomatic ? contract2().TokenBridgeRelayer().transferTokensWithRelay().build(params) : contract2().TokenBridge().transferTokens().build(params);
+        const contract2 = isAutomatic ? contract().TokenBridgeRelayer().transferTokensWithRelay().build(params) : contract().TokenBridge().transferTokens().build(params);
         const approveTx = encodeFunctionData3({
           abi: ERC20_ABI,
           functionName: "approve",
-          args: [contract3.address, tokenAmountOnMoonChain]
+          args: [contract2.address, tokenAmountOnMoonChain]
         });
         const batchAll = encodeFunctionData3({
           abi: BATCH_CONTRACT_ABI,
           functionName: "batchAll",
           args: [
-            [tokenAddressOnMoonChain, contract3.address],
+            [tokenAddressOnMoonChain, contract2.address],
             [0n, 0n],
             // Value to send for each call
-            [approveTx, contract3.encodeFunctionData()],
+            [approveTx, contract2.encodeFunctionData()],
             // Call data for each call
             []
             // Gas limit for each call
@@ -7586,7 +6539,7 @@ function ethereumXcm() {
           getArgs: () => [
             {
               V2: {
-                gasLimit: bridgeChainGasLimit,
+                gasLimit: moonGasLimit,
                 action: {
                   Call: BATCH_CONTRACT_ADDRESS
                 },
@@ -7602,15 +6555,15 @@ function ethereumXcm() {
 }
 
 // src/mrl/providers/wormhole/extrinsic/index.ts
-function extrinsic2() {
+function extrinsic() {
   return { ethereumXcm, polkadotXcm: polkadotXcm2 };
 }
 
 // src/mrl/providers/wormhole/index.ts
 function wormhole2() {
   return {
-    contract: contract2,
-    extrinsic: extrinsic2,
+    contract,
+    extrinsic,
     wormhole
   };
 }
@@ -7618,7 +6571,6 @@ function wormhole2() {
 // src/mrl/MrlBuilder.ts
 function MrlBuilder() {
   return {
-    snowbridge,
     wormhole: wormhole2
   };
 }
@@ -7634,11 +6586,9 @@ export {
   ExtrinsicBuilder,
   ExtrinsicConfig,
   FeeBuilder,
-  GATEWAY_ABI,
   MonitoringBuilder,
   MrlBuilder,
   Protocols,
-  SnowbridgeConfig,
   SubstrateCallConfig,
   SubstrateQueryConfig,
   TransferType,
@@ -7646,7 +6596,6 @@ export {
   XcmVersion,
   calculateSystemAccountBalance,
   evm,
-  snowbridge,
   substrate,
   wormhole2 as wormhole,
   wormholeFactory