@moonbeam-network/mrl 1.0.0-dev.268 → 1.0.0-dev.269

package/build/index.mjs

@@ -16755,189 +16755,34 @@ async function getExecuteTransferData({
 
 // src/getTransferData/getTransferData.ts
 import {
-  ContractConfig as ContractConfig3,
+  ContractConfig as ContractConfig2,
   ExtrinsicConfig,
-  SnowbridgeConfig as SnowbridgeConfig2,
   WormholeConfig as WormholeConfig2
 } from "@moonbeam-network/xcm-builder";
 import {
   convertToChainDecimals as convertToChainDecimals2,
-  EvmService as EvmService4,
+  EvmService as EvmService2,
   getDestinationData,
-  PolkadotService as PolkadotService3
+  PolkadotService as PolkadotService2
 } from "@moonbeam-network/xcm-sdk";
 import {
   AssetAmount as AssetAmount3,
-  EvmChain as EvmChain3,
-  EvmParachain as EvmParachain4
+  EvmChain,
+  EvmParachain as EvmParachain3
 } from "@moonbeam-network/xcm-types";
 import { toBigInt as toBigInt3 } from "@moonbeam-network/xcm-utils";
 import Big2 from "big.js";
 
-// src/services/snowbridge/SnowbridgeService.ts
-import {
-  ContractConfig,
-  ERC20_ABI,
-  GATEWAY_ABI
-} from "@moonbeam-network/xcm-builder";
-import { EvmService as EvmService2 } from "@moonbeam-network/xcm-sdk";
-import { EvmChain } from "@moonbeam-network/xcm-types";
-import { u8aToHex } from "@polkadot/util";
-import { decodeAddress } from "@polkadot/util-crypto";
-import { encodeFunctionData } from "viem";
-var SnowbridgeService = class _SnowbridgeService {
-  chain;
-  #evmService;
-  #gatewayAddress;
-  static create(chain2) {
-    return new _SnowbridgeService(chain2);
-  }
-  constructor(chain2) {
-    if (!EvmChain.is(chain2) || !chain2.contracts?.Gateway) {
-      throw new Error(
-        "Chain must be an EVMChain with the Gateway contract address configured for Snowbridge operations"
-      );
-    }
-    this.chain = chain2;
-    this.#gatewayAddress = chain2.contracts.Gateway;
-    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,
-      this.#gatewayAddress
-    );
-    if (currentAllowance < amount) {
-      await this.approve(signer, tokenAddress, this.#gatewayAddress, 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: this.#gatewayAddress,
-      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,
-      this.#gatewayAddress
-    );
-    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: [this.#gatewayAddress, 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();
-      return (approveGas + sendGas) * gasPrice;
-    } catch (error) {
-      console.error("Error estimating approve + send fee:", error);
-      return 0n;
-    }
-  }
-};
-
-// src/getTransferData/getBridgeChainData.ts
+// src/getTransferData/getMoonChainData.ts
+import { getMoonChain } from "@moonbeam-network/xcm-config";
 import { getBalance, getDestinationFee } from "@moonbeam-network/xcm-sdk";
-import { EvmParachain, Parachain } from "@moonbeam-network/xcm-types";
+import {
+  EvmParachain,
+  Parachain
+} from "@moonbeam-network/xcm-types";
 import { getMultilocationDerivedAddresses } from "@moonbeam-network/xcm-utils";
 import { evmToAddress } from "@polkadot/util-crypto";
-async function getBridgeChainData({
+async function getMoonChainData({
   route,
   sourceAddress,
   destinationAddress
@@ -16947,86 +16792,80 @@ async function getBridgeChainData({
       `MRL config is not defined for source chain ${route.source.chain.name} and asset ${route.source.asset.originSymbol}`
     );
   }
-  const bridgeChain = route.mrl.bridgeChain.chain;
-  const bridgeChainAddress = getBridgeChainAddress({
-    route,
+  const moonChain = getMoonChain(route.source.chain);
+  const moonChainAddress = getMoonChainAddress({
+    source: route.source.chain,
+    destination: route.destination.chain,
     sourceAddress,
     destinationAddress
   });
   const fee = await getDestinationFee({
-    address: bridgeChainAddress,
+    address: moonChainAddress,
     asset: route.source.asset,
-    destination: bridgeChain,
-    fee: route.mrl.bridgeChain.fee.amount,
-    feeAsset: route.mrl.bridgeChain.fee.asset,
+    destination: moonChain,
+    fee: route.mrl.moonChain.fee.amount,
+    feeAsset: route.mrl.moonChain.fee.asset,
     source: route.source.chain
   });
   const balance = await getBalance({
-    address: bridgeChainAddress,
-    asset: bridgeChain.getChainAsset(route.mrl.bridgeChain.asset),
-    builder: route.mrl.bridgeChain.balance,
-    chain: bridgeChain
+    address: moonChainAddress,
+    asset: moonChain.getChainAsset(route.mrl.moonChain.asset),
+    builder: route.mrl.moonChain.balance,
+    chain: moonChain
   });
   const feeBalance = await getBalance({
-    address: bridgeChainAddress,
-    asset: bridgeChain.getChainAsset(route.mrl.bridgeChain.fee.asset),
-    builder: route.mrl.bridgeChain.fee.balance,
-    chain: bridgeChain
+    address: moonChainAddress,
+    asset: moonChain.getChainAsset(route.mrl.moonChain.fee.asset),
+    builder: route.mrl.moonChain.fee.balance,
+    chain: moonChain
   });
   return {
-    address: bridgeChainAddress,
+    address: moonChainAddress,
     balance,
     feeBalance,
-    chain: bridgeChain,
+    chain: moonChain,
     fee
   };
 }
-function getBridgeChainAddress({
-  route,
+function getMoonChainAddress({
+  source,
+  destination,
   sourceAddress,
   destinationAddress
 }) {
-  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 moonChain = getMoonChain(source);
+  const isDestinationMoonChain = moonChain.isEqual(destination);
+  const isSourceMoonChain = moonChain.isEqual(source);
+  let moonChainAddress = isDestinationMoonChain ? destinationAddress : sourceAddress;
+  if (Parachain.is(source) && !isSourceMoonChain) {
     const isSourceEvmSigner = EvmParachain.is(source) && source.isEvmSigner;
     const { address20: computedOriginAccount } = getMultilocationDerivedAddresses({
       address: isSourceEvmSigner ? evmToAddress(sourceAddress) : sourceAddress,
       paraId: source.parachainId,
       isParents: true
     });
-    bridgeChainAddress = computedOriginAccount;
+    moonChainAddress = computedOriginAccount;
   }
-  return bridgeChainAddress;
+  return moonChainAddress;
 }
 
 // src/getTransferData/getSourceData.ts
 import {
-  ContractConfig as ContractConfig2,
+  ContractConfig,
   MrlBuilder as MrlBuilder3,
-  SnowbridgeConfig,
-  SubstrateQueryConfig,
   WormholeConfig
 } from "@moonbeam-network/xcm-builder";
 import {
-  EvmService as EvmService3,
   getAssetMin,
   getBalance as getBalance2,
   getContractFee,
   getDestinationFeeBalance,
   getExistentialDeposit,
   getExtrinsicFee,
-  getMax,
-  PolkadotService as PolkadotService2
+  getMax
 } from "@moonbeam-network/xcm-sdk";
 import {
-  AssetAmount as AssetAmount2,
-  EvmChain as EvmChain2,
-  EvmParachain as EvmParachain3
+  AssetAmount as AssetAmount2
 } from "@moonbeam-network/xcm-types";
 import { toBigInt as toBigInt2 } from "@moonbeam-network/xcm-utils";
 
@@ -17034,12 +16873,14 @@ import { toBigInt as toBigInt2 } from "@moonbeam-network/xcm-utils";
 import {
   BATCH_CONTRACT_ABI,
   BATCH_CONTRACT_ADDRESS,
-  ERC20_ABI as ERC20_ABI2,
+  ERC20_ABI,
   MrlBuilder as MrlBuilder2
 } from "@moonbeam-network/xcm-builder";
 import {
+  getMoonChain as getMoonChain2,
   moonbaseAlpha,
-  moonbeam
+  moonbeam,
+  moonriver
 } from "@moonbeam-network/xcm-config";
 import {
   convertToChainDecimals,
@@ -17054,33 +16895,34 @@ import {
 import Big from "big.js";
 import {
   createPublicClient as createPublicClient2,
-  encodeFunctionData as encodeFunctionData2,
+  encodeFunctionData,
   http as http2
 } from "viem";
 var MOON_CHAIN_AUTOMATIC_GAS_ESTIMATION = {
   [moonbeam.key]: 1273110n,
+  [moonriver.key]: 1273110n,
   [moonbaseAlpha.key]: 1470417n
 };
-function getBridgeChainFeeValueOnSource({
+function getMoonChainFeeValueOnSource({
   destinationData,
-  bridgeChainData,
+  moonChainData,
   sourceData
 }) {
   const isSourceParachain = EvmParachain2.isAnyParachain(sourceData.chain);
-  const isDestinationBridgeChain = destinationData.chain.isEqual(
-    bridgeChainData.chain
+  const isDestinationMoonChain = destinationData.chain.isEqual(
+    moonChainData.chain
   );
-  const isSameAssetPayingBridgeChainFee = sourceData.balance.isSame(
-    bridgeChainData.fee
+  const isSameAssetPayingMoonChainFee = sourceData.balance.isSame(
+    moonChainData.fee
   );
-  return !isDestinationBridgeChain && isSourceParachain && isSameAssetPayingBridgeChainFee ? convertToChainDecimals({
-    asset: bridgeChainData.fee,
-    target: sourceData.chain.getChainAsset(bridgeChainData.fee)
+  return !isDestinationMoonChain && isSourceParachain && isSameAssetPayingMoonChainFee ? convertToChainDecimals({
+    asset: moonChainData.fee,
+    target: sourceData.chain.getChainAsset(moonChainData.fee)
   }).toBig() : Big(0);
 }
 function getMrlMin({
   destinationData,
-  bridgeChainData,
+  moonChainData,
   sourceData
 }) {
   const minInDestination = getMin(destinationData);
@@ -17090,19 +16932,16 @@ function getMrlMin({
       amount: minInDestination.amount
     }
   );
-  const bridgeChainFee = getBridgeChainFeeValueOnSource({
+  const moonChainFee = getMoonChainFeeValueOnSource({
     destinationData,
-    bridgeChainData,
+    moonChainData,
     sourceData
   });
-  const relayerFee = sourceData.otherFees?.relayer?.amount ? sourceData.otherFees.relayer.toBig() : Big(0);
+  const relayerFee = sourceData.relayerFee?.amount ? sourceData.relayerFee.toBig() : Big(0);
   return min.copyWith({
-    amount: BigInt(min.toBig().add(bridgeChainFee).add(relayerFee).toFixed())
+    amount: BigInt(min.toBig().add(moonChainFee).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) {
@@ -17118,12 +16957,11 @@ async function buildTransfer(params) {
   const builderParams = await getMrlBuilderParams(params);
   return route.mrl.transfer.build({
     ...builderParams,
-    transact: requiresTransact(route) ? await getTransact(builderParams) : void 0
+    transact: EvmParachain2.isAnyParachain(route.source.chain) ? await getTransact(builderParams) : void 0
   });
 }
 async function getMrlBuilderParams({
   asset,
-  protocolFee,
   destinationAddress,
   feeAsset,
   isAutomatic,
@@ -17138,23 +16976,22 @@ async function getMrlBuilderParams({
   }
   const source = route.source.chain;
   const destination = route.destination.chain;
-  const bridgeChain = route.mrl.bridgeChain.chain;
-  const [sourceApi, destinationApi, bridgeApi] = await Promise.all([
+  const moonChain = getMoonChain2(source);
+  const [sourceApi, destinationApi, moonApi] = await Promise.all([
     EvmParachain2.isAnyParachain(source) ? getPolkadotApi(source.ws) : void 0,
     EvmParachain2.isAnyParachain(destination) ? getPolkadotApi(destination.ws) : void 0,
-    getPolkadotApi(bridgeChain.ws)
+    getPolkadotApi(moonChain.ws)
   ]);
   return {
     asset,
-    protocolFee,
     destination,
     destinationAddress,
     destinationApi,
     fee: feeAsset,
     isAutomatic,
-    moonApi: bridgeApi,
-    moonAsset: bridgeChain.nativeAsset,
-    bridgeChain,
+    moonApi,
+    moonAsset: moonChain.nativeAsset,
+    moonChain,
     sendOnlyRemoteExecution,
     source,
     sourceAddress,
@@ -17162,9 +16999,9 @@ async function getMrlBuilderParams({
   };
 }
 async function getTransact(params) {
-  const { sourceAddress, source, bridgeChain } = params;
-  const polkadot = await PolkadotService.create(bridgeChain);
-  const bridgeChainGasLimit = await getBridgeChainGasLimit(params);
+  const { sourceAddress, source, moonChain } = params;
+  const polkadot = await PolkadotService.create(moonChain);
+  const moonGasLimit = await getMoonGasLimit(params);
   if (!EvmParachain2.isAnyParachain(source)) {
     throw new Error("Source chain must be Parachain or EvmParachain");
   }
@@ -17173,8 +17010,9 @@ async function getTransact(params) {
     paraId: source.parachainId,
     isParents: true
   });
-  const extrinsic = MrlBuilder2().wormhole().extrinsic().ethereumXcm().transact().build({ ...params, bridgeChainGasLimit });
+  const extrinsic = MrlBuilder2().wormhole().extrinsic().ethereumXcm().transact().build({ ...params, moonGasLimit });
   const { weight } = await polkadot.getPaymentInfo(address20, extrinsic);
+  console.log("extrinsic", extrinsic.getArgs());
   return {
     call: polkadot.getExtrinsicCallHash(extrinsic),
     txWeight: {
@@ -17183,16 +17021,13 @@ async function getTransact(params) {
     }
   };
 }
-async function getBridgeChainGasLimit(params) {
-  const { asset, isAutomatic, bridgeChain, source, sourceAddress } = params;
+async function getMoonGasLimit(params) {
+  const { asset, isAutomatic, moonChain, 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: bridgeChain.getViemChain(),
+    chain: moonChain.getViemChain(),
     transport: http2()
   });
   const { address20 } = getMultilocationDerivedAddresses2({
@@ -17201,28 +17036,28 @@ async function getBridgeChainGasLimit(params) {
     isParents: true
   });
   if (isAutomatic) {
-    return MOON_CHAIN_AUTOMATIC_GAS_ESTIMATION[bridgeChain.key] * 110n / 100n;
+    return MOON_CHAIN_AUTOMATIC_GAS_ESTIMATION[moonChain.key] * 110n / 100n;
   }
   const contract = MrlBuilder2().wormhole().contract().TokenBridge().transferTokens().build({
     ...params,
     asset: asset.copyWith({ amount: 0n })
   });
-  const approveTx = encodeFunctionData2({
-    abi: ERC20_ABI2,
+  const approveTx = encodeFunctionData({
+    abi: ERC20_ABI,
     functionName: "approve",
     args: [contract.address, 0n]
   });
-  const tokenAddressOnBridgeChain = bridgeChain.getChainAsset(asset).address;
-  if (!tokenAddressOnBridgeChain) {
+  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 batchAll = encodeFunctionData2({
+  const batchAll = encodeFunctionData({
     abi: BATCH_CONTRACT_ABI,
     functionName: "batchAll",
     args: [
-      [tokenAddressOnBridgeChain, contract.address],
+      [tokenAddressOnMoonChain, contract.address],
       [0n, 0n],
       // Value to send for each call
       [approveTx, contract.encodeFunctionData()],
@@ -17253,7 +17088,6 @@ 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({
@@ -17274,7 +17108,7 @@ async function getSourceData({
     route,
     sourceAddress
   });
-  const bridgeChainFeeBalance = await getBridgeChainFeeBalance({
+  const moonChainFeeBalance = await getMoonChainFeeBalance({
     balance,
     feeBalance,
     route,
@@ -17286,19 +17120,8 @@ 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.copyWith({ amount: balance.amount - protocolFee.amount }),
-    protocolFee,
+    asset: balance,
     destinationAddress,
     feeAsset: feeBalance,
     isAutomatic,
@@ -17335,16 +17158,13 @@ async function getSourceData({
     chain: source,
     destinationFee,
     destinationFeeBalance,
-    bridgeChainFeeBalance,
+    moonChainFeeBalance,
     existentialDeposit,
     fee,
     feeBalance,
     max,
     min,
-    otherFees: {
-      protocol: protocolFee,
-      relayer: relayerFee?.amount ? relayerFee : void 0
-    }
+    relayerFee
   };
 }
 async function getFee({
@@ -17361,29 +17181,17 @@ async function getFee({
       amount: 0n
     });
   }
-  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 (ContractConfig.is(transfer)) {
+    return getContractFee({
+      address: sourceAddress,
+      balance,
+      chain: chain2,
+      contract: transfer,
+      destinationFee,
+      feeBalance,
+      feeConfig
     });
   }
-  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,
@@ -17403,25 +17211,19 @@ 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 });
   }
-  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;
+  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 });
 }
 async function getWormholeFee({
   asset,
@@ -17438,76 +17240,33 @@ async function getWormholeFee({
   }
   return;
 }
-async function getBridgeChainFeeBalance({
+async function getMoonChainFeeBalance({
   balance,
   feeBalance,
   route,
   sourceAddress
 }) {
-  if (!route.source.bridgeChainFee) {
+  if (!route.source.moonChainFee) {
     return void 0;
   }
-  if (route.mrl?.bridgeChain.fee.asset.isEqual(balance)) {
+  if (route.mrl?.moonChain.fee.asset.isEqual(balance)) {
     return balance;
   }
-  if (route.mrl?.bridgeChain.fee.asset.isEqual(feeBalance)) {
+  if (route.mrl?.moonChain.fee.asset.isEqual(feeBalance)) {
     return feeBalance;
   }
-  if (!route.source.bridgeChainFee.balance) {
+  if (!route.source.moonChainFee.balance) {
     throw new Error(
-      "BalanceBuilder must be defined for source.bridgeChainFee.balance for MrlAssetRoute"
+      "BalanceBuilder must be defined for source.moonChainFee.balance for MrlAssetRoute"
     );
   }
   return getBalance2({
     address: sourceAddress,
-    asset: route.source.chain.getChainAsset(route.source.bridgeChainFee.asset),
-    builder: route.source.bridgeChainFee.balance,
+    asset: route.source.chain.getChainAsset(route.source.moonChainFee.asset),
+    builder: route.source.moonChainFee.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) && EvmChain2.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({
@@ -17536,7 +17295,7 @@ async function getTransferData({
     destinationFee,
     sourceAddress
   });
-  const bridgeChainData = await getBridgeChainData({
+  const moonChainData = await getMoonChainData({
     route,
     sourceAddress,
     destinationAddress
@@ -17548,14 +17307,14 @@ async function getTransferData({
       const bigAmount = Big2(
         toBigInt3(amount, sourceData.balance.decimals).toString()
       );
-      const fee = getBridgeChainFeeValueOnSource({
+      const fee = getMoonChainFeeValueOnSource({
         destinationData,
-        bridgeChainData,
+        moonChainData,
         sourceData
       });
       const result = bigAmount.minus(
         isSameAssetPayingDestinationFee ? destinationFee.toBig() : Big2(0)
-      ).minus(fee).minus(sourceData.otherFees?.relayer?.toBig() || Big2(0));
+      ).minus(fee).minus(sourceData.relayerFee?.toBig() || Big2(0));
       return sourceData.balance.copyWith({
         amount: result.lt(0) ? 0n : BigInt(result.toFixed())
       });
@@ -17564,10 +17323,10 @@ async function getTransferData({
     max: sourceData.max,
     min: getMrlMin({
       destinationData,
-      bridgeChainData,
+      moonChainData,
       sourceData
     }),
-    bridgeChain: bridgeChainData,
+    moonChain: moonChainData,
     source: sourceData,
     async transfer({
       amount,
@@ -17590,7 +17349,6 @@ async function getTransferData({
       );
       const transfer = await buildTransfer({
         asset,
-        protocolFee: sourceData.otherFees?.protocol,
         destinationAddress,
         feeAsset,
         isAutomatic: isAutomatic2,
@@ -17598,19 +17356,19 @@ async function getTransferData({
         sendOnlyRemoteExecution,
         sourceAddress
       });
-      if (ContractConfig3.is(transfer) && (EvmChain3.is(source) || EvmParachain4.is(source))) {
+      if (ContractConfig2.is(transfer) && (EvmChain.is(source) || EvmParachain3.is(source))) {
         if (!evmSigner) {
           throw new Error("EVM Signer must be provided");
         }
-        const evm = EvmService4.create(source);
+        const evm = EvmService2.create(source);
         const hash = await evm.transfer(evmSigner, transfer);
         return [hash];
       }
-      if (ExtrinsicConfig.is(transfer) && EvmParachain4.isAnyParachain(source)) {
+      if (ExtrinsicConfig.is(transfer) && EvmParachain3.isAnyParachain(source)) {
         if (!polkadotSigner) {
           throw new Error("Polkadot signer must be provided");
         }
-        const polkadot = await PolkadotService3.create(source);
+        const polkadot = await PolkadotService2.create(source);
         const hash = await polkadot.transfer(
           sourceAddress,
           transfer,
@@ -17619,21 +17377,13 @@ async function getTransferData({
         );
         return [hash];
       }
-      if (WormholeConfig2.is(transfer) && (EvmChain3.is(source) || EvmParachain4.is(source))) {
+      if (WormholeConfig2.is(transfer) && (EvmChain.is(source) || EvmParachain3.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) && (EvmChain3.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");
     }
   };