@moonbeam-network/xcm-builder 4.3.0 → 4.4.0

package/build/index.mjs

@@ -92,6 +92,7 @@ var BaseConfig = class {
 // src/types/substrate/SubstrateQueryConfig.ts
 var SubstrateQueryConfig = class _SubstrateQueryConfig extends BaseConfig {
   args;
+  queryType;
   transform;
   static is(obj) {
     return obj instanceof _SubstrateQueryConfig;
@@ -99,10 +100,12 @@ var SubstrateQueryConfig = class _SubstrateQueryConfig extends BaseConfig {
   constructor({
     args = [],
     transform,
+    queryType = "query",
     ...other
   }) {
     super({ ...other });
     this.args = args;
+    this.queryType = queryType;
     this.transform = transform;
   }
 };
@@ -116,11 +119,11 @@ function AssetMinBuilder() {
   };
 }
 function assetRegistry() {
-  const pallet6 = "assetRegistry";
+  const pallet8 = "assetRegistry";
   return {
     assetMetadatas: () => ({
       build: ({ asset }) => new SubstrateQueryConfig({
-        module: pallet6,
+        module: pallet8,
         func: "assetMetadatas",
         args: [asset],
         // biome-ignore lint/suspicious/noExplicitAny: not sure how to fix this
@@ -129,7 +132,7 @@ function assetRegistry() {
     }),
     currencyMetadatas: () => ({
       build: ({ asset }) => new SubstrateQueryConfig({
-        module: pallet6,
+        module: pallet8,
         func: "currencyMetadatas",
         args: [asset],
         // biome-ignore lint/suspicious/noExplicitAny: not sure how to fix this
@@ -138,7 +141,7 @@ function assetRegistry() {
     }),
     metadata: () => ({
       build: ({ asset }) => new SubstrateQueryConfig({
-        module: pallet6,
+        module: pallet8,
         func: "metadata",
         args: [asset],
         // biome-ignore lint/suspicious/noExplicitAny: not sure how to fix this
@@ -202,8 +205,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;
   }
@@ -211,12 +214,14 @@ 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({
@@ -3083,41 +3088,888 @@ function xTransfer() {
                 }
               },
               {
-                parents: 1,
-                interior: {
-                  X2: [
-                    {
-                      Parachain: destination.parachainId
-                    },
-                    getExtrinsicAccount(destinationAddress)
-                  ]
-                }
+                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"
               },
               {
-                refTime: 5e9,
-                proofSize: 0
+                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"
+          });
+        }
       };
     }
   };
 }
 
-// src/extrinsic/ExtrinsicBuilder.ts
-function ExtrinsicBuilder() {
+// src/fee/outboundQueueApi/outboundQueueApi.ts
+function outboundQueueApi() {
   return {
-    eqBalances,
-    xTokens,
-    xTransfer,
-    polkadotXcm,
-    xcmPallet
+    calculateFee: () => {
+      return {
+        build: ({ address, balance, feeAsset }) => {
+          const args = [
+            {
+              MintForeignToken: {
+                tokenId: feeAsset.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()
+          });
+        }
+      };
+    }
   };
 }
 
 // src/fee/FeeBuilder.utils.ts
-import { EvmParachain as EvmParachain2 } from "@moonbeam-network/xcm-types";
+import { EvmParachain as EvmParachain3 } 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";
@@ -3138,7 +3990,7 @@ function getWithdrawAssetInstruction(assetTypes) {
   };
 }
 function getUniversalOriginInstruction(source) {
-  if (!EvmParachain2.isAnyParachain(source)) {
+  if (!EvmParachain3.isAnyParachain(source)) {
     throw new Error("Source is not a parachain");
   }
   return {
@@ -3148,7 +4000,7 @@ function getUniversalOriginInstruction(source) {
   };
 }
 function getDescendOriginInstruction(source) {
-  if (!EvmParachain2.isAnyParachain(source)) {
+  if (!EvmParachain3.isAnyParachain(source)) {
     throw new Error("Source is not a parachain");
   }
   return {
@@ -3537,35 +4389,39 @@ var createXcmFeeBuilder = ({
   getVersionedTransferAsset,
   options
 }) => ({
-  build: (params) => new SubstrateCallConfig({
-    api: params.api,
-    call: async () => {
-      const [assets3, versionedFeeAssetId] = await getVersionedAssets({
-        getVersionedFeeAsset,
-        getVersionedTransferAsset,
-        options,
-        params
-      });
-      const instructions = getInstructions({
-        isAssetReserveChain: options.isAssetReserveChain,
-        assets: assets3,
-        versionedFeeAssetId,
-        address: params.address,
-        source: params.source,
-        isEcosystemBridge: options.isEcosystemBridge
-      });
-      return getFeeForXcmInstructionsAndAsset(
-        params.api,
-        instructions,
-        versionedFeeAssetId
-      );
-    }
-  })
+  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
+        );
+      }
+    });
+  }
 });
 
 // src/fee/FeeBuilder.ts
 function FeeBuilder() {
   return {
+    gateway,
+    outboundQueueApi,
     xcmPaymentApi
   };
 }
@@ -3827,9 +4683,272 @@ function MonitoringBuilder() {
   };
 }
 
+// src/mrl/providers/snowbridge/contract/Gateway/Gateway.ts
+import {
+  EvmParachain as EvmParachain4
+} from "@moonbeam-network/xcm-types";
+
+// src/mrl/MrlBuilder.interfaces.ts
+var Provider = /* @__PURE__ */ ((Provider2) => {
+  Provider2["Snowbridge"] = "snowbridge";
+  Provider2["Wormhole"] = "wormhole";
+  return Provider2;
+})(Provider || {});
+
+// src/mrl/providers/snowbridge/snowbridge/SnowbridgeConfig.ts
+var SnowbridgeConfig = class _SnowbridgeConfig {
+  args;
+  func;
+  provider = "snowbridge" /* 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" /* 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" /* 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" /* 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 EvmParachain3
+  EvmParachain as EvmParachain5
 } from "@moonbeam-network/xcm-types";
 import { getMultilocationDerivedAddresses as getMultilocationDerivedAddresses2 } from "@moonbeam-network/xcm-utils";
 import { evmToAddress as evmToAddress3 } from "@polkadot/util-crypto";
@@ -3844,8 +4963,10 @@ import { getMultilocationDerivedAddresses } from "@moonbeam-network/xcm-utils";
 var BUY_EXECUTION_FEE = 100000000000000000n;
 var CROSS_CHAIN_FEE = 100000000000000000n;
 function polkadotXcm2() {
+  const provider = "wormhole" /* Wormhole */;
   return {
     send: () => ({
+      provider,
       build: ({
         asset,
         destination,
@@ -3853,7 +4974,7 @@ function polkadotXcm2() {
         fee,
         isAutomatic,
         moonAsset,
-        moonChain,
+        bridgeChain,
         moonApi,
         sendOnlyRemoteExecution,
         source,
@@ -3884,7 +5005,7 @@ function polkadotXcm2() {
           isAutomatic,
           moonApi,
           moonAsset,
-          moonChain,
+          bridgeChain,
           source,
           sourceAddress,
           sourceApi
@@ -3897,7 +5018,7 @@ function polkadotXcm2() {
           fee,
           isAutomatic,
           moonAsset,
-          moonChain,
+          bridgeChain,
           moonApi,
           source,
           sourceAddress,
@@ -3917,7 +5038,7 @@ function polkadotXcm2() {
 function buildSendExtrinsic({
   computedOriginAccount,
   moonAsset,
-  moonChain,
+  bridgeChain,
   sourceApi,
   transact
 }) {
@@ -3930,7 +5051,7 @@ function buildSendExtrinsic({
       [version]: normalizeX1(version, {
         parents: 1,
         interior: {
-          X1: { Parachain: moonChain.parachainId }
+          X1: { Parachain: bridgeChain.parachainId }
         }
       })
     },
@@ -4013,7 +5134,7 @@ function getAssetTransferTxs({
   fee,
   moonApi,
   moonAsset,
-  moonChain,
+  bridgeChain,
   source,
   sourceAddress,
   sourceApi
@@ -4029,7 +5150,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: moonChain,
+        destination: bridgeChain,
         destinationAddress: computedOriginAccount,
         destinationApi: moonApi,
         fee,
@@ -4043,7 +5164,7 @@ function getAssetTransferTxs({
         asset: AssetAmount.fromChainAsset(source.getChainAsset(moonAsset), {
           amount: CROSS_CHAIN_FEE + BUY_EXECUTION_FEE
         }),
-        destination: moonChain,
+        destination: bridgeChain,
         destinationAddress: computedOriginAccount,
         destinationApi: moonApi,
         fee,
@@ -4057,7 +5178,7 @@ function getAssetTransferTxs({
   const multiCurrenciesTransferTx = transferMulticurrencies(
     ...transferMulticurrenciesBuilder.build({
       asset,
-      destination: moonChain,
+      destination: bridgeChain,
       destinationAddress: computedOriginAccount,
       destinationApi: moonApi,
       fee: AssetAmount.fromChainAsset(source.getChainAsset(moonAsset), {
@@ -4613,8 +5734,10 @@ function getAbisForChain(_) {
 // src/mrl/providers/wormhole/contract/Batch/Batch.ts
 var module = "Batch";
 function Batch() {
+  const provider = "wormhole" /* Wormhole */;
   return {
     transferAssetsAndMessage: () => ({
+      provider,
       build: ({
         asset,
         destination,
@@ -4622,14 +5745,14 @@ function Batch() {
         fee,
         isAutomatic,
         moonAsset,
-        moonChain,
+        bridgeChain,
         moonApi,
         source,
         sourceAddress,
         sourceApi,
         transact
       }) => {
-        if (!EvmParachain3.is(source)) {
+        if (!EvmParachain5.is(source)) {
           throw new Error("Source chain needs to be an EVMParachain");
         }
         if (!sourceApi) {
@@ -4655,7 +5778,7 @@ function Batch() {
           fee,
           isAutomatic,
           moonAsset,
-          moonChain,
+          bridgeChain,
           moonApi,
           source,
           sourceAddress,
@@ -4663,7 +5786,7 @@ function Batch() {
           transact
         });
         const encodedXcmMessage = send.args[1].toHex();
-        const { destinationParachain, destinationParachainAndAddress } = getDestinationInHex(moonChain, computedOriginAccount);
+        const { destinationParachain, destinationParachainAndAddress } = getDestinationInHex(bridgeChain, computedOriginAccount);
         const { currencies, feeItem } = getCurrencies({
           source,
           moonAsset,
@@ -4696,15 +5819,15 @@ function Batch() {
     })
   };
 }
-function getDestinationInHex(moonChain, computedOriginAccount) {
+function getDestinationInHex(bridgeChain, computedOriginAccount) {
   const destinationParachain = {
     parents: 1,
-    interior: getPrecompileDestinationInterior(moonChain)
+    interior: getPrecompileDestinationInterior(bridgeChain)
   };
   const destinationParachainAndAddress = {
     parents: 1,
     interior: getPrecompileDestinationInterior(
-      moonChain,
+      bridgeChain,
       computedOriginAccount
     )
   };
@@ -4781,6 +5904,7 @@ var Protocols = /* @__PURE__ */ ((Protocols2) => {
 var WormholeConfig = class _WormholeConfig {
   args;
   func;
+  provider = "wormhole" /* Wormhole */;
   static is(obj) {
     return obj instanceof _WormholeConfig;
   }
@@ -4791,20 +5915,20 @@ var WormholeConfig = class _WormholeConfig {
 };
 
 // src/mrl/providers/wormhole/wormhole/wormhole.ts
-import { EvmChain, EvmParachain as EvmParachain5, Parachain as Parachain3 } from "@moonbeam-network/xcm-types";
+import { EvmChain as EvmChain3, EvmParachain as EvmParachain7, 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 EvmParachain4 } from "@moonbeam-network/xcm-types";
+import { EvmParachain as EvmParachain6 } 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],
-    EvmParachain4.isAnyEvmChain(chain) && chain.wh ? {
+    EvmParachain6.isAnyEvmChain(chain) && chain.wh ? {
       chains: {
         [chain.wh.name]: {
           rpc: chain.rpc
@@ -4816,21 +5940,23 @@ function wormholeFactory(chain) {
 
 // src/mrl/providers/wormhole/wormhole/wormhole.ts
 function wormhole() {
+  const provider = "wormhole" /* Wormhole */;
   return {
     tokenTransfer: () => ({
+      provider,
       build: ({
         asset,
         destination,
         destinationAddress,
         isAutomatic,
         moonApi,
-        moonChain,
+        bridgeChain: moonChain,
         source,
         sourceAddress
       }) => {
         const isSourceParachain = Parachain3.is(source);
         const isDestinationMoonChain = destination.isEqual(moonChain);
-        const isDestinationEvmChain = EvmChain.is(destination);
+        const isDestinationEvmChain = EvmChain3.is(destination);
         const isNativeAsset = asset.isSame(
           isDestinationEvmChain ? moonChain.nativeAsset : source.nativeAsset
         );
@@ -4875,12 +6001,12 @@ function getPayload({
   destination,
   destinationAddress
 }) {
-  if (!EvmParachain5.isAnyParachain(destination)) {
+  if (!EvmParachain7.isAnyParachain(destination)) {
     throw new Error(
       `Destination ${destination.name} is not a Parachain or EvmParachain`
     );
   }
-  const isEvmDestination = EvmParachain5.is(destination);
+  const isEvmDestination = EvmParachain7.is(destination);
   const version = getExtrinsicArgumentVersion(moonApi.tx.polkadotXcm.send);
   const multilocation = moonApi.createType("XcmVersionedLocation", {
     [version]: {
@@ -6096,33 +7222,35 @@ var TOKEN_BRIDGE_ABI = [
 // src/mrl/providers/wormhole/contract/TokenBridge/TokenBridge.ts
 var module3 = "TokenBridge";
 function TokenBridge() {
+  const provider = "wormhole" /* Wormhole */;
   return {
     transferTokens: () => ({
-      build: ({ asset, destination, destinationAddress, moonChain }) => {
-        const wh = wormholeFactory(moonChain);
+      provider,
+      build: ({ asset, destination, destinationAddress, bridgeChain }) => {
+        const wh = wormholeFactory(bridgeChain);
         const whDestination = wh.getChain(destination.getWormholeName()).config.chainId;
-        const tokenAddressOnMoonChain = moonChain.getChainAsset(asset).address;
-        if (!tokenAddressOnMoonChain) {
+        const tokenAddressOnBridgeChain = bridgeChain.getChainAsset(asset).address;
+        if (!tokenAddressOnBridgeChain) {
           throw new Error(
-            `Asset ${asset.symbol} does not have a token address on chain ${moonChain.name}`
+            `Asset ${asset.symbol} does not have a token address on chain ${bridgeChain.name}`
           );
         }
         const destinationAddress32bytes = convertAddressTo32Bytes(
           destinationAddress
         );
-        const tokenAmountOnMoonChain = asset.convertDecimals(
-          moonChain.getChainAsset(asset).decimals
+        const tokenAmountOnBridgeChain = asset.convertDecimals(
+          bridgeChain.getChainAsset(asset).decimals
         ).amount;
         const contractAddress = wh.getChain("Moonbeam").config.contracts.tokenBridge;
         if (!contractAddress) {
-          throw new Error(`Wormhole address not found for ${moonChain.name}`);
+          throw new Error(`Wormhole address not found for ${bridgeChain.name}`);
         }
         return new ContractConfig({
           address: contractAddress,
           abi: TOKEN_BRIDGE_ABI,
           args: [
-            tokenAddressOnMoonChain,
-            tokenAmountOnMoonChain,
+            tokenAddressOnBridgeChain,
+            tokenAmountOnBridgeChain,
             whDestination,
             destinationAddress32bytes,
             0n,
@@ -6253,33 +7381,35 @@ var TOKEN_BRIDGE_RELAYER_ABI = [
 // src/mrl/providers/wormhole/contract/TokenBridgeRelayer/TokenBridgeRelayer.ts
 var module4 = "TokenBridgeRelayer";
 function TokenBridgeRelayer() {
+  const provider = "wormhole" /* Wormhole */;
   return {
     transferTokensWithRelay: () => ({
-      build: ({ asset, destination, destinationAddress, moonChain }) => {
-        const wh = wormholeFactory(moonChain);
+      provider,
+      build: ({ asset, destination, destinationAddress, bridgeChain }) => {
+        const wh = wormholeFactory(bridgeChain);
         const whDestination = wh.getChain(destination.getWormholeName()).config.chainId;
-        const tokenAddressOnMoonChain = moonChain.getChainAsset(asset).address;
-        if (!tokenAddressOnMoonChain) {
+        const tokenAddressOnBridgeChain = bridgeChain.getChainAsset(asset).address;
+        if (!tokenAddressOnBridgeChain) {
           throw new Error(
-            `Asset ${asset.symbol} does not have a token address on chain ${moonChain.name}`
+            `Asset ${asset.symbol} does not have a token address on chain ${bridgeChain.name}`
           );
         }
         const destinationAddress32bytes = convertAddressTo32Bytes2(
           destinationAddress
         );
-        const tokenAmountOnMoonChain = asset.convertDecimals(
-          moonChain.getChainAsset(asset).decimals
+        const tokenAmountOnBridgeChain = asset.convertDecimals(
+          bridgeChain.getChainAsset(asset).decimals
         ).amount;
         const contractAddress = wh.getChain("Moonbeam").config.contracts.tokenBridgeRelayer;
         if (!contractAddress) {
-          throw new Error(`Wormhole address not found for ${moonChain.name}`);
+          throw new Error(`Wormhole address not found for ${bridgeChain.name}`);
         }
         return new ContractConfig({
           address: contractAddress,
           abi: TOKEN_BRIDGE_RELAYER_ABI,
           args: [
-            tokenAddressOnMoonChain,
-            tokenAmountOnMoonChain,
+            tokenAddressOnBridgeChain,
+            tokenAmountOnBridgeChain,
             0,
             whDestination,
             destinationAddress32bytes,
@@ -6294,7 +7424,7 @@ function TokenBridgeRelayer() {
 }
 
 // src/mrl/providers/wormhole/contract/index.ts
-function contract() {
+function contract2() {
   return { Batch, Gmp, TokenBridge, TokenBridgeRelayer };
 }
 
@@ -6420,36 +7550,38 @@ var BATCH_CONTRACT_ABI = [
 
 // src/mrl/providers/wormhole/extrinsic/ethereumXcm/ethereumXcm.ts
 function ethereumXcm() {
+  const provider = "wormhole" /* Wormhole */;
   return {
     transact: () => ({
+      provider,
       build: (params) => {
-        const { asset, isAutomatic, moonChain, moonGasLimit } = params;
-        if (!moonGasLimit) {
-          throw new Error("moonGasLimit must be defined");
+        const { asset, isAutomatic, bridgeChain, bridgeChainGasLimit } = params;
+        if (!bridgeChainGasLimit) {
+          throw new Error("bridgeChainGasLimit must be defined");
         }
-        const tokenAddressOnMoonChain = moonChain.getChainAsset(asset).address;
-        if (!tokenAddressOnMoonChain) {
+        const tokenAddressOnBridgeChain = bridgeChain.getChainAsset(asset).address;
+        if (!tokenAddressOnBridgeChain) {
           throw new Error(
-            `Asset ${asset.symbol} does not have a token address on chain ${moonChain.name}`
+            `Asset ${asset.symbol} does not have a token address on chain ${bridgeChain.name}`
           );
         }
-        const tokenAmountOnMoonChain = asset.convertDecimals(
-          moonChain.getChainAsset(asset).decimals
+        const tokenAmountOnBridgeChain = asset.convertDecimals(
+          bridgeChain.getChainAsset(asset).decimals
         ).amount;
-        const contract2 = isAutomatic ? contract().TokenBridgeRelayer().transferTokensWithRelay().build(params) : contract().TokenBridge().transferTokens().build(params);
+        const contract3 = isAutomatic ? contract2().TokenBridgeRelayer().transferTokensWithRelay().build(params) : contract2().TokenBridge().transferTokens().build(params);
         const approveTx = encodeFunctionData3({
           abi: ERC20_ABI,
           functionName: "approve",
-          args: [contract2.address, tokenAmountOnMoonChain]
+          args: [contract3.address, tokenAmountOnBridgeChain]
         });
         const batchAll = encodeFunctionData3({
           abi: BATCH_CONTRACT_ABI,
           functionName: "batchAll",
           args: [
-            [tokenAddressOnMoonChain, contract2.address],
+            [tokenAddressOnBridgeChain, contract3.address],
             [0n, 0n],
             // Value to send for each call
-            [approveTx, contract2.encodeFunctionData()],
+            [approveTx, contract3.encodeFunctionData()],
             // Call data for each call
             []
             // Gas limit for each call
@@ -6461,7 +7593,7 @@ function ethereumXcm() {
           getArgs: () => [
             {
               V2: {
-                gasLimit: moonGasLimit,
+                gasLimit: bridgeChainGasLimit,
                 action: {
                   Call: BATCH_CONTRACT_ADDRESS
                 },
@@ -6477,15 +7609,15 @@ function ethereumXcm() {
 }
 
 // src/mrl/providers/wormhole/extrinsic/index.ts
-function extrinsic() {
+function extrinsic2() {
   return { ethereumXcm, polkadotXcm: polkadotXcm2 };
 }
 
 // src/mrl/providers/wormhole/index.ts
 function wormhole2() {
   return {
-    contract,
-    extrinsic,
+    contract: contract2,
+    extrinsic: extrinsic2,
     wormhole
   };
 }
@@ -6493,6 +7625,7 @@ function wormhole2() {
 // src/mrl/MrlBuilder.ts
 function MrlBuilder() {
   return {
+    snowbridge,
     wormhole: wormhole2
   };
 }
@@ -6508,9 +7641,12 @@ export {
   ExtrinsicBuilder,
   ExtrinsicConfig,
   FeeBuilder,
+  GATEWAY_ABI,
   MonitoringBuilder,
   MrlBuilder,
   Protocols,
+  Provider,
+  SnowbridgeConfig,
   SubstrateCallConfig,
   SubstrateQueryConfig,
   TransferType,
@@ -6518,6 +7654,7 @@ export {
   XcmVersion,
   calculateSystemAccountBalance,
   evm,
+  snowbridge,
   substrate,
   wormhole2 as wormhole,
   wormholeFactory