@moonbeam-network/mrl 1.0.0-dev.263 → 1.0.0-dev.265

package/build/index.mjs

@@ -16755,34 +16755,191 @@ async function getExecuteTransferData({
 
 // src/getTransferData/getTransferData.ts
 import {
-  ContractConfig as ContractConfig2,
+  ContractConfig as ContractConfig3,
   ExtrinsicConfig,
+  SnowbridgeConfig as SnowbridgeConfig2,
   WormholeConfig as WormholeConfig2
 } from "@moonbeam-network/xcm-builder";
 import {
   convertToChainDecimals as convertToChainDecimals2,
-  EvmService as EvmService2,
+  EvmService as EvmService4,
   getDestinationData,
-  PolkadotService as PolkadotService2
+  PolkadotService as PolkadotService3
 } from "@moonbeam-network/xcm-sdk";
 import {
   AssetAmount as AssetAmount3,
-  EvmChain,
-  EvmParachain as EvmParachain3
+  EvmChain as EvmChain2,
+  EvmParachain as EvmParachain4
 } from "@moonbeam-network/xcm-types";
 import { toBigInt as toBigInt3 } from "@moonbeam-network/xcm-utils";
 import Big2 from "big.js";
 
-// src/getTransferData/getMoonChainData.ts
-import { getMoonChain } from "@moonbeam-network/xcm-config";
-import { getBalance, getDestinationFee } from "@moonbeam-network/xcm-sdk";
+// src/services/snowbridge/SnowbridgeService.ts
 import {
-  EvmParachain,
-  Parachain
-} from "@moonbeam-network/xcm-types";
+  ContractConfig,
+  ERC20_ABI,
+  GATEWAY_ABI,
+  GATEWAY_CONTRACT_ADDRESS
+} from "@moonbeam-network/xcm-builder";
+import { EvmService as EvmService2 } from "@moonbeam-network/xcm-sdk";
+import { u8aToHex } from "@polkadot/util";
+import { decodeAddress } from "@polkadot/util-crypto";
+import { encodeFunctionData } from "viem";
+var SnowbridgeService = class _SnowbridgeService {
+  chain;
+  #evmService;
+  static create(chain2) {
+    return new _SnowbridgeService(chain2);
+  }
+  constructor(chain2) {
+    this.chain = chain2;
+    this.#evmService = EvmService2.create(chain2);
+  }
+  async checkAllowance(ownerAddress, tokenAddress, spenderAddress) {
+    const allowance = await this.#evmService.client.readContract({
+      abi: ERC20_ABI,
+      address: tokenAddress,
+      args: [ownerAddress, spenderAddress],
+      functionName: "allowance"
+    });
+    if (typeof allowance !== "bigint") {
+      throw new Error(
+        `Could not get allowance on ${this.chain.name} for token ${tokenAddress}`
+      );
+    }
+    return allowance;
+  }
+  async transfer(signer, transfer) {
+    const { args } = transfer;
+    const { tokenAddress, amount, requiresApproval } = args;
+    if (!signer.account) {
+      throw new Error("Signer account is required");
+    }
+    const contract = this.buildContractConfig(transfer);
+    if (!requiresApproval) {
+      return await this.#evmService.transfer(signer, contract);
+    }
+    const currentAllowance = await this.checkAllowance(
+      signer.account.address,
+      tokenAddress,
+      GATEWAY_CONTRACT_ADDRESS
+    );
+    console.log("currentAllowance", currentAllowance);
+    if (currentAllowance < amount) {
+      await this.approve(
+        signer,
+        tokenAddress,
+        GATEWAY_CONTRACT_ADDRESS,
+        amount
+      );
+    }
+    return await this.#evmService.transfer(signer, contract);
+  }
+  buildContractConfig(transfer) {
+    const { args } = transfer;
+    const {
+      tokenAddress,
+      destinationAddress,
+      destinationParaId,
+      amount,
+      bridgeFeeAmount,
+      requiresApproval
+    } = args;
+    const value = requiresApproval ? bridgeFeeAmount : amount + bridgeFeeAmount;
+    const contractArgs = [
+      tokenAddress,
+      destinationParaId,
+      {
+        kind: 1,
+        data: u8aToHex(decodeAddress(destinationAddress))
+      },
+      0n,
+      amount
+    ];
+    return new ContractConfig({
+      address: GATEWAY_CONTRACT_ADDRESS,
+      abi: GATEWAY_ABI,
+      args: contractArgs,
+      func: "sendToken",
+      value,
+      module: "Gateway"
+    });
+  }
+  async approve(signer, tokenAddress, spenderAddress, amount) {
+    const { request } = await this.#evmService.client.simulateContract({
+      abi: ERC20_ABI,
+      account: signer.account,
+      address: tokenAddress,
+      functionName: "approve",
+      args: [spenderAddress, amount]
+    });
+    const hash = await signer.writeContract(request);
+    await this.#evmService.client.waitForTransactionReceipt({
+      hash
+    });
+    return hash;
+  }
+  async getFee(address, transfer) {
+    const { args } = transfer;
+    const { tokenAddress, amount, requiresApproval } = args;
+    const contract = this.buildContractConfig(transfer);
+    if (!requiresApproval) {
+      return await this.#evmService.getFee(address, contract);
+    }
+    const currentAllowance = await this.checkAllowance(
+      address,
+      tokenAddress,
+      GATEWAY_CONTRACT_ADDRESS
+    );
+    if (currentAllowance >= amount) {
+      return await this.#evmService.getFee(address, contract);
+    }
+    return await this.estimateApproveAndSendFee(address, transfer);
+  }
+  async estimateApproveAndSendFee(address, transfer) {
+    const { args } = transfer;
+    const { tokenAddress, amount } = args;
+    const contract = this.buildContractConfig(transfer);
+    try {
+      const approveData = encodeFunctionData({
+        abi: ERC20_ABI,
+        functionName: "approve",
+        args: [GATEWAY_CONTRACT_ADDRESS, amount]
+      });
+      const approveGas = await this.#evmService.client.estimateGas({
+        account: address,
+        to: tokenAddress,
+        data: approveData
+      });
+      const sendData = encodeFunctionData({
+        abi: contract.abi,
+        functionName: contract.func,
+        args: contract.args
+      });
+      const sendGas = await this.#evmService.client.estimateGas({
+        account: address,
+        to: contract.address,
+        data: sendData,
+        value: contract.value
+      });
+      const gasPrice = await this.#evmService.client.getGasPrice();
+      console.log("gasPrice", gasPrice);
+      console.log("approveGas", approveGas);
+      console.log("sendGas", sendGas);
+      return (approveGas + sendGas) * gasPrice;
+    } catch (error) {
+      console.error("Error estimating approve + send fee:", error);
+      return 0n;
+    }
+  }
+};
+
+// src/getTransferData/getBridgeChainData.ts
+import { getBalance, getDestinationFee } from "@moonbeam-network/xcm-sdk";
+import { EvmParachain, Parachain } from "@moonbeam-network/xcm-types";
 import { getMultilocationDerivedAddresses } from "@moonbeam-network/xcm-utils";
 import { evmToAddress } from "@polkadot/util-crypto";
