stableflow-ai-sdk 2.0.1 → 2.0.3

package/dist/index.mjs

@@ -498,7 +498,8 @@ var ONECLICK_PROXY = {
   ["Solana"]: "HWk6MsFEGzXxpe9B4mfEHpvVoCwNeVVMFxb5Mi7qNTM",
   ["Near"]: "stbflow.near",
   ["Aptos"]: "0x3000ceb3211d23ef73ad1b602a7a99b72020c9ce9537f580ac5bba556ec3bff9",
-  ["Base"]: "0x7A18854b695BA7efB7229c17D0E1Cd2679481D28"
+  ["Base"]: "0x7A18854b695BA7efB7229c17D0E1Cd2679481D28",
+  ["X Layer"]: "0xc8dB1175132C64e311D01258dD05D4e2e75fD7b8"
 };
 var ONECLICK_PROXY_ABI = [
   {
@@ -586,26 +587,35 @@ var OneClickService = class {
     this.offsetTime = 1e3 * 60 * 30;
   }
   async quote(params) {
+    const {
+      wallet,
+      fromToken,
+      toToken,
+      prices,
+      amountWei,
+      appFees = [],
+      swapType = "EXACT_INPUT",
+      isProxy = true,
+      ...restParams
+    } = params;
+    const isExactOutput = swapType === "EXACT_OUTPUT";
     const response = await request(OpenAPI, {
       method: "POST",
       url: "/v0/quote",
       body: {
         depositMode: "SIMPLE",
-        swapType: "EXACT_INPUT",
+        swapType,
         depositType: "ORIGIN_CHAIN",
         sessionId: `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
         recipientType: "DESTINATION_CHAIN",
         deadline: new Date(Date.now() + this.offsetTime).toISOString(),
         quoteWaitingTimeMs: 3e3,
-        appFees: BridgeFee,
+        appFees: [
+          ...BridgeFee,
+          ...appFees
+        ],
         referral: "stableflow",
-        ...params,
-        // delete params
-        wallet: void 0,
-        fromToken: void 0,
-        toToken: void 0,
-        prices: void 0,
-        amountWei: void 0
+        ...restParams
       },
       mediaType: "application/json",
       errors: {
@@ -619,7 +629,10 @@ var OneClickService = class {
       res.data.estimateTime = res.data?.quote?.timeEstimate;
       res.data.outputAmount = numberRemoveEndZero(Big(res.data?.quote?.amountOut || 0).div(10 ** params.toToken.decimals).toFixed(params.toToken.decimals, 0));
       try {
-        const netFee = Big(params.amount).div(10 ** params.fromToken.decimals).minus(Big(res.data?.quote?.amountOut || 0).div(10 ** params.toToken.decimals));
+        let netFee = Big(params.amount).div(10 ** params.fromToken.decimals).minus(Big(res.data?.quote?.amountOut || 0).div(10 ** params.toToken.decimals));
+        if (isExactOutput) {
+          netFee = Big(res.data?.quote?.amountIn || 0).div(10 ** params.fromToken.decimals).minus(Big(params.amount).div(10 ** params.toToken.decimals));
+        }
         const bridgeFeeValue = BridgeFee.reduce((acc, item) => {
           return acc.plus(Big(params.amount).div(10 ** params.fromToken.decimals).times(Big(item.fee).div(1e4)));
         }, Big(0));
@@ -652,14 +665,14 @@ var OneClickService = class {
         console.log("oneclick estimate failed: %o", error);
       }
       const proxyAddress = ONECLICK_PROXY[params.fromToken.chainName];
-      if (proxyAddress) {
+      if (proxyAddress && isProxy) {
         const proxyResult = await params.wallet.quote(Service.OneClick, {
           proxyAddress,
           abi: ONECLICK_PROXY_ABI,
           fromToken: params.fromToken,
           refundTo: params.refundTo,
           recipient: params.recipient,
-          amountWei: params.amount,
+          amountWei: isExactOutput ? res.data?.quote?.amountIn : params.amount,
           prices: params.prices,
           depositAddress: res.data?.quote?.depositAddress || DefaultAddresses[params.fromToken.chainType]
         });
@@ -734,8 +747,10 @@ var USDT0_CONFIG = {
     chainKey: "ethereum",
     blockTime: 12,
     // Ethereum average block time ~12 seconds
-    confirmations: 15
+    confirmations: 15,
     // Default confirmations from layerzeroscan.com
+    lzReceiveOptionGas: 8e4,
+    lzReceiveOptionGasLegacy: 2e5
   },
   Arbitrum: {
     contractAddress: "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9",
@@ -746,8 +761,10 @@ var USDT0_CONFIG = {
     chainKey: "arbitrum",
     blockTime: 0.25,
     // Arbitrum average block time ~0.25 seconds
-    confirmations: 20
+    confirmations: 20,
     // Default confirmations from layerzeroscan.com
+    lzReceiveOptionGas: 8e4,
+    lzReceiveOptionGasLegacy: 2e5
   },
   Polygon: {
     contractAddress: "0xc2132D05D31c914a87C6611C10748AEb04B58e8F",
@@ -756,8 +773,11 @@ var USDT0_CONFIG = {
     chainKey: "polygon",
     blockTime: 2,
     // Polygon average block time ~2 seconds
-    confirmations: 20
+    confirmations: 20,
     // Default confirmations from layerzeroscan.com 
+    lzReceiveOptionGas: 8e4,
+    lzReceiveOptionGasLegacy: 2e5,
+    composeOptionGas: 6e5
   },
   Optimism: {
     contractAddress: "0x01bFF41798a0BcF287b996046Ca68b395DbC1071",
@@ -766,8 +786,11 @@ var USDT0_CONFIG = {
     chainKey: "optimism",
     blockTime: 2,
     // Optimism average block time ~2 seconds
-    confirmations: 20
+    confirmations: 20,
     // Default confirmations from layerzeroscan.com
+    lzReceiveOptionGas: 8e4,
+    lzReceiveOptionGasLegacy: 2e5,
+    composeOptionGas: 6e5
   },
   Berachain: {
     contractAddress: "0x779Ded0c9e1022225f8E0630b35a9b54bE713736",
@@ -777,8 +800,11 @@ var USDT0_CONFIG = {
     chainKey: "berachain",
     blockTime: 2,
     // Optimism average block time ~2 seconds
-    confirmations: 20
+    confirmations: 20,
     // Default confirmations from layerzeroscan.com
+    lzReceiveOptionGas: 8e4,
+    lzReceiveOptionGasLegacy: 2e5,
+    composeOptionGas: 6e5
   },
   Solana: {
     contractAddress: "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB",
@@ -787,8 +813,11 @@ var USDT0_CONFIG = {
     chainKey: "solana",
     blockTime: 0.4,
     // Solana average block time ~0.4 seconds
-    confirmations: 32
+    confirmations: 32,
     // Default confirmations from layerzeroscan.com
+    lzReceiveOptionGas: 2e5,
+    lzReceiveOptionGasLegacy: 2e5,
+    composeOptionGas: 5e5
   },
   Tron: {
     contractAddress: "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t",
@@ -797,12 +826,33 @@ var USDT0_CONFIG = {
     chainKey: "tron",
     blockTime: 3,
     // Tron average block time ~3 seconds
-    confirmations: 5
+    confirmations: 5,
+    // Default confirmations from layerzeroscan.com
+    lzReceiveOptionGas: 3e5,
+    lzReceiveOptionGasLegacy: 3e5,
+    composeOptionGas: 5e5
+  },
+  "X Layer": {
+    contractAddress: "0x779Ded0c9e1022225f8E0630b35a9b54bE713736",
+    oft: "0x94bcca6bdfd6a61817ab0e960bfede4984505554",
+    eid: 30274,
+    chainKey: "xlayer",
+    blockTime: 3,
+    // Tron average block time ~3 seconds
+    confirmations: 20,
     // Default confirmations from layerzeroscan.com
+    lzReceiveOptionGas: 8e4,
+    lzReceiveOptionGasLegacy: 2e5,
+    composeOptionGas: 6e5
   }
 };
+var LZ_RECEIVE_VALUE = {
+  Solana: 2039280
+};
 var USDT0_DVN_COUNT = 2;
-var USDT0_LEGACY_FEE = 1e-4;
+var USDT0_LEGACY_MESH_TRANSFTER_FEE = 3e-4;
+var DATA_HEX_PROTOBUF_EXTRA = 3;
+var SIGNATURE_SIZE = 67;
 
 // src/bridges/usdt0/contract.ts
 var OFT_ABI = [
@@ -3511,17 +3561,6 @@ function calculateEstimateTime(originChain, destinationChain) {
   const sourceTime = sourceBlockTime * blockConfirmations;
   const destinationTime = destinationBlockTime * (2 + dvnCount);
   const totalTime = Math.ceil(sourceTime + destinationTime);
-  console.log(`USDT0 estimate time calculation:`, {
-    originChain,
-    destinationChain,
-    sourceBlockTime,
-    blockConfirmations,
-    destinationBlockTime,
-    dvnCount,
-    sourceTime,
-    destinationTime,
-    totalTime
-  });
   return totalTime;
 }
 var Usdt0Service = class {
@@ -3572,7 +3611,9 @@ var Usdt0Service = class {
         multiHopComposer: USDT0_CONFIG["Arbitrum"],
         isMultiHopComposer: isMultiHopComposer2,
         isOriginLegacy: isOriginLegacy2,
-        isDestinationLegacy: isDestinationLegacy2
+        isDestinationLegacy: isDestinationLegacy2,
+        originLayerzero,
+        destinationLayerzero
       });
       result.estimateTime = estimateTime;
       return result;
@@ -3606,7 +3647,9 @@ var Usdt0Service = class {
         multiHopComposer: USDT0_CONFIG["Arbitrum"],
         isMultiHopComposer,
         isOriginLegacy,
-        isDestinationLegacy
+        isDestinationLegacy,
+        originLayerzero,
+        destinationLayerzero
       });
       result.estimateTime = estimateTime;
       return result;
@@ -3629,8 +3672,11 @@ var Usdt0Service = class {
         multiHopComposer: USDT0_CONFIG["Arbitrum"],
         isMultiHopComposer,
         isOriginLegacy,
-        isDestinationLegacy
+        isDestinationLegacy,
+        originLayerzero,
+        destinationLayerzero
       });
+      result.estimateTime = estimateTime;
       return result;
     }
   }
@@ -3843,23 +3889,42 @@ var ServiceLogoMap = {
 };
 
 // src/services/SFA.ts
-import Big2 from "big.js";
+import Big3 from "big.js";
 
 // src/wallets/config/rpcs.ts
-var chainsRpcUrls = {
-  "Ethereum": "https://eth.merkle.io",
-  "Arbitrum": "https://arb1.arbitrum.io/rpc",
-  "BNB Chain": "https://56.rpc.thirdweb.com",
-  "Avalanche": "https://api.avax.network/ext/bc/C/rpc",
-  "Base": "https://mainnet.base.org",
-  "Polygon": "https://polygon-rpc.com",
-  "Gnosis": "https://rpc.gnosischain.com",
-  "Optimism": "https://mainnet.optimism.io",
-  "Berachain": "https://rpc.berachain.com",
-  "Tron": "https://api.trongrid.io",
-  "Aptos": "https://api.mainnet.aptoslabs.com/v1",
-  "Solana": "https://mainnet.helius-rpc.com/?api-key=28fc7f18-acf0-48a1-9e06-bd1b6cba1170",
-  "Near": "https://nearinner.deltarpc.com"
+var NetworkRpcUrlsMap = {
+  "eth": ["https://eth.merkle.io"],
+  "arb": ["https://arb1.arbitrum.io/rpc"],
+  "bsc": ["https://56.rpc.thirdweb.com"],
+  "avax": ["https://api.avax.network/ext/bc/C/rpc"],
+  "base": ["https://mainnet.base.org"],
+  "pol": ["https://polygon-rpc.com"],
+  "gnosis": ["https://rpc.gnosischain.com"],
+  "op": ["https://mainnet.optimism.io"],
+  "bera": ["https://rpc.berachain.com"],
+  "tron": ["https://api.trongrid.io"],
+  "aptos": ["https://api.mainnet.aptoslabs.com/v1"],
+  "sol": ["https://solana-rpc.publicnode.com"],
+  "near": ["https://nearinner.deltarpc.com"],
+  "xlayer": ["https://rpc.xlayer.tech"],
+  "plasma": ["https://rpc.plasma.to"]
+};
+var getRpcUrls = (blockchain) => {
+  return NetworkRpcUrlsMap[blockchain] || [];
+};
+var setRpcUrls = (urls) => {
+  for (const blockchain in urls) {
+    const prev = NetworkRpcUrlsMap[blockchain] ?? [];
+    const next = urls[blockchain];
+    for (let i = next.length - 1; i >= 0; i--) {
+      const rpc = next[i];
+      if (prev.some((_rpc) => _rpc.toLowerCase() === rpc.toLowerCase())) {
+        continue;
+      }
+      prev.unshift(rpc);
+    }
+  }
+  return NetworkRpcUrlsMap;
 };
 
 // src/wallets/config/chains.ts
@@ -3893,6 +3958,7 @@ var chainTypes = {
 var chains = {
   near: {
     chainName: "Near",
+    blockchain: "near",
     chainIcon: "/chains/near.png",
     chainIconGray: "/chains/near-gray.png",
     chainType: chainTypes.near.value,
@@ -3902,10 +3968,11 @@ var chains = {
       symbol: "NEAR",
       decimals: 24
     },
-    rpcUrl: chainsRpcUrls["Near"]
+    rpcUrls: getRpcUrls("near")
   },
   sol: {
     chainName: "Solana",
+    blockchain: "sol",
     chainIcon: "/chains/solana.png",
     chainIconGray: "/chains/solana-gray.png",
     chainType: chainTypes.sol.value,
@@ -3915,10 +3982,11 @@ var chains = {
       symbol: "SOL",
       decimals: 9
     },
-    rpcUrl: chainsRpcUrls["Solana"]
+    rpcUrls: getRpcUrls("sol")
   },
   eth: {
     chainName: "Ethereum",
+    blockchain: "eth",
     chainIcon: "/chains/ethereum.png",
     chainIconGray: "/chains/ethereum-gray.png",
     chainType: chainTypes.evm.value,
@@ -3929,10 +3997,11 @@ var chains = {
       symbol: "ETH",
       decimals: 18
     },
-    rpcUrl: chainsRpcUrls["Ethereum"]
+    rpcUrls: getRpcUrls("eth")
   },
   arb: {
     chainName: "Arbitrum",
+    blockchain: "arb",
     chainIcon: "/chains/arbitrum.png",
     chainIconGray: "/chains/arbitrum-gray.png",
     chainType: chainTypes.evm.value,
@@ -3943,10 +4012,11 @@ var chains = {
       symbol: "ETH",
       decimals: 18
     },
-    rpcUrl: chainsRpcUrls["Arbitrum"]
+    rpcUrls: getRpcUrls("arb")
   },
   bsc: {
     chainName: "BNB Chain",
+    blockchain: "bsc",
     chainIcon: "/chains/bsc.png",
     chainIconGray: "/chains/bsc-gray.png",
     chainType: chainTypes.evm.value,
@@ -3957,10 +4027,11 @@ var chains = {
       symbol: "BNB",
       decimals: 18
     },
-    rpcUrl: chainsRpcUrls["BNB Chain"]
+    rpcUrls: getRpcUrls("bsc")
   },
   avax: {
     chainName: "Avalanche",
+    blockchain: "avax",
     chainIcon: "/chains/avalanche.png",
     chainIconGray: "/chains/avalanche-gray.png",
     chainType: chainTypes.evm.value,
@@ -3971,10 +4042,11 @@ var chains = {
       symbol: "AVAX",
       decimals: 18
     },
-    rpcUrl: chainsRpcUrls["Avalanche"]
+    rpcUrls: getRpcUrls("avax")
   },
   base: {
     chainName: "Base",
+    blockchain: "base",
     chainIcon: "/chains/base.png",
     chainIconGray: "/chains/base-gray.png",
     chainType: chainTypes.evm.value,
@@ -3985,10 +4057,11 @@ var chains = {
       symbol: "ETH",
       decimals: 18
     },
-    rpcUrl: chainsRpcUrls["Base"]
+    rpcUrls: getRpcUrls("base")
   },
   pol: {
     chainName: "Polygon",
+    blockchain: "pol",
     chainIcon: "/chains/polygon.png",
     chainIconGray: "/chains/polygon-gray.png",
     chainType: chainTypes.evm.value,
@@ -3999,10 +4072,11 @@ var chains = {
       symbol: "POL",
       decimals: 18
     },
-    rpcUrl: chainsRpcUrls["Polygon"]
+    rpcUrls: getRpcUrls("pol")
   },
   gnosis: {
     chainName: "Gnosis",
+    blockchain: "gnosis",
     chainIcon: "/chains/gnosis.png",
     chainIconGray: "/chains/gnosis-gray.png",
     chainType: chainTypes.evm.value,
@@ -4013,10 +4087,11 @@ var chains = {
       symbol: "XDAI",
       decimals: 18
     },
-    rpcUrl: chainsRpcUrls["Gnosis"]
+    rpcUrls: getRpcUrls("gnosis")
   },
   op: {
     chainName: "Optimism",
+    blockchain: "op",
     chainIcon: "/chains/optimism.png",
     chainIconGray: "/chains/optimism-gray.png",
     chainType: chainTypes.evm.value,
@@ -4027,10 +4102,11 @@ var chains = {
       symbol: "ETH",
       decimals: 18
     },
-    rpcUrl: chainsRpcUrls["Optimism"]
+    rpcUrls: getRpcUrls("op")
   },
   tron: {
     chainName: "Tron",
+    blockchain: "tron",
     chainIcon: "/chains/tron.png",
     chainIconGray: "/chains/tron-gray.png",
     chainType: chainTypes.tron.value,
@@ -4040,10 +4116,11 @@ var chains = {
       symbol: "TRX",
       decimals: 6
     },
-    rpcUrl: chainsRpcUrls["Tron"]
+    rpcUrls: getRpcUrls("tron")
   },
   aptos: {
     chainName: "Aptos",
+    blockchain: "aptos",
     chainIcon: "/chains/aptos.png",
     chainIconGray: "/chains/aptos-gray.png",
     chainType: chainTypes.aptos.value,
@@ -4053,10 +4130,11 @@ var chains = {
       symbol: "APT",
       decimals: 8
     },
-    rpcUrl: chainsRpcUrls["Aptos"]
+    rpcUrls: getRpcUrls("aptos")
   },
   bera: {
     chainName: "Berachain",
+    blockchain: "bera",
     chainIcon: "/chains/berachain.png",
     chainIconGray: "/chains/berachain-gray.png",
     chainType: chainTypes.evm.value,
@@ -4067,7 +4145,37 @@ var chains = {
       symbol: "BERA",
       decimals: 18
     },
-    rpcUrl: chainsRpcUrls["Berachain"]
+    rpcUrls: getRpcUrls("bera")
+  },
+  xlayer: {
+    chainName: "X Layer",
+    blockchain: "xlayer",
+    chainIcon: "/chains/xlayer.png",
+    chainIconGray: "/chains/xlayer-gray.png",
+    chainType: chainTypes.evm.value,
+    chainId: 196,
+    blockExplorerUrl: "https://www.oklink.com/xlayer/tx/",
+    primaryColor: "#000000",
+    nativeToken: {
+      symbol: "OKB",
+      decimals: 18
+    },
+    rpcUrls: getRpcUrls("xlayer")
+  },
+  plasma: {
+    chainName: "Plasma",
+    blockchain: "plasma",
+    chainIcon: "/chains/plasma.png",
+    chainIconGray: "/chains/plasma-gray.png",
+    chainType: chainTypes.evm.value,
+    chainId: 9745,
+    blockExplorerUrl: "https://plasmascan.to/tx/",
+    primaryColor: "#162F29",
+    nativeToken: {
+      symbol: "XPL",
+      decimals: 18
+    },
+    rpcUrls: getRpcUrls("plasma")
   }
 };
 var chains_default = chains;
@@ -4076,7 +4184,8 @@ var chains_default = chains;
 var usdt = {
   symbol: "USDT",
   decimals: 6,
-  icon: "/usdt.png"
+  icon: "/usdt.png",
+  name: "Tether USD"
 };
 var usdtChains = {
   eth: {
@@ -4134,7 +4243,7 @@ var usdtChains = {
     assetId: "nep141:sol-c800a4bd850783ccb82c2b2c7e84175443606352.omft.near",
     contractAddress: "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB",
     ...chains_default.sol,
-    services: [Service.OneClick]
+    services: [Service.OneClick, Service.Usdt0]
   },
   tron: {
     ...usdt,
@@ -4156,6 +4265,20 @@ var usdtChains = {
     contractAddress: "0x779Ded0c9e1022225f8E0630b35a9b54bE713736",
     ...chains_default.bera,
     services: [Service.OneClick, Service.Usdt0]
+  },
+  xlayer: {
+    ...usdt,
+    assetId: "nep245:v2_1.omni.hot.tg:196_2fezDCvVYRsG8wrK6deJ2VRPiAS1",
+    contractAddress: "0x779ded0c9e1022225f8e0630b35a9b54be713736",
+    ...chains_default.xlayer,
+    services: [Service.OneClick, Service.Usdt0]
+  },
+  plasma: {
+    ...usdt,
+    assetId: "nep245:v2_1.omni.hot.tg:9745_3aL9skCy1yhPoDB8oKMmRHRN7SJW",
+    contractAddress: "0xb8ce59fc3717ada4c02eadf9682a9e934f625ebb",
+    ...chains_default.plasma,
+    services: [Service.OneClick]
   }
 };
 
@@ -4163,7 +4286,8 @@ var usdtChains = {
 var usdc = {
   symbol: "USDC",
   decimals: 6,
-  icon: "/usdc.png"
+  icon: "/usdc.png",
+  name: "USD Coin"
 };
 var usdcChains = {
   eth: {
@@ -4229,6 +4353,13 @@ var usdcChains = {
     contractAddress: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
     ...chains_default.sol,
     services: [Service.OneClick, Service.CCTP]
+  },
+  xlayer: {
+    ...usdc,
+    assetId: "nep245:v2_1.omni.hot.tg:196_2dK9kLNR7Ekq7su8FxNGiUW3djTw",
+    contractAddress: "0x74b7f16337b8972027f6196a17a631ac6de26d22",
+    ...chains_default.xlayer,
+    services: [Service.OneClick]
   }
 };
 
@@ -4248,6 +4379,45 @@ var TransactionStatus = /* @__PURE__ */ ((TransactionStatus2) => {
   return TransactionStatus2;
 })(TransactionStatus || {});
 
+// src/utils/error.ts
+import Big2 from "big.js";
+var formatQuoteError = (error, options) => {
+  const { service, fromToken } = options;
+  const defaultErrorMessage = "Failed to get quote, please try again later";
+  if (service === Service.OneClick) {
+    const getQuoteErrorMessage = () => {
+      const _messageResult = {
+        message: defaultErrorMessage,
+        sourceMessage: error?.response?.data?.message || defaultErrorMessage
+      };
+      if (error?.response?.data?.message && error?.response?.data?.message !== "Internal server error") {
+        if (error?.response?.data?.message === "Failed to get quote") {
+          _messageResult.message = "Amount exceeds max";
+          return _messageResult;
+        }
+        if (error?.response?.data?.message?.includes("Amount is too low for bridge, try at least")) {
+          const match = error.response.data.message.match(/try at least\s+(\d+(?:\.\d+)?)/i);
+          let minimumAmount = match ? match[1] : Big2(1).times(10 ** fromToken.decimals).toFixed(0);
+          minimumAmount = Big2(minimumAmount).div(10 ** fromToken.decimals).toFixed(fromToken.decimals);
+          _messageResult.message = `Amount is too low, at least ${minimumAmount}`;
+          return _messageResult;
+        }
+        return _messageResult;
+      }
+      return _messageResult;
+    };
+    const onclickErrMsg = getQuoteErrorMessage();
+    return {
+      serviceType: service,
+      error: onclickErrMsg.message
+    };
+  }
+  return {
+    serviceType: service,
+    error: error?.message || defaultErrorMessage
+  };
+};
+
 // src/services/SFA.ts
 var submitOneclickDepositTx = (requestBody) => {
   return request(OpenAPI, {
@@ -4352,10 +4522,10 @@ var SFA = class {
   static async getAllQuote(params) {
     const results = [];
     let { minInputAmount = "1" } = params;
-    if (Big2(minInputAmount).lte(0)) {
+    if (Big3(minInputAmount).lte(0)) {
       minInputAmount = "1";
     }
-    if (!params.fromToken || !params.fromToken.contractAddress || !params.toToken || !params.toToken.contractAddress || !params.refundTo || !params.recipient || !params.amountWei || Big2(params.amountWei).lte(minInputAmount)) {
+    if (!params.fromToken || !params.fromToken.contractAddress || !params.toToken || !params.toToken.contractAddress || !params.refundTo || !params.recipient || !params.amountWei || Big3(params.amountWei).lte(minInputAmount)) {
       throw new Error("Invalid parameters");
     }
     const formatQuoteParams = (service) => {
@@ -4376,6 +4546,9 @@ var SFA = class {
         _params.destinationAsset = params.toToken.assetId;
         _params.amount = params.amountWei;
         _params.refundType = "ORIGIN_CHAIN";
+        _params.appFees = params.oneclickParams?.appFees;
+        _params.swapType = params.oneclickParams?.swapType;
+        _params.isProxy = params.oneclickParams?.isProxy;
       }
       if (service === Service.Usdt0) {
         _params.originChain = params.fromToken.chainName;
@@ -4404,42 +4577,6 @@ var SFA = class {
         });
       }
     }
-    const formatQuoteError = (service, error) => {
-      const defaultErrorMessage = "Failed to get quote, please try again later";
-      if (service === Service.OneClick) {
-        const getQuoteErrorMessage = () => {
-          const _messageResult = {
-            message: defaultErrorMessage,
-            sourceMessage: error?.response?.data?.message || defaultErrorMessage
-          };
-          if (error?.response?.data?.message && error?.response?.data?.message !== "Internal server error") {
-            if (error?.response?.data?.message === "Failed to get quote") {
-              _messageResult.message = "Amount exceeds max";
-              return _messageResult;
-            }
-            if (error?.response?.data?.message?.includes("Amount is too low for bridge, try at least")) {
-              const match = error.response.data.message.match(/try at least\s+(\d+(?:\.\d+)?)/i);
-              let minimumAmount = match ? match[1] : Big2(1).times(10 ** fromToken.decimals).toFixed(0);
-              minimumAmount = Big2(minimumAmount).div(10 ** fromToken.decimals).toFixed(fromToken.decimals);
-              _messageResult.message = `Amount is too low, at least ${minimumAmount}`;
-              return _messageResult;
-            }
-            return _messageResult;
-          }
-          return _messageResult;
-        };
-        const onclickErrMsg = getQuoteErrorMessage();
-        results.push({
-          serviceType: service,
-          error: onclickErrMsg.message
-        });
-      } else {
-        results.push({
-          serviceType: service,
-          error: error?.message || defaultErrorMessage
-        });
-      }
-    };
     if (params.singleService) {
       const quoteService = quoteServices.find((service) => service.service === params.singleService);
       if (quoteService) {
@@ -4450,7 +4587,8 @@ var SFA = class {
             quote: quoteRes
           });
         } catch (error) {
-          formatQuoteError(quoteService.service, error);
+          const _err = formatQuoteError(error, { service: quoteService.service, fromToken });
+          results.push(_err);
         }
       }
       return results;
@@ -4466,7 +4604,8 @@ var SFA = class {
           });
         } catch (error) {
           console.log("%s quote failed: %o", quoteService.service, error);
-          formatQuoteError(quoteService.service, error);
+          const _err = formatQuoteError(error, { service: quoteService.service, fromToken });
+          results.push(_err);
         }
       })();
       promises.push(promise);
@@ -4521,7 +4660,7 @@ var SFA = class {
         project: projectMap[serviceType],
         address: params.quote?.quoteParam?.refundTo,
         receive_address: params.quote?.quoteParam?.recipient,
-        amount: Big2(params.quote?.quoteParam?.amountWei || 0).div(10 ** (params.quote?.fromToken?.decimals || 6)).toFixed(params.quote?.fromToken?.decimals || 6, 0)
+        amount: Big3(params.quote?.quoteParam?.amountWei || 0).div(10 ** (params.quote?.fromToken?.decimals || 6)).toFixed(params.quote?.fromToken?.decimals || 6, 0)
       };
       if (serviceType === Service.OneClick) {
         reportParams.deposit_address = params.quote?.quote?.depositAddress;
@@ -4608,13 +4747,184 @@ var SFA = class {
  */
 SFA.submitDepositTx = submitOneclickDepositTx;
 
+// src/services/Hyperliquid.ts
+import { ethers } from "ethers";
+import Big4 from "big.js";
+var SPENDER = "0x2df1c51e09aecf9cacb7bc98cb1742757f163df7";
+var DESTINATION_TOKEN = usdcChains["arb"];
+var MIN_AMOUNT = Big4(5).times(10 ** DESTINATION_TOKEN.decimals).toFixed(0);
+var HyperliquidService = class {
+  async quote(params) {
+    const result = { quote: null, error: null };
+    if (Big4(params.amountWei || 0).lt(MIN_AMOUNT)) {
+      result.error = `Amount is too low, at least ${MIN_AMOUNT}`;
+      return result;
+    }
+    const quoteParams = {
+      ...params,
+      dry: params.dry ?? true,
+      slippageTolerance: params.slippageTolerance * 100,
+      originAsset: params.fromToken.assetId,
+      toToken: DESTINATION_TOKEN,
+      destinationAsset: DESTINATION_TOKEN.assetId,
+      amount: params.amountWei,
+      refundType: "ORIGIN_CHAIN",
+      appFees: params.oneclickParams?.appFees,
+      swapType: "EXACT_OUTPUT",
+      isProxy: false
+    };
+    try {
+      const quoteRes = await ServiceMap[Service.OneClick].quote(quoteParams);
+      result.quote = quoteRes;
+    } catch (error) {
+      const _err = formatQuoteError(error, { service: Service.OneClick, fromToken: params.fromToken });
+      result.error = _err.error;
+    }
+    return result;
+  }
+  async transfer(params) {
+    const {
+      quote,
+      wallet
+    } = params;
+    const sendParams = {
+      wallet,
+      sendParam: quote?.sendParam,
+      fromToken: quote?.quoteParam.fromToken,
+      depositAddress: quote?.quote?.depositAddress,
+      amountWei: quote?.quote?.amountIn
+    };
+    const txhash = await ServiceMap[Service.OneClick].send(sendParams);
+    return txhash;
+  }
+  async deposit(params) {
+    const {
+      evmWallet,
+      evmWalletAddress,
+      quote,
+      txhash
+    } = params;
+    const permitParams = await this.generatePermit({
+      address: evmWalletAddress,
+      evmWallet,
+      amountWei: quote?.quote?.amountOut
+    });
+    const depositParams = {
+      deposit_address: quote?.quote?.depositAddress,
+      from_addr: quote?.quoteParam?.refundTo,
+      from_amount: quote?.quote?.amountIn,
+      from_chain: quote?.quoteParam?.fromToken?.blockchain,
+      from_hash: txhash,
+      from_token: quote?.quoteParam?.fromToken?.contractAddress,
+      sender: quote?.quoteParam?.recipient,
+      to_amount: quote?.quote?.amountOut,
+      to_chain: quote?.quoteParam?.toToken?.blockchain,
+      to_token: quote?.quoteParam?.toToken?.contractAddress,
+      type: Service.OneClick,
+      permit: permitParams
+    };
+    const depositRes = await request(OpenAPI, {
+      method: "POST",
+      url: "/v0/deposit",
+      body: depositParams,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request - Invalid input data`,
+        401: `Unauthorized - JWT token is invalid`
+      }
+    });
+    return depositRes;
+  }
+  async getStatus(params) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/v0/deposit",
+      query: {
+        depositId: params.depositId
+      },
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request - Invalid input data`,
+        401: `Unauthorized - JWT token is invalid`
+      }
+    });
+  }
+  async generatePermit(params) {
+    const {
+      address,
+      evmWallet,
+      amountWei
+    } = params;
+    const tokenAddress = DESTINATION_TOKEN.contractAddress;
+    const name = DESTINATION_TOKEN.name;
+    const chainId = DESTINATION_TOKEN.chainId;
+    const provider = new ethers.JsonRpcProvider(getRpcUrls("arb")[0]);
+    const erc20 = new ethers.Contract(
+      tokenAddress,
+      [
+        "function name() view returns (string)",
+        "function nonces(address) view returns (uint256)",
+        "function decimals() view returns (uint8)"
+      ],
+      provider
+    );
+    const deadline = Math.floor(Date.now() / 1e3) + 86400;
+    const nonce = await erc20.nonces(address);
+    const value = amountWei;
+    const domain = {
+      name,
+      version: "2",
+      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: address,
+      spender: SPENDER,
+      value,
+      nonce: nonce.toString(),
+      deadline
+    };
+    const signature = await evmWallet.signTypedData({
+      domain,
+      types,
+      values
+    });
+    const { v, r, s } = ethers.Signature.from(signature);
+    const permitParams = {
+      amount: value,
+      deadline,
+      owner: address,
+      r,
+      s,
+      spender: SPENDER,
+      token: tokenAddress,
+      v,
+      nonce: Number(nonce)
+    };
+    return permitParams;
+  }
+};
+var Hyperliquid = new HyperliquidService();
+var HyperliquidFromTokens = tokens.filter((token) => !(token.chainName === "Arbitrum" && token.symbol === "USDC"));
+var HyperliuquidToToken = DESTINATION_TOKEN;
+var HyperliuquidMinAmount = MIN_AMOUNT;
+
 // src/wallets/near.ts
 import { Buffer as Buffer2 } from "buffer";
-import Big3 from "big.js";
+import Big5 from "big.js";
 var NearWallet = class {
   constructor(_selector) {
     this.selector = _selector;
-    this.rpcUrl = chainsRpcUrls["Near"];
+    this.rpcUrl = getRpcUrls("near")[0];
   }
   async query(contractId, methodName, args = {}) {
     const response = await fetch(this.rpcUrl, {
@@ -4901,10 +5211,10 @@ var NearWallet = class {
       totalGasLimit = totalGasLimit * 120n / 100n;
       const gasPrice = BigInt("100000000");
       const estimateGas = totalGasLimit * gasPrice;
-      const estimateGasUsd = Big3(estimateGas.toString()).div(10 ** fromToken.nativeToken.decimals).times(getPrice(prices, fromToken.nativeToken.symbol));
-      result.fees.sourceGasFeeUsd = numberRemoveEndZero(Big3(estimateGasUsd).toFixed(20));
+      const estimateGasUsd = Big5(estimateGas.toString()).div(10 ** fromToken.nativeToken.decimals).times(getPrice(prices, fromToken.nativeToken.symbol));
+      result.fees.sourceGasFeeUsd = numberRemoveEndZero(Big5(estimateGasUsd).toFixed(20));
       result.estimateSourceGas = estimateGas.toString();
-      result.estimateSourceGasUsd = numberRemoveEndZero(Big3(estimateGasUsd).toFixed(20));
+      result.estimateSourceGasUsd = numberRemoveEndZero(Big5(estimateGasUsd).toFixed(20));
       result.sendParam = {
         transactions,
         callbackUrl: "/"
@@ -4914,10 +5224,10 @@ var NearWallet = class {
       const defaultGasLimit = BigInt("80000000000000");
       const gasPrice = BigInt("100000000");
       const estimateGas = defaultGasLimit * gasPrice;
-      const estimateGasUsd = Big3(estimateGas.toString()).div(10 ** fromToken.nativeToken.decimals).times(getPrice(prices, fromToken.nativeToken.symbol));
-      result.fees.sourceGasFeeUsd = numberRemoveEndZero(Big3(estimateGasUsd).toFixed(20));
+      const estimateGasUsd = Big5(estimateGas.toString()).div(10 ** fromToken.nativeToken.decimals).times(getPrice(prices, fromToken.nativeToken.symbol));
+      result.fees.sourceGasFeeUsd = numberRemoveEndZero(Big5(estimateGasUsd).toFixed(20));
       result.estimateSourceGas = estimateGas.toString();
-      result.estimateSourceGasUsd = numberRemoveEndZero(Big3(estimateGasUsd).toFixed(20));
+      result.estimateSourceGasUsd = numberRemoveEndZero(Big5(estimateGasUsd).toFixed(20));
     }
     return result;
   }
@@ -4968,12 +5278,14 @@ var NearWallet = class {
 
 // src/wallets/solana.ts
 import {
-  Connection,
-  PublicKey,
+  Connection as Connection2,
+  PublicKey as PublicKey2,
   Transaction,
   VersionedTransaction,
   SystemProgram,
-  LAMPORTS_PER_SOL
+  LAMPORTS_PER_SOL,
+  TransactionInstruction,
+  ComputeBudgetProgram
 } from "@solana/web3.js";
 import {
   getAssociatedTokenAddress,
@@ -4984,7 +5296,7 @@ import {
   getAssociatedTokenAddressSync
 } from "@solana/spl-token";
 import { AnchorProvider, BN, Program } from "@coral-xyz/anchor";
-import Big4 from "big.js";
+import Big6 from "big.js";
 
 // src/bridges/oneclick/stableflow-proxy.json
 var stableflow_proxy_default = {
@@ -5284,9 +5596,109 @@ var stableflow_proxy_default = {
 };
 
 // src/wallets/solana.ts
+import { ethers as ethers3 } from "ethers";
+import { addressToBytes32, Options } from "@layerzerolabs/lz-v2-utilities";
+
+// src/bridges/usdt0/hop-composer.ts
+import { ethers as ethers2 } from "ethers";
+var getHopMsgFee = async (params) => {
+  const {
+    sendParam,
+    toToken
+  } = params;
+  const originLayerzero = USDT0_CONFIG["Arbitrum"];
+  const destinationLayerzero = USDT0_CONFIG[toToken.chainName];
+  let arbitrumOft = originLayerzero.oft;
+  let destinationLayerzeroAddress = destinationLayerzero.oft || destinationLayerzero.oftLegacy;
+  const isDestinationLegacy = destinationLayerzeroAddress === destinationLayerzero.oftLegacy;
+  if (isDestinationLegacy) {
+    arbitrumOft = originLayerzero.oftLegacy || originLayerzero.oft;
+  }
+  const provider = new ethers2.JsonRpcProvider(getRpcUrls("arb")[0]);
+  const oftContractRead = new ethers2.Contract(arbitrumOft, OFT_ABI, provider);
+  try {
+    const msgFee = await oftContractRead.quoteSend.staticCall(sendParam, false);
+    const [nativeFee] = msgFee;
+    return nativeFee * 120n / 100n;
+  } catch (error) {
+    console.log("getHopMsgFee failed: %o", error);
+    throw new Error("Quote multi hop message fee failed");
+  }
+};
+
+// src/wallets/utils/layerzero.ts
+import {
+  PublicKey
+} from "@solana/web3.js";
+import { struct, u32, u64, bytes, option, bool } from "@metaplex-foundation/umi/serializers";
+var SEEDS = {
+  OFT: Buffer.from("OFT"),
+  PEER: Buffer.from("Peer"),
+  CREDITS: Buffer.from("Credits"),
+  EVENT_AUTHORITY: Buffer.from("__event_authority")
+};
+var DISCRIMINATOR = {
+  quoteSend: new Uint8Array([207, 0, 49, 214, 160, 211, 76, 211]),
+  send: new Uint8Array([102, 251, 20, 187, 65, 75, 12, 69])
+};
+function u32be(n) {
+  const buf = Buffer.alloc(4);
+  buf.writeUInt32BE(n, 0);
+  return buf;
+}
+function deriveOftPdas(programId, dstEid) {
+  return {
+    oftStore: PublicKey.findProgramAddressSync([SEEDS.OFT], programId)[0],
+    peer: PublicKey.findProgramAddressSync([SEEDS.PEER, u32be(dstEid)], programId)[0],
+    credits: PublicKey.findProgramAddressSync([SEEDS.CREDITS], programId)[0],
+    eventAuthority: PublicKey.findProgramAddressSync([SEEDS.EVENT_AUTHORITY], programId)[0]
+  };
+}
+async function getPeerAddress(connection, programId, dstEid) {
+  const { peer } = deriveOftPdas(programId, dstEid);
+  const info = await connection.getAccountInfo(peer);
+  if (!info) throw new Error(`Peer not found for EID ${dstEid}`);
+  return `0x${info.data.subarray(8, 40).toString("hex")}`;
+}
+var quoteSendParamsSerializer = struct([
+  ["dstEid", u32()],
+  ["to", bytes({ size: 32 })],
+  ["amountLd", u64()],
+  ["minAmountLd", u64()],
+  ["extraOptions", bytes({ size: u32() })],
+  ["composeMsg", option(bytes({ size: u32() }))],
+  ["payInLzToken", bool()]
+]);
+function encodeQuoteSend(params) {
+  const paramsData = quoteSendParamsSerializer.serialize(params);
+  const data = new Uint8Array(8 + paramsData.length);
+  data.set(DISCRIMINATOR.quoteSend, 0);
+  data.set(paramsData, 8);
+  return data;
+}
+var sendParamsSerializer = struct([
+  ["dstEid", u32()],
+  ["to", bytes({ size: 32 })],
+  ["amountLd", u64()],
+  ["minAmountLd", u64()],
+  ["extraOptions", bytes({ size: u32() })],
+  ["composeMsg", option(bytes({ size: u32() }))],
+  ["nativeFee", u64()],
+  ["lzTokenFee", u64()]
+]);
+function encodeSend(params) {
+  const paramsData = sendParamsSerializer.serialize(params);
+  const data = new Uint8Array(8 + paramsData.length);
+  data.set(DISCRIMINATOR.send, 0);
+  data.set(paramsData, 8);
+  return data;
+}
+
+// src/wallets/solana.ts
+import { buildVersionedTransaction, SendHelper } from "@layerzerolabs/lz-solana-sdk-v2";
 var SolanaWallet = class {
   constructor(options) {
-    this.connection = new Connection(chainsRpcUrls["Solana"], "confirmed");
+    this.connection = new Connection2(getRpcUrls("sol")[0], "confirmed");
     this.publicKey = options.publicKey;
     this.signTransaction = options.signer.signTransaction;
     this.signer = options.signer;
@@ -5297,7 +5709,7 @@ var SolanaWallet = class {
       throw new Error("Wallet not connected");
     }
     const fromPubkey = this.publicKey;
-    const toPubkey = new PublicKey(to);
+    const toPubkey = new PublicKey2(to);
     const lamports = Math.floor(parseFloat(amount) * LAMPORTS_PER_SOL);
     const transaction = new Transaction().add(
       SystemProgram.transfer({
@@ -5322,8 +5734,8 @@ var SolanaWallet = class {
       throw new Error("Wallet not connected");
     }
     const fromPubkey = this.publicKey;
-    const toPubkey = new PublicKey(to);
-    const mint = new PublicKey(tokenMint);
+    const toPubkey = new PublicKey2(to);
+    const mint = new PublicKey2(tokenMint);
     const fromTokenAccount = getAssociatedTokenAddressSync(mint, fromPubkey);
     const toTokenAccount = getAssociatedTokenAddressSync(mint, toPubkey);
     const transaction = new Transaction();
@@ -5377,13 +5789,13 @@ var SolanaWallet = class {
     return result;
   }
   async getSOLBalance(account) {
-    const publicKey = new PublicKey(account);
+    const publicKey = new PublicKey2(account);
     const balance = await this.connection.getBalance(publicKey);
     return balance;
   }
   async getTokenBalance(tokenMint, account) {
-    const mint = new PublicKey(tokenMint);
-    const owner = new PublicKey(account);
+    const mint = new PublicKey2(tokenMint);
+    const owner = new PublicKey2(account);
     try {
       const tokenAccount = await getAssociatedTokenAddress(mint, owner);
       const accountInfo = await getAccount(this.connection, tokenAccount);
@@ -5416,8 +5828,8 @@ var SolanaWallet = class {
     let estimatedFee = 5000n;
     const { originAsset, depositAddress } = data;
     if (originAsset !== "SOL" && originAsset !== "sol") {
-      const mint = new PublicKey(originAsset);
-      const toPubkey = new PublicKey(depositAddress);
+      const mint = new PublicKey2(originAsset);
+      const toPubkey = new PublicKey2(depositAddress);
       const toTokenAccount = getAssociatedTokenAddressSync(mint, toPubkey);
       try {
         await getAccount(this.connection, toTokenAccount);
@@ -5518,6 +5930,8 @@ var SolanaWallet = class {
         return await this.quoteCCTP(params);
       case Service.OneClick:
         return await this.quoteOneClickProxy(params);
+      case Service.Usdt0:
+        return await this.quoteOFT(params);
       default:
         throw new Error(`Unsupported quote type: ${type}`);
     }
@@ -5548,13 +5962,13 @@ var SolanaWallet = class {
     } = params;
     try {
       const result = { fees: {} };
-      const PROGRAM_ID = new PublicKey(proxyAddress);
-      const STATE_PDA = new PublicKey("9E8az3Y9sdXvM2f3CCH6c9N3iFyNfDryQCZhqDxRYGUw");
-      const MINT = new PublicKey(fromToken.contractAddress);
+      const PROGRAM_ID = new PublicKey2(proxyAddress);
+      const STATE_PDA = new PublicKey2("9E8az3Y9sdXvM2f3CCH6c9N3iFyNfDryQCZhqDxRYGUw");
+      const MINT = new PublicKey2(fromToken.contractAddress);
       const AMOUNT = new BN(amountWei);
-      const RECIPIENT = new PublicKey(depositAddress);
+      const RECIPIENT = new PublicKey2(depositAddress);
       const sender = this.publicKey;
-      const userPubkey = new PublicKey(refundTo || sender.toString());
+      const userPubkey = new PublicKey2(refundTo || sender.toString());
       const provider = new AnchorProvider(this.connection, this.signer, {
         commitment: "confirmed"
       });
@@ -5601,7 +6015,7 @@ var SolanaWallet = class {
         transaction
       };
       const estimatedFee = simulation.value.fee || 5000n;
-      const estimateGasUsd = Big4(estimatedFee.toString()).div(10 ** fromToken.nativeToken.decimals).times(getPrice(prices, fromToken.nativeToken.symbol));
+      const estimateGasUsd = Big6(estimatedFee.toString()).div(10 ** fromToken.nativeToken.decimals).times(getPrice(prices, fromToken.nativeToken.symbol));
       const usd = numberRemoveEndZero(estimateGasUsd.toFixed(20));
       const wei = estimatedFee;
       result.fees.sourceGasFeeUsd = usd;
@@ -5641,13 +6055,13 @@ var SolanaWallet = class {
         estimateSourceGas: void 0,
         estimateSourceGasUsd: void 0,
         estimateTime: 0,
-        outputAmount: numberRemoveEndZero(Big4(amountWei || 0).div(10 ** fromToken.decimals).toFixed(fromToken.decimals, 0))
+        outputAmount: numberRemoveEndZero(Big6(amountWei || 0).div(10 ** fromToken.decimals).toFixed(fromToken.decimals, 0))
       };
-      const PROGRAM_ID = new PublicKey(proxyAddress);
-      const MINT = new PublicKey(fromToken.contractAddress);
+      const PROGRAM_ID = new PublicKey2(proxyAddress);
+      const MINT = new PublicKey2(fromToken.contractAddress);
       const sender = this.publicKey;
-      const userPubkey = new PublicKey(refundTo || sender.toString());
-      const [userStatePda] = PublicKey.findProgramAddressSync(
+      const userPubkey = new PublicKey2(refundTo || sender.toString());
+      const [userStatePda] = PublicKey2.findProgramAddressSync(
         [Buffer.from("user"), userPubkey.toBuffer()],
         PROGRAM_ID
       );
@@ -5664,7 +6078,7 @@ var SolanaWallet = class {
       const userTokenAccount = getAssociatedTokenAddressSync(MINT, userPubkey);
       const signatureRes = await cctp_default.quoteSignature({
         address: userPubkey.toString(),
-        amount: numberRemoveEndZero(Big4(amountWei || 0).div(10 ** fromToken.decimals).toFixed(fromToken.decimals, 0)),
+        amount: numberRemoveEndZero(Big6(amountWei || 0).div(10 ** fromToken.decimals).toFixed(fromToken.decimals, 0)),
         destination_domain_id: destinationDomain,
         receipt_address: recipient,
         source_domain_id: sourceDomain,
@@ -5678,13 +6092,13 @@ var SolanaWallet = class {
         signature
       } = signatureRes;
       result.fees.estimateMintGasUsd = numberRemoveEndZero(
-        Big4(mint_fee || 0).div(10 ** fromToken.decimals).toFixed(fromToken.decimals)
+        Big6(mint_fee || 0).div(10 ** fromToken.decimals).toFixed(fromToken.decimals)
       );
       result.fees.bridgeFeeUsd = numberRemoveEndZero(
-        Big4(bridge_fee || 0).div(10 ** fromToken.decimals).toFixed(fromToken.decimals)
+        Big6(bridge_fee || 0).div(10 ** fromToken.decimals).toFixed(fromToken.decimals)
       );
       result.outputAmount = numberRemoveEndZero(
-        Big4(receipt_amount || 0).div(10 ** fromToken.decimals).toFixed(fromToken.decimals, 0)
+        Big6(receipt_amount || 0).div(10 ** fromToken.decimals).toFixed(fromToken.decimals, 0)
       );
       const operatorTx = Transaction.from(Buffer.from(signature, "base64"));
       if (!operatorTx.verifySignatures(false)) {
@@ -5697,7 +6111,7 @@ var SolanaWallet = class {
         sigVerify: false
       });
       const estimatedFee = simulation.value.fee || 5000n;
-      const estimateGasUsd = Big4(estimatedFee.toString()).div(10 ** fromToken.nativeToken.decimals).times(getPrice(prices, fromToken.nativeToken.symbol));
+      const estimateGasUsd = Big6(estimatedFee.toString()).div(10 ** fromToken.nativeToken.decimals).times(getPrice(prices, fromToken.nativeToken.symbol));
       result.fees.estimateDepositGasUsd = numberRemoveEndZero(estimateGasUsd.toFixed(20));
       result.estimateSourceGas = estimatedFee;
       result.estimateSourceGasUsd = numberRemoveEndZero(estimateGasUsd.toFixed(20));
@@ -5708,15 +6122,249 @@ var SolanaWallet = class {
         if (excludeFees4 && excludeFees4.includes(feeKey) || !/Usd$/.test(feeKey)) {
           continue;
         }
-        result.totalFeesUsd = Big4(result.totalFeesUsd || 0).plus(result.fees[feeKey] || 0);
+        result.totalFeesUsd = Big6(result.totalFeesUsd || 0).plus(result.fees[feeKey] || 0);
       }
-      result.totalFeesUsd = numberRemoveEndZero(Big4(result.totalFeesUsd || 0).toFixed(20));
+      result.totalFeesUsd = numberRemoveEndZero(Big6(result.totalFeesUsd || 0).toFixed(20));
       return result;
     } catch (error) {
       console.log("quoteCCTP failed: %o", error);
       return { errMsg: error.message };
     }
   }
+  async quoteOFT(params) {
+    const {
+      originLayerzeroAddress,
+      destinationLayerzeroAddress,
+      fromToken,
+      toToken,
+      dstEid,
+      refundTo,
+      recipient,
+      amountWei,
+      payInLzToken,
+      slippageTolerance,
+      multiHopComposer,
+      isMultiHopComposer,
+      isOriginLegacy,
+      prices,
+      excludeFees: excludeFees4,
+      originLayerzero
+    } = params;
+    try {
+      const result = {
+        needApprove: false,
+        sendParam: void 0,
+        fees: {},
+        estimateSourceGas: void 0,
+        estimateSourceGasUsd: void 0,
+        outputAmount: numberRemoveEndZero(Big6(amountWei || 0).div(10 ** fromToken.decimals).toFixed(fromToken.decimals, 0)),
+        quoteParam: {
+          ...params
+        },
+        totalFeesUsd: void 0,
+        estimateTime: 0
+      };
+      const programId = new PublicKey2(originLayerzeroAddress);
+      const tokenMint = new PublicKey2(fromToken.contractAddress);
+      const quotePayer = new PublicKey2("4NkxtcfRTCxJ1N2j6xENcDLPbiJ3541T6r5BqhTzMD9J");
+      const lookupTable = new PublicKey2("6zcTrmdkiQp6dZHYUxVr6A2XVDSYi44X1rcPtvwNcrXi");
+      const tokenEscrow = new PublicKey2("F1YkdxaiLA1eJt12y3uMAQef48Td3zdJfYhzjphma8hG");
+      const sender = this.publicKey;
+      const userPubkey = new PublicKey2(refundTo || sender.toString());
+      const mintInfo = await this.connection.getParsedAccountInfo(tokenMint);
+      const decimals = (mintInfo.value?.data).parsed.info.decimals;
+      const amountLd = BigInt(amountWei);
+      const slippage = slippageTolerance || 0.01;
+      const minAmountLd = BigInt(Big6(amountWei).times(Big6(1).minus(Big6(slippage).div(100))).toFixed(0));
+      const lzReceiveOptionGas = isOriginLegacy ? originLayerzero.lzReceiveOptionGasLegacy : originLayerzero.lzReceiveOptionGas;
+      const lzReceiveOptionValue = LZ_RECEIVE_VALUE[toToken.chainName] || 0;
+      let _dstEid = dstEid;
+      let to = new Uint8Array(Buffer.from(addressToBytes32(recipient)));
+      let extraOptions = Options.newOptions().addExecutorLzReceiveOption(lzReceiveOptionGas, lzReceiveOptionValue).toBytes();
+      let composeMsg = null;
+      if (isMultiHopComposer) {
+        _dstEid = multiHopComposer.eid;
+        to = new Uint8Array(Buffer.from(addressToBytes32(multiHopComposer.oftMultiHopComposer)));
+        const composeMsgSendParam = {
+          dstEid,
+          to: addressToBytes32(recipient),
+          amountLD: amountLd,
+          minAmountLD: minAmountLd,
+          extraOptions: Options.newOptions().addExecutorLzReceiveOption(lzReceiveOptionGas, lzReceiveOptionValue).toHex(),
+          composeMsg: "0x",
+          oftCmd: "0x"
+        };
+        const hopMsgFee = await getHopMsgFee({
+          sendParam: composeMsgSendParam,
+          toToken
+        });
+        extraOptions = Options.newOptions().addExecutorLzReceiveOption(lzReceiveOptionGas, lzReceiveOptionValue).addExecutorComposeOption(0, originLayerzero.composeOptionGas || 5e5, hopMsgFee).toBytes();
+        const abiCoder = ethers3.AbiCoder.defaultAbiCoder();
+        const composeEncoder = abiCoder.encode(
+          ["tuple(uint32 dstEid, bytes32 to, uint256 amountLD, uint256 minAmountLD, bytes extraOptions, bytes composeMsg, bytes oftCmd)"],
+          [Object.values(composeMsgSendParam)]
+        );
+        composeMsg = ethers3.getBytes(composeEncoder);
+      }
+      const pdas = deriveOftPdas(programId, _dstEid);
+      const peerAddress = await getPeerAddress(this.connection, programId, _dstEid);
+      const tokenSource = await getAssociatedTokenAddress(
+        tokenMint,
+        userPubkey,
+        false,
+        TOKEN_PROGRAM_ID
+      );
+      const sendHelper = new SendHelper();
+      const remainingAccounts = await sendHelper.getQuoteAccounts(
+        this.connection,
+        quotePayer,
+        pdas.oftStore,
+        _dstEid,
+        peerAddress
+      );
+      const ix = new TransactionInstruction({
+        programId,
+        keys: [
+          { pubkey: pdas.oftStore, isSigner: false, isWritable: false },
+          { pubkey: pdas.credits, isSigner: false, isWritable: false },
+          { pubkey: pdas.peer, isSigner: false, isWritable: false },
+          ...remainingAccounts
+        ],
+        data: Buffer.from(
+          encodeQuoteSend({
+            dstEid: _dstEid,
+            to,
+            amountLd,
+            minAmountLd,
+            extraOptions,
+            composeMsg,
+            payInLzToken: false
+          })
+        )
+      });
+      const computeIx = ComputeBudgetProgram.setComputeUnitLimit({ units: 14e5 });
+      const tx = await buildVersionedTransaction(
+        this.connection,
+        quotePayer,
+        [computeIx, ix],
+        void 0,
+        void 0,
+        lookupTable
+      );
+      const sim = await this.connection.simulateTransaction(tx, {
+        sigVerify: false,
+        replaceRecentBlockhash: true
+      });
+      if (sim.value.err) {
+        console.error("Simulation logs:", sim.value.logs);
+        throw new Error(`Quote failed: ${JSON.stringify(sim.value.err)}`);
+      }
+      const prefix = `Program return: ${programId} `;
+      const log = sim.value.logs?.find((l) => l.startsWith(prefix));
+      if (!log) throw new Error("Return data not found");
+      const data = Buffer.from(log.slice(prefix.length), "base64");
+      const nativeFee = data.readBigUInt64LE(0);
+      const lzTokenFee = data.readBigUInt64LE(8);
+      if (prices && fromToken.nativeToken) {
+        const nativeFeeUsd = Big6(nativeFee.toString()).div(10 ** fromToken.nativeToken.decimals).times(getPrice(prices, fromToken.nativeToken.symbol));
+        result.fees.nativeFeeUsd = numberRemoveEndZero(nativeFeeUsd.toFixed(20));
+      }
+      result.fees.nativeFee = Big6(nativeFee.toString()).div(10 ** fromToken.nativeToken.decimals).toFixed(fromToken.nativeToken.decimals, 0);
+      if (lzTokenFee > 0n && prices && fromToken) {
+        const lzTokenFeeUsd = Big6(lzTokenFee.toString()).div(10 ** fromToken.decimals).times(getPrice(prices, fromToken.symbol));
+        result.fees.lzTokenFeeUsd = numberRemoveEndZero(lzTokenFeeUsd.toFixed(20));
+      }
+      result.fees.lzTokenFee = lzTokenFee.toString();
+      const sendSendHelper = new SendHelper();
+      const sendRemainingAccounts = await sendSendHelper.getSendAccounts(
+        this.connection,
+        userPubkey,
+        pdas.oftStore,
+        _dstEid,
+        peerAddress
+      );
+      const sendIx = new TransactionInstruction({
+        programId,
+        keys: [
+          { pubkey: userPubkey, isSigner: true, isWritable: true },
+          { pubkey: pdas.peer, isSigner: false, isWritable: false },
+          { pubkey: pdas.oftStore, isSigner: false, isWritable: true },
+          { pubkey: pdas.credits, isSigner: false, isWritable: true },
+          { pubkey: tokenSource, isSigner: false, isWritable: true },
+          { pubkey: tokenEscrow, isSigner: false, isWritable: true },
+          { pubkey: tokenMint, isSigner: false, isWritable: false },
+          { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+          { pubkey: pdas.eventAuthority, isSigner: false, isWritable: false },
+          { pubkey: programId, isSigner: false, isWritable: false },
+          ...sendRemainingAccounts
+        ],
+        data: Buffer.from(
+          encodeSend({
+            dstEid: _dstEid,
+            to,
+            amountLd,
+            minAmountLd,
+            extraOptions,
+            composeMsg,
+            nativeFee,
+            lzTokenFee: 0n
+          })
+        )
+      });
+      const computeSendIx = ComputeBudgetProgram.setComputeUnitLimit({ units: 4e5 });
+      const sendTx = await buildVersionedTransaction(
+        this.connection,
+        userPubkey,
+        [computeSendIx, sendIx],
+        void 0,
+        void 0,
+        lookupTable
+      );
+      let estimatedFee = 5000n;
+      try {
+        const sendSim = await this.connection.simulateTransaction(sendTx, {
+          sigVerify: false,
+          replaceRecentBlockhash: true
+        });
+        console.log("sendSim: %o", JSON.stringify(sendSim));
+        if (!sendSim.value.err) {
+          estimatedFee = sendSim.value.fee || 5000n;
+        } else {
+          console.warn("Send simulation failed (this is normal in quote phase):", sendSim.value.err);
+          const fee = sendSim.value.fee;
+          if (fee) {
+            estimatedFee = fee;
+          }
+        }
+      } catch (simError) {
+        console.warn("Send simulation error (this is normal in quote phase):", simError.message);
+      }
+      if (prices && fromToken.nativeToken) {
+        const estimateGasUsd = Big6(estimatedFee.toString()).div(10 ** fromToken.nativeToken.decimals).times(getPrice(prices, fromToken.nativeToken.symbol));
+        result.fees.estimateSourceGasUsd = numberRemoveEndZero(estimateGasUsd.toFixed(20));
+        result.estimateSourceGasUsd = numberRemoveEndZero(estimateGasUsd.toFixed(20));
+      }
+      result.estimateSourceGas = estimatedFee;
+      result.fees.legacyMeshFeeUsd = numberRemoveEndZero(Big6(amountWei || 0).div(10 ** params.fromToken.decimals).times(USDT0_LEGACY_MESH_TRANSFTER_FEE).toFixed(params.fromToken.decimals));
+      result.outputAmount = numberRemoveEndZero(Big6(Big6(amountWei || 0).div(10 ** params.fromToken.decimals)).minus(result.fees.legacyMeshFeeUsd || 0).toFixed(params.fromToken.decimals, 0));
+      result.sendParam = {
+        transaction: sendTx
+      };
+      if (prices) {
+        for (const feeKey in result.fees) {
+          if (excludeFees4 && excludeFees4.includes(feeKey) || !/Usd$/.test(feeKey)) {
+            continue;
+          }
+          result.totalFeesUsd = Big6(result.totalFeesUsd || 0).plus(result.fees[feeKey] || 0);
+        }
+        result.totalFeesUsd = numberRemoveEndZero(Big6(result.totalFeesUsd || 0).toFixed(20));
+      }
+      return result;
+    } catch (error) {
+      console.log("quoteOFT failed: %o", error);
+      return { errMsg: error.message };
+    }
+  }
   async createAssociatedTokenAddress(params) {
     const {
       tokenMint
@@ -5725,7 +6373,7 @@ var SolanaWallet = class {
       throw new Error("Wallet not connected");
     }
     const ownerPubkey = this.publicKey;
-    const mint = new PublicKey(tokenMint);
+    const mint = new PublicKey2(tokenMint);
     const associatedTokenAccount = getAssociatedTokenAddressSync(mint, ownerPubkey);
     console.log("associatedTokenAccount: %o", associatedTokenAccount);
     const createTokenAccount = async () => {
@@ -5801,9 +6449,9 @@ var erc20_default = [
 ];
 
 // src/wallets/evm.ts
-import Big5 from "big.js";
-import { ethers } from "ethers";
-import { Options } from "@layerzerolabs/lz-v2-utilities";
+import Big7 from "big.js";
+import { ethers as ethers4 } from "ethers";
+import { Options as Options2 } from "@layerzerolabs/lz-v2-utilities";
 
 // src/utils/address.ts
 import bs58 from "bs58";
@@ -5833,7 +6481,7 @@ function solanaAddressToBytes32(solanaAddress) {
   }
   return "0x" + Buffer.from(decoded).toString("hex");
 }
-function addressToBytes32(chainType, address) {
+function addressToBytes322(chainType, address) {
   if (chainType === "evm") {
     return zeroPadValue(address, 32);
   }
@@ -5845,9 +6493,40 @@ function addressToBytes32(chainType, address) {
   }
 }
 
-// src/wallets/evm.ts
-import { Connection as Connection2, PublicKey as PublicKey2 } from "@solana/web3.js";
+// src/wallets/utils/solana.ts
 import { getAssociatedTokenAddressSync as getAssociatedTokenAddressSync2 } from "@solana/spl-token";
+import { Connection as Connection3, PublicKey as PublicKey3 } from "@solana/web3.js";
+var getDestinationAssociatedTokenAddress = async (params) => {
+  const {
+    recipient,
+    toToken
+  } = params;
+  const result = {
+    needCreateTokenAccount: false,
+    associatedTokenAddress: ""
+  };
+  if (toToken.chainType !== "sol") {
+    return result;
+  }
+  try {
+    const connection = new Connection3(getRpcUrls("sol")[0]);
+    const wallet = new PublicKey3(recipient);
+    const TOKEN_MINT = new PublicKey3(toToken.contractAddress);
+    const ata = getAssociatedTokenAddressSync2(TOKEN_MINT, wallet);
+    const accountInfo = await connection.getAccountInfo(ata);
+    console.log("accountInfo: %o", accountInfo);
+    if (!accountInfo) {
+      result.needCreateTokenAccount = true;
+      return result;
+    }
+    result.associatedTokenAddress = ata.toBase58();
+  } catch (error) {
+    console.log("getDestinationAssociatedTokenAddress failed: %o", error);
+  }
+  return result;
+};
+
+// src/wallets/evm.ts
 var DEFAULT_GAS_LIMIT = 100000n;
 var EVMWallet = class {
   constructor(_provider, _signer) {
@@ -5859,12 +6538,12 @@ var EVMWallet = class {
     if (originAsset === "eth") {
       const tx2 = await this.signer.sendTransaction({
         to: depositAddress,
-        value: ethers.parseEther(amount)
+        value: ethers4.parseEther(amount)
       });
       await tx2.wait();
       return tx2;
     }
-    const contract = new ethers.Contract(originAsset, erc20_default, this.signer);
+    const contract = new ethers4.Contract(originAsset, erc20_default, this.signer);
     const tx = await contract.transfer(depositAddress, amount);
     const result = await tx.wait();
     return result.hash;
@@ -5872,14 +6551,15 @@ var EVMWallet = class {
   async getBalance(token, account) {
     try {
       let provider = this.provider;
-      if (token.rpcUrl) {
-        provider = new ethers.JsonRpcProvider(token.rpcUrl);
+      if (token.rpcUrls) {
+        const providers = token.rpcUrls.map((url) => new ethers4.JsonRpcProvider(url));
+        provider = new ethers4.FallbackProvider(providers);
       }
       if (token.symbol === "eth" || token.symbol === "ETH" || token.symbol === "native") {
         const balance2 = await provider.getBalance(account);
         return balance2.toString();
       }
-      const contract = new ethers.Contract(token.contractAddress, erc20_default, provider);
+      const contract = new ethers4.Contract(token.contractAddress, erc20_default, provider);
       const balance = await contract.balanceOf(account);
       return balance.toString();
     } catch (err) {
@@ -5906,11 +6586,11 @@ var EVMWallet = class {
       const tx = {
         from: fromAddress,
         to: depositAddress,
-        value: ethers.parseEther(amount)
+        value: ethers4.parseEther(amount)
       };
       gasLimit = await this.provider.estimateGas(tx);
     } else {
-      const contract = new ethers.Contract(originAsset, erc20_default, this.signer);
+      const contract = new ethers4.Contract(originAsset, erc20_default, this.signer);
       gasLimit = await contract.transfer.estimateGas(depositAddress, amount);
     }
     gasLimit = gasLimit * 120n / 100n;
@@ -5928,7 +6608,7 @@ var EVMWallet = class {
       contractAddress,
       abi
     } = params;
-    return new ethers.Contract(contractAddress, abi, this.signer);
+    return new ethers4.Contract(contractAddress, abi, this.signer);
   }
   async allowance(params) {
     const {
@@ -5937,7 +6617,7 @@ var EVMWallet = class {
       address,
       amountWei
     } = params;
-    const contract = new ethers.Contract(contractAddress, erc20_default, this.signer);
+    const contract = new ethers4.Contract(contractAddress, erc20_default, this.signer);
     let allowance = "0";
     try {
       allowance = await contract.allowance(address, spender);
@@ -5948,7 +6628,7 @@ var EVMWallet = class {
     return {
       contract,
       allowance,
-      needApprove: Big5(amountWei || 0).gt(allowance || 0)
+      needApprove: Big7(amountWei || 0).gt(allowance || 0)
     };
   }
   async approve(params) {
@@ -5958,10 +6638,10 @@ var EVMWallet = class {
       amountWei,
       isApproveMax = false
     } = params;
-    const contract = new ethers.Contract(contractAddress, erc20_default, this.signer);
+    const contract = new ethers4.Contract(contractAddress, erc20_default, this.signer);
     let _amountWei = amountWei;
     if (isApproveMax) {
-      _amountWei = ethers.MaxUint256;
+      _amountWei = ethers4.MaxUint256;
     }
     try {
       const tx = await contract.approve(spender, _amountWei);
@@ -5980,13 +6660,13 @@ var EVMWallet = class {
     const feeData = await this.provider.getFeeData();
     const gasPrice = feeData.maxFeePerGas || feeData.gasPrice || BigInt("20000000000");
     const estimateGas = BigInt(gasLimit) * BigInt(gasPrice);
-    const estimateGasAmount = Big5(estimateGas.toString()).div(10 ** nativeToken.decimals);
-    const estimateGasUsd = Big5(estimateGasAmount).times(price || 1);
+    const estimateGasAmount = Big7(estimateGas.toString()).div(10 ** nativeToken.decimals);
+    const estimateGasUsd = Big7(estimateGasAmount).times(price || 1);
     return {
       gasPrice,
-      usd: numberRemoveEndZero(Big5(estimateGasUsd).toFixed(20)),
+      usd: numberRemoveEndZero(Big7(estimateGasUsd).toFixed(20)),
       wei: estimateGas,
-      amount: numberRemoveEndZero(Big5(estimateGasAmount).toFixed(nativeToken.decimals))
+      amount: numberRemoveEndZero(Big7(estimateGasAmount).toFixed(nativeToken.decimals))
     };
   }
   async quoteOFT(params) {
@@ -6007,7 +6687,8 @@ var EVMWallet = class {
       multiHopComposer,
       isMultiHopComposer,
       isOriginLegacy,
-      isDestinationLegacy
+      isDestinationLegacy,
+      originLayerzero
     } = params;
     const result = {
       needApprove: false,
@@ -6024,12 +6705,11 @@ var EVMWallet = class {
       estimateSourceGasUsd: void 0,
       estimateTime: 0,
       // seconds - dynamically calculated using LayerZero formula
-      outputAmount: numberRemoveEndZero(Big5(amountWei || 0).div(10 ** params.fromToken.decimals).toFixed(params.fromToken.decimals, 0))
+      outputAmount: numberRemoveEndZero(Big7(amountWei || 0).div(10 ** params.fromToken.decimals).toFixed(params.fromToken.decimals, 0))
     };
-    const oftContract = new ethers.Contract(originLayerzeroAddress, abi, this.signer);
-    const oftContractRead = new ethers.Contract(originLayerzeroAddress, abi, this.provider);
+    const oftContract = new ethers4.Contract(originLayerzeroAddress, abi, this.signer);
+    const oftContractRead = new ethers4.Contract(originLayerzeroAddress, abi, this.provider);
     const approvalRequired = await oftContractRead.approvalRequired();
-    console.log("%cApprovalRequired: %o", "background:blue;color:white;", approvalRequired);
     if (approvalRequired) {
       try {
         const allowanceResult = await this.allowance({
@@ -6043,42 +6723,52 @@ var EVMWallet = class {
         console.log("Error checking allowance: %o", error);
       }
     }
+    const lzReceiveOptionGas = isOriginLegacy ? originLayerzero.lzReceiveOptionGasLegacy : originLayerzero.lzReceiveOptionGas;
+    let lzReceiveOptionValue = 0;
+    const destATA = await getDestinationAssociatedTokenAddress({
+      recipient,
+      toToken
+    });
+    if (destATA.needCreateTokenAccount) {
+      lzReceiveOptionValue = LZ_RECEIVE_VALUE[toToken.chainName] || 0;
+    }
     const sendParam = {
       dstEid,
-      to: addressToBytes32(toToken.chainType, recipient),
+      to: addressToBytes322(toToken.chainType, recipient),
       amountLD: amountWei,
       minAmountLD: 0n,
-      extraOptions: "0x0003",
+      extraOptions: Options2.newOptions().addExecutorLzReceiveOption(lzReceiveOptionGas, lzReceiveOptionValue).toHex(),
       composeMsg: "0x",
       oftCmd: "0x"
     };
     if (isMultiHopComposer) {
       sendParam.dstEid = multiHopComposer.eid;
-      sendParam.to = addressToBytes32("evm", multiHopComposer.oftMultiHopComposer);
-      sendParam.extraOptions = Options.newOptions().addExecutorLzReceiveOption(250000000n, 0n).toHex();
-      const abiCoder = ethers.AbiCoder.defaultAbiCoder();
+      sendParam.to = addressToBytes322("evm", multiHopComposer.oftMultiHopComposer);
+      const composeMsgSendParam = {
+        dstEid,
+        to: addressToBytes322(toToken.chainType, recipient),
+        amountLD: sendParam.amountLD,
+        minAmountLD: sendParam.minAmountLD,
+        extraOptions: Options2.newOptions().addExecutorLzReceiveOption(lzReceiveOptionGas, lzReceiveOptionValue).toHex(),
+        composeMsg: "0x",
+        oftCmd: "0x"
+      };
+      const hopMsgFee = await getHopMsgFee({
+        sendParam: composeMsgSendParam,
+        toToken
+      });
+      sendParam.extraOptions = Options2.newOptions().addExecutorLzReceiveOption(lzReceiveOptionGas, lzReceiveOptionValue).addExecutorComposeOption(0, originLayerzero.composeOptionGas || 8e5, hopMsgFee).toHex();
+      const abiCoder = ethers4.AbiCoder.defaultAbiCoder();
       sendParam.composeMsg = abiCoder.encode(
         ["tuple(uint32 dstEid, bytes32 to, uint256 amountLD, uint256 minAmountLD, bytes extraOptions, bytes composeMsg, bytes oftCmd)"],
-        [[
-          dstEid,
-          addressToBytes32(toToken.chainType, recipient),
-          sendParam.amountLD,
-          sendParam.minAmountLD,
-          "0x",
-          "0x",
-          "0x"
-        ]]
+        [Object.values(composeMsgSendParam)]
       );
     }
-    if (isDestinationLegacy) {
-      result.fees.legacyMeshFeeUsd = numberRemoveEndZero(Big5(amountWei || 0).div(10 ** params.fromToken.decimals).times(3e-4).toFixed(params.fromToken.decimals));
-    }
     const oftData = await oftContractRead.quoteOFT.staticCall(sendParam);
     const [, , oftReceipt] = oftData;
     sendParam.minAmountLD = oftReceipt[1] * (1000000n - BigInt(slippageTolerance * 1e4)) / 1000000n;
     const msgFee = await oftContractRead.quoteSend.staticCall(sendParam, payInLzToken);
     result.estimateSourceGas = msgFee[0];
-    console.log("%cMsgFee: %o", "background:blue;color:white;", msgFee);
     result.sendParam = {
       contract: oftContract,
       method: "send",
@@ -6092,13 +6782,13 @@ var EVMWallet = class {
         { value: msgFee[0] }
       ]
     };
-    console.log("%cParams: %o", "background:blue;color:white;", result.sendParam);
-    const nativeFeeUsd = Big5(msgFee[0]?.toString() || 0).div(10 ** fromToken.nativeToken.decimals).times(getPrice(prices, fromToken.nativeToken.symbol));
-    result.fees.nativeFeeUsd = numberRemoveEndZero(Big5(nativeFeeUsd).toFixed(20));
-    result.fees.lzTokenFeeUsd = numberRemoveEndZero(Big5(msgFee[1]?.toString() || 0).div(10 ** fromToken.decimals).toFixed(20));
-    if (!isOriginLegacy && isDestinationLegacy) {
-      result.fees.legacyMeshFeeUsd = numberRemoveEndZero(Big5(amountWei || 0).div(10 ** fromToken.decimals).times(USDT0_LEGACY_FEE).toFixed(fromToken.decimals));
-      result.outputAmount = numberRemoveEndZero(Big5(Big5(amountWei || 0).div(10 ** params.fromToken.decimals)).minus(result.fees.legacyMeshFeeUsd || 0).toFixed(params.fromToken.decimals, 0));
+    const nativeFeeUsd = Big7(msgFee[0]?.toString() || 0).div(10 ** fromToken.nativeToken.decimals).times(getPrice(prices, fromToken.nativeToken.symbol));
+    result.fees.nativeFee = numberRemoveEndZero(Big7(msgFee[0]?.toString() || 0).div(10 ** fromToken.nativeToken.decimals).toFixed(fromToken.nativeToken.decimals));
+    result.fees.nativeFeeUsd = numberRemoveEndZero(Big7(nativeFeeUsd).toFixed(20));
+    result.fees.lzTokenFeeUsd = numberRemoveEndZero(Big7(msgFee[1]?.toString() || 0).div(10 ** fromToken.decimals).toFixed(20));
+    if (isOriginLegacy || isDestinationLegacy) {
+      result.fees.legacyMeshFeeUsd = numberRemoveEndZero(Big7(amountWei || 0).div(10 ** params.fromToken.decimals).times(USDT0_LEGACY_MESH_TRANSFTER_FEE).toFixed(params.fromToken.decimals));
+      result.outputAmount = numberRemoveEndZero(Big7(Big7(amountWei || 0).div(10 ** params.fromToken.decimals)).minus(result.fees.legacyMeshFeeUsd || 0).toFixed(params.fromToken.decimals, 0));
     }
     try {
       const gasLimit = await oftContract.send.estimateGas(...result.sendParam.param);
@@ -6124,9 +6814,9 @@ var EVMWallet = class {
       if (excludeFees4.includes(feeKey)) {
         continue;
       }
-      result.totalFeesUsd = Big5(result.totalFeesUsd || 0).plus(result.fees[feeKey] || 0);
+      result.totalFeesUsd = Big7(result.totalFeesUsd || 0).plus(result.fees[feeKey] || 0);
     }
-    result.totalFeesUsd = numberRemoveEndZero(Big5(result.totalFeesUsd).toFixed(20));
+    result.totalFeesUsd = numberRemoveEndZero(Big7(result.totalFeesUsd).toFixed(20));
     return result;
   }
   async sendTransaction(params) {
@@ -6204,22 +6894,18 @@ var EVMWallet = class {
       estimateSourceGas: void 0,
       estimateSourceGasUsd: void 0,
       estimateTime: Math.floor(Math.random() * 8) + 3,
-      outputAmount: numberRemoveEndZero(Big5(amountWei || 0).div(10 ** fromToken.decimals).toFixed(fromToken.decimals, 0))
+      outputAmount: numberRemoveEndZero(Big7(amountWei || 0).div(10 ** fromToken.decimals).toFixed(fromToken.decimals, 0))
     };
-    const proxyContract = new ethers.Contract(proxyAddress, abi, this.signer);
-    const proxyContractRead = new ethers.Contract(proxyAddress, abi, this.provider);
+    const proxyContract = new ethers4.Contract(proxyAddress, abi, this.signer);
+    const proxyContractRead = new ethers4.Contract(proxyAddress, abi, this.provider);
     let realRecipient = recipient;
-    if (toToken.chainType === "sol") {
-      const connection = new Connection2(chainsRpcUrls.Solana);
-      const wallet = new PublicKey2(recipient);
-      const USDC_MINT = new PublicKey2(toToken.contractAddress);
-      const ata = getAssociatedTokenAddressSync2(USDC_MINT, wallet);
-      const accountInfo = await connection.getAccountInfo(ata);
-      if (!accountInfo) {
-        result.needCreateTokenAccount = true;
-      } else {
-        realRecipient = ata.toBase58();
-      }
+    const destATA = await getDestinationAssociatedTokenAddress({
+      recipient,
+      toToken
+    });
+    result.needCreateTokenAccount = destATA.needCreateTokenAccount;
+    if (destATA.associatedTokenAddress) {
+      realRecipient = destATA.associatedTokenAddress;
     }
     let userNonce = 0n;
     try {
@@ -6228,7 +6914,7 @@ var EVMWallet = class {
     }
     const signatureRes = await cctp_default.quoteSignature({
       address: refundTo,
-      amount: numberRemoveEndZero(Big5(amountWei || 0).div(10 ** fromToken.decimals).toFixed(fromToken.decimals, 0)),
+      amount: numberRemoveEndZero(Big7(amountWei || 0).div(10 ** fromToken.decimals).toFixed(fromToken.decimals, 0)),
       destination_domain_id: destinationDomain,
       receipt_address: realRecipient,
       source_domain_id: sourceDomain,
@@ -6243,10 +6929,10 @@ var EVMWallet = class {
       signature,
       destination_caller
     } = signatureRes;
-    result.fees.estimateMintGasUsd = numberRemoveEndZero(Big5(mint_fee || 0).div(10 ** fromToken.decimals).toFixed(fromToken.decimals));
-    result.fees.bridgeFeeUsd = numberRemoveEndZero(Big5(bridge_fee || 0).div(10 ** fromToken.decimals).toFixed(fromToken.decimals));
+    result.fees.estimateMintGasUsd = numberRemoveEndZero(Big7(mint_fee || 0).div(10 ** fromToken.decimals).toFixed(fromToken.decimals));
+    result.fees.bridgeFeeUsd = numberRemoveEndZero(Big7(bridge_fee || 0).div(10 ** fromToken.decimals).toFixed(fromToken.decimals));
     const chargedAmount = BigInt(amountWei) - BigInt(mint_fee);
-    result.outputAmount = numberRemoveEndZero(Big5(receipt_amount || 0).div(10 ** fromToken.decimals).toFixed(fromToken.decimals, 0));
+    result.outputAmount = numberRemoveEndZero(Big7(receipt_amount || 0).div(10 ** fromToken.decimals).toFixed(fromToken.decimals, 0));
     const depositParam = [
       // originalAmount
       amountWei,
@@ -6255,11 +6941,11 @@ var EVMWallet = class {
       // destinationDomain
       destinationDomain,
       // mintRecipient
-      addressToBytes32(toToken.chainType, realRecipient),
+      addressToBytes322(toToken.chainType, realRecipient),
       // burnToken
       fromToken.contractAddress,
       // destinationCaller
-      destination_caller ? addressToBytes32(toToken.chainType, destination_caller) : "0x0000000000000000000000000000000000000000000000000000000000000000",
+      destination_caller ? addressToBytes322(toToken.chainType, destination_caller) : "0x0000000000000000000000000000000000000000000000000000000000000000",
       // maxFee
       max_fee,
       // minFinalityThreshold
@@ -6321,9 +7007,9 @@ var EVMWallet = class {
       if (excludeFees4.includes(feeKey) || !/Usd$/.test(feeKey)) {
         continue;
       }
-      result.totalFeesUsd = Big5(result.totalFeesUsd || 0).plus(result.fees[feeKey] || 0);
+      result.totalFeesUsd = Big7(result.totalFeesUsd || 0).plus(result.fees[feeKey] || 0);
     }
-    result.totalFeesUsd = numberRemoveEndZero(Big5(result.totalFeesUsd).toFixed(20));
+    result.totalFeesUsd = numberRemoveEndZero(Big7(result.totalFeesUsd).toFixed(20));
     return result;
   }
   async quoteOneClickProxy(params) {
@@ -6349,7 +7035,7 @@ var EVMWallet = class {
     } catch (error) {
       console.log("oneclick check allowance failed: %o", error);
     }
-    const proxyContract = new ethers.Contract(proxyAddress, abi, this.signer);
+    const proxyContract = new ethers4.Contract(proxyAddress, abi, this.signer);
     const proxyParam = [
       // tokenAddress
       fromToken.contractAddress,
@@ -6367,18 +7053,18 @@ var EVMWallet = class {
         price: getPrice(prices, fromToken.nativeToken.symbol),
         nativeToken: fromToken.nativeToken
       });
-      result.fees.sourceGasFeeUsd = numberRemoveEndZero(Big5(usd).toFixed(20));
+      result.fees.sourceGasFeeUsd = numberRemoveEndZero(Big7(usd).toFixed(20));
       result.estimateSourceGas = wei;
-      result.estimateSourceGasUsd = numberRemoveEndZero(Big5(usd).toFixed(20));
+      result.estimateSourceGasUsd = numberRemoveEndZero(Big7(usd).toFixed(20));
     } catch (error) {
       const { usd, wei } = await this.getEstimateGas({
         gasLimit: DEFAULT_GAS_LIMIT,
         price: getPrice(prices, fromToken.nativeToken.symbol),
         nativeToken: fromToken.nativeToken
       });
-      result.fees.sourceGasFeeUsd = numberRemoveEndZero(Big5(usd).toFixed(20));
+      result.fees.sourceGasFeeUsd = numberRemoveEndZero(Big7(usd).toFixed(20));
       result.estimateSourceGas = wei;
-      result.estimateSourceGasUsd = numberRemoveEndZero(Big5(usd).toFixed(20));
+      result.estimateSourceGasUsd = numberRemoveEndZero(Big7(usd).toFixed(20));
     }
     result.sendParam = {
       method: "proxyTransfer",
@@ -6390,27 +7076,50 @@ var EVMWallet = class {
     };
     return result;
   }
+  async signTypedData(params) {
+    const { domain, types, values } = params;
+    return await this.signer?.signTypedData(domain, types, values);
+  }
 };
 
 // src/wallets/tron.ts
-import { Options as Options2 } from "@layerzerolabs/lz-v2-utilities";
-import { ethers as ethers2 } from "ethers";
-import Big6 from "big.js";
+import { Options as Options3 } from "@layerzerolabs/lz-v2-utilities";
+import { ethers as ethers5 } from "ethers";
+import Big8 from "big.js";
 import { TronWeb } from "tronweb";
+var DefaultTronWalletAddress = DefaultAddresses["tron"];
+var getCustomTronWeb = () => {
+  return new TronWeb({
+    fullHost: getRpcUrls("tron")[0],
+    headers: {},
+    privateKey: ""
+  });
+};
 var TronWallet = class {
   constructor(options) {
     this.signAndSendTransaction = options.signAndSendTransaction;
-    this.tronWeb = options.tronWeb;
+    this.address = options.address;
+    const customTronWeb = getCustomTronWeb();
+    customTronWeb.setAddress(this.address || DefaultTronWalletAddress);
+    this.tronWeb = customTronWeb;
   }
   async waitForTronWeb() {
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve2) => {
       if (this.tronWeb) {
+        const address = this.tronWeb.defaultAddress.base58 || DefaultTronWalletAddress;
+        const customTronWeb = getCustomTronWeb();
+        customTronWeb.setAddress(address);
+        this.tronWeb = customTronWeb;
         resolve2(this.tronWeb);
         return;
       }
       const checkTronWeb = () => {
         if (window.tronWeb) {
           this.tronWeb = window.tronWeb;
+          const address = this.tronWeb.defaultAddress.base58 || DefaultTronWalletAddress;
+          const customTronWeb = getCustomTronWeb();
+          customTronWeb.setAddress(address);
+          this.tronWeb = customTronWeb;
           resolve2(this.tronWeb);
         } else {
           setTimeout(checkTronWeb, 100);
@@ -6418,12 +7127,9 @@ var TronWallet = class {
       };
       checkTronWeb();
       setTimeout(() => {
-        this.tronWeb = new TronWeb({
-          fullHost: chainsRpcUrls["Tron"],
-          headers: {},
-          privateKey: ""
-        });
-        this.tronWeb.setAddress(DefaultAddresses["tron"]);
+        const customTronWeb = getCustomTronWeb();
+        customTronWeb.setAddress(DefaultTronWalletAddress);
+        this.tronWeb = customTronWeb;
         resolve2(this.tronWeb);
         console.log(new Error("TronWeb initialization timeout"));
       }, 1e4);
@@ -6487,10 +7193,10 @@ var TronWallet = class {
     return await this.getBalance(token, account);
   }
   /**
-   * Estimate gas limit for transfer transaction
-   * @param data Transfer data
-   * @returns Gas limit estimate (bandwidth or energy), gas price, and estimated gas cost
-   */
+    * Estimate gas limit for transfer transaction
+    * @param data Transfer data
+    * @returns Gas limit estimate (bandwidth or energy), gas price, and estimated gas cost
+    */
   async estimateTransferGas(data) {
     const { originAsset } = data;
     await this.waitForTronWeb();
@@ -6501,14 +7207,7 @@ var TronWallet = class {
       gasLimit = 30000n;
     }
     gasLimit = gasLimit * 120n / 100n;
-    let gasPrice;
-    try {
-      const chainParameters = await this.tronWeb.trx.getChainParameters();
-      const energyPrice = chainParameters?.find((p) => p.key === "getEnergyFee")?.value || 420;
-      gasPrice = BigInt(energyPrice);
-    } catch (error) {
-      gasPrice = 420n;
-    }
+    let gasPrice = 100n;
     const estimateGas = gasLimit * gasPrice;
     return {
       gasLimit,
@@ -6528,6 +7227,15 @@ var TronWallet = class {
       return false;
     }
   }
+  async getTransactionResult(txHash) {
+    await this.waitForTronWeb();
+    try {
+      const txInfo = await this.tronWeb.trx.getTransactionInfo(txHash);
+      return txInfo;
+    } catch (error) {
+      return {};
+    }
+  }
   async allowance(params) {
     const {
       contractAddress,
@@ -6548,7 +7256,7 @@ var TronWallet = class {
       return {
         contract,
         allowance,
-        needApprove: Big6(amountWei || 0).gt(allowance || 0)
+        needApprove: Big8(amountWei || 0).gt(allowance || 0)
       };
     } catch (error) {
       console.log("Error in allowance: %o", error);
@@ -6595,14 +7303,7 @@ var TronWallet = class {
   }
   async getEnergyPrice() {
     await this.waitForTronWeb();
-    let energyFee = 280;
-    try {
-      const params = await this.tronWeb.trx.getChainParameters();
-      energyFee = params.find((p) => p.key === "getEnergyFee")?.value || 280;
-      console.log("Energy Fee:", energyFee, "Sun/Energy");
-    } catch (err) {
-      console.error("Error getting energy price:", err);
-    }
+    let energyFee = 100;
     return energyFee;
   }
   toBytes32(addr) {
@@ -6625,9 +7326,10 @@ var TronWallet = class {
       excludeFees: excludeFees4,
       refundTo,
       multiHopComposer,
-      isMultiHopComposer
-      // isOriginLegacy,
-      // isDestinationLegacy,
+      isMultiHopComposer,
+      isOriginLegacy,
+      isDestinationLegacy,
+      originLayerzero
     } = params;
     const result = {
       needApprove: false,
@@ -6644,12 +7346,11 @@ var TronWallet = class {
       estimateSourceGasUsd: void 0,
       estimateTime: 0,
       // seconds - dynamically calculated using LayerZero formula
-      outputAmount: numberRemoveEndZero(Big6(amountWei || 0).div(10 ** params.fromToken.decimals).toFixed(params.fromToken.decimals, 0))
+      outputAmount: numberRemoveEndZero(Big8(amountWei || 0).div(10 ** params.fromToken.decimals).toFixed(params.fromToken.decimals, 0))
     };
     await this.waitForTronWeb();
     const oftContract = await this.tronWeb.contract(abi, originLayerzeroAddress);
     const approvalRequired = await oftContract.approvalRequired().call();
-    console.log("%cApprovalRequired: %o", "background:blue;color:white;", result.needApprove);
     if (approvalRequired) {
       try {
         const userAddress = refundTo || this.tronWeb.defaultAddress.base58;
@@ -6664,18 +7365,27 @@ var TronWallet = class {
         console.log("Error checking allowance: %o", error);
       }
     }
+    const lzReceiveOptionGas = isOriginLegacy ? originLayerzero.lzReceiveOptionGasLegacy : originLayerzero.lzReceiveOptionGas;
+    let lzReceiveOptionValue = 0;
+    const destATA = await getDestinationAssociatedTokenAddress({
+      recipient,
+      toToken
+    });
+    if (destATA.needCreateTokenAccount) {
+      lzReceiveOptionValue = LZ_RECEIVE_VALUE[toToken.chainName] || 0;
+    }
     const sendParam = [
       // dstEid
       dstEid,
       // to
       // "0x0000000000000000000000000000000000000000000000000000000000000000",
-      addressToBytes32(toToken.chainType, recipient),
+      addressToBytes322(toToken.chainType, recipient),
       // amountLD
       amountWei,
       // minAmountLD
       "0",
       // extraOptions
-      "0x",
+      Options3.newOptions().addExecutorLzReceiveOption(lzReceiveOptionGas, lzReceiveOptionValue).toHex(),
       // composeMsg
       "0x",
       // oftCmd
@@ -6683,71 +7393,63 @@ var TronWallet = class {
     ];
     if (isMultiHopComposer) {
       sendParam[0] = multiHopComposer.eid;
-      sendParam[1] = addressToBytes32("evm", multiHopComposer.oftMultiHopComposer);
+      sendParam[1] = addressToBytes322("evm", multiHopComposer.oftMultiHopComposer);
     }
     const oftData = await oftContract.quoteOFT(sendParam).call();
-    console.log("oftData: %o", oftData);
     const [, , oftReceipt] = oftData;
-    sendParam[3] = Big6(oftReceipt[1].toString()).times(Big6(1).minus(Big6(slippageTolerance || 0).div(100))).toFixed(0);
+    sendParam[3] = Big8(oftReceipt[1].toString()).times(Big8(1).minus(Big8(slippageTolerance || 0).div(100))).toFixed(0);
     const msgFee = await oftContract.quoteSend(sendParam, payInLzToken).call();
-    result.estimateSourceGas = msgFee[0]["nativeFee"];
+    let nativeMsgFee = msgFee[0]["nativeFee"];
+    if (nativeMsgFee) {
+      nativeMsgFee = BigInt(Big8(nativeMsgFee.toString()).times(1.2).toFixed(0));
+    }
+    result.estimateSourceGas = nativeMsgFee;
     if (isMultiHopComposer) {
-      sendParam[4] = Options2.newOptions().addExecutorLzReceiveOption(250000000n, 0n).toHex();
-      const abiCoder = ethers2.AbiCoder.defaultAbiCoder();
+      const composeMsgSendParam = {
+        dstEid,
+        to: addressToBytes322(toToken.chainType, recipient),
+        amountLD: sendParam[2],
+        minAmountLD: sendParam[3],
+        extraOptions: Options3.newOptions().addExecutorLzReceiveOption(lzReceiveOptionGas, lzReceiveOptionValue).toHex(),
+        composeMsg: "0x",
+        oftCmd: "0x"
+      };
+      const hopMsgFee = await getHopMsgFee({
+        sendParam: composeMsgSendParam,
+        toToken
+      });
+      sendParam[4] = Options3.newOptions().addExecutorLzReceiveOption(lzReceiveOptionGas, lzReceiveOptionValue).addExecutorComposeOption(0, originLayerzero.composeOptionGas || 8e5, hopMsgFee).toHex();
+      const abiCoder = ethers5.AbiCoder.defaultAbiCoder();
       sendParam[5] = abiCoder.encode(
         ["tuple(uint32 dstEid, bytes32 to, uint256 amountLD, uint256 minAmountLD, bytes extraOptions, bytes composeMsg, bytes oftCmd)"],
-        [[
-          dstEid,
-          addressToBytes32(toToken.chainType, recipient),
-          sendParam[2],
-          // amountLD
-          sendParam[3],
-          // minAmountLD
-          "0x",
-          "0x",
-          "0x"
-        ]]
+        [Object.values(composeMsgSendParam)]
       );
     }
-    console.log("%cMsgFee: %o", "background:blue;color:white;", msgFee);
     result.sendParam = {
-      contract: oftContract,
       param: [
         // sendParam
         sendParam,
         // feeParam
         [
           // nativeFee
-          msgFee[0]["nativeFee"].toString(),
+          nativeMsgFee.toString(),
           // lzTokenFee
           msgFee[0]["lzTokenFee"].toString()
         ],
         // refundAddress
         refundTo
       ],
-      options: { callValue: msgFee[0]["nativeFee"].toString() }
+      options: { callValue: nativeMsgFee.toString() }
     };
-    console.log("%cParams: %o", "background:blue;color:white;", result.sendParam);
-    const nativeFeeUsd = Big6(msgFee[0]["nativeFee"]?.toString() || 0).div(10 ** fromToken.nativeToken.decimals).times(getPrice(prices, fromToken.nativeToken.symbol));
-    result.fees.nativeFeeUsd = numberRemoveEndZero(Big6(nativeFeeUsd).toFixed(20));
-    result.fees.lzTokenFeeUsd = numberRemoveEndZero(Big6(msgFee[0]["lzTokenFee"]?.toString() || 0).div(10 ** fromToken.decimals).toFixed(20));
-    try {
-      const energyUsed = msgFee[0]["nativeFee"] || 15e5;
-      const usd = numberRemoveEndZero(Big6(energyUsed || 0).div(10 ** fromToken.nativeToken.decimals).times(getPrice(prices, fromToken.nativeToken.symbol)).toFixed(20));
-      result.fees.estimateGasUsd = usd;
-      result.estimateSourceGas = energyUsed;
-      result.estimateSourceGasUsd = usd;
-    } catch (error) {
-      console.log("usdt0 estimate gas failed: %o", error);
-    }
-    for (const feeKey in result.fees) {
-      if (excludeFees4.includes(feeKey)) {
-        continue;
-      }
-      result.totalFeesUsd = Big6(result.totalFeesUsd || 0).plus(result.fees[feeKey] || 0);
-    }
-    result.totalFeesUsd = numberRemoveEndZero(Big6(result.totalFeesUsd).toFixed(20));
-    const tx = await this.tronWeb.transactionBuilder.triggerSmartContract(
+    const nativeFeeUsd = Big8(nativeMsgFee?.toString() || 0).div(10 ** fromToken.nativeToken.decimals).times(getPrice(prices, fromToken.nativeToken.symbol));
+    result.fees.nativeFee = numberRemoveEndZero(Big8(nativeMsgFee?.toString() || 0).div(10 ** fromToken.nativeToken.decimals).toFixed(fromToken.nativeToken.decimals));
+    result.fees.nativeFeeUsd = numberRemoveEndZero(Big8(nativeFeeUsd).toFixed(20));
+    result.fees.lzTokenFeeUsd = numberRemoveEndZero(Big8(msgFee[0]["lzTokenFee"]?.toString() || 0).div(10 ** fromToken.decimals).toFixed(20));
+    if (isOriginLegacy || isDestinationLegacy) {
+      result.fees.legacyMeshFeeUsd = numberRemoveEndZero(Big8(amountWei || 0).div(10 ** fromToken.decimals).times(USDT0_LEGACY_MESH_TRANSFTER_FEE).toFixed(fromToken.decimals));
+      result.outputAmount = numberRemoveEndZero(Big8(Big8(amountWei || 0).div(10 ** params.fromToken.decimals)).minus(result.fees.legacyMeshFeeUsd || 0).toFixed(params.fromToken.decimals, 0));
+    }
+    const transactionParams = [
       originLayerzeroAddress,
       "send((uint32,bytes32,uint256,uint256,bytes,bytes,bytes),(uint256,uint256),address)",
       result.sendParam.options,
@@ -6765,9 +7467,41 @@ var TronWallet = class {
           value: result.sendParam.param[2]
         }
       ],
-      this.tronWeb.defaultAddress.base58
-    );
+      this.tronWeb.defaultAddress.base58 || refundTo
+    ];
+    const energyPrice = await this.getEnergyPrice();
+    const tx = await this.tronWeb.transactionBuilder.triggerSmartContract(...transactionParams);
     result.sendParam.tx = tx;
+    try {
+      const transaction = await this.tronWeb.transactionBuilder.triggerConstantContract(...transactionParams);
+      const energyUsed = transaction.energy_used || 2e5;
+      const rawDataHexLength = transaction.transaction.raw_data_hex.length || 1e3;
+      const bandwidthAmount = (rawDataHexLength / 2 + DATA_HEX_PROTOBUF_EXTRA + SIGNATURE_SIZE) * 1e-3;
+      const amount = Big8(energyUsed || 0).times(energyPrice).div(10 ** fromToken.nativeToken.decimals);
+      const totalAmount = Big8(amount).plus(bandwidthAmount);
+      const usd = numberRemoveEndZero(Big8(totalAmount).times(getPrice(prices, fromToken.nativeToken.symbol)).toFixed(20));
+      result.fees.estimateGasUsd = usd;
+      result.estimateSourceGas = numberRemoveEndZero(Big8(totalAmount).times(10 ** fromToken.nativeToken.decimals).toFixed(fromToken.nativeToken.decimals));
+      result.estimateSourceGasUsd = usd;
+    } catch (error) {
+      const energyUsed = 2e5;
+      const rawDataHexLength = 1e3;
+      const bandwidthAmount = (rawDataHexLength / 2 + DATA_HEX_PROTOBUF_EXTRA + SIGNATURE_SIZE) * 1e-3;
+      const amount = Big8(energyUsed || 0).times(energyPrice).div(10 ** fromToken.nativeToken.decimals);
+      const totalAmount = Big8(amount).plus(bandwidthAmount);
+      const usd = numberRemoveEndZero(Big8(totalAmount).times(getPrice(prices, fromToken.nativeToken.symbol)).toFixed(20));
+      result.fees.estimateGasUsd = usd;
+      result.estimateSourceGas = numberRemoveEndZero(Big8(totalAmount).times(10 ** fromToken.nativeToken.decimals).toFixed(fromToken.nativeToken.decimals));
+      result.estimateSourceGasUsd = usd;
+    }
+    for (const feeKey in result.fees) {
+      if (excludeFees4.includes(feeKey) || !/Usd$/.test(feeKey)) {
+        continue;
+      }
+      result.totalFeesUsd = Big8(result.totalFeesUsd || 0).plus(result.fees[feeKey] || 0);
+    }
+    result.totalFeesUsd = numberRemoveEndZero(Big8(result.totalFeesUsd).toFixed(20));
+    result.sendParam.transactionParams = transactionParams;
     return result;
   }
   async sendTransaction(params) {
@@ -6776,7 +7510,6 @@ var TronWallet = class {
     } = params;
     const result = await this.signAndSendTransaction(tx.transaction);
     if (typeof result === "object" && result.message) {
-      console.log("%cTron send transaction message: %o", "background:#f00;color:#fff;", result.message);
       if (/user rejected the transaction/i.test(result.message)) {
         throw new Error("User rejected the transaction");
       }
@@ -6841,7 +7574,6 @@ var TronWallet = class {
     } catch (error) {
       console.log("oneclick check allowance failed: %o", error);
     }
-    const proxyContract = await this.tronWeb.contract(abi, proxyAddress);
     const proxyParam = [
       // tokenAddress
       fromToken.contractAddress,
@@ -6851,22 +7583,9 @@ var TronWallet = class {
       amountWei
     ];
     result.sendParam = {
-      contract: proxyContract,
       param: proxyParam
     };
-    try {
-      const gasLimit = 30000n;
-      const energyPrice = await this.getEnergyPrice();
-      const gasPrice = BigInt(energyPrice);
-      const estimateGas = gasLimit * gasPrice;
-      const estimateGasUsd = Big6(estimateGas.toString()).div(10 ** fromToken.nativeToken.decimals).times(getPrice(prices, fromToken.nativeToken.symbol));
-      result.fees.sourceGasFeeUsd = numberRemoveEndZero(Big6(estimateGasUsd).toFixed(20));
-      result.estimateSourceGas = estimateGas.toString();
-      result.estimateSourceGasUsd = numberRemoveEndZero(Big6(estimateGasUsd).toFixed(20));
-    } catch (error) {
-      console.log("onclick estimate proxy failed: %o", error);
-    }
-    const tx = await this.tronWeb.transactionBuilder.triggerSmartContract(
+    const transactionParams = [
       proxyAddress,
       "proxyTransfer(address,address,uint256)",
       {},
@@ -6887,20 +7606,99 @@ var TronWallet = class {
           // amount
         }
       ],
-      this.tronWeb.defaultAddress.base58
-    );
+      this.tronWeb.defaultAddress.base58 || refundTo
+    ];
+    const energyPrice = await this.getEnergyPrice();
+    const tx = await this.tronWeb.transactionBuilder.triggerSmartContract(...transactionParams);
     result.sendParam.tx = tx;
+    try {
+      const transaction = await this.tronWeb.transactionBuilder.triggerConstantContract(...transactionParams);
+      const energyUsed = transaction.energy_used || 3e4;
+      const rawDataHexLength = transaction.transaction.raw_data_hex.length || 500;
+      const bandwidthAmount = (rawDataHexLength / 2 + DATA_HEX_PROTOBUF_EXTRA + SIGNATURE_SIZE) * 1e-3;
+      const amount = Big8(energyUsed || 0).times(energyPrice).div(10 ** fromToken.nativeToken.decimals);
+      const totalAmount = Big8(amount).plus(bandwidthAmount);
+      const usd = numberRemoveEndZero(Big8(totalAmount).times(getPrice(prices, fromToken.nativeToken.symbol)).toFixed(20));
+      result.fees.sourceGasFeeUsd = usd;
+      result.estimateSourceGas = numberRemoveEndZero(Big8(totalAmount).times(10 ** fromToken.nativeToken.decimals).toFixed(fromToken.nativeToken.decimals));
+      result.estimateSourceGasUsd = usd;
+    } catch (error) {
+      const energyUsed = 169e3;
+      const rawDataHexLength = 500;
+      const bandwidthAmount = (rawDataHexLength / 2 + DATA_HEX_PROTOBUF_EXTRA + SIGNATURE_SIZE) * 1e-3;
+      const amount = Big8(energyUsed || 0).times(energyPrice).div(10 ** fromToken.nativeToken.decimals);
+      const totalAmount = Big8(amount).plus(bandwidthAmount);
+      const usd = numberRemoveEndZero(Big8(totalAmount).times(getPrice(prices, fromToken.nativeToken.symbol)).toFixed(20));
+      result.fees.estimateGasUsd = usd;
+      result.estimateSourceGas = numberRemoveEndZero(Big8(totalAmount).times(10 ** fromToken.nativeToken.decimals).toFixed(fromToken.nativeToken.decimals));
+      result.estimateSourceGasUsd = usd;
+    }
+    result.sendParam.transactionParams = transactionParams;
+    return result;
+  }
+  async getAccountResources(params) {
+    const { account } = params;
+    const result = {
+      energy: 0,
+      bandwidth: 0,
+      success: false,
+      error: "TronWeb is not initialized or the wallet is not connected"
+    };
+    await this.waitForTronWeb();
+    if (!this.tronWeb || !account) {
+      return result;
+    }
+    try {
+      let availableEnergy;
+      let availableBandwidth;
+      try {
+        if (this.tronWeb.trx.getAccountResources) {
+          const resources = await this.tronWeb.trx.getAccountResources(account);
+          console.log("resources: %o", resources);
+          if (resources) {
+            availableEnergy = (resources.EnergyLimit || 0) - (resources.EnergyUsed || 0);
+            availableBandwidth = (resources.freeNetLimit || 0) - (resources.freeNetUsed || 0);
+          }
+        }
+      } catch (resourcesErr) {
+        console.warn("getAccountResources API is not available, try other way:", resourcesErr);
+      }
+      if (availableEnergy === void 0 && availableBandwidth === void 0) {
+        const accountInfo = await this.tronWeb.trx.getAccount(account);
+        if (accountInfo.account_resource) {
+          const accountResource = accountInfo.account_resource;
+          availableEnergy = (accountResource.EnergyLimit || 0) - (accountResource.EnergyUsed || 0);
+          availableBandwidth = (accountResource.NetLimit || 0) - (accountResource.NetUsed || 0);
+        } else if (accountInfo.energy !== void 0) {
+          availableEnergy = accountInfo.energy || 0;
+        }
+        if (accountInfo.bandwidth !== void 0) {
+          if (typeof accountInfo.bandwidth === "number") {
+            availableBandwidth = accountInfo.bandwidth;
+          } else if (accountInfo.bandwidth) {
+            availableBandwidth = accountInfo.bandwidth.available || accountInfo.bandwidth.freeNetUsage || 0;
+          }
+        }
+      }
+      result.energy = Math.max(0, availableEnergy);
+      result.bandwidth = Math.max(0, availableBandwidth);
+      result.success = true;
+      result.error = null;
+    } catch (error) {
+      console.error("Failed to get account resources:", error);
+    }
     return result;
   }
 };
 
 // src/wallets/aptos.ts
 import { Aptos, AptosConfig, Network, parseTypeTag, TypeTagAddress, TypeTagU64 } from "@aptos-labs/ts-sdk";
-import Big7 from "big.js";
+import Big9 from "big.js";
 var AptosWallet = class {
   constructor(options) {
     const config = new AptosConfig({
-      network: Network.MAINNET
+      network: Network.MAINNET,
+      fullnode: getRpcUrls("aptos")[0]
     });
     const aptos = new Aptos(config);
     this.aptos = aptos;
@@ -7204,10 +8002,10 @@ var AptosWallet = class {
         const defaultGasLimit = 5000n;
         const defaultGasPrice = 100n;
         const defaultEstimateGas = defaultGasLimit * defaultGasPrice;
-        const estimateGasUsd2 = Big7(defaultEstimateGas.toString()).div(10 ** fromToken.nativeToken.decimals).times(getPrice(prices, fromToken.nativeToken.symbol));
-        result.fees.sourceGasFeeUsd = numberRemoveEndZero(Big7(estimateGasUsd2).toFixed(20));
+        const estimateGasUsd2 = Big9(defaultEstimateGas.toString()).div(10 ** fromToken.nativeToken.decimals).times(getPrice(prices, fromToken.nativeToken.symbol));
+        result.fees.sourceGasFeeUsd = numberRemoveEndZero(Big9(estimateGasUsd2).toFixed(20));
         result.estimateSourceGas = defaultEstimateGas.toString();
-        result.estimateSourceGasUsd = numberRemoveEndZero(Big7(estimateGasUsd2).toFixed(20));
+        result.estimateSourceGasUsd = numberRemoveEndZero(Big9(estimateGasUsd2).toFixed(20));
         result.sendParam = {
           function: functionId,
           typeArguments: [typeArgument],
@@ -7220,10 +8018,10 @@ var AptosWallet = class {
         const defaultGasLimit = 5000n;
         const defaultGasPrice = 100n;
         const defaultEstimateGas = defaultGasLimit * defaultGasPrice;
-        const estimateGasUsd2 = Big7(defaultEstimateGas.toString()).div(10 ** fromToken.nativeToken.decimals).times(getPrice(prices, fromToken.nativeToken.symbol));
-        result.fees.sourceGasFeeUsd = numberRemoveEndZero(Big7(estimateGasUsd2).toFixed(20));
+        const estimateGasUsd2 = Big9(defaultEstimateGas.toString()).div(10 ** fromToken.nativeToken.decimals).times(getPrice(prices, fromToken.nativeToken.symbol));
+        result.fees.sourceGasFeeUsd = numberRemoveEndZero(Big9(estimateGasUsd2).toFixed(20));
         result.estimateSourceGas = defaultEstimateGas.toString();
-        result.estimateSourceGasUsd = numberRemoveEndZero(Big7(estimateGasUsd2).toFixed(20));
+        result.estimateSourceGasUsd = numberRemoveEndZero(Big9(estimateGasUsd2).toFixed(20));
         result.sendParam = {
           function: functionId,
           typeArguments: [typeArgument],
@@ -7235,10 +8033,10 @@ var AptosWallet = class {
       const gasLimit = gasUsed * 150n / 100n;
       const gasPrice = BigInt(simulation.gas_unit_price || 100);
       const estimateGas = gasLimit * gasPrice;
-      const estimateGasUsd = Big7(estimateGas.toString()).div(10 ** fromToken.nativeToken.decimals).times(getPrice(prices, fromToken.nativeToken.symbol));
-      result.fees.sourceGasFeeUsd = numberRemoveEndZero(Big7(estimateGasUsd).toFixed(20));
+      const estimateGasUsd = Big9(estimateGas.toString()).div(10 ** fromToken.nativeToken.decimals).times(getPrice(prices, fromToken.nativeToken.symbol));
+      result.fees.sourceGasFeeUsd = numberRemoveEndZero(Big9(estimateGasUsd).toFixed(20));
       result.estimateSourceGas = estimateGas.toString();
-      result.estimateSourceGasUsd = numberRemoveEndZero(Big7(estimateGasUsd).toFixed(20));
+      result.estimateSourceGasUsd = numberRemoveEndZero(Big9(estimateGasUsd).toFixed(20));
       result.sendParam = {
         function: functionId,
         typeArguments: [typeArgument],
@@ -7249,10 +8047,10 @@ var AptosWallet = class {
       const defaultGasLimit = 5000n;
       const defaultGasPrice = 100n;
       const defaultEstimateGas = defaultGasLimit * defaultGasPrice;
-      const estimateGasUsd = Big7(defaultEstimateGas.toString()).div(10 ** fromToken.nativeToken.decimals).times(getPrice(prices, fromToken.nativeToken.symbol));
-      result.fees.sourceGasFeeUsd = numberRemoveEndZero(Big7(estimateGasUsd).toFixed(20));
+      const estimateGasUsd = Big9(defaultEstimateGas.toString()).div(10 ** fromToken.nativeToken.decimals).times(getPrice(prices, fromToken.nativeToken.symbol));
+      result.fees.sourceGasFeeUsd = numberRemoveEndZero(Big9(estimateGasUsd).toFixed(20));
       result.estimateSourceGas = defaultEstimateGas.toString();
-      result.estimateSourceGasUsd = numberRemoveEndZero(Big7(estimateGasUsd).toFixed(20));
+      result.estimateSourceGasUsd = numberRemoveEndZero(Big9(estimateGasUsd).toFixed(20));
     }
     return result;
   }
@@ -7329,7 +8127,12 @@ export {
   CancelablePromise,
   EVMWallet,
   GetExecutionStatusResponse,
+  Hyperliquid,
+  HyperliquidFromTokens,
+  HyperliuquidMinAmount,
+  HyperliuquidToToken,
   NearWallet,
+  NetworkRpcUrlsMap,
   OpenAPI,
   QuoteRequest,
   SFA,
@@ -7339,7 +8142,8 @@ export {
   TokenResponse,
   TransactionStatus,
   TronWallet,
-  chainsRpcUrls,
+  getRpcUrls,
+  setRpcUrls,
   tokens,
   usdcChains,
   usdcTokens,