@stableflow/wallet-evm 0.0.0-experimental-5a8afd7389-20260703

package/dist/index.js

@@ -0,0 +1,1557 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var core = require('@stableflow/core');
+var bridges = require('@stableflow/bridges');
+var utilsEvm = require('@stableflow/utils-evm');
+var utilsSolana = require('@stableflow/utils-solana');
+var Big = require('big.js');
+var ethers = require('ethers');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var Big__default = /*#__PURE__*/_interopDefault(Big);
+
+// src/evm.ts
+var DEFAULT_GAS_LIMIT = 100000n;
+var DEFAULT_GAS_LIMIT_FAILED = 4000000n;
+var EVMWallet = class {
+  constructor(_provider, _signer) {
+    this.provider = _provider;
+    this.signer = _signer;
+    const cs = new core.Csl(core.OpenAPI.DEBUG);
+    this.csl = cs.log;
+  }
+  async transfer(data) {
+    const { originAsset, depositAddress, amount } = data;
+    if (originAsset === "eth") {
+      const tx2 = await this.signer.sendTransaction({
+        to: depositAddress,
+        value: ethers.ethers.parseEther(amount)
+      });
+      await tx2.wait();
+      return tx2;
+    }
+    const contract = new ethers.ethers.Contract(originAsset, core.erc20Abi, this.signer);
+    const tx = await contract.transfer(depositAddress, amount);
+    const result = await tx.wait();
+    return result.hash;
+  }
+  async getBalance(token, account, options) {
+    const { isCatchError = false } = options || {};
+    try {
+      let provider = this.provider;
+      if (token.rpcUrls) {
+        provider = utilsEvm.evmRpcFallbackProvider(token);
+      }
+      if (token.symbol === "eth" || token.symbol === "ETH" || token.symbol === "native") {
+        const balance2 = await provider.getBalance(account);
+        return balance2.toString();
+      }
+      const contract = new ethers.ethers.Contract(token.contractAddress, core.erc20Abi, provider);
+      const balance = await contract.balanceOf(account);
+      this.csl("EVM getBalance", "green-500", "Success getting %s token balance: %o", token.contractAddress, balance);
+      return balance.toString();
+    } catch (err) {
+      this.csl("EVM getBalance", "red-500", "Get balance failed: %o", err);
+      if (isCatchError) {
+        throw err;
+      }
+      return "0";
+    }
+  }
+  async balanceOf(token, account, options) {
+    return await this.getBalance(token, account, options);
+  }
+  /**
+   * Estimate gas limit for transfer transaction
+   * @param data Transfer data
+   * @returns Gas limit estimate, gas price, and estimated gas cost
+   */
+  async estimateTransferGas(data) {
+    const { fromToken, depositAddress, amount, account } = data;
+    const originAsset = fromToken.contractAddress;
+    const provider = utilsEvm.evmRpcFallbackProvider(fromToken);
+    let gasLimit;
+    if (originAsset === "eth") {
+      const tx = {
+        from: account,
+        to: depositAddress,
+        value: ethers.ethers.parseEther(amount)
+      };
+      gasLimit = await provider.estimateGas(tx);
+    } else {
+      const contract = new ethers.ethers.Contract(originAsset, core.erc20Abi, provider);
+      gasLimit = await contract.transfer.estimateGas(depositAddress, amount);
+    }
+    gasLimit = gasLimit * 120n / 100n;
+    const feeData = await provider.getFeeData();
+    const gasPrice = feeData.gasPrice || 0n;
+    const estimateGas = gasLimit * gasPrice;
+    return {
+      gasLimit,
+      gasPrice,
+      estimateGas
+    };
+  }
+  getContract(params) {
+    const {
+      contractAddress,
+      abi
+    } = params;
+    return new ethers.ethers.Contract(contractAddress, abi, this.signer);
+  }
+  async allowance(params) {
+    const {
+      dry,
+      contractAddress,
+      spender,
+      address,
+      amountWei,
+      provider,
+      blockTag,
+      strict = false
+    } = params;
+    const runner = provider || this.provider;
+    const contract = new ethers.ethers.Contract(contractAddress, core.erc20Abi, runner);
+    if (dry) {
+      return {
+        contract,
+        allowance: "0",
+        needApprove: false
+      };
+    }
+    let allowance = "0";
+    try {
+      allowance = blockTag ? await contract.allowance(address, spender, { blockTag }) : await contract.allowance(address, spender);
+      allowance = allowance.toString();
+    } catch (error) {
+      this.csl("EVM allowance", "red-500", "Error getting allowance: %o", error);
+      if (strict) {
+        throw error;
+      }
+    }
+    return {
+      contract,
+      allowance,
+      needApprove: Big__default.default(amountWei || 0).gt(allowance || 0)
+    };
+  }
+  async approve(params) {
+    const {
+      contractAddress,
+      spender,
+      amountWei,
+      isApproveMax = false,
+      isDetails = false,
+      isWaitTxReceipt = true
+    } = params;
+    const contract = new ethers.ethers.Contract(contractAddress, core.erc20Abi, this.signer);
+    let _amountWei = amountWei;
+    if (isApproveMax) {
+      _amountWei = ethers.ethers.MaxUint256;
+    }
+    const detailResult = {
+      success: false,
+      data: {},
+      message: null
+    };
+    try {
+      const tx = await contract.approve(spender, _amountWei);
+      const txReceipt = await tx.wait();
+      if (txReceipt.status === 1) {
+        if (isDetails) {
+          const confirmations = typeof txReceipt.confirmations === "function" ? await txReceipt.confirmations() : txReceipt.confirmations;
+          detailResult.success = true;
+          detailResult.data = {
+            txHash: txReceipt.hash,
+            blockNumber: txReceipt.blockNumber,
+            confirmations
+          };
+          return detailResult;
+        }
+        return true;
+      }
+      if (isDetails) {
+        detailResult.message = "Arrove failed";
+        return detailResult;
+      }
+      return false;
+    } catch (error) {
+      this.csl("EVM approve", "red-500", "Error approve: %o", error);
+      if (isDetails) {
+        detailResult.message = error.message;
+      }
+    }
+    if (isDetails) {
+      return detailResult;
+    }
+    return false;
+  }
+  async getEstimateGas(params) {
+    const { gasLimit, price, nativeToken, provider, gasPrice } = params;
+    let finalGasPrice = gasPrice;
+    if (!finalGasPrice) {
+      const feeData = await provider.getFeeData();
+      finalGasPrice = feeData.maxFeePerGas || feeData.gasPrice || BigInt("20000000000");
+    }
+    const estimateGas = BigInt(gasLimit) * BigInt(finalGasPrice);
+    const estimateGasAmount = Big__default.default(estimateGas.toString()).div(10 ** nativeToken.decimals);
+    const estimateGasUsd = Big__default.default(estimateGasAmount).times(price || 1);
+    return {
+      gasPrice: finalGasPrice,
+      usd: core.numberRemoveEndZero(Big__default.default(estimateGasUsd).toFixed(20)),
+      wei: estimateGas,
+      amount: core.numberRemoveEndZero(Big__default.default(estimateGasAmount).toFixed(nativeToken.decimals))
+    };
+  }
+  async estimateTransaction(params) {
+    const {
+      dry,
+      contract,
+      method,
+      param,
+      fromToken,
+      prices,
+      evmGasFees,
+      defaultGasLimit = DEFAULT_GAS_LIMIT,
+      refundTo,
+      txRequest
+    } = params;
+    const cs = new core.Csl(core.OpenAPI.DEBUG);
+    const csl = cs.log;
+    const provider = utilsEvm.evmRpcFallbackProvider(fromToken);
+    const nativeTokenPrice = core.getPrice(prices, fromToken.nativeToken.symbol);
+    const result = {
+      estimateSourceGasLimit: dry ? DEFAULT_GAS_LIMIT_FAILED : DEFAULT_GAS_LIMIT,
+      estimateSourceGas: 0n,
+      estimateSourceGasUsd: "0"
+    };
+    const setDefaultGasLimit = async () => {
+      const { usd, wei } = await this.getEstimateGas({
+        gasLimit: DEFAULT_GAS_LIMIT,
+        price: nativeTokenPrice,
+        nativeToken: fromToken.nativeToken,
+        provider,
+        gasPrice: dry ? evmGasFees[fromToken.chainId].gasPrice : void 0
+      });
+      result.estimateSourceGas = wei;
+      result.estimateSourceGasUsd = usd;
+    };
+    let finalGasLimit = defaultGasLimit;
+    if (dry) {
+      await setDefaultGasLimit();
+      return result;
+    }
+    if (txRequest) {
+      try {
+        const gasLimit = await provider.estimateGas({
+          to: txRequest.target,
+          data: txRequest.calldata,
+          from: refundTo || this.signer?.address
+        });
+        finalGasLimit = gasLimit * 120n / 100n;
+        const { usd, wei } = await this.getEstimateGas({
+          gasLimit: finalGasLimit,
+          price: nativeTokenPrice,
+          nativeToken: fromToken.nativeToken,
+          provider
+        });
+        result.estimateSourceGasLimit = finalGasLimit;
+        result.estimateSourceGas = wei;
+        result.estimateSourceGasUsd = usd;
+      } catch (error) {
+        csl("EVM estimateTransaction", "red-500", "%s estimateGas failed: %o", method, error);
+        await setDefaultGasLimit();
+        result.estimateSourceGasLimit = DEFAULT_GAS_LIMIT_FAILED / 2n;
+      }
+      return result;
+    }
+    try {
+      const gasLimit = await contract[method].estimateGas(...param);
+      finalGasLimit = gasLimit * 120n / 100n;
+      const { usd, wei } = await this.getEstimateGas({
+        gasLimit: finalGasLimit,
+        price: nativeTokenPrice,
+        nativeToken: fromToken.nativeToken,
+        provider
+      });
+      result.estimateSourceGasLimit = finalGasLimit;
+      result.estimateSourceGas = wei;
+      result.estimateSourceGasUsd = usd;
+    } catch (error) {
+      csl("EVM estimateTransaction", "red-500", "%s estimateGas failed: %o", method, error);
+      await setDefaultGasLimit();
+      result.estimateSourceGasLimit = DEFAULT_GAS_LIMIT_FAILED / 2n;
+    }
+    return result;
+  }
+  async quoteOFT(params) {
+    const { Options } = await import('@layerzerolabs/lz-v2-utilities');
+    const {
+      dry,
+      abi,
+      dstEid,
+      recipient,
+      amountWei,
+      slippageTolerance,
+      payInLzToken,
+      fromToken,
+      toToken,
+      prices,
+      evmGasFees,
+      originLayerzeroAddress,
+      destinationLayerzeroAddress,
+      excludeFees,
+      refundTo,
+      multiHopComposer,
+      isMultiHopComposer,
+      isOriginLegacy,
+      isDestinationLegacy,
+      originLayerzero,
+      destinationLayerzero
+    } = params;
+    const result = {
+      needApprove: false,
+      approveSpender: originLayerzeroAddress,
+      sendParam: void 0,
+      quoteParam: {
+        ...params,
+        originLayerzeroAddress,
+        destinationLayerzeroAddress
+      },
+      fees: {},
+      totalFeesUsd: "0",
+      estimateSourceGas: 0n,
+      totalEstimateSourceGas: 0n,
+      estimateSourceGasUsd: "0",
+      estimateTime: 0,
+      // seconds - dynamically calculated using LayerZero formula
+      outputAmount: core.numberRemoveEndZero(Big__default.default(amountWei || 0).div(10 ** params.fromToken.decimals).toFixed(params.fromToken.decimals, 0))
+    };
+    const execTime = new core.ExecTime({ type: `Usdt0 EVM ${fromToken.chainName}->${toToken.chainName}`, logStyle: "stone-100", isDebug: core.OpenAPI.DEBUG });
+    const provider = utilsEvm.evmRpcFallbackProvider(fromToken);
+    const oftContract = new ethers.ethers.Contract(originLayerzeroAddress, abi, this.signer);
+    const oftContractRead = new ethers.ethers.Contract(originLayerzeroAddress, abi, provider);
+    execTime.breakpoint();
+    const approvalRequired = isOriginLegacy ? originLayerzero.oftLegacyApprovalRequired : originLayerzero.oftApprovalRequired;
+    this.csl("EVM quoteOFT", "blue-900", "approvalRequired: %o", approvalRequired);
+    execTime.log("approvalRequired");
+    const lzReceiveOptionGas = isDestinationLegacy ? destinationLayerzero.lzReceiveOptionGasLegacy : destinationLayerzero.lzReceiveOptionGas || 2e5;
+    let lzReceiveOptionValue = 0;
+    execTime.breakpoint();
+    const destATA = await utilsSolana.getDestinationAssociatedTokenAddress({
+      recipient,
+      toToken
+    });
+    execTime.log("getDestinationAssociatedTokenAddress");
+    if (destATA.needCreateTokenAccount) {
+      lzReceiveOptionValue = bridges.LZ_RECEIVE_VALUE[toToken.chainName] || 0;
+    }
+    let unMultiHopExtraOptions = Options.newOptions().toHex();
+    if (!isMultiHopComposer && lzReceiveOptionValue) {
+      unMultiHopExtraOptions = Options.newOptions().addExecutorLzReceiveOption(lzReceiveOptionGas, lzReceiveOptionValue).toHex();
+    }
+    const sendParam = {
+      dstEid,
+      to: bridges.addressToBytes32(toToken.chainType, recipient),
+      amountLD: amountWei,
+      minAmountLD: 0n,
+      extraOptions: unMultiHopExtraOptions,
+      composeMsg: "0x",
+      oftCmd: "0x"
+    };
+    if (isMultiHopComposer) {
+      sendParam.dstEid = multiHopComposer.eid;
+      sendParam.to = bridges.addressToBytes32("evm", multiHopComposer.oftMultiHopComposer);
+      let multiHopExtraOptions = Options.newOptions().toHex();
+      if (lzReceiveOptionValue) {
+        multiHopExtraOptions = Options.newOptions().addExecutorLzReceiveOption(lzReceiveOptionGas, lzReceiveOptionValue).toHex();
+      }
+      const composeMsgSendParam = {
+        dstEid,
+        to: bridges.addressToBytes32(toToken.chainType, recipient),
+        amountLD: sendParam.amountLD,
+        minAmountLD: sendParam.minAmountLD,
+        extraOptions: multiHopExtraOptions,
+        composeMsg: "0x",
+        oftCmd: "0x"
+      };
+      execTime.breakpoint();
+      const hopMsgFee = await bridges.getHopMsgFee({
+        sendParam: composeMsgSendParam,
+        toToken
+      });
+      execTime.log("getHopMsgFee");
+      sendParam.extraOptions = Options.newOptions().addExecutorComposeOption(0, originLayerzero.composeOptionGas || 8e5, hopMsgFee).toHex();
+      const abiCoder = ethers.ethers.AbiCoder.defaultAbiCoder();
+      sendParam.composeMsg = abiCoder.encode(
+        ["tuple(uint32 dstEid, bytes32 to, uint256 amountLD, uint256 minAmountLD, bytes extraOptions, bytes composeMsg, bytes oftCmd)"],
+        [Object.values(composeMsgSendParam)]
+      );
+    }
+    if (isOriginLegacy || isDestinationLegacy) {
+      result.fees.legacyMeshFeeUsd = core.numberRemoveEndZero(Big__default.default(amountWei || 0).div(10 ** params.fromToken.decimals).times(bridges.USDT0_LEGACY_MESH_TRANSFTER_FEE).toFixed(params.fromToken.decimals));
+      result.outputAmount = core.numberRemoveEndZero(Big__default.default(Big__default.default(amountWei || 0).div(10 ** params.fromToken.decimals)).minus(result.fees.legacyMeshFeeUsd || 0).toFixed(params.fromToken.decimals, 0));
+    }
+    if (!dry) {
+      execTime.breakpoint();
+      const oftData = await oftContractRead.quoteOFT.staticCall(sendParam);
+      const [, , oftReceipt] = oftData;
+      sendParam.minAmountLD = Big__default.default(amountWei).times(Big__default.default(1).minus(Big__default.default(slippageTolerance || 0).div(100))).toFixed(0);
+      result.outputAmount = core.numberRemoveEndZero(core.numberRemoveEndZero(Big__default.default(oftReceipt[1].toString()).div(10 ** params.toToken.decimals).toFixed(params.toToken.decimals, 0)));
+      execTime.log("quoteOFT.staticCall");
+    }
+    this.csl("EVMWallet quoteOFT", "red-600", "result.outputAmount: %o", result.outputAmount);
+    this.csl("EVMWallet quoteOFT", "red-600", "slippageTolerance: %o", slippageTolerance + "%");
+    this.csl("EVMWallet quoteOFT", "red-600", "Minimum received amount: %o", Big__default.default(amountWei).div(10 ** fromToken.decimals).times(Big__default.default(1).minus(Big__default.default(slippageTolerance || 0).div(100))).toFixed(6, 0));
+    if (Big__default.default(result.outputAmount).lt(Big__default.default(amountWei).div(10 ** fromToken.decimals).times(Big__default.default(1).minus(Big__default.default(slippageTolerance || 0).div(100))))) {
+      result.errMsg = "Slippage limit exceeded";
+      return result;
+    }
+    execTime.breakpoint();
+    const mergedCall = [
+      oftContractRead.quoteSend.staticCall(sendParam, payInLzToken)
+    ];
+    if (approvalRequired) {
+      mergedCall.push(
+        this.allowance({
+          dry,
+          contractAddress: fromToken.contractAddress,
+          spender: originLayerzeroAddress,
+          address: refundTo,
+          amountWei,
+          provider
+        })
+      );
+    }
+    const [msgFee, allowanceResult] = await Promise.all(mergedCall);
+    if (approvalRequired) {
+      result.needApprove = allowanceResult?.needApprove;
+    }
+    execTime.log("quoteSend.staticCall and allowance");
+    let nativeMsgFee = msgFee[0];
+    const lzMsgFee = msgFee[1];
+    result.totalEstimateSourceGas = nativeMsgFee;
+    nativeMsgFee = nativeMsgFee * utilsEvm.NATIVE_MSG_FEE_BUFFER / 100n;
+    const nativeFeeUsd = Big__default.default(nativeMsgFee?.toString() || 0).div(10 ** fromToken.nativeToken.decimals).times(core.getPrice(prices, fromToken.nativeToken.symbol));
+    result.fees.nativeFee = core.numberRemoveEndZero(Big__default.default(nativeMsgFee?.toString() || 0).div(10 ** fromToken.nativeToken.decimals).toFixed(fromToken.nativeToken.decimals));
+    result.fees.nativeFeeUsd = core.numberRemoveEndZero(Big__default.default(nativeFeeUsd).toFixed(20));
+    result.fees.lzTokenFeeUsd = core.numberRemoveEndZero(Big__default.default(lzMsgFee?.toString() || 0).div(10 ** fromToken.decimals).toFixed(20));
+    const finalSendParam = [
+      sendParam,
+      {
+        nativeFee: nativeMsgFee,
+        lzTokenFee: lzMsgFee
+      },
+      refundTo,
+      { value: nativeMsgFee }
+    ];
+    execTime.breakpoint();
+    const ett = await this.estimateTransaction({
+      dry,
+      contract: oftContract,
+      method: "send",
+      param: finalSendParam,
+      fromToken,
+      prices,
+      evmGasFees
+    });
+    result.fees.estimateGasUsd = ett.estimateSourceGasUsd;
+    result.estimateSourceGas = ett.estimateSourceGas;
+    result.totalEstimateSourceGas += ett.estimateSourceGas;
+    result.estimateSourceGasUsd = ett.estimateSourceGasUsd;
+    finalSendParam[3].gasLimit = ett.estimateSourceGasLimit;
+    execTime.log("send.estimateGas");
+    result.sendParam = {
+      contract: oftContract,
+      method: "send",
+      param: finalSendParam
+    };
+    for (const feeKey in result.fees) {
+      if (excludeFees.includes(feeKey) || !/Usd$/.test(feeKey)) {
+        continue;
+      }
+      result.totalFeesUsd = Big__default.default(result.totalFeesUsd || 0).plus(result.fees[feeKey] || 0);
+    }
+    result.totalFeesUsd = core.numberRemoveEndZero(Big__default.default(result.totalFeesUsd).toFixed(20));
+    execTime.logTotal("quoteOFT");
+    return result;
+  }
+  async sendTransaction(params) {
+    const {
+      method,
+      contract,
+      param
+    } = params;
+    const overridesIndex = param.length - 1;
+    const overrides = param[overridesIndex] && typeof param[overridesIndex] === "object" && !Array.isArray(param[overridesIndex]) ? { ...param[overridesIndex] } : {};
+    if (!overrides.maxFeePerGas) {
+      try {
+        const feeData = await this.provider.getFeeData();
+        if (feeData.maxFeePerGas) {
+          overrides.maxFeePerGas = feeData.maxFeePerGas * 120n / 100n;
+        }
+        if (feeData.maxPriorityFeePerGas && !overrides.maxPriorityFeePerGas) {
+          overrides.maxPriorityFeePerGas = feeData.maxPriorityFeePerGas;
+        }
+      } catch (error) {
+        this.csl("EVM sendTransaction", "red-500", "Failed to get fee data for gas buffer: %o", error);
+      }
+    }
+    const finalParam = [...param];
+    if (param[overridesIndex] && typeof param[overridesIndex] === "object" && !Array.isArray(param[overridesIndex])) {
+      finalParam[overridesIndex] = overrides;
+    } else {
+      finalParam.push(overrides);
+    }
+    try {
+      const tx = await contract[method](...finalParam);
+      return tx.hash;
+    } catch (error) {
+      this.csl("EVM sendTransaction", "red-500", "Error sending transaction: %o, message: %o", error, error.message);
+      let _finalErrorMessage = `Transaction failed: ${error.message}`;
+      if (error?.message?.includes("user rejected action")) {
+        _finalErrorMessage = error.message;
+      }
+      throw new Error(_finalErrorMessage);
+    }
+  }
+  /**
+   * Unified quote method that routes to specific quote methods based on type
+   * @param type Service type from Service
+   * @param params Parameters for the quote
+   */
+  async quote(type, params) {
+    switch (type) {
+      case core.Service.CCTP:
+        return await this.quoteCCTP(params);
+      case core.Service.Usdt0:
+        return await this.quoteOFT(params);
+      case core.Service.OneClick:
+        return await this.quoteOneClickProxy(params);
+      case core.Service.Native:
+        return await this.quoteNative(params);
+      case core.Service.FraxZero:
+        return await this.quoteFraxZero(params);
+      default:
+        throw new Error(`Unsupported quote type: ${type}`);
+    }
+  }
+  /**
+   * Unified send method that routes to specific send methods based on type
+   * @param type Send type from SendType enum
+   * @param params Parameters for the send transaction
+   */
+  async send(type, params) {
+    switch (type) {
+      case core.SendType.SEND:
+        return await this.sendTransaction(params);
+      case core.SendType.TRANSFER:
+        return await this.transfer(params);
+      default:
+        throw new Error(`Unsupported send type: ${type}`);
+    }
+  }
+  async quoteCCTP(params) {
+    const {
+      dry,
+      proxyAddress,
+      abi,
+      refundTo,
+      recipient,
+      amountWei,
+      // slippageTolerance,
+      fromToken,
+      toToken,
+      prices,
+      evmGasFees,
+      excludeFees,
+      destinationDomain,
+      sourceDomain
+    } = params;
+    const result = {
+      needApprove: false,
+      approveSpender: proxyAddress,
+      sendParam: void 0,
+      quoteParam: {
+        sourceDomain,
+        destinationDomain,
+        proxyAddress,
+        ...params
+      },
+      fees: {},
+      totalFeesUsd: void 0,
+      estimateSourceGas: void 0,
+      totalEstimateSourceGas: 0n,
+      estimateSourceGasUsd: void 0,
+      estimateTime: Math.floor(Math.random() * 8) + 3,
+      outputAmount: core.numberRemoveEndZero(Big__default.default(amountWei || 0).div(10 ** fromToken.decimals).toFixed(fromToken.decimals, 0))
+    };
+    const provider = utilsEvm.evmRpcFallbackProvider(fromToken);
+    const execTime = new core.ExecTime({ type: `CCTP EVM ${fromToken.chainName}->${toToken.chainName}`, logStyle: "stone-200", isDebug: core.OpenAPI.DEBUG });
+    const proxyContract = new ethers.ethers.Contract(proxyAddress, abi, this.signer);
+    new ethers.ethers.Contract(proxyAddress, abi, provider);
+    let realRecipient = recipient;
+    execTime.breakpoint();
+    const getUsrNonce = async () => {
+      let userNonce2 = 0n;
+      try {
+        userNonce2 = await proxyContract.userNonces(refundTo);
+      } catch (error) {
+      }
+      return userNonce2;
+    };
+    const mergedCalls = [
+      utilsSolana.getDestinationAssociatedTokenAddress({
+        recipient,
+        toToken
+      }),
+      getUsrNonce(),
+      this.allowance({
+        dry,
+        contractAddress: fromToken.contractAddress,
+        address: refundTo,
+        spender: proxyAddress,
+        amountWei,
+        provider
+      })
+    ];
+    const [destATA, userNonce, allowance] = await Promise.all(mergedCalls);
+    execTime.log("getDestinationATA & getUsrNonce & get allowance", "destATA: %o, userNonce: %o, allowance: %o", destATA, userNonce, allowance);
+    result.needCreateTokenAccount = destATA.needCreateTokenAccount;
+    if (destATA.associatedTokenAddress) {
+      realRecipient = destATA.associatedTokenAddress;
+    }
+    result.needApprove = allowance.needApprove;
+    execTime.breakpoint();
+    const signatureRes = await bridges.quoteSignature({
+      address: refundTo,
+      amount: core.numberRemoveEndZero(Big__default.default(amountWei || 0).div(10 ** fromToken.decimals).toFixed(fromToken.decimals, 0)),
+      destination_domain_id: destinationDomain,
+      receipt_address: realRecipient,
+      source_domain_id: sourceDomain,
+      user_nonce: Number(userNonce)
+    });
+    const {
+      bridge_fee,
+      finality_threshold,
+      max_fee,
+      mint_fee,
+      receipt_amount,
+      signature,
+      destination_caller
+    } = signatureRes;
+    execTime.log("quoteSignature");
+    result.fees.estimateMintGasUsd = core.numberRemoveEndZero(Big__default.default(mint_fee || 0).div(10 ** fromToken.decimals).toFixed(fromToken.decimals));
+    result.fees.bridgeFeeUsd = core.numberRemoveEndZero(Big__default.default(bridge_fee || 0).div(10 ** fromToken.decimals).toFixed(fromToken.decimals));
+    const chargedAmount = BigInt(amountWei) - BigInt(mint_fee);
+    result.outputAmount = core.numberRemoveEndZero(Big__default.default(receipt_amount || 0).div(10 ** fromToken.decimals).toFixed(fromToken.decimals, 0));
+    const depositParam = [
+      // originalAmount
+      amountWei,
+      // chargedAmount = originalAmount - gas fee
+      chargedAmount,
+      // destinationDomain
+      destinationDomain,
+      // mintRecipient
+      bridges.addressToBytes32(toToken.chainType, realRecipient),
+      // burnToken
+      fromToken.contractAddress,
+      // destinationCaller
+      destination_caller ? bridges.addressToBytes32(toToken.chainType, destination_caller) : "0x0000000000000000000000000000000000000000000000000000000000000000",
+      // maxFee
+      max_fee,
+      // minFinalityThreshold
+      finality_threshold,
+      // signature
+      signature
+    ];
+    execTime.breakpoint();
+    const ett = await this.estimateTransaction({
+      dry,
+      contract: proxyContract,
+      method: "depositWithFee",
+      param: depositParam,
+      fromToken,
+      prices,
+      evmGasFees
+    });
+    result.fees.estimateGasUsd = ett.estimateSourceGasUsd;
+    result.estimateSourceGas = ett.estimateSourceGas;
+    result.totalEstimateSourceGas = ett.estimateSourceGas;
+    result.estimateSourceGasUsd = ett.estimateSourceGasUsd;
+    depositParam.push({ gasLimit: ett.estimateSourceGasLimit });
+    execTime.log("estimateTransaction");
+    result.sendParam = {
+      method: "depositWithFee",
+      contract: proxyContract,
+      param: depositParam
+    };
+    for (const feeKey in result.fees) {
+      if (excludeFees.includes(feeKey) || !/Usd$/.test(feeKey)) {
+        continue;
+      }
+      result.totalFeesUsd = Big__default.default(result.totalFeesUsd || 0).plus(result.fees[feeKey] || 0);
+    }
+    result.totalFeesUsd = core.numberRemoveEndZero(Big__default.default(result.totalFeesUsd).toFixed(20));
+    execTime.logTotal("quoteCCTP");
+    return result;
+  }
+  async quoteOneClickProxy(params) {
+    const {
+      dry,
+      proxyAddress,
+      abi,
+      fromToken,
+      refundTo,
+      depositAddress,
+      amountWei,
+      prices,
+      evmGasFees
+    } = params;
+    const execTime = new core.ExecTime({ type: `OneClick EVM ${fromToken.chainName}`, logStyle: "stone-300", isDebug: core.OpenAPI.DEBUG });
+    const result = { fees: {} };
+    const provider = utilsEvm.evmRpcFallbackProvider(fromToken);
+    const proxyContract = new ethers.ethers.Contract(proxyAddress, abi, this.signer);
+    const proxyParam = [
+      // tokenAddress
+      fromToken.contractAddress,
+      // recipient
+      depositAddress,
+      // amount
+      amountWei
+    ];
+    execTime.breakpoint();
+    const mergedCalls = [
+      this.allowance({
+        dry,
+        contractAddress: fromToken.contractAddress,
+        address: refundTo,
+        spender: proxyAddress,
+        amountWei,
+        provider
+      }),
+      this.estimateTransaction({
+        dry,
+        contract: proxyContract,
+        method: "proxyTransfer",
+        param: proxyParam,
+        fromToken,
+        prices,
+        evmGasFees
+      })
+    ];
+    const [allowance, ett] = await Promise.all(mergedCalls);
+    result.needApprove = allowance.needApprove;
+    result.approveSpender = proxyAddress;
+    result.fees.estimateGasUsd = ett.estimateSourceGasUsd;
+    result.estimateSourceGas = ett.estimateSourceGas;
+    result.totalEstimateSourceGas = ett.estimateSourceGas;
+    result.estimateSourceGasUsd = ett.estimateSourceGasUsd;
+    proxyParam.push({ gasLimit: ett.estimateSourceGasLimit });
+    execTime.log("allowance & estimateTransaction");
+    result.sendParam = {
+      method: "proxyTransfer",
+      contract: proxyContract,
+      param: proxyParam
+    };
+    execTime.logTotal("quoteOneClickPorxy");
+    return result;
+  }
+  async quoteNative(params) {
+    const {
+      quoteResponse,
+      bridgeRouterAddress,
+      ...restParams
+    } = params;
+    const {
+      dry,
+      amountWei,
+      refundTo,
+      fromToken,
+      toToken,
+      prices,
+      evmGasFees
+    } = restParams;
+    const result = {
+      ...quoteResponse,
+      fees: {},
+      needApprove: false,
+      approveSpender: bridgeRouterAddress,
+      quoteParam: {
+        ...restParams
+      },
+      sendParam: {
+        txRequest: quoteResponse.txRequest
+      },
+      totalFeesUsd: void 0,
+      estimateSourceGas: void 0,
+      totalEstimateSourceGas: 0n,
+      estimateSourceGasUsd: void 0,
+      estimateTime: quoteResponse.priority === "fast" ? Math.floor(Math.random() * 10) + 50 : Math.floor(Math.random() * 60) + 300,
+      outputAmount: 0
+    };
+    const execTime = new core.ExecTime({ type: `Native EVM ${fromToken.chainName}->${toToken.chainName}`, logStyle: "stone-400", isDebug: core.OpenAPI.DEBUG });
+    utilsEvm.evmRpcFallbackProvider(fromToken);
+    const estimateNativeGas = async () => {
+      if (dry) {
+        const ett = await this.estimateTransaction({
+          dry,
+          fromToken,
+          prices,
+          evmGasFees
+        });
+        result.outputAmount = quoteResponse.buyerTokenAmount + "";
+        result.fees = {
+          estimateGasUsd: ett.estimateSourceGasUsd,
+          widgetFeeUsd: quoteResponse.widgetFeeUsd,
+          liquidityProviderFeeUsd: quoteResponse.liquidityProviderFeeUsd
+        };
+        result.estimateSourceGas = ett.estimateSourceGas;
+        result.totalEstimateSourceGas = ett.estimateSourceGas;
+        result.estimateSourceGasUsd = ett.estimateSourceGasUsd;
+        result.totalFeesUsd = core.numberRemoveEndZero(Big__default.default(quoteResponse.totalFeeUsd).toFixed(20));
+      } else {
+        const ett = await this.estimateTransaction({
+          dry,
+          fromToken,
+          prices,
+          evmGasFees,
+          txRequest: quoteResponse.txRequest,
+          refundTo
+        });
+        result.outputAmount = Big__default.default(quoteResponse.amountOut || 0).div(10 ** (toToken.decimals || 6)).toFixed(toToken.decimals || 6, 0);
+        result.fees = {
+          estimateGasUsd: ett.estimateSourceGasUsd,
+          // maybe 100 = 1%
+          widgetFeeUsd: core.numberRemoveEndZero(Big__default.default(amountWei || 0).div(10 ** (fromToken.decimals || 6)).times(quoteResponse.widgetFee.feeRate || 0).toFixed(20, 0)),
+          // not return by api
+          liquidityProviderFeeUsd: "0"
+        };
+        result.estimateSourceGas = ett.estimateSourceGas;
+        result.totalEstimateSourceGas = ett.estimateSourceGas;
+        result.estimateSourceGasUsd = ett.estimateSourceGasUsd;
+        result.totalFeesUsd = core.numberRemoveEndZero(Big__default.default(quoteResponse.amountOutBeforeFee || 0).minus(quoteResponse.amountOut).div(10 ** (fromToken.decimals || 6)).toFixed(20, 0));
+        result.txRequest.gasLimit = ett.estimateSourceGasLimit;
+      }
+    };
+    execTime.breakpoint();
+    const mergedCalls = [
+      this.allowance({
+        dry,
+        contractAddress: fromToken.contractAddress,
+        spender: bridgeRouterAddress,
+        address: refundTo,
+        amountWei
+      }),
+      estimateNativeGas()
+    ];
+    const [allowanceResult] = await Promise.all(mergedCalls);
+    result.needApprove = allowanceResult.needApprove;
+    execTime.log("allowance & estimateNativeGas");
+    execTime.logTotal("quoteNative");
+    return result;
+  }
+  async quoteFraxZero(params) {
+    const {
+      dry,
+      abi,
+      recipient,
+      amountWei,
+      slippageTolerance,
+      fromToken,
+      toToken,
+      prices,
+      evmGasFees,
+      excludeFees,
+      refundTo,
+      originLayerzero,
+      destinationLayerzero
+    } = params;
+    const {
+      eid: srcEid,
+      remoteHop,
+      lockbox
+    } = originLayerzero;
+    const {
+      eid: dstEid
+    } = destinationLayerzero;
+    const isFromEthereum = fromToken.chainId === 1;
+    const result = {
+      needApprove: false,
+      approveSpender: remoteHop,
+      sendParam: void 0,
+      quoteParam: {
+        ...params
+      },
+      fees: {},
+      totalFeesUsd: 0,
+      estimateSourceGas: 0n,
+      totalEstimateSourceGas: 0n,
+      estimateSourceGasUsd: 0,
+      estimateTime: 0,
+      outputAmount: core.numberRemoveEndZero(Big__default.default(amountWei || 0).div(10 ** params.fromToken.decimals).toFixed(params.fromToken.decimals, 0))
+    };
+    const provider = utilsEvm.evmRpcFallbackProvider(fromToken);
+    const execTime = new core.ExecTime({ type: `FraxZero EVM ${fromToken.chainName}->${toToken.chainName}`, logStyle: "stone-500", isDebug: core.OpenAPI.DEBUG });
+    const remoteHopContract = new ethers.ethers.Contract(remoteHop, abi, this.signer);
+    const remoteHopContractRead = new ethers.ethers.Contract(remoteHop, abi, provider);
+    const sendParams = [
+      // _oft
+      isFromEthereum ? lockbox : fromToken.contractAddress,
+      // _dstEid
+      dstEid,
+      // _to
+      bridges.addressToBytes32(toToken.chainType, recipient),
+      // _amountLD
+      amountWei
+    ];
+    execTime.breakpoint();
+    const mergedCalls = [
+      this.allowance({
+        dry,
+        contractAddress: fromToken.contractAddress,
+        spender: remoteHop,
+        address: refundTo,
+        amountWei,
+        provider
+      }),
+      remoteHopContractRead.quote.staticCall(...sendParams)
+    ];
+    const [allowanceResult, msgFee] = await Promise.all(mergedCalls);
+    execTime.log("allowance & quote.staticCall");
+    result.needApprove = allowanceResult.needApprove;
+    let nativeMsgFee = msgFee[0];
+    this.csl("EVM quoteFraxZero", "blue-700", "nativeMsgFee: %o", nativeMsgFee);
+    nativeMsgFee = nativeMsgFee * utilsEvm.NATIVE_MSG_FEE_BUFFER / 100n;
+    this.csl("EVM quoteFraxZero", "blue-700", "nativeMsgFee after buffer: %o", nativeMsgFee);
+    result.totalEstimateSourceGas = nativeMsgFee;
+    const nativeFeeUsd = Big__default.default(nativeMsgFee?.toString() || 0).div(10 ** fromToken.nativeToken.decimals).times(core.getPrice(prices, fromToken.nativeToken.symbol));
+    result.fees.nativeFee = core.numberRemoveEndZero(Big__default.default(nativeMsgFee?.toString() || 0).div(10 ** fromToken.nativeToken.decimals).toFixed(fromToken.nativeToken.decimals));
+    result.fees.nativeFeeUsd = core.numberRemoveEndZero(Big__default.default(nativeFeeUsd).toFixed(20));
+    result.fees.lzTokenFeeUsd = core.numberRemoveEndZero(Big__default.default(msgFee[1]?.toString() || 0).div(10 ** fromToken.decimals).toFixed(20));
+    this.csl("EVM quoteFraxZero", "blue-700", "msgFee: %o", msgFee);
+    execTime.breakpoint();
+    const finalSendParam = [...sendParams, { value: nativeMsgFee }];
+    const ett = await this.estimateTransaction({
+      dry,
+      contract: remoteHopContract,
+      method: "sendOFT",
+      param: finalSendParam,
+      fromToken,
+      prices,
+      evmGasFees
+    });
+    result.fees.estimateGasUsd = ett.estimateSourceGasUsd;
+    result.estimateSourceGas = ett.estimateSourceGas;
+    result.totalEstimateSourceGas += ett.estimateSourceGas;
+    result.estimateSourceGasUsd = ett.estimateSourceGasUsd;
+    finalSendParam[finalSendParam.length - 1].gasLimit = ett.estimateSourceGasLimit;
+    execTime.log("sendOFT.estimateTransaction");
+    result.sendParam = {
+      contract: remoteHopContract,
+      method: "sendOFT",
+      param: finalSendParam
+    };
+    for (const feeKey in result.fees) {
+      if (excludeFees.includes(feeKey) || !/Usd$/.test(feeKey)) {
+        continue;
+      }
+      result.totalFeesUsd = Big__default.default(result.totalFeesUsd || 0).plus(result.fees[feeKey] || 0);
+    }
+    result.totalFeesUsd = core.numberRemoveEndZero(Big__default.default(result.totalFeesUsd).toFixed(20));
+    execTime.logTotal("quoteFraxZero");
+    return result;
+  }
+  async preivewRedeemFrxUSD(params) {
+    const {
+      dry,
+      amountWei,
+      fromToken,
+      abi,
+      usdcCustodianAddress,
+      rwaCustodianAddress,
+      redemptionAddress
+    } = params;
+    if (dry) {
+      return {
+        maxUsdc: 0n,
+        maxRwa: 0n,
+        amountWeiBigInt: 0n,
+        // The token obtained from redeem is Ethereum USDC
+        totalAssetsOut: BigInt(Big__default.default(amountWei || 0).div(10 ** fromToken.decimals).times(10 ** bridges.FRAXZERO_MIDDLE_TOKEN_USDC.decimals).toFixed(0, 0)),
+        isInsufficientLiquidity: false
+      };
+    }
+    const execTime = new core.ExecTime({ type: `FraxZero EVM preivewRedeemFrxUSD ${fromToken.chainName}`, logStyle: "stone-600", isDebug: core.OpenAPI.DEBUG });
+    const provider = utilsEvm.evmRpcFallbackProvider(fromToken);
+    const usdcCustodian = new ethers.ethers.Contract(usdcCustodianAddress, abi, provider);
+    const rwaCustodian = new ethers.ethers.Contract(rwaCustodianAddress, abi, provider);
+    const redemption = new ethers.ethers.Contract(redemptionAddress, abi, provider);
+    execTime.breakpoint();
+    const [usdcView, redemptionView] = await Promise.all([
+      usdcCustodian.mdwrComboView.staticCall(),
+      redemption.maxUstbRedemptionAmount.staticCall()
+    ]);
+    execTime.log("usdcCustodian & redemption");
+    const maxUsdc = usdcView[3];
+    const superstateTokenAmount = redemptionView[0];
+    const [maxRwa] = await redemption.calculateUsdcOut.staticCall(superstateTokenAmount);
+    const amountWeiBigInt = BigInt(amountWei || 0);
+    this.csl("EVM preivewRedeemFrxUSD", "blue-700", "usdcCustodian maxSharesRedeemable(frxUSD wei amount): %o", maxUsdc);
+    this.csl("EVM preivewRedeemFrxUSD", "blue-700", "rwaCustodian maxSharesRedeemable(USDC wei amount): %o", maxRwa);
+    this.csl("EVM preivewRedeemFrxUSD", "blue-700", "amountWei: %o", amountWeiBigInt);
+    let totalAssetsOut = 0n;
+    let isInsufficientLiquidity = false;
+    if (amountWeiBigInt <= maxUsdc) {
+      execTime.breakpoint();
+      const assetsOut = await usdcCustodian.previewRedeem.staticCall(amountWeiBigInt);
+      execTime.log("usdcCustodian.previewRedeem (USDC only)");
+      this.csl("EVM preivewRedeemFrxUSD", "blue-700", "USDC path only, usdcCustodian previewRedeem input: %o, value: %o", amountWeiBigInt, assetsOut);
+      totalAssetsOut = assetsOut;
+      this.csl("EVM preivewRedeemFrxUSD", "blue-700", "USDC path only, totalAssetsOut: %o", totalAssetsOut);
+    } else {
+      if (maxUsdc > 0n) {
+        execTime.breakpoint();
+        const usdcAssetsOut = await usdcCustodian.previewRedeem.staticCall(maxUsdc);
+        execTime.log("usdcCustodian.previewRedeem (mixed)");
+        this.csl("EVM preivewRedeemFrxUSD", "blue-700", "USDC first (maxUsdc), usdcCustodian previewRedeem input: %o, value: %o", maxUsdc, usdcAssetsOut);
+        totalAssetsOut += usdcAssetsOut;
+        this.csl("EVM preivewRedeemFrxUSD", "blue-700", "USDC first (maxUsdc), totalAssetsOut: %o", totalAssetsOut);
+      }
+      const rwaAmount = amountWeiBigInt - maxUsdc;
+      this.csl("EVM preivewRedeemFrxUSD", "blue-700", "RWA for remainder, rwaAmount: %o", rwaAmount);
+      if (rwaAmount > 0n) {
+        execTime.breakpoint();
+        const superstateTokenInAmount = await rwaCustodian.previewRedeem.staticCall(rwaAmount);
+        execTime.log("rwaCustodian.previewRedeem (mixed)");
+        this.csl("EVM preivewRedeemFrxUSD", "blue-700", "USDC first (maxUsdc), rwaCustodian previewRedeem input: %o, superstateTokenInAmount: %o", rwaAmount, superstateTokenInAmount);
+        execTime.breakpoint();
+        const [rwaAssetsOut] = await redemption.calculateUsdcOut.staticCall(superstateTokenInAmount);
+        execTime.log("redemption.calculateUsdcOut (mixed)");
+        this.csl("EVM preivewRedeemFrxUSD", "blue-700", "USDC first (maxUsdc), rwaCustodian previewRedeem input: %o, value: %o", rwaAmount, rwaAssetsOut);
+        totalAssetsOut += rwaAssetsOut;
+        this.csl("EVM preivewRedeemFrxUSD", "blue-700", "RWA for remainder, totalAssetsOut: %o", totalAssetsOut);
+        if (rwaAssetsOut > maxRwa) {
+          isInsufficientLiquidity = true;
+        }
+      }
+    }
+    this.csl("EVM preivewRedeemFrxUSD", "blue-700", "final totalAssetsOut: %o", totalAssetsOut);
+    this.csl("EVM preivewRedeemFrxUSD", "blue-700", "final insufficient liquidity: %o", isInsufficientLiquidity);
+    execTime.logTotal("preivewRedeemFrxUSD");
+    return {
+      maxUsdc,
+      maxRwa,
+      amountWeiBigInt,
+      totalAssetsOut,
+      isInsufficientLiquidity
+    };
+  }
+  async previewMintFrxUSD(params) {
+    const {
+      dry,
+      amountWei,
+      fromToken,
+      abi,
+      usdcCustodianAddress
+    } = params;
+    this.csl("EVM previewMintFrxUSD", "blue-700", "params: %o", params);
+    if (dry) {
+      return {
+        maxUsdc: 0n,
+        amountWeiBigInt: 0n,
+        totalMax: 0n,
+        // Minting means converting Ethereum USDC into Ethereum frxUSD
+        totalAssetsOut: BigInt(Big__default.default(amountWei || 0).div(10 ** fromToken.decimals).times(10 ** bridges.FRAXZERO_MIDDLE_TOKEN_FRXUSD.decimals).toFixed(0, 0))
+      };
+    }
+    const execTime = new core.ExecTime({ type: `FraxZero EVM previewMintFrxUSD ${fromToken.chainName}`, logStyle: "stone-700", isDebug: core.OpenAPI.DEBUG });
+    const provider = utilsEvm.evmRpcFallbackProvider(fromToken);
+    const usdcCustodian = new ethers.ethers.Contract(usdcCustodianAddress, abi, provider);
+    execTime.breakpoint();
+    const usdcView = await usdcCustodian.mdwrComboView.staticCall();
+    execTime.log("usdcCustodian.mdwrComboView");
+    const maxUsdc = usdcView[0];
+    const amountWeiBigInt = BigInt(amountWei || 0);
+    const totalMax = maxUsdc;
+    execTime.breakpoint();
+    const totalAssetsOut = await usdcCustodian.previewDeposit.staticCall(amountWeiBigInt);
+    execTime.log("usdcCustodian.previewDeposit");
+    execTime.logTotal("previewMintFrxUSD");
+    return {
+      maxUsdc,
+      amountWeiBigInt,
+      totalMax,
+      totalAssetsOut
+    };
+  }
+  /**
+   * Redeem frxUSD to USDC via USDC and/or RWA custodian contracts.
+   * Uses mdwrComboView to get max redeemable liquidity and splits redemption across USDC/RWA paths.
+   * Uses previewRedeem to get accurate output amount (USDC).
+   */
+  async redeemFrxUSD(params) {
+    const {
+      dry,
+      recipient,
+      amountWei,
+      fromToken,
+      toToken,
+      prices,
+      evmGasFees,
+      refundTo,
+      abi,
+      usdcCustodianAddress,
+      rwaCustodianAddress,
+      redeemAndMintContractAddress,
+      preivewRedeemResult
+    } = params;
+    this.csl("EVM redeemFrxUSD", "blue-700", "params: %o", params);
+    const ETH_AVG_BLOCK_TIME = 12;
+    const estimateTime = ETH_AVG_BLOCK_TIME * 2 + Math.floor(Math.random() * 11) - 5;
+    const result = {
+      needApprove: false,
+      approveSpender: redeemAndMintContractAddress,
+      sendParam: void 0,
+      quoteParam: {
+        ...params
+      },
+      fees: {},
+      totalFeesUsd: 0,
+      estimateSourceGas: 0n,
+      totalEstimateSourceGas: 0n,
+      estimateSourceGasUsd: 0,
+      estimateTime,
+      outputAmount: "0"
+    };
+    const provider = utilsEvm.evmRpcFallbackProvider(fromToken);
+    const execTime = new core.ExecTime({ type: `FraxZero EVM redeemFrxUSD ${fromToken.chainName}->${toToken.chainName}`, logStyle: "stone-800", isDebug: core.OpenAPI.DEBUG });
+    new ethers.ethers.Contract(redeemAndMintContractAddress, abi, provider);
+    const redeemContract = new ethers.ethers.Contract(redeemAndMintContractAddress, abi, this.signer);
+    execTime.breakpoint();
+    let finalPreivewRedeemResult = preivewRedeemResult;
+    if (!finalPreivewRedeemResult) {
+      finalPreivewRedeemResult = await this.preivewRedeemFrxUSD(params);
+    }
+    const {
+      isInsufficientLiquidity,
+      totalAssetsOut
+    } = finalPreivewRedeemResult;
+    execTime.log("preivewRedeemFrxUSD");
+    if (isInsufficientLiquidity) {
+      throw new Error("Insufficient liquidity");
+    }
+    result.outputAmount = core.numberRemoveEndZero(
+      Big__default.default(totalAssetsOut.toString()).div(10 ** toToken.decimals).toFixed(toToken.decimals, 0)
+    );
+    execTime.breakpoint();
+    const allowanceResult = await this.allowance({
+      dry,
+      contractAddress: fromToken.contractAddress,
+      spender: redeemAndMintContractAddress,
+      address: refundTo,
+      amountWei,
+      provider
+    });
+    result.needApprove = allowanceResult.needApprove;
+    execTime.log("allowance");
+    result.sendParam = {
+      contract: redeemContract,
+      method: "redeemToUsdcAndTransfer",
+      param: [
+        amountWei,
+        recipient
+      ]
+    };
+    execTime.breakpoint();
+    const ett = await this.estimateTransaction({
+      dry,
+      contract: redeemContract,
+      method: result.sendParam.method,
+      param: [...result.sendParam.param, { gasLimit: DEFAULT_GAS_LIMIT_FAILED }],
+      fromToken,
+      prices,
+      evmGasFees
+    });
+    result.fees.estimateGasUsd = ett.estimateSourceGasUsd;
+    result.estimateSourceGas = ett.estimateSourceGas;
+    result.totalEstimateSourceGas = ett.estimateSourceGas;
+    result.estimateSourceGasUsd = ett.estimateSourceGasUsd;
+    result.totalFeesUsd = ett.estimateSourceGasUsd;
+    result.sendParam.param[2] = { gasLimit: ett.estimateSourceGasLimit };
+    execTime.log("estimateTransaction");
+    execTime.logTotal("redeemFrxUSD");
+    return result;
+  }
+  /**
+   * Mint frxUSD by depositing USDC into the custodian contract.
+   * Calls deposit(assetsIn, receiver) on usdcCustodianAddress.
+   * assetsIn = USDC amount (6 decimals), sharesOut = frxUSD amount (18 decimals).
+   */
+  async mintFrxUSD(params) {
+    const {
+      dry,
+      recipient,
+      amountWei,
+      fromToken,
+      toToken,
+      prices,
+      evmGasFees,
+      refundTo,
+      abi,
+      usdcCustodianAddress,
+      previewMintResult
+    } = params;
+    this.csl("EVM mintFrxUSD", "blue-700", "params: %o", params);
+    const ETH_AVG_BLOCK_TIME = 12;
+    const estimateTime = ETH_AVG_BLOCK_TIME * 2 + Math.floor(Math.random() * 11) - 5;
+    const result = {
+      needApprove: false,
+      approveSpender: usdcCustodianAddress,
+      sendParam: void 0,
+      quoteParam: {
+        ...params
+      },
+      fees: {},
+      totalFeesUsd: 0,
+      estimateSourceGas: 0n,
+      totalEstimateSourceGas: 0n,
+      estimateSourceGasUsd: 0,
+      estimateTime,
+      outputAmount: "0"
+    };
+    const execTime = new core.ExecTime({ type: `FraxZero EVM mintFrxUSD ${fromToken.chainName}->${toToken.chainName}`, logStyle: "stone-900", isDebug: core.OpenAPI.DEBUG });
+    const provider = utilsEvm.evmRpcFallbackProvider(fromToken);
+    execTime.breakpoint();
+    const allowanceResult = await this.allowance({
+      dry,
+      contractAddress: fromToken.contractAddress,
+      spender: usdcCustodianAddress,
+      address: refundTo,
+      amountWei,
+      provider
+    });
+    result.needApprove = allowanceResult.needApprove;
+    execTime.log("allowance");
+    new ethers.ethers.Contract(usdcCustodianAddress, abi, provider);
+    const usdcCustodianWithSigner = new ethers.ethers.Contract(usdcCustodianAddress, abi, this.signer);
+    execTime.breakpoint();
+    let finalPreviewMintResult = previewMintResult;
+    if (!finalPreviewMintResult) {
+      finalPreviewMintResult = await this.previewMintFrxUSD(params);
+    }
+    const {
+      maxUsdc,
+      amountWeiBigInt,
+      totalMax,
+      totalAssetsOut
+    } = finalPreviewMintResult;
+    execTime.log("previewMintFrxUSD");
+    result.outputAmount = core.numberRemoveEndZero(
+      Big__default.default(totalAssetsOut.toString()).div(10 ** toToken.decimals).toFixed(toToken.decimals, 0)
+    );
+    result.sendParam = {
+      contract: usdcCustodianWithSigner,
+      method: "deposit",
+      param: [
+        amountWeiBigInt,
+        recipient
+      ]
+    };
+    execTime.breakpoint();
+    const ett = await this.estimateTransaction({
+      dry,
+      contract: usdcCustodianWithSigner,
+      method: "deposit",
+      param: [...result.sendParam.param, { gasLimit: DEFAULT_GAS_LIMIT_FAILED }],
+      fromToken,
+      prices,
+      evmGasFees
+    });
+    result.fees.estimateGasUsd = ett.estimateSourceGasUsd;
+    result.estimateSourceGas = ett.estimateSourceGas;
+    result.totalEstimateSourceGas = ett.estimateSourceGas;
+    result.estimateSourceGasUsd = ett.estimateSourceGasUsd;
+    result.totalFeesUsd = ett.estimateSourceGasUsd;
+    result.sendParam.param[2] = { gasLimit: ett.estimateSourceGasLimit };
+    execTime.log("estimateTransaction");
+    execTime.logTotal("mintFrxUSD");
+    return result;
+  }
+  async mintAndSendFrxUSD(params) {
+    const {
+      dry,
+      recipient,
+      amountWei,
+      fromToken,
+      toToken,
+      prices,
+      evmGasFees,
+      refundTo,
+      abi,
+      usdcCustodianAddress,
+      redeemAndMintContractAddress,
+      originLayerzero,
+      destinationLayerzero,
+      previewMintResult
+    } = params;
+    this.csl("EVM mintAndSendFrxUSD", "blue-700", "params: %o", params);
+    const {
+      eid: dstEid
+    } = destinationLayerzero;
+    const ETH_AVG_BLOCK_TIME = 12;
+    const estimateTime = ETH_AVG_BLOCK_TIME * 2 + Math.floor(Math.random() * 11) - 5;
+    const result = {
+      needApprove: false,
+      approveSpender: redeemAndMintContractAddress,
+      sendParam: void 0,
+      quoteParam: {
+        ...params
+      },
+      fees: {},
+      totalFeesUsd: 0,
+      estimateSourceGas: 0n,
+      totalEstimateSourceGas: 0n,
+      estimateSourceGasUsd: 0,
+      estimateTime,
+      outputAmount: "0"
+    };
+    const execTime = new core.ExecTime({ type: `FraxZero EVM mintAndSendFrxUSD ${fromToken.chainName}->${toToken.chainName}`, logStyle: "stone-950", isDebug: core.OpenAPI.DEBUG });
+    const provider = utilsEvm.evmRpcFallbackProvider(fromToken);
+    execTime.breakpoint();
+    const allowanceResult = await this.allowance({
+      dry,
+      contractAddress: fromToken.contractAddress,
+      spender: redeemAndMintContractAddress,
+      address: refundTo,
+      amountWei,
+      provider
+    });
+    result.needApprove = allowanceResult.needApprove;
+    execTime.log("allowance");
+    const redeemAndMintContractWithSigner = new ethers.ethers.Contract(redeemAndMintContractAddress, abi, this.signer);
+    execTime.breakpoint();
+    let finalPreviewMintResult = previewMintResult;
+    if (!finalPreviewMintResult) {
+      finalPreviewMintResult = await this.previewMintFrxUSD(params);
+    }
+    const {
+      totalAssetsOut
+    } = finalPreviewMintResult;
+    execTime.log("previewMintFrxUSD");
+    this.csl("EVM mintAndSendFrxUSD", "gray-600", "previewMintFrxUSD totalAssetsOut: %o", totalAssetsOut);
+    result.outputAmount = core.numberRemoveEndZero(
+      Big__default.default(totalAssetsOut.toString()).div(10 ** 18).toFixed(18, 0)
+    );
+    const mintAndSendParam = [
+      // assetsIn
+      amountWei,
+      // dstEid
+      dstEid,
+      // receiver
+      bridges.addressToBytes32(toToken.chainType, recipient)
+    ];
+    result.sendParam = {
+      contract: redeemAndMintContractWithSigner,
+      method: "mintAndSend",
+      param: mintAndSendParam
+    };
+    execTime.breakpoint();
+    const ett = await this.estimateTransaction({
+      dry,
+      contract: redeemAndMintContractWithSigner,
+      method: "mintAndSend",
+      param: [...mintAndSendParam, { gasLimit: DEFAULT_GAS_LIMIT_FAILED }],
+      fromToken,
+      prices,
+      evmGasFees
+    });
+    result.fees.estimateGasUsd = ett.estimateSourceGasUsd;
+    result.estimateSourceGas = ett.estimateSourceGas;
+    result.totalEstimateSourceGas = ett.estimateSourceGas;
+    result.estimateSourceGasUsd = ett.estimateSourceGasUsd;
+    result.totalFeesUsd = ett.estimateSourceGasUsd;
+    result.sendParam.param.push({ gasLimit: ett.estimateSourceGasLimit });
+    execTime.log("estimateTransaction");
+    execTime.logTotal("mintAndSendFrxUSD");
+    return result;
+  }
+  async retryLayerzeroLzComponse(params) {
+    const { Options } = await import('@layerzerolabs/lz-v2-utilities');
+    const {
+      layerzeroData,
+      history
+    } = params;
+    const LayerZeroEndpointV2 = "0x1a44076050125825900e736c501f859c50fe728c";
+    const LayerZeroEndpointV2ABI = [
+      {
+        "inputs": [
+          {
+            "internalType": "address",
+            "name": "_from",
+            "type": "address"
+          },
+          {
+            "internalType": "address",
+            "name": "_to",
+            "type": "address"
+          },
+          {
+            "internalType": "bytes32",
+            "name": "_guid",
+            "type": "bytes32"
+          },
+          {
+            "internalType": "uint16",
+            "name": "_index",
+            "type": "uint16"
+          },
+          {
+            "internalType": "bytes",
+            "name": "_message",
+            "type": "bytes"
+          },
+          {
+            "internalType": "bytes",
+            "name": "_extraData",
+            "type": "bytes"
+          }
+        ],
+        "name": "lzCompose",
+        "outputs": [],
+        "stateMutability": "payable",
+        "type": "function"
+      }
+    ];
+    const LayerZeroEndpointV2Contract = new ethers.ethers.Contract(LayerZeroEndpointV2, LayerZeroEndpointV2ABI, this.signer);
+    const toToken = core.usdtTokens[history.destination_chain.blockchain];
+    const amountWei = Big__default.default(history.token_in_amount).times(10 ** (toToken.decimals || 6)).toFixed(0);
+    const originLayerzero = bridges.USDT0_CONFIG["Arbitrum"];
+    const isOriginLegacy = layerzeroData.destination.lzCompose.failedTx[0].from.toLowerCase() === originLayerzero.oftLegacy?.toLowerCase();
+    isOriginLegacy ? originLayerzero.lzReceiveOptionGasLegacy : originLayerzero.lzReceiveOptionGas;
+    const destATA = await utilsSolana.getDestinationAssociatedTokenAddress({
+      recipient: history.receive_address,
+      toToken
+    });
+    if (destATA.needCreateTokenAccount) {
+      bridges.LZ_RECEIVE_VALUE[toToken.chainName] || 0;
+    }
+    const composeFrom = layerzeroData.source.tx.from;
+    const composeMsg = layerzeroData.source.tx.payload.split(composeFrom.replace(/^0x/, ""))[1];
+    const _message = utilsEvm.buildEndpointV2LzComposePayload({
+      nonce: layerzeroData.pathway.nonce,
+      srcEid: layerzeroData.pathway.srcEid,
+      amountLD: amountWei,
+      composeFrom,
+      composeMsg
+    });
+    const contractParams = [
+      layerzeroData.destination.lzCompose.failedTx[0].from,
+      layerzeroData.destination.lzCompose.failedTx[0].to,
+      layerzeroData.guid,
+      layerzeroData.destination.lzCompose.failedTx[0].index,
+      _message,
+      "0x"
+    ];
+    const dstOFT = isOriginLegacy ? originLayerzero.oft : originLayerzero.oftLegacy;
+    const sendParam = {
+      dstEid: bridges.USDT0_CONFIG[history.destination_chain.chainName].eid,
+      to: bridges.addressToBytes32(toToken.chainType, history.receive_address),
+      amountLD: amountWei,
+      minAmountLD: 0n,
+      extraOptions: Options.newOptions().toHex(),
+      composeMsg: "0x",
+      oftCmd: "0x"
+    };
+    const dstOFTContract = new ethers.ethers.Contract(dstOFT, bridges.OFT_ABI, this.provider);
+    const msgFee = await dstOFTContract.quoteSend.staticCall(sendParam, false);
+    let nativeFee = msgFee[0];
+    nativeFee = nativeFee * utilsEvm.NATIVE_MSG_FEE_BUFFER / 100n;
+    const tx = await LayerZeroEndpointV2Contract.lzCompose(
+      ...contractParams,
+      {
+        gasLimit: originLayerzero.composeOptionGas || 8e5,
+        value: nativeFee
+      }
+    );
+    const txReceipt = await tx.wait();
+    if (txReceipt.status === 1) {
+      return txReceipt.hash;
+    }
+    return null;
+  }
+  async signTypedData(params) {
+    const { fromToken, amountWei, spender } = params;
+    this.csl("EVM signTypedData", "blue-900", "params: %o", params);
+    const provider = utilsEvm.evmRpcFallbackProvider(fromToken);
+    const value = amountWei;
+    const tokenAddress = fromToken.contractAddress;
+    const chainId = fromToken.chainId;
+    const deadline = Math.floor(Date.now() / 1e3) + 60 * 60 * 24 * 3;
+    const account = this.signer.address;
+    const erc20 = new ethers.ethers.Contract(tokenAddress, core.erc20Abi, provider);
+    const nonce = await erc20.nonces(account);
+    const name = await erc20.name();
+    let _version = "1";
+    if (fromToken.symbol === "USDC") {
+      _version = "2";
+    }
+    const domain = {
+      name,
+      version: _version,
+      chainId: Number(chainId),
+      verifyingContract: tokenAddress
+    };
+    const types = {
+      Permit: [
+        { name: "owner", type: "address" },
+        { name: "spender", type: "address" },
+        { name: "value", type: "uint256" },
+        { name: "nonce", type: "uint256" },
+        { name: "deadline", type: "uint256" }
+      ]
+    };
+    const values = {
+      owner: account,
+      spender,
+      value,
+      nonce: nonce.toString(),
+      deadline
+    };
+    const signature = await this.signer?.signTypedData(domain, types, values);
+    const { v, r, s } = ethers.ethers.Signature.from(signature);
+    try {
+      const permitParams = [
+        account,
+        spender,
+        value,
+        deadline,
+        v,
+        r,
+        s
+      ];
+      const permitResponse = await erc20.permit.staticCall(...permitParams);
+      this.csl("EVM signTypedData", "green-500", "permit response: %o", permitResponse);
+    } catch (error) {
+      this.csl("EVM signTypedData", "red-500", "check permit signature failed: %o", error);
+      throw new Error("Permit signature verification failed");
+    }
+    return {
+      owner: account,
+      value,
+      deadline,
+      nonce: Number(nonce),
+      v,
+      r,
+      s
+    };
+  }
+};
+
+exports.EVMWallet = EVMWallet;
+exports.default = EVMWallet;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map