-async function getMoonChainData({
+async function getBridgeChainData({
   route,
   sourceAddress,
   destinationAddress
@@ -16792,80 +16949,86 @@ async function getMoonChainData({
       `MRL config is not defined for source chain ${route.source.chain.name} and asset ${route.source.asset.originSymbol}`
     );
   }
-  const moonChain = getMoonChain(route.source.chain);
-  const moonChainAddress = getMoonChainAddress({
-    source: route.source.chain,
-    destination: route.destination.chain,
+  const bridgeChain = route.mrl.bridgeChain.chain;
+  const bridgeChainAddress = getBridgeChainAddress({
+    route,
     sourceAddress,
     destinationAddress
   });
   const fee = await getDestinationFee({
-    address: moonChainAddress,
+    address: bridgeChainAddress,
     asset: route.source.asset,
-    destination: moonChain,
-    fee: route.mrl.moonChain.fee.amount,
-    feeAsset: route.mrl.moonChain.fee.asset,
+    destination: bridgeChain,
+    fee: route.mrl.bridgeChain.fee.amount,
+    feeAsset: route.mrl.bridgeChain.fee.asset,
     source: route.source.chain
   });
   const balance = await getBalance({
-    address: moonChainAddress,
-    asset: moonChain.getChainAsset(route.mrl.moonChain.asset),
-    builder: route.mrl.moonChain.balance,
-    chain: moonChain
+    address: bridgeChainAddress,
+    asset: bridgeChain.getChainAsset(route.mrl.bridgeChain.asset),
+    builder: route.mrl.bridgeChain.balance,
+    chain: bridgeChain
   });
   const feeBalance = await getBalance({
-    address: moonChainAddress,
-    asset: moonChain.getChainAsset(route.mrl.moonChain.fee.asset),
-    builder: route.mrl.moonChain.fee.balance,
-    chain: moonChain
+    address: bridgeChainAddress,
+    asset: bridgeChain.getChainAsset(route.mrl.bridgeChain.fee.asset),
+    builder: route.mrl.bridgeChain.fee.balance,
+    chain: bridgeChain
   });
   return {
-    address: moonChainAddress,
+    address: bridgeChainAddress,
     balance,
     feeBalance,
-    chain: moonChain,
+    chain: bridgeChain,
     fee
   };
 }
-function getMoonChainAddress({
-  source,
-  destination,
+function getBridgeChainAddress({
+  route,
   sourceAddress,
   destinationAddress
 }) {
-  const moonChain = getMoonChain(source);
-  const isDestinationMoonChain = moonChain.isEqual(destination);
-  const isSourceMoonChain = moonChain.isEqual(source);
-  let moonChainAddress = isDestinationMoonChain ? destinationAddress : sourceAddress;
-  if (Parachain.is(source) && !isSourceMoonChain) {
+  const source = route.source.chain;
+  const destination = route.destination.chain;
+  const bridgeChain = route.mrl.bridgeChain.chain;
+  const isDestinationBridgeChain = bridgeChain.isEqual(destination);
+  const isSourceBridgeChain = bridgeChain.isEqual(source);
+  let bridgeChainAddress = isDestinationBridgeChain ? destinationAddress : sourceAddress;
+  if (Parachain.is(source) && !isSourceBridgeChain) {
     const isSourceEvmSigner = EvmParachain.is(source) && source.isEvmSigner;
     const { address20: computedOriginAccount } = getMultilocationDerivedAddresses({
       address: isSourceEvmSigner ? evmToAddress(sourceAddress) : sourceAddress,
       paraId: source.parachainId,
       isParents: true
     });
-    moonChainAddress = computedOriginAccount;
+    bridgeChainAddress = computedOriginAccount;
   }
-  return moonChainAddress;
+  return bridgeChainAddress;
 }
 
 // src/getTransferData/getSourceData.ts
 import {
-  ContractConfig,
+  ContractConfig as ContractConfig2,
   MrlBuilder as MrlBuilder3,
+  SnowbridgeConfig,
+  SubstrateQueryConfig,
   WormholeConfig
 } from "@moonbeam-network/xcm-builder";
 import {
+  EvmService as EvmService3,
   getAssetMin,
   getBalance as getBalance2,
   getContractFee,
   getDestinationFeeBalance,
   getExistentialDeposit,
   getExtrinsicFee,
-  getMax
+  getMax,
+  PolkadotService as PolkadotService2
 } from "@moonbeam-network/xcm-sdk";
 import {
-  AssetAmount as AssetAmount2
+  AssetAmount as AssetAmount2,
+  EvmChain,
+  EvmParachain as EvmParachain3
 } from "@moonbeam-network/xcm-types";
 import { toBigInt as toBigInt2 } from "@moonbeam-network/xcm-utils";
 
@@ -16873,11 +17036,10 @@ import { toBigInt as toBigInt2 } from "@moonbeam-network/xcm-utils";
 import {
   BATCH_CONTRACT_ABI,
   BATCH_CONTRACT_ADDRESS,
-  ERC20_ABI,
+  ERC20_ABI as ERC20_ABI2,
   MrlBuilder as MrlBuilder2
 } from "@moonbeam-network/xcm-builder";
 import {
-  getMoonChain as getMoonChain2,
   moonbaseAlpha,
   moonbeam
 } from "@moonbeam-network/xcm-config";
@@ -16894,33 +17056,33 @@ import {
 import Big from "big.js";
 import {
   createPublicClient as createPublicClient2,
-  encodeFunctionData,
+  encodeFunctionData as encodeFunctionData2,
   http as http2
 } from "viem";
 var MOON_CHAIN_AUTOMATIC_GAS_ESTIMATION = {
   [moonbeam.key]: 1273110n,
   [moonbaseAlpha.key]: 1470417n
 };
-function getMoonChainFeeValueOnSource({
+function getBridgeChainFeeValueOnSource({
   destinationData,
-  moonChainData,
+  bridgeChainData,
   sourceData
 }) {
   const isSourceParachain = EvmParachain2.isAnyParachain(sourceData.chain);
-  const isDestinationMoonChain = destinationData.chain.isEqual(
-    moonChainData.chain
+  const isDestinationBridgeChain = destinationData.chain.isEqual(
+    bridgeChainData.chain
   );
-  const isSameAssetPayingMoonChainFee = sourceData.balance.isSame(
-    moonChainData.fee
+  const isSameAssetPayingBridgeChainFee = sourceData.balance.isSame(
+    bridgeChainData.fee
   );
-  return !isDestinationMoonChain && isSourceParachain && isSameAssetPayingMoonChainFee ? convertToChainDecimals({
-    asset: moonChainData.fee,
-    target: sourceData.chain.getChainAsset(moonChainData.fee)
+  return !isDestinationBridgeChain && isSourceParachain && isSameAssetPayingBridgeChainFee ? convertToChainDecimals({
+    asset: bridgeChainData.fee,
+    target: sourceData.chain.getChainAsset(bridgeChainData.fee)
   }).toBig() : Big(0);
 }
 function getMrlMin({
   destinationData,
-  moonChainData,
+  bridgeChainData,
   sourceData
 }) {
   const minInDestination = getMin(destinationData);
@@ -16930,16 +17092,19 @@ function getMrlMin({
       amount: minInDestination.amount
     }
   );
-  const moonChainFee = getMoonChainFeeValueOnSource({
+  const bridgeChainFee = getBridgeChainFeeValueOnSource({
     destinationData,
-    moonChainData,
+    bridgeChainData,
     sourceData
   });
-  const relayerFee = sourceData.relayerFee?.amount ? sourceData.relayerFee.toBig() : Big(0);
+  const relayerFee = sourceData.otherFees?.relayer?.amount ? sourceData.otherFees.relayer.toBig() : Big(0);
   return min.copyWith({
-    amount: BigInt(min.toBig().add(moonChainFee).add(relayerFee).toFixed())
+    amount: BigInt(min.toBig().add(bridgeChainFee).add(relayerFee).toFixed())
   });
 }
+function requiresTransact(route) {
+  return route.mrl?.transfer.provider === "wormhole" && EvmParachain2.isAnyParachain(route.source.chain);
+}
 async function buildTransfer(params) {
   const { route } = params;
   if (!route.mrl) {
@@ -16955,11 +17120,12 @@ async function buildTransfer(params) {
   const builderParams = await getMrlBuilderParams(params);
   return route.mrl.transfer.build({
     ...builderParams,
-    transact: EvmParachain2.isAnyParachain(route.source.chain) ? await getTransact(builderParams) : void 0
+    transact: requiresTransact(route) ? await getTransact(builderParams) : void 0
   });
 }
 async function getMrlBuilderParams({
   asset,
+  protocolFee,
   destinationAddress,
   feeAsset,
   isAutomatic,
@@ -16974,22 +17140,23 @@ async function getMrlBuilderParams({
   }
   const source = route.source.chain;
   const destination = route.destination.chain;
-  const moonChain = getMoonChain2(source);
-  const [sourceApi, destinationApi, moonApi] = await Promise.all([
+  const bridgeChain = route.mrl.bridgeChain.chain;
+  const [sourceApi, destinationApi, bridgeApi] = await Promise.all([
     EvmParachain2.isAnyParachain(source) ? getPolkadotApi(source.ws) : void 0,
     EvmParachain2.isAnyParachain(destination) ? getPolkadotApi(destination.ws) : void 0,
-    getPolkadotApi(moonChain.ws)
+    getPolkadotApi(bridgeChain.ws)
   ]);
   return {
     asset,
+    protocolFee,
     destination,
     destinationAddress,
     destinationApi,
     fee: feeAsset,
     isAutomatic,
-    moonApi,
-    moonAsset: moonChain.nativeAsset,
-    moonChain,
+    moonApi: bridgeApi,
+    moonAsset: bridgeChain.nativeAsset,
+    bridgeChain,
     sendOnlyRemoteExecution,
     source,
     sourceAddress,
@@ -16997,9 +17164,9 @@ async function getMrlBuilderParams({
   };
 }
 async function getTransact(params) {
-  const { sourceAddress, source, moonChain } = params;
-  const polkadot = await PolkadotService.create(moonChain);
-  const moonGasLimit = await getMoonGasLimit(params);
+  const { sourceAddress, source, bridgeChain } = params;
+  const polkadot = await PolkadotService.create(bridgeChain);
+  const bridgeChainGasLimit = await getBridgeChainGasLimit(params);
   if (!EvmParachain2.isAnyParachain(source)) {
     throw new Error("Source chain must be Parachain or EvmParachain");
   }
@@ -17008,7 +17175,7 @@ async function getTransact(params) {
     paraId: source.parachainId,
     isParents: true
   });
-  const extrinsic = MrlBuilder2().wormhole().extrinsic().ethereumXcm().transact().build({ ...params, moonGasLimit });
+  const extrinsic = MrlBuilder2().wormhole().extrinsic().ethereumXcm().transact().build({ ...params, bridgeChainGasLimit });
   const { weight } = await polkadot.getPaymentInfo(address20, extrinsic);
   return {
     call: polkadot.getExtrinsicCallHash(extrinsic),
@@ -17018,13 +17185,16 @@ async function getTransact(params) {
     }
   };
 }
-async function getMoonGasLimit(params) {
-  const { asset, isAutomatic, moonChain, source, sourceAddress } = params;
+async function getBridgeChainGasLimit(params) {
+  const { asset, isAutomatic, bridgeChain, source, sourceAddress } = params;
   if (!EvmParachain2.isAnyParachain(source)) {
     throw new Error("Source chain must be Parachain or EvmParachain");
   }
+  if (!EvmParachain2.is(bridgeChain)) {
+    throw new Error("Bridge chain must be an EvmParachain");
+  }
   const client = createPublicClient2({
-    chain: moonChain.getViemChain(),
+    chain: bridgeChain.getViemChain(),
     transport: http2()
   });
   const { address20 } = getMultilocationDerivedAddresses2({
@@ -17033,28 +17203,28 @@ async function getMoonGasLimit(params) {
     isParents: true
   });
   if (isAutomatic) {
-    return MOON_CHAIN_AUTOMATIC_GAS_ESTIMATION[moonChain.key] * 110n / 100n;
+    return MOON_CHAIN_AUTOMATIC_GAS_ESTIMATION[bridgeChain.key] * 110n / 100n;
   }
   const contract = MrlBuilder2().wormhole().contract().TokenBridge().transferTokens().build({
     ...params,
     asset: asset.copyWith({ amount: 0n })
   });
-  const approveTx = encodeFunctionData({
-    abi: ERC20_ABI,
+  const approveTx = encodeFunctionData2({
+    abi: ERC20_ABI2,
     functionName: "approve",
     args: [contract.address, 0n]
   });
-  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 batchAll = encodeFunctionData({
+  const batchAll = encodeFunctionData2({
     abi: BATCH_CONTRACT_ABI,
     functionName: "batchAll",
     args: [
-      [tokenAddressOnMoonChain, contract.address],
+      [tokenAddressOnBridgeChain, contract.address],
       [0n, 0n],
       // Value to send for each call
       [approveTx, contract.encodeFunctionData()],
@@ -17085,6 +17255,7 @@ async function getSourceData({
     );
   }
   const source = route.source.chain;
+  const destination = route.destination.chain;
   const asset = source.getChainAsset(route.source.asset);
   const feeAsset = route.source.fee ? source.getChainAsset(route.source.fee.asset) : asset;
   const balance = await getBalance2({
@@ -17105,7 +17276,7 @@ async function getSourceData({
     route,
     sourceAddress
   });
-  const moonChainFeeBalance = await getMoonChainFeeBalance({
+  const bridgeChainFeeBalance = await getBridgeChainFeeBalance({
     balance,
     feeBalance,
     route,
@@ -17117,8 +17288,19 @@ async function getSourceData({
     builder: route.source.min,
     chain: source
   });
+  const protocolFee = await getProtocolFee({
+    source,
+    destination,
+    // For now, the fee asset is always the one used for the protocol fee
+    // If it where to change, we need make protocolFee a FeeConfig in MrlSourceConfig
+    asset: feeAsset,
+    balance,
+    protocolFee: route.source.protocolFee,
+    address: destinationAddress
+  });
   const transfer = await buildTransfer({
-    asset: balance,
+    asset: balance.copyWith({ amount: balance.amount - protocolFee.amount }),
+    protocolFee,
     destinationAddress,
     feeAsset: feeBalance,
     isAutomatic,
@@ -17155,13 +17337,16 @@ async function getSourceData({
     chain: source,
     destinationFee,
     destinationFeeBalance,
-    moonChainFeeBalance,
+    bridgeChainFeeBalance,
     existentialDeposit,
     fee,
     feeBalance,
     max,
     min,
-    relayerFee
+    otherFees: {
+      protocol: protocolFee,
+      relayer: relayerFee?.amount ? relayerFee : void 0
+    }
   };
 }
 async function getFee({
@@ -17178,17 +17363,31 @@ async function getFee({
       amount: 0n
     });
   }
-  if (ContractConfig.is(transfer)) {
-    return getContractFee({
-      address: sourceAddress,
-      balance,
-      chain: chain2,
-      contract: transfer,
-      destinationFee,
-      feeBalance,
-      feeConfig
+  if (SnowbridgeConfig.is(transfer)) {
+    const snowbridge = SnowbridgeService.create(
+      chain2
+    );
+    const feeAmount = await snowbridge.getFee(sourceAddress, transfer);
+    return AssetAmount2.fromChainAsset(chain2.getChainAsset(feeBalance), {
+      amount: feeAmount
     });
   }
+  if (ContractConfig2.is(transfer)) {
+    try {
+      return getContractFee({
+        address: sourceAddress,
+        balance,
+        chain: chain2,
+        contract: transfer,
+        destinationFee,
+        feeBalance,
+        feeConfig
+      });
+    } catch (error) {
+      console.error(error);
+      return feeBalance.copyWith({ amount: 0n });
+    }
+  }
   return getExtrinsicFee({
     address: sourceAddress,
     balance,
@@ -17208,19 +17407,25 @@ async function getRelayerFee({
   sourceAddress,
   transfer
 }) {
+  if (route.mrl.transfer.provider === "snowbridge" || SnowbridgeConfig.is(transfer)) {
+    return void 0;
+  }
   if (WormholeConfig.is(transfer)) {
     return getWormholeFee({ asset, chain: chain2, config: transfer });
   }
-  const builderParams = await getMrlBuilderParams({
-    asset,
-    destinationAddress,
-    feeAsset,
-    isAutomatic,
-    route,
-    sourceAddress
-  });
-  const wormholeConfig = MrlBuilder3().wormhole().wormhole().tokenTransfer().build(builderParams);
-  return getWormholeFee({ asset, chain: chain2, config: wormholeConfig });
+  if (route.mrl.transfer.provider === "wormhole") {
+    const builderParams = await getMrlBuilderParams({
+      asset,
+      destinationAddress,
+      feeAsset,
+      isAutomatic,
+      route,
+      sourceAddress
+    });
+    const wormholeConfig = MrlBuilder3().wormhole().wormhole().tokenTransfer().build(builderParams);
+    return getWormholeFee({ asset, chain: chain2, config: wormholeConfig });
+  }
+  return;
 }
 async function getWormholeFee({
   asset,
@@ -17237,33 +17442,76 @@ async function getWormholeFee({
   }
   return;
 }
-async function getMoonChainFeeBalance({
+async function getBridgeChainFeeBalance({
   balance,
   feeBalance,
   route,
   sourceAddress
 }) {
-  if (!route.source.moonChainFee) {
+  if (!route.source.bridgeChainFee) {
     return void 0;
   }
-  if (route.mrl?.moonChain.fee.asset.isEqual(balance)) {
+  if (route.mrl?.bridgeChain.fee.asset.isEqual(balance)) {
     return balance;
   }
-  if (route.mrl?.moonChain.fee.asset.isEqual(feeBalance)) {
+  if (route.mrl?.bridgeChain.fee.asset.isEqual(feeBalance)) {
     return feeBalance;
   }
-  if (!route.source.moonChainFee.balance) {
+  if (!route.source.bridgeChainFee.balance) {
     throw new Error(
-      "BalanceBuilder must be defined for source.moonChainFee.balance for MrlAssetRoute"
+      "BalanceBuilder must be defined for source.bridgeChainFee.balance for MrlAssetRoute"
     );
   }
   return getBalance2({
     address: sourceAddress,
-    asset: route.source.chain.getChainAsset(route.source.moonChainFee.asset),
-    builder: route.source.moonChainFee.balance,
+    asset: route.source.chain.getChainAsset(route.source.bridgeChainFee.asset),
+    builder: route.source.bridgeChainFee.balance,
     chain: route.source.chain
   });
 }
+async function getProtocolFee({
+  address,
+  asset,
+  balance,
+  protocolFee,
+  destination,
+  source
+}) {
+  if (typeof protocolFee === "number") {
+    return AssetAmount2.fromChainAsset(asset, {
+      amount: protocolFee
+    });
+  }
+  const config = protocolFee?.build({
+    address,
+    asset,
+    balance,
+    destination,
+    source
+  });
+  if (ContractConfig2.is(config) && EvmChain.is(source)) {
+    const evm = EvmService3.create(source);
+    const amount = await evm.read(config);
+    if (typeof amount !== "bigint") {
+      throw new Error(
+        `Error getting bridge fee: expected bigint from contract call, but received ${typeof amount}. `
+      );
+    }
+    return AssetAmount2.fromChainAsset(asset, {
+      amount
+    });
+  }
+  if (SubstrateQueryConfig.is(config) && EvmParachain3.isAnyParachain(source)) {
+    const polkadot = await PolkadotService2.create(source);
+    const amount = await polkadot.query(config);
+    return AssetAmount2.fromChainAsset(asset, {
+      amount
+    });
+  }
+  return AssetAmount2.fromChainAsset(source.getChainAsset(asset), {
+    amount: 0n
+  });
+}
 
 // src/getTransferData/getTransferData.ts
 async function getTransferData({
@@ -17281,10 +17529,12 @@ async function getTransferData({
     route,
     destinationAddress
   });
+  console.log("destinationData", destinationData);
   const destinationFee = convertToChainDecimals2({
     asset: destinationData.fee,
     target: route.getDestinationFeeAssetOnSource()
   });
+  console.log("destinationFee", destinationFee);
   const sourceData = await getSourceData({
     isAutomatic: route.mrl.isAutomaticPossible && isAutomatic,
     route,
@@ -17292,11 +17542,13 @@ async function getTransferData({
     destinationFee,
     sourceAddress
   });
-  const moonChainData = await getMoonChainData({
+  console.log("sourceData", sourceData);
+  const bridgeChainData = await getBridgeChainData({
     route,
     sourceAddress,
     destinationAddress
   });
+  console.log("bridgeChainData", bridgeChainData);
   return {
     destination: destinationData,
     getEstimate(amount) {
@@ -17304,14 +17556,14 @@ async function getTransferData({
       const bigAmount = Big2(
         toBigInt3(amount, sourceData.balance.decimals).toString()
       );
-      const fee = getMoonChainFeeValueOnSource({
+      const fee = getBridgeChainFeeValueOnSource({
         destinationData,
-        moonChainData,
+        bridgeChainData,
         sourceData
       });
       const result = bigAmount.minus(
         isSameAssetPayingDestinationFee ? destinationFee.toBig() : Big2(0)
-      ).minus(fee).minus(sourceData.relayerFee?.toBig() || Big2(0));
+      ).minus(fee).minus(sourceData.otherFees?.relayer?.toBig() || Big2(0));
       return sourceData.balance.copyWith({
         amount: result.lt(0) ? 0n : BigInt(result.toFixed())
       });
@@ -17320,10 +17572,10 @@ async function getTransferData({
     max: sourceData.max,
     min: getMrlMin({
       destinationData,
-      moonChainData,
+      bridgeChainData,
       sourceData
     }),
-    moonChain: moonChainData,
+    bridgeChain: bridgeChainData,
     source: sourceData,
     async transfer({
       amount,
@@ -17346,6 +17598,7 @@ async function getTransferData({
       );
       const transfer = await buildTransfer({
         asset,
+        protocolFee: sourceData.otherFees?.protocol,
         destinationAddress,
         feeAsset,
         isAutomatic: isAutomatic2,
@@ -17353,19 +17606,19 @@ async function getTransferData({
         sendOnlyRemoteExecution,
         sourceAddress
       });
-      if (ContractConfig2.is(transfer) && (EvmChain.is(source) || EvmParachain3.is(source))) {
+      if (ContractConfig3.is(transfer) && (EvmChain2.is(source) || EvmParachain4.is(source))) {
         if (!evmSigner) {
           throw new Error("EVM Signer must be provided");
         }
-        const evm = EvmService2.create(source);
+        const evm = EvmService4.create(source);
         const hash = await evm.transfer(evmSigner, transfer);
         return [hash];
       }
-      if (ExtrinsicConfig.is(transfer) && EvmParachain3.isAnyParachain(source)) {
+      if (ExtrinsicConfig.is(transfer) && EvmParachain4.isAnyParachain(source)) {
         if (!polkadotSigner) {
           throw new Error("Polkadot signer must be provided");
         }
-        const polkadot = await PolkadotService2.create(source);
+        const polkadot = await PolkadotService3.create(source);
         const hash = await polkadot.transfer(
           sourceAddress,
           transfer,
@@ -17374,13 +17627,21 @@ async function getTransferData({
         );
         return [hash];
       }
-      if (WormholeConfig2.is(transfer) && (EvmChain.is(source) || EvmParachain3.is(source))) {
+      if (WormholeConfig2.is(transfer) && (EvmChain2.is(source) || EvmParachain4.is(source))) {
         if (!evmSigner) {
           throw new Error("EVM Signer must be provided");
         }
         const wh = WormholeService.create(source);
         return wh.transfer(evmSigner, transfer);
       }
+      if (SnowbridgeConfig2.is(transfer) && (EvmChain2.is(source) || EvmParachain4.is(source))) {
+        if (!evmSigner) {
+          throw new Error("EVM Signer must be provided");
+        }
+        const snowbridge = SnowbridgeService.create(source);
+        const hash = await snowbridge.transfer(evmSigner, transfer);
+        return [hash];
+      }
       throw new Error("Either contract or extrinsic must be provided");
     }
   };