@swapkit/toolboxes 4.0.0-beta.36 → 4.0.0-beta.38

package/src/tron/helpers/trongrid.ts

@@ -0,0 +1,54 @@
+import { SwapKitError } from "@swapkit/helpers";
+import { TronWeb } from "tronweb";
+import type { TronGridAccountResponse } from "../types.js";
+
+const TRONGRID_API_BASE = "https://api.trongrid.io";
+
+/**
+ * Fetch account information including TRC20 balances from TronGrid API
+ */
+export async function fetchAccountFromTronGrid(address: string) {
+  try {
+    const response = await fetch(`${TRONGRID_API_BASE}/v1/accounts/${address}`);
+
+    if (!response.ok) {
+      throw new Error(`TronGrid API error: ${response.status} ${response.statusText}`);
+    }
+
+    const data = (await response.json()) as TronGridAccountResponse;
+
+    if (!(data.success && data.data) || data.data.length === 0) {
+      throw new Error("Invalid response from TronGrid API");
+    }
+
+    // Convert search address to hex format for comparison
+    let searchAddressHex: string;
+    try {
+      // If address is base58, convert to hex
+      searchAddressHex = TronWeb.address.toHex(address).toLowerCase();
+    } catch {
+      // If conversion fails, assume it's already hex
+      searchAddressHex = address.toLowerCase();
+    }
+
+    // Find the account that matches the requested address
+    const account = data.data.find((acc) => {
+      return acc.address.toLowerCase() === searchAddressHex;
+    });
+
+    if (!account) {
+      return;
+    }
+
+    // Return simplified object with balance and trc20 array
+    return {
+      balance: account.balance,
+      trc20: account.trc20 || [],
+    };
+  } catch (error) {
+    throw new SwapKitError("toolbox_tron_trongrid_api_error", {
+      message: error instanceof Error ? error.message : "Unknown error",
+      address,
+    });
+  }
+}

package/src/tron/index.ts

@@ -9,6 +9,7 @@ export type {
   TronTransferParams,
   TronContract,
   TronTransaction,
+  TronSignedTransaction,
 } from "./types";
 export { trc20ABI } from "./helpers/trc20.abi";
 

package/src/tron/toolbox.ts

