@stableflow/wallet-tron 3.0.0-beta-02a59f37a0-20260515

package/dist/index.js

@@ -0,0 +1,884 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var core = require('@stableflow/core');
+var bridges = require('@stableflow/bridges');
+var utilsEvm = require('@stableflow/utils-evm');
+var utilsSolana = require('@stableflow/utils-solana');
+var ethers = require('ethers');
+var Big = require('big.js');
+var tronweb = require('tronweb');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var Big__default = /*#__PURE__*/_interopDefault(Big);
+
+// src/tron.ts
+var DefaultTronWalletAddress = core.DefaultAddresses["tron"];
+var getCustomTronWeb = () => {
+  return new tronweb.TronWeb({
+    fullHost: core.getChainRpcUrl("tron").rpcUrl,
+    headers: {},
+    privateKey: ""
+  });
+};
+var TronWallet = class {
+  constructor(options) {
+    this.signAndSendTransaction = options.signAndSendTransaction;
+    this.address = options.address;
+    const customTronWeb = getCustomTronWeb();
+    customTronWeb.setAddress(this.address || DefaultTronWalletAddress);
+    this.tronWeb = customTronWeb;
+    const cs = new core.Csl(core.OpenAPI.DEBUG);
+    this.csl = cs.log;
+  }
+  async waitForTronWeb() {
+    return new Promise((resolve) => {
+      if (this.tronWeb) {
+        const address = this.tronWeb.defaultAddress.base58 || DefaultTronWalletAddress;
+        const customTronWeb = getCustomTronWeb();
+        customTronWeb.setAddress(address);
+        this.tronWeb = customTronWeb;
+        resolve(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;
+          resolve(this.tronWeb);
+        } else {
+          setTimeout(checkTronWeb, 100);
+        }
+      };
+      checkTronWeb();
+      setTimeout(() => {
+        const customTronWeb = getCustomTronWeb();
+        customTronWeb.setAddress(DefaultTronWalletAddress);
+        this.tronWeb = customTronWeb;
+        resolve(this.tronWeb);
+        this.csl("TronWallet waitForTronWeb", "red-500", "TronWeb initialization timeout");
+      }, 1e4);
+    });
+  }
+  async transfer(data) {
+    const { originAsset, depositAddress, amount } = data;
+    await this.waitForTronWeb();
+    if (originAsset === "TRX" || originAsset === "trx") {
+      return await this.transferTRX(depositAddress, amount);
+    }
+    return await this.transferToken(originAsset, depositAddress, amount);
+  }
+  async transferTRX(to, amount) {
+    await this.waitForTronWeb();
+    const transaction = await this.tronWeb.transactionBuilder.sendTrx(
+      to,
+      this.tronWeb.toSun(amount)
+    );
+    return this.sendTransaction({ tx: { transaction } });
+  }
+  async transferToken(contractAddress, to, amount) {
+    await this.waitForTronWeb();
+    const functionSelector = "transfer(address,uint256)";
+    const parameter = [{ type: "address", value: to }, { type: "uint256", value: amount }];
+    const tx = await this.tronWeb.transactionBuilder.triggerSmartContract(contractAddress, functionSelector, {}, parameter);
+    return this.sendTransaction({ tx });
+  }
+  async getBalance(token, account, options) {
+    await this.waitForTronWeb();
+    if (token.symbol === "TRX" || token.symbol === "trx" || token.symbol === "native") {
+      return await this.getTRXBalance(account, options);
+    }
+    return await this.getTokenBalance(token.contractAddress, account, options);
+  }
+  async getTRXBalance(account, options) {
+    const { isCatchError = false } = options || {};
+    await this.waitForTronWeb();
+    try {
+      const balance = await this.tronWeb.trx.getBalance(account);
+      return balance.toString();
+    } catch (error) {
+      this.csl("Tron getTRXBalance", "red-500", "Get TRX balance failed: %o", error);
+      if (isCatchError) {
+        throw error;
+      }
+      return "0";
+    }
+  }
+  async getTokenBalance(contractAddress, account, options) {
+    const { isCatchError = false } = options || {};
+    await this.waitForTronWeb();
+    try {
+      const contract = await this.tronWeb.contract().at(contractAddress);
+      const balance = await contract.balanceOf(account).call();
+      return balance.toString();
+    } catch (error) {
+      this.csl("Tron getTokenBalance", "red-500", "Get token balance failed: %o", error);
+      if (isCatchError) {
+        throw error;
+      }
+      return "0";
+    }
+  }
+  async balanceOf(token, account, options) {
+    return await this.getBalance(token, account, options);
+  }
+  /**
+   * Estimate gas limit for transfer transaction
+   * @param data Transfer data
+   * @returns Gas limit estimate (bandwidth or energy), gas price, and estimated gas cost
+   */
+  async estimateTransferGas(data) {
+    const { fromToken } = data;
+    const originAsset = fromToken.contractAddress;
+    let gasLimit;
+    if (originAsset === "TRX" || originAsset === "trx") {
+      gasLimit = 268n;
+    } else {
+      gasLimit = 30000n;
+    }
+    gasLimit = gasLimit * 120n / 100n;
+    let gasPrice = 100n;
+    const estimateGas = gasLimit * gasPrice;
+    return {
+      gasLimit,
+      gasPrice,
+      estimateGas
+    };
+  }
+  async getEstimateGas(params) {
+    const { gasLimit, price, nativeToken } = params;
+    const energyPrice = BigInt(100);
+    const estimateGas = Big__default.default(gasLimit.toString()).times(energyPrice.toString());
+    const estimateGasAmount = Big__default.default(estimateGas).div(10 ** nativeToken.decimals);
+    const estimateGasUsd = Big__default.default(estimateGasAmount).times(price || 1);
+    return {
+      gasPrice: energyPrice,
+      usd: core.numberRemoveEndZero(Big__default.default(estimateGasUsd).toFixed(20)),
+      wei: BigInt(estimateGas.toFixed(0)),
+      amount: core.numberRemoveEndZero(Big__default.default(estimateGasAmount).toFixed(nativeToken.decimals))
+    };
+  }
+  async estimateTransaction(params) {
+    const {
+      dry,
+      transactionParams,
+      fromToken,
+      prices,
+      defaultEnergyUsed,
+      defaultRawDataHexLength,
+      buffer
+    } = params;
+    const nativeTokenPrice = core.getPrice(prices, fromToken.nativeToken.symbol);
+    let energyUsed = defaultEnergyUsed || 2e5;
+    let rawDataHexLength = defaultRawDataHexLength || 1e3;
+    try {
+      const transaction = await this.tronWeb.transactionBuilder.triggerConstantContract(...transactionParams);
+      energyUsed = transaction.energy_used || 2e5;
+      rawDataHexLength = transaction.transaction.raw_data_hex.length || 1e3;
+    } catch (error) {
+      this.csl("Usdt0 Tron", "red-500", "estimateTransaction triggerConstantContract error: %o, action: %o", error, transactionParams?.[1]);
+    }
+    const bandwidthAmount = Big__default.default(Big__default.default(rawDataHexLength).div(2).plus(bridges.DATA_HEX_PROTOBUF_EXTRA).plus(bridges.SIGNATURE_SIZE)).times(1e-3);
+    const bandwidthUsed = Big__default.default(bandwidthAmount).div(100).times(10 ** fromToken.nativeToken.decimals);
+    let totalUsed = Big__default.default(energyUsed).plus(bandwidthUsed);
+    if (buffer) {
+      totalUsed = Big__default.default(totalUsed).times(Big__default.default(1).plus(buffer));
+    }
+    const { usd, wei } = await this.getEstimateGas({
+      gasLimit: totalUsed.toFixed(0),
+      price: nativeTokenPrice,
+      nativeToken: fromToken.nativeToken
+    });
+    const result = {
+      estimateSourceGasLimit: energyUsed,
+      estimateSourceGas: wei,
+      estimateSourceGasUsd: usd
+    };
+    return result;
+  }
+  async estimateApprove(params) {
+    const {
+      dry,
+      spender,
+      amountWei,
+      fromToken,
+      prices
+    } = params;
+    const approveParams = [
+      fromToken.contractAddress,
+      "approve(address,uint256)",
+      {},
+      [
+        { type: "address", value: spender },
+        { type: "uint256", value: amountWei }
+      ]
+    ];
+    return this.estimateTransaction({
+      dry,
+      transactionParams: approveParams,
+      fromToken,
+      prices,
+      defaultEnergyUsed: 1e5,
+      defaultRawDataHexLength: 500,
+      // +10%
+      buffer: 0.1
+    });
+  }
+  async pollingTransactionStatus(txHash, options) {
+    await this.waitForTronWeb();
+    const { maxPolls = 60, pollInterval = 2e3, isTRX } = options || {};
+    let pollCount = 0;
+    return new Promise((resolve) => {
+      const poll = async () => {
+        pollCount++;
+        this.csl("TronWallet pollingTransactionStatus", "teal-400", "polling transaction status (%s), %d times", txHash, pollCount);
+        try {
+          const txInfo = await this.tronWeb.trx.getTransactionInfo(txHash);
+          this.csl("TronWallet pollingTransactionStatus", "teal-400", "transaction info (%s): %o", txHash, txInfo);
+          if (txInfo && txInfo.receipt) {
+            if (isTRX) {
+              resolve(true);
+              return;
+            }
+            const result = txInfo.receipt.result;
+            if (result === "SUCCESS") {
+              this.csl("TronWallet pollingTransactionStatus", "teal-400", "transaction success (%s)", txHash);
+              resolve(true);
+              return;
+            } else if (result === "FAILED" || result === "REVERT") {
+              this.csl("TronWallet pollingTransactionStatus", "red-500", "transaction failed (%s), result: %s", txHash, result);
+              resolve(false);
+              return;
+            } else {
+              this.csl("TronWallet pollingTransactionStatus", "teal-400", "unknown transaction status (%s), result: %s, continue polling...", txHash, result);
+            }
+          } else {
+            this.csl("TronWallet pollingTransactionStatus", "teal-400", "transaction not confirmed (%s), continue polling...", txHash);
+          }
+        } catch (error) {
+          const errorMessage = error?.message || String(error);
+          if (errorMessage.includes("not found") || errorMessage.includes("does not exist") || errorMessage.includes("not exist")) {
+            this.csl("TronWallet pollingTransactionStatus", "teal-400", "transaction not on-chain (%s), continue polling...", txHash);
+          } else {
+            console.warn(`query transaction status error (${txHash}): %o`, errorMessage);
+          }
+        }
+        if (pollCount >= maxPolls) {
+          console.error(`polling timeout (${txHash}), maximum polling times reached: ${maxPolls}`);
+          resolve(false);
+          return;
+        }
+        setTimeout(poll, pollInterval);
+      };
+      poll();
+    });
+  }
+  async checkTransactionStatus(txHash) {
+    await this.waitForTronWeb();
+    try {
+      const txInfo = await this.tronWeb.trx.getTransactionInfo(txHash);
+      if (txInfo && txInfo.receipt) {
+        return txInfo.receipt.result === "SUCCESS";
+      }
+      return false;
+    } catch (error) {
+      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 {
+      dry,
+      contractAddress,
+      spender,
+      address,
+      amountWei,
+      strict = false
+    } = params;
+    const contract = await this.tronWeb.contract().at(contractAddress);
+    if (dry) {
+      return {
+        contract,
+        allowance: "0",
+        needApprove: false
+      };
+    }
+    await this.waitForTronWeb();
+    try {
+      let allowance = "0";
+      try {
+        const allowanceResult = await contract.allowance(address, spender).call();
+        allowance = allowanceResult.toString();
+      } catch (error) {
+        this.csl("TronWallet allowance", "red-500", "Error getting allowance: %o", error);
+        if (strict) {
+          throw error;
+        }
+      }
+      return {
+        contract,
+        allowance,
+        needApprove: Big__default.default(amountWei || 0).gt(allowance || 0)
+      };
+    } catch (error) {
+      this.csl("TronWallet allowance", "red-500", "Error in allowance: %o", error);
+      if (strict) {
+        throw error;
+      }
+      return {
+        contract: null,
+        allowance: "0",
+        needApprove: true
+      };
+    }
+  }
+  async approve(params) {
+    const {
+      contractAddress,
+      spender,
+      amountWei,
+      isApproveMax = false,
+      isDetails = false,
+      isWaitTxReceipt = true
+    } = params;
+    await this.waitForTronWeb();
+    const detailResult = {
+      success: false,
+      data: {},
+      message: null
+    };
+    try {
+      let _amountWei = amountWei;
+      if (isApproveMax) {
+        _amountWei = "115792089237316195423570985008687907853269984665640564039457584007913129639935";
+      }
+      const functionSelector = "approve(address,uint256)";
+      const parameter = [
+        { type: "address", value: spender },
+        { type: "uint256", value: _amountWei }
+      ];
+      const tx = await this.tronWeb.transactionBuilder.triggerSmartContract(
+        contractAddress,
+        functionSelector,
+        {},
+        parameter
+      );
+      const txHash = await this.sendTransaction({ tx });
+      let txInfo = null;
+      if (isWaitTxReceipt) {
+        const pollingResult = await this.pollingTransactionStatus(txHash, {
+          maxPolls: 120,
+          pollInterval: 2e3
+        });
+        if (!pollingResult) {
+          this.csl("TronWallet approve", "red-500", "Failed polling approve transaction status");
+          if (isDetails) {
+            detailResult.message = "Failed to get approve result";
+            return detailResult;
+          }
+          return false;
+        }
+        txInfo = await this.getTransactionResult(txHash);
+      }
+      if (isDetails) {
+        const txReceipt = txInfo?.receipt;
+        detailResult.success = true;
+        detailResult.data = {
+          txHash,
+          txInfo,
+          receiptResult: txReceipt?.result,
+          blockNumber: txInfo?.blockNumber,
+          blockTimeStamp: txInfo?.blockTimeStamp
+        };
+        return detailResult;
+      }
+      return txHash;
+    } catch (error) {
+      this.csl("TronWallet approve", "red-500", "Error approve: %o", error);
+      if (isDetails) {
+        detailResult.message = error.message;
+        return detailResult;
+      }
+      return false;
+    }
+  }
+  toBytes32(addr) {
+    const hex = this.tronWeb.address.toHex(addr).slice(2);
+    return "0x" + hex.padStart(64, "0");
+  }
+  async quoteOFT(params) {
+    const {
+      dry,
+      abi,
+      dstEid,
+      recipient,
+      amountWei,
+      slippageTolerance,
+      payInLzToken,
+      fromToken,
+      toToken,
+      prices,
+      originLayerzeroAddress,
+      destinationLayerzeroAddress,
+      excludeFees,
+      refundTo,
+      multiHopComposer,
+      isMultiHopComposer,
+      isOriginLegacy,
+      isDestinationLegacy,
+      originLayerzero,
+      destinationLayerzero
+    } = params;
+    const { Options } = await import('@layerzerolabs/lz-v2-utilities');
+    const result = {
+      needApprove: false,
+      approveSpender: originLayerzeroAddress,
+      sendParam: void 0,
+      quoteParam: {
+        ...params,
+        originLayerzeroAddress,
+        destinationLayerzeroAddress
+      },
+      fees: {},
+      totalFeesUsd: void 0,
+      estimateSourceGas: void 0,
+      totalEstimateSourceGas: 0n,
+      estimateSourceGasUsd: void 0,
+      estimateTime: 0,
+      // seconds - dynamically calculated using LayerZero formula
+      outputAmount: core.numberRemoveEndZero(Big__default.default(amountWei || 0).div(10 ** params.fromToken.decimals).toFixed(params.fromToken.decimals, 0))
+    };
+    const execTime = new core.ExecTime({ type: "USDT0 Tron", logStyle: "indigo-300", isDebug: core.OpenAPI.DEBUG });
+    await this.waitForTronWeb();
+    execTime.log("waitForTronWeb");
+    execTime.breakpoint();
+    const oftContract = await this.tronWeb.contract(abi, originLayerzeroAddress);
+    execTime.log("tronWeb.contract originLayerzeroAddress");
+    execTime.breakpoint();
+    const userAddress = refundTo || this.tronWeb.defaultAddress.base58;
+    const approvalRequired = isOriginLegacy ? originLayerzero.oftLegacyApprovalRequired : originLayerzero.oftApprovalRequired;
+    execTime.log("approvalRequired");
+    const lzReceiveOptionGas = isDestinationLegacy ? destinationLayerzero.lzReceiveOptionGasLegacy : destinationLayerzero.lzReceiveOptionGas;
+    let lzReceiveOptionValue = 0;
+    execTime.breakpoint();
+    const destATA = await utilsSolana.getDestinationAssociatedTokenAddress({
+      recipient,
+      toToken
+    });
+    execTime.log("getDestinationAssociatedTokenAddress");
+    if (destATA.needCreateTokenAccount) {
+      lzReceiveOptionValue = bridges.LZ_RECEIVE_VALUE[toToken.chainName] || 0;
+    }
+    let unMultiHopExtraOptions = Options.newOptions().toHex();
+    if (!isMultiHopComposer && lzReceiveOptionValue) {
+      unMultiHopExtraOptions = Options.newOptions().addExecutorLzReceiveOption(lzReceiveOptionGas, lzReceiveOptionValue).toHex();
+    }
+    const sendParam = [
+      // dstEid
+      dstEid,
+      // to
+      // "0x0000000000000000000000000000000000000000000000000000000000000000",
+      core.addressToBytes32(toToken.chainType, recipient),
+      // amountLD
+      amountWei,
+      // minAmountLD
+      "0",
+      // extraOptions
+      unMultiHopExtraOptions,
+      // composeMsg
+      "0x",
+      // oftCmd
+      "0x"
+    ];
+    if (isMultiHopComposer) {
+      sendParam[0] = multiHopComposer.eid;
+      sendParam[1] = core.addressToBytes32("evm", multiHopComposer.oftMultiHopComposer);
+    }
+    if (!dry) {
+      execTime.breakpoint();
+      const oftData = await oftContract.quoteOFT(sendParam).call();
+      execTime.log("quoteOFT");
+      const [, , oftReceipt] = oftData;
+      sendParam[3] = Big__default.default(oftReceipt[1].toString()).times(Big__default.default(1).minus(Big__default.default(slippageTolerance || 0).div(100))).toFixed(0);
+    }
+    if (isMultiHopComposer) {
+      let multiHopExtraOptions = Options.newOptions().toHex();
+      if (lzReceiveOptionValue) {
+        multiHopExtraOptions = Options.newOptions().addExecutorLzReceiveOption(lzReceiveOptionGas, lzReceiveOptionValue).toHex();
+      }
+      const composeMsgSendParam = {
+        dstEid,
+        to: core.addressToBytes32(toToken.chainType, recipient),
+        amountLD: sendParam[2],
+        minAmountLD: sendParam[3],
+        extraOptions: multiHopExtraOptions,
+        composeMsg: "0x",
+        oftCmd: "0x"
+      };
+      execTime.breakpoint();
+      const hopMsgFee = await bridges.getHopMsgFee({
+        sendParam: composeMsgSendParam,
+        toToken
+      });
+      execTime.log("getHopMsgFee");
+      sendParam[4] = Options.newOptions().addExecutorComposeOption(0, originLayerzero.composeOptionGas || 8e5, hopMsgFee).toHex();
+      const abiCoder = ethers.ethers.AbiCoder.defaultAbiCoder();
+      sendParam[5] = abiCoder.encode(
+        ["tuple(uint32 dstEid, bytes32 to, uint256 amountLD, uint256 minAmountLD, bytes extraOptions, bytes composeMsg, bytes oftCmd)"],
+        [Object.values(composeMsgSendParam)]
+      );
+    }
+    execTime.breakpoint();
+    const mergedCalls = [
+      oftContract.quoteSend(sendParam, payInLzToken).call()
+    ];
+    if (approvalRequired) {
+      mergedCalls.push(
+        this.allowance({
+          dry,
+          contractAddress: fromToken.contractAddress,
+          spender: originLayerzeroAddress,
+          address: userAddress,
+          amountWei
+        })
+      );
+    }
+    const [msgFee, allowanceResult] = await Promise.all(mergedCalls);
+    if (approvalRequired) {
+      result.needApprove = allowanceResult.needApprove;
+    }
+    execTime.log("quoteSend & allowance", "allowanceResult: %o", allowanceResult);
+    let nativeMsgFee = msgFee[0]["nativeFee"];
+    this.csl("Tron quoteOFT", "red-600", "nativeFee: %o", nativeMsgFee);
+    if (nativeMsgFee) {
+      nativeMsgFee = BigInt(Big__default.default(nativeMsgFee.toString()).times(Number(utilsEvm.NATIVE_MSG_FEE_BUFFER) / 100).toFixed(0));
+    }
+    this.csl("Tron quoteOFT", "red-600", "nativeFee after buffer: %o", nativeMsgFee);
+    result.totalEstimateSourceGas = nativeMsgFee;
+    this.csl("TronWallet quoteOFT", "teal-400", "MsgFee: %o", msgFee);
+    result.sendParam = {
+      param: [
+        // sendParam
+        sendParam,
+        // feeParam
+        [
+          // nativeFee
+          nativeMsgFee.toString(),
+          // lzTokenFee
+          msgFee[0]["lzTokenFee"].toString()
+        ],
+        // refundAddress
+        refundTo
+      ],
+      options: { callValue: nativeMsgFee.toString() }
+    };
+    const nativeFeeUsd = Big__default.default(nativeMsgFee?.toString() || 0).div(10 ** fromToken.nativeToken.decimals).times(core.getPrice(prices, fromToken.nativeToken.symbol));
+    result.fees.nativeFee = core.numberRemoveEndZero(Big__default.default(nativeMsgFee?.toString() || 0).div(10 ** fromToken.nativeToken.decimals).toFixed(fromToken.nativeToken.decimals));
+    result.fees.nativeFeeUsd = core.numberRemoveEndZero(Big__default.default(nativeFeeUsd).toFixed(20));
+    result.fees.lzTokenFeeUsd = core.numberRemoveEndZero(Big__default.default(msgFee[0]["lzTokenFee"]?.toString() || 0).div(10 ** fromToken.decimals).toFixed(20));
+    if (isOriginLegacy || isDestinationLegacy) {
+      result.fees.legacyMeshFeeUsd = core.numberRemoveEndZero(Big__default.default(amountWei || 0).div(10 ** fromToken.decimals).times(bridges.USDT0_LEGACY_MESH_TRANSFTER_FEE).toFixed(fromToken.decimals));
+      result.outputAmount = core.numberRemoveEndZero(Big__default.default(Big__default.default(amountWei || 0).div(10 ** params.fromToken.decimals)).minus(result.fees.legacyMeshFeeUsd || 0).toFixed(params.fromToken.decimals, 0));
+    }
+    const transactionParams = [
+      originLayerzeroAddress,
+      "send((uint32,bytes32,uint256,uint256,bytes,bytes,bytes),(uint256,uint256),address)",
+      result.sendParam.options,
+      [
+        {
+          type: "tuple(uint32,bytes32,uint256,uint256,bytes,bytes,bytes)",
+          value: result.sendParam.param[0]
+        },
+        {
+          type: "tuple(uint256,uint256)",
+          value: result.sendParam.param[1]
+        },
+        {
+          type: "address",
+          value: result.sendParam.param[2]
+        }
+      ],
+      this.tronWeb.defaultAddress.base58 || refundTo
+    ];
+    if (!dry) {
+      execTime.breakpoint();
+      const tx = await this.tronWeb.transactionBuilder.triggerSmartContract(...transactionParams);
+      execTime.log("transactionBuilder.triggerSmartContract");
+      result.sendParam.tx = tx;
+    }
+    execTime.breakpoint();
+    const ett = await this.estimateTransaction({
+      dry,
+      transactionParams,
+      fromToken,
+      prices,
+      defaultEnergyUsed: 3e5,
+      defaultRawDataHexLength: 1e3
+    });
+    execTime.log("estimateTransaction");
+    result.fees.estimateGasUsd = ett.estimateSourceGasUsd;
+    result.estimateSourceGas = ett.estimateSourceGas;
+    result.totalEstimateSourceGas += ett.estimateSourceGas;
+    result.estimateSourceGasUsd = ett.estimateSourceGasUsd;
+    if (result.needApprove) {
+      execTime.breakpoint();
+      const estApproveGas = await this.estimateApprove({
+        dry,
+        amountWei,
+        spender: result.approveSpender,
+        fromToken,
+        prices
+      });
+      result.estimateApproveGas = estApproveGas.estimateSourceGas;
+      execTime.log("estimateApprove");
+    }
+    for (const feeKey in result.fees) {
+      if (excludeFees.includes(feeKey) || !/Usd$/.test(feeKey)) {
+        continue;
+      }
+      result.totalFeesUsd = Big__default.default(result.totalFeesUsd || 0).plus(result.fees[feeKey] || 0);
+    }
+    result.totalFeesUsd = core.numberRemoveEndZero(Big__default.default(result.totalFeesUsd).toFixed(20));
+    result.sendParam.transactionParams = transactionParams;
+    execTime.log("quoteOFT");
+    return result;
+  }
+  async sendTransaction(params) {
+    const {
+      tx
+    } = params;
+    const transaction = tx?.transaction;
+    if (!transaction?.raw_data) {
+      throw new Error("Invalid transaction");
+    }
+    this.csl("Tron sendTransaction", "red-400", "transaction: %o", transaction);
+    const startTimestamp = Date.now();
+    const expirationDuration = 5 * 60 * 1e3;
+    const expiration = startTimestamp + expirationDuration;
+    let transactionWithExpiration = {
+      ...transaction,
+      raw_data: {
+        ...transaction.raw_data,
+        expiration
+      }
+    };
+    try {
+      await this.waitForTronWeb();
+      transactionWithExpiration = await this.tronWeb.transactionBuilder.newTxID(transactionWithExpiration, { txLocal: true });
+    } catch (error) {
+      console.warn("Failed to refresh transaction ID after extending expiration:", error);
+    }
+    this.csl("Tron sendTransaction", "red-400", "override transaction: %o", transactionWithExpiration);
+    const result = await this.signAndSendTransaction(transactionWithExpiration);
+    this.csl("Tron sendTransaction", "red-400", "Transaction sent with result: %o", result);
+    if (typeof result === "object") {
+      const code = result.code ? String(result.code) : "";
+      const message = result.message ? String(result.message) : "";
+      const combined = `${code} ${message}`.toUpperCase();
+      if (combined.includes("TRANSACTION_EXPIRATION_ERROR") || combined.includes("TRANSACTION_EXPIRED") || combined.includes("EXPIRED")) {
+        throw new Error("Transaction expired. Try again.");
+      }
+    }
+    this.csl("Tron sendTransaction", "red-400", "success: %o", result);
+    if (typeof result === "string") {
+      return result;
+    }
+    return result?.txid || result?.txID || transactionWithExpiration.txID;
+  }
+  /**
+   * Unified quote method that routes to specific quote methods based on type
+   * @param type Service type from Service
+   * @param params Parameters for the quote
+   */
+  async quote(type, params) {
+    switch (type) {
+      case core.Service.Usdt0:
+        return await this.quoteOFT(params);
+      case core.Service.OneClick:
+        return await this.quoteOneClickProxy(params);
+      default:
+        throw new Error(`Unsupported quote type: ${type}`);
+    }
+  }
+  /**
+   * Unified send method that routes to specific send methods based on type
+   * @param type Send type from SendType enum
+   * @param params Parameters for the send transaction
+   */
+  async send(type, params) {
+    switch (type) {
+      case core.SendType.SEND:
+        return await this.sendTransaction(params);
+      case core.SendType.TRANSFER:
+        return await this.transfer(params);
+      default:
+        throw new Error(`Unsupported send type: ${type}`);
+    }
+  }
+  async quoteOneClickProxy(params) {
+    const {
+      dry,
+      proxyAddress,
+      abi,
+      fromToken,
+      refundTo,
+      depositAddress,
+      amountWei,
+      prices
+    } = params;
+    const result = { fees: {} };
+    const execTime = new core.ExecTime({ type: "Oneclick Tron", logStyle: "indigo-400", isDebug: core.OpenAPI.DEBUG });
+    await this.waitForTronWeb();
+    execTime.log("waitForTronWeb");
+    const userAddress = refundTo || this.tronWeb.defaultAddress.base58;
+    execTime.breakpoint();
+    const allowance = await this.allowance({
+      dry,
+      contractAddress: fromToken.contractAddress,
+      address: userAddress,
+      spender: proxyAddress,
+      amountWei
+    });
+    result.needApprove = allowance.needApprove;
+    result.approveSpender = proxyAddress;
+    execTime.log("allowance");
+    const proxyParam = [
+      // tokenAddress
+      fromToken.contractAddress,
+      // recipient
+      depositAddress,
+      // amount
+      amountWei
+    ];
+    result.sendParam = {
+      param: proxyParam
+    };
+    const transactionParams = [
+      proxyAddress,
+      "proxyTransfer(address,address,uint256)",
+      {},
+      [
+        {
+          type: "address",
+          value: result.sendParam.param[0]
+          // tokenAddress
+        },
+        {
+          type: "address",
+          value: result.sendParam.param[1]
+          // recipient
+        },
+        {
+          type: "uint256",
+          value: result.sendParam.param[2]
+          // amount
+        }
+      ],
+      this.tronWeb.defaultAddress.base58 || refundTo
+    ];
+    execTime.breakpoint();
+    const tx = await this.tronWeb.transactionBuilder.triggerSmartContract(...transactionParams);
+    execTime.log("transactionBuilder.triggerSmartContract");
+    result.sendParam.tx = tx;
+    execTime.breakpoint();
+    const ett = await this.estimateTransaction({
+      dry,
+      transactionParams,
+      fromToken,
+      prices,
+      defaultEnergyUsed: 2e5,
+      defaultRawDataHexLength: 500
+    });
+    execTime.log("estimateTransaction");
+    result.fees.estimateGasUsd = ett.estimateSourceGasUsd;
+    result.estimateSourceGas = ett.estimateSourceGas;
+    result.totalEstimateSourceGas = ett.estimateSourceGas;
+    result.estimateSourceGasUsd = ett.estimateSourceGasUsd;
+    if (result.needApprove) {
+      execTime.breakpoint();
+      const estApproveGas = await this.estimateApprove({
+        dry,
+        amountWei,
+        spender: result.approveSpender,
+        fromToken,
+        prices
+      });
+      result.estimateApproveGas = estApproveGas.estimateSourceGas;
+      execTime.log("estimateApprove");
+    }
+    result.sendParam.transactionParams = transactionParams;
+    execTime.logTotal("quoteOneClickPorxy");
+    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);
+          this.csl("TronWallet getAccountResources", "teal-400", "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;
+  }
+};
+
+exports.TronWallet = TronWallet;
+exports.default = TronWallet;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map