@@ -11,6 +11,7 @@ import {
 import { P, match } from "ts-pattern";
 
 import { trc20ABI } from "./helpers/trc20.abi.js";
+import { fetchAccountFromTronGrid } from "./helpers/trongrid.js";
 import type {
   TronCreateTransactionParams,
   TronSignedTransaction,
@@ -22,6 +23,14 @@ import type {
 
 import { TronWeb } from "tronweb";
 
+// Constants for TRON resource calculation
+const TRX_TRANSFER_BANDWIDTH = 268; // Bandwidth consumed by a TRX transfer
+const TRC20_TRANSFER_ENERGY = 13000; // Average energy consumed by TRC20 transfer
+const TRC20_TRANSFER_BANDWIDTH = 345; // Bandwidth consumed by TRC20 transfer
+
+// Known TRON tokens
+const TRON_USDT_CONTRACT = "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t";
+
 export async function getTronAddressValidator() {
   return (address: string) => {
     return TronWeb.isAddress(address);
@@ -131,50 +140,201 @@ export const createTronToolbox = async (options: TronToolboxOptions = {}) => {
     return 100_000_000; // 100 TRX in SUN
   };
 
-  const getBalance = async (address: string, scamFilter = true) => {
-    const { getBalance: getBalanceFromApi } = await import("../utils.js");
+  /**
+   * Get current chain parameters including resource prices
+   */
+  const getChainParameters = async () => {
+    try {
+      const parameters = await tronWeb.trx.getChainParameters();
+      const paramMap: Record<string, number> = {};
+
+      for (const param of parameters) {
+        paramMap[param.key] = param.value;
+      }
+
+      return {
+        energyFee: paramMap.getEnergyFee || 420, // SUN per energy unit
+        bandwidthFee: paramMap.getTransactionFee || 1000, // SUN per bandwidth unit
+        createAccountFee: paramMap.getCreateAccountFee || 100000, // 0.1 TRX in SUN
+      };
+    } catch {
+      // Return default values if unable to fetch
+      return {
+        energyFee: 420,
+        bandwidthFee: 1000,
+        createAccountFee: 100000,
+      };
+    }
+  };
+
+  /**
+   * Check if an address exists on the blockchain
+   */
+  const accountExists = async (address: string) => {
+    try {
+      const account = await tronWeb.trx.getAccount(address);
+      return account && Object.keys(account).length > 0;
+    } catch {
+      return false;
+    }
+  };
 
+  /**
+   * Get account resources (bandwidth and energy)
+   */
+  const getAccountResources = async (address: string) => {
     try {
-      // Use SwapKit API for comprehensive balance fetching (includes TRX + TRC20 tokens)
-      const apiBalances = await getBalanceFromApi(Chain.Tron)(address, scamFilter);
+      const resources = await tronWeb.trx.getAccountResources(address);
+
+      return {
+        bandwidth: {
+          free: resources.freeNetLimit - resources.freeNetUsed,
+          total: resources.NetLimit || 0,
+          used: resources.NetUsed || 0,
+        },
+        energy: {
+          total: resources.EnergyLimit || 0,
+          used: resources.EnergyUsed || 0,
+        },
+      };
+    } catch {
+      // Return default structure if unable to fetch
+      return {
+        bandwidth: { free: 600, total: 0, used: 0 }, // 600 free bandwidth daily
+        energy: { total: 0, used: 0 },
+      };
+    }
+  };
+
+  /**
+   * Get token balance and info directly from contract
+   */
+  const fetchTokenBalance = async (address: string, contractAddress: string) => {
+    try {
+      const contract = tronWeb.contract(trc20ABI, contractAddress);
 
-      // If API returns balances, use those
-      if (apiBalances.length > 0) {
-        return apiBalances;
+      if (!contract.methods?.balanceOf) {
+        return 0n;
       }
 
-      // Fallback to on-chain TRX balance if API fails or returns empty
-      const trxBalanceInSun = await tronWeb.trx.getBalance(address);
-      return [
-        AssetValue.from({
-          chain: Chain.Tron,
-          value: trxBalanceInSun,
-          fromBaseDecimal: 6, // TRX has 6 decimals
-        }),
-      ];
+      const balance = (await contract.methods.balanceOf(address).call())[0] as string;
+
+      return BigInt(balance || 0); // Convert to BigInt for consistency
+    } catch (err) {
+      console.warn(`balanceOf() failed for ${contractAddress}:`, err);
+      return 0n;
+    }
+  };
+
+  /**
+   * Get token balance and info directly from contract
+   */
+  const fetchTokenMetadata = async (contractAddress: string, address: string) => {
+    try {
+      tronWeb.setAddress(address); // Set address for contract calls
+      const contract = tronWeb.contract(trc20ABI, contractAddress);
+
+      const [symbolRaw, decimalsRaw] = await Promise.all([
+        contract
+          .symbol()
+          .call()
+          .catch(() => "UNKNOWN"),
+        contract
+          .decimals()
+          .call()
+          .catch(() => "18"),
+      ]);
+
+      return {
+        symbol: symbolRaw ?? "UNKNOWN",
+        decimals: Number(decimalsRaw ?? 18),
+      };
+    } catch (error) {
+      warnOnce(
+        true,
+        `Failed to get token balance for ${contractAddress}: ${error instanceof Error ? error.message : error}`,
+      );
+      return null;
+    }
+  };
+
+  // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: <explanation>
+  const getBalance = async (address: string, _scamFilter = true) => {
+    const fallbackBalance = [
+      AssetValue.from({
+        chain: Chain.Tron,
+      }),
+    ];
+    // Try primary source (TronGrid)
+    try {
+      const accountData = await fetchAccountFromTronGrid(address);
+      if (accountData) {
+        const balances: AssetValue[] = [];
+
+        // Add TRX balance
+        balances.push(
+          AssetValue.from({
+            chain: Chain.Tron,
+            value: accountData.balance,
+            fromBaseDecimal: 6,
+          }),
+        );
+
+        // Add TRC20 balances
+
+        for (const token of accountData.trc20) {
+          const [contractAddress, balance] = Object.entries(token)[0] || [];
+
+          if (!(contractAddress && balance)) continue;
+
+          const tokenMetaData = await fetchTokenMetadata(contractAddress, address);
+
+          if (!tokenMetaData) continue;
+
+          balances.push(
+            AssetValue.from({
+              asset: `TRX.${tokenMetaData.symbol}-${contractAddress}`,
+              value: BigInt(balance || 0),
+              fromBaseDecimal: tokenMetaData.decimals,
+            }),
+          );
+        }
+
+        return balances;
+      }
+      return fallbackBalance;
     } catch (error) {
       warnOnce(
         true,
-        `Failed to get Tron balance for ${address}: ${error instanceof Error ? error.message : error}`,
+        `Tron API getBalance failed: ${error instanceof Error ? error.message : error}`,
       );
 
-      // Final fallback: try to get just the native TRX balance
-      try {
-        const trxBalanceInSun = await tronWeb.trx.getBalance(address);
-        return [
+      // Fallback: get TRX and USDT directly
+      const balances: AssetValue[] = [];
+
+      const trxBalanceInSun = await tronWeb.trx.getBalance(address);
+      if (trxBalanceInSun && Number(trxBalanceInSun) > 0) {
+        balances.push(
           AssetValue.from({
             chain: Chain.Tron,
             value: trxBalanceInSun,
             fromBaseDecimal: 6,
           }),
-        ];
-      } catch (fallbackError) {
-        warnOnce(
-          true,
-          `Failed to get native TRX balance for ${address}: ${fallbackError instanceof Error ? fallbackError.message : fallbackError}`,
         );
-        return [];
       }
+
+      const usdtBalance = await fetchTokenBalance(address, TRON_USDT_CONTRACT);
+      if (usdtBalance) {
+        balances.push(
+          AssetValue.from({
+            asset: `TRX.USDT-${TRON_USDT_CONTRACT}`,
+            value: usdtBalance,
+            fromBaseDecimal: 6,
+          }),
+        );
+      }
+
+      return balances;
     }
   };
 
@@ -218,7 +378,7 @@ export const createTronToolbox = async (options: TronToolboxOptions = {}) => {
     }
 
     const feeLimit = calculateFeeLimit();
-    const contract = await tronWeb.contract(trc20ABI, contractAddress);
+    const contract = tronWeb.contract(trc20ABI, contractAddress);
 
     if (!contract.methods?.transfer) {
       throw new SwapKitError("toolbox_tron_token_transfer_failed");
@@ -239,17 +399,94 @@ export const createTronToolbox = async (options: TronToolboxOptions = {}) => {
     return txid;
   };
 
-  const estimateTransactionFee = ({ assetValue }: TronTransferParams) => {
+  const estimateTransactionFee = async ({
+    assetValue,
+    recipient,
+    sender,
+    // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: <explanation>
+  }: TronTransferParams & { sender?: string }) => {
     const isNative = assetValue.isGasAsset;
 
-    if (isNative) {
-      // Native TRX transfers typically consume bandwidth, which is free up to daily limit
-      // Return a minimal fee estimation for bandwidth cost
-      return AssetValue.from({ chain: Chain.Tron, value: 1 }); // 1 TRX
-    }
+    try {
+      // Get sender address
+      const senderAddress = sender ? sender : signer ? await getAddress() : undefined;
+      if (!senderAddress) {
+        // If no signer, return conservative estimate
+        return isNative
+          ? AssetValue.from({ chain: Chain.Tron, value: 0.1, fromBaseDecimal: 0 })
+          : AssetValue.from({ chain: Chain.Tron, value: 15, fromBaseDecimal: 0 });
+      }
+
+      // Get chain parameters for current resource prices
+      const chainParams = await getChainParameters();
 
-    // TRC20 transfers consume energy, estimate higher fee
-    return AssetValue.from({ chain: Chain.Tron, value: 10 }); // 10 TRX
+      // Check if recipient account exists (new accounts require activation fee)
+      const recipientExists = await accountExists(recipient);
+      const activationFee = recipientExists ? 0 : chainParams.createAccountFee;
+
+      // Get account resources
+      const resources = await getAccountResources(senderAddress);
+
+      if (isNative) {
+        // Calculate bandwidth needed for TRX transfer
+        const bandwidthNeeded = TRX_TRANSFER_BANDWIDTH;
+        const availableBandwidth =
+          resources.bandwidth.free + (resources.bandwidth.total - resources.bandwidth.used);
+
+        let bandwidthFee = 0;
+        if (bandwidthNeeded > availableBandwidth) {
+          // Need to burn TRX for bandwidth
+          const bandwidthToBuy = bandwidthNeeded - availableBandwidth;
+          bandwidthFee = bandwidthToBuy * chainParams.bandwidthFee;
+        }
+
+        // Total fee in SUN
+        const totalFeeSun = activationFee + bandwidthFee;
+
+        return AssetValue.from({
+          chain: Chain.Tron,
+          value: totalFeeSun,
+          fromBaseDecimal: 6, // SUN to TRX
+        });
+      }
+
+      // TRC20 Transfer - needs both bandwidth and energy
+      const bandwidthNeeded = TRC20_TRANSFER_BANDWIDTH;
+      const energyNeeded = TRC20_TRANSFER_ENERGY;
+
+      const availableBandwidth =
+        resources.bandwidth.free + (resources.bandwidth.total - resources.bandwidth.used);
+      const availableEnergy = resources.energy.total - resources.energy.used;
+
+      let bandwidthFee = 0;
+      if (bandwidthNeeded > availableBandwidth) {
+        const bandwidthToBuy = bandwidthNeeded - availableBandwidth;
+        bandwidthFee = bandwidthToBuy * chainParams.bandwidthFee;
+      }
+
+      let energyFee = 0;
+      if (energyNeeded > availableEnergy) {
+        const energyToBuy = energyNeeded - availableEnergy;
+        energyFee = energyToBuy * chainParams.energyFee;
+      }
+
+      // Total fee in SUN
+      const totalFeeSun = activationFee + bandwidthFee + energyFee;
+
+      return AssetValue.from({
+        chain: Chain.Tron,
+        value: totalFeeSun,
+        fromBaseDecimal: 6, // SUN to TRX
+      });
+    } catch (error) {
+      // Fallback to conservative estimates if calculation fails
+      warnOnce(
+        true,
+        `Failed to calculate exact fee, using conservative estimate: ${error instanceof Error ? error.message : error}`,
+      );
+
+      throw new SwapKitError("toolbox_tron_fee_estimation_failed", { error });
+    }
   };
 
   const createTransaction = async (params: TronCreateTransactionParams) => {

package/src/tron/types.ts

@@ -29,3 +29,70 @@ export interface TronCreateTransactionParams
   extends Omit<GenericCreateTransactionParams, "feeRate"> {
   // No additional fields needed - all inherited from GenericCreateTransactionParams
 }
+
+// TronGrid API Types
+export type TronGridTRC20Balance = Array<{
+  [contractAddress: string]: string; // Balance as string
+}>;
+
+export interface TronGridAccountResponse {
+  data: Array<{
+    address: string;
+    balance: number; // TRX balance in SUN
+    create_time: number;
+    latest_opration_time: number; // Note: typo in API response
+    free_net_usage: number;
+    net_window_size: number;
+    net_window_optimized: boolean;
+    trc20: TronGridTRC20Balance;
+    assetV2?: Array<{
+      key: string;
+      value: number;
+    }>;
+    frozenV2?: Array<{
+      type?: string;
+    }>;
+    free_asset_net_usageV2?: Array<{
+      key: string;
+      value: number;
+    }>;
+    latest_consume_free_time?: number;
+    owner_permission?: {
+      keys: Array<{
+        address: string;
+        weight: number;
+      }>;
+      threshold: number;
+      permission_name: string;
+    };
+    active_permission?: Array<{
+      operations: string;
+      keys: Array<{
+        address: string;
+        weight: number;
+      }>;
+      threshold: number;
+      id: number;
+      type: string;
+      permission_name: string;
+    }>;
+    account_resource?: {
+      energy_window_optimized: boolean;
+      energy_window_size: number;
+    };
+  }>;
+  success: boolean;
+  meta: {
+    at: number;
+    page_size: number;
+  };
+}
+
+export interface TronGridTokenInfo {
+  symbol: string;
+  address: string;
+  decimals: number;
+  name: string;
+  totalSupply: string;
+  owner: string;
+}

package/dist/chunk-6f98phv2.js

@@ -1,5 +0,0 @@
-import"./chunk-s47y8512.js";import{AssetValue as c,BaseDecimal as p}from"@swapkit/helpers";import{SwapKitApi as u}from"@swapkit/helpers/api";var l=typeof process!=="undefined"&&process.pid?process.pid.toString(36):"",a=0;function g(){function t(){let e=Date.now(),n=a||e;return a=n,e>a?e:n+1}return l+t().toString(36)}function w(t){return async function e(n,i=!0){return(await u.getChainBalance({chain:t,address:n,scamFilter:i})).map(({identifier:r,value:o,decimal:s})=>{return new c({decimal:s||p[t],value:o,identifier:r})})}}export{g as uniqid,w as getBalance};
-export{g as a,w as b};
-
-//# debugId=8C6F04B3BE4067A464756E2164756E21
-//# sourceMappingURL=chunk-6f98phv2.js.map