@uswap/toolboxes 4.3.6

package/src/ton/__tests__/toolbox.test.ts

@@ -0,0 +1,63 @@
+import { beforeAll, describe, expect, test } from "bun:test";
+import { AssetValue, Chain } from "@uswap/helpers";
+import { getTONToolbox } from "../toolbox";
+
+const TEST_PHRASE = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about";
+const KNOWN_TON_ADDRESS = "EQCC1GV4iL5EkQqICYshf3AF7ESbceCYhVK-go1SkOMOBTNE";
+
+const context: { toolbox: Awaited<ReturnType<typeof getTONToolbox>> } = {} as any;
+
+beforeAll(async () => {
+  context.toolbox = await getTONToolbox({ phrase: TEST_PHRASE });
+});
+
+describe("TON Toolbox", () => {
+  test("should validate valid TON addresses", () => {
+    const validAddresses = [KNOWN_TON_ADDRESS, "EQBvW8Z5huBkMJYdnfAEM5JqTNkuWX3diqYENkWsIL0XggGG"];
+
+    for (const address of validAddresses) {
+      expect(context.toolbox.validateAddress(address)).toBe(true);
+    }
+  });
+
+  test("should reject invalid TON addresses", () => {
+    const invalidAddresses = [
+      "",
+      "invalid",
+      "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+      "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t",
+      "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa",
+    ];
+
+    for (const address of invalidAddresses) {
+      expect(context.toolbox.validateAddress(address)).toBe(false);
+    }
+  });
+
+  test("should generate valid TON address from phrase", () => {
+    const address = context.toolbox.getAddress();
+    expect(context.toolbox.validateAddress(address)).toBe(true);
+  });
+
+  test("should fetch balance for known address", async () => {
+    const balances = await context.toolbox.getBalance(KNOWN_TON_ADDRESS);
+    expect(balances[0]?.chain).toBe(Chain.Ton);
+    expect(balances[0]?.symbol).toBe("TON");
+  });
+
+  test("should estimate transaction fee", async () => {
+    const fee = await context.toolbox.estimateTransactionFee();
+    expect(fee.chain).toBe(Chain.Ton);
+    expect(fee.getValue("number")).toBeGreaterThan(0);
+  });
+
+  test("should create transaction without broadcasting", async () => {
+    const transferCell = await context.toolbox.createTransaction({
+      assetValue: AssetValue.from({ chain: Chain.Ton, value: "0.001" }),
+      recipient: KNOWN_TON_ADDRESS,
+    });
+
+    const hash = transferCell.hash().toString("hex");
+    expect(hash.length).toBeGreaterThan(0);
+  });
+});

package/src/ton/index.ts

@@ -0,0 +1,2 @@
+export * from "./toolbox";
+export * from "./types";

package/src/ton/toolbox.ts

@@ -0,0 +1,136 @@
+import type { Cell, OpenedContract, TonClient, WalletContractV4 } from "@ton/ton";
+import { AssetValue, Chain, getChainConfig, SwapKitError, SwapKitNumber } from "@uswap/helpers";
+import { match, P } from "ts-pattern";
+
+import type { TONSigner, TONToolboxParams, TONTransferParams } from "./types";
+
+export async function getTONToolbox(toolboxParams: TONToolboxParams = {}) {
+  const { mnemonicToWalletKey } = await import("@ton/crypto");
+  const { Address, TonClient, WalletContractV4 } = await import("@ton/ton");
+  const validateAddress = await getTONAddressValidator();
+  let client: TonClient;
+  let wallet: OpenedContract<WalletContractV4>;
+
+  const signer = await match(toolboxParams)
+    .with({ phrase: P.string }, async ({ phrase }) => mnemonicToWalletKey(phrase.split(" ")))
+    .with({ signer: P.any }, ({ signer }) => signer as TONSigner)
+    .otherwise(() => undefined);
+
+  function getClient() {
+    const { rpcUrls } = getChainConfig(Chain.Ton);
+    const [endpoint] = rpcUrls;
+
+    if (!client || client.parameters.endpoint !== endpoint) {
+      client = new TonClient({ endpoint });
+    }
+
+    return client;
+  }
+
+  function getWallet(paramSigner?: TONSigner) {
+    if (!wallet || paramSigner) {
+      const client = getClient();
+      const walletSigner = paramSigner || signer;
+
+      if (!walletSigner) {
+        throw new SwapKitError("core_wallet_connection_not_found");
+      }
+
+      const walletContract = WalletContractV4.create({ publicKey: walletSigner.publicKey, workchain: 0 });
+      const contract = client.open(walletContract);
+
+      wallet = contract;
+    }
+
+    return wallet;
+  }
+
+  async function getBalance(address: string) {
+    const client = getClient();
+    const { baseDecimal } = getChainConfig(Chain.Ton);
+
+    try {
+      const balance = await client.getBalance(Address.parse(address));
+      return [AssetValue.from({ chain: Chain.Ton, value: SwapKitNumber.fromBigInt(balance, baseDecimal) })];
+    } catch (error) {
+      throw new SwapKitError("core_wallet_connection_not_found", { error });
+    }
+  }
+
+  async function createTransaction({ assetValue, recipient, memo }: TONTransferParams) {
+    const wallet = getWallet();
+    if (!wallet || !signer) {
+      throw new SwapKitError("core_wallet_connection_not_found");
+    }
+
+    const { toNano, comment, internal } = await import("@ton/ton");
+    const seqno = await wallet.getSeqno();
+    const amount = toNano(assetValue.getValue("string"));
+    const messageBody = memo ? comment(memo) : undefined;
+
+    const transfer = wallet.createTransfer({
+      messages: [internal({ body: messageBody, to: recipient, value: amount })],
+      secretKey: signer.secretKey,
+      seqno,
+    });
+
+    return transfer;
+  }
+
+  async function transfer({ assetValue, recipient, memo }: TONTransferParams) {
+    const wallet = getWallet();
+    if (!wallet || !signer) {
+      throw new SwapKitError("core_wallet_connection_not_found");
+    }
+
+    const transfer = await createTransaction({ assetValue, memo, recipient });
+    await wallet.send(transfer);
+
+    return transfer.hash().toString();
+  }
+
+  async function sendTransaction(transferCell: Cell) {
+    const wallet = getWallet();
+    if (!wallet) {
+      throw new SwapKitError("core_wallet_connection_not_found");
+    }
+
+    try {
+      await wallet.send(transferCell);
+      return transferCell.hash().toString("hex");
+    } catch (error) {
+      throw new SwapKitError("core_wallet_connection_not_found", { error });
+    }
+  }
+
+  function getAddress() {
+    const wallet = getWallet();
+    return wallet.address.toString();
+  }
+
+  function estimateTransactionFee() {
+    return Promise.resolve(AssetValue.from({ chain: Chain.Ton, value: "0.0001" }));
+  }
+
+  return {
+    createTransaction,
+    estimateTransactionFee,
+    getAddress,
+    getBalance,
+    sendTransaction,
+    transfer,
+    validateAddress,
+  };
+}
+
+export async function getTONAddressValidator() {
+  const { Address } = await import("@ton/ton");
+  return function validateAddress(address: string) {
+    try {
+      Address.parse(address);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+}

package/src/ton/types.ts

@@ -0,0 +1,13 @@
+import type { AssetValue, DerivationPathArray, GenericTransferParams } from "@uswap/helpers";
+import type { getTONToolbox } from "./toolbox";
+
+export type TONSigner = { publicKey: any; secretKey: any };
+
+export type TONToolboxParams = { provider?: string } & (
+  | { signer?: TONSigner }
+  | { phrase?: string; derivationPath?: DerivationPathArray; index?: number }
+);
+
+export type TONTransferParams = GenericTransferParams & { assetValue: AssetValue; recipient: string; memo?: string };
+
+export type TONWallet = Awaited<ReturnType<typeof getTONToolbox>>;

package/src/tron/__tests__/toolbox.test.ts

@@ -0,0 +1,221 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { AssetValue, Chain, SKConfig } from "@uswap/helpers";
+import { createTronToolbox, getTronAddressValidator } from "../toolbox";
+
+const context: {
+  toolbox: Awaited<ReturnType<typeof createTronToolbox>>;
+  validateAddress: (address: string) => boolean;
+} = {} as any;
+
+beforeAll(async () => {
+  context.validateAddress = await getTronAddressValidator();
+});
+
+beforeEach(async () => {
+  context.toolbox = await createTronToolbox({ phrase: process.env.TEST_PHRASE });
+});
+
+afterAll(() => {
+  SKConfig.reinitialize();
+});
+
+describe("TRON Address Validation", () => {
+  test("should validate valid TRON addresses", () => {
+    const validAddresses = [
+      "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t", // USDT contract
+      "TLa2f6VPqDgRE67v1736s7bJ8Ray5wYjU7", // Mainnet address
+      "TQn9Y2khEsLJW1ChVWFMSMeRDow5KcbLSE", // Another valid address
+    ];
+
+    for (const address of validAddresses) {
+      expect(context.validateAddress(address)).toBe(true);
+      expect(context.toolbox.validateAddress(address)).toBe(true);
+    }
+  });
+
+  test("should reject invalid TRON addresses", () => {
+    const invalidAddresses = [
+      "",
+      "invalid",
+      "0x742d35Cc6648C532F5e7c3d2a7a8E1e1e5b7c8D3",
+      "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa",
+      "cosmos1abc123",
+      "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6",
+      "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6tt",
+      "XR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t",
+      "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6O",
+    ];
+
+    for (const address of invalidAddresses) {
+      expect(context.validateAddress(address)).toBe(false);
+      expect(context.toolbox.validateAddress(address)).toBe(false);
+    }
+  });
+
+  test("should create TRON transaction with valid addresses", async () => {
+    const toolbox = context.toolbox;
+    const fromAddress = "TQn9Y2khEsLJW1ChVWFMSMeRDow5KcbLSE";
+    const toAddress = "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t";
+
+    expect(toolbox.validateAddress(fromAddress)).toBe(true);
+    expect(toolbox.validateAddress(toAddress)).toBe(true);
+
+    const transaction = await toolbox.createTransaction({
+      assetValue: AssetValue.from({
+        chain: Chain.Tron,
+        value: "1", // 1 TRX
+      }),
+      recipient: toAddress,
+      sender: fromAddress,
+    });
+
+    expect(transaction).toBeDefined();
+    expect(transaction.raw_data_hex).toBeDefined();
+  });
+
+  test("should create TRON.USDT transaction with valid addresses", async () => {
+    const toolbox = context.toolbox;
+    const fromAddress = "TQn9Y2khEsLJW1ChVWFMSMeRDow5KcbLSE";
+    const toAddress = "TT87ESmqUmH87hMx1MKCEqYrJKaQyNg9ao";
+
+    expect(toolbox.validateAddress(fromAddress)).toBe(true);
+    expect(toolbox.validateAddress(toAddress)).toBe(true);
+
+    // Create a transaction
+    const transaction = await toolbox.createTransaction({
+      assetValue: AssetValue.from({
+        asset: "TRON.USDT-TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t",
+        value: "100", // 1 TRX
+      }),
+      recipient: toAddress,
+      sender: fromAddress,
+    });
+
+    expect(transaction).toBeDefined();
+    expect(transaction.raw_data_hex).toBeDefined();
+  });
+
+  test("should handle case sensitivity in addresses", () => {
+    const address = "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t";
+    const lowerCase = address.toLowerCase();
+    const upperCase = address.toUpperCase();
+
+    expect(context.validateAddress(address)).toBe(true);
+    expect(context.validateAddress(lowerCase)).toBe(false);
+    expect(context.validateAddress(upperCase)).toBe(false);
+  });
+
+  test("should handle edge cases", () => {
+    const edgeCases = [null, undefined, 123, {}, [], true, false];
+
+    for (const testCase of edgeCases) {
+      expect(context.validateAddress(testCase as any)).toBe(false);
+      expect(context.toolbox.validateAddress(testCase as any)).toBe(false);
+    }
+  });
+});
+
+describe("TRON createTransaction with Extended Expiration", () => {
+  const baseExpiration = 60; // default is 60s
+  const extendedExpiration = 240; // Adding 240 for 5 minutes total
+  const fromAddress = "TQn9Y2khEsLJW1ChVWFMSMeRDow5KcbLSE";
+  const toAddress = "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t";
+  const buffer = 10000;
+  const memo = "Test transfer with memo";
+
+  test("should create native TRX transfer with extended expiration", async () => {
+    const toolbox = context.toolbox;
+    const beforeTimestamp = Date.now();
+
+    const transaction = await toolbox.createTransaction({
+      assetValue: AssetValue.from({
+        chain: Chain.Tron,
+        value: "1", // 1 TRX
+      }),
+      expiration: extendedExpiration,
+      recipient: toAddress,
+      sender: fromAddress,
+    });
+
+    expect(transaction.raw_data.expiration).toBeDefined();
+
+    const expectedExpiration = beforeTimestamp + (baseExpiration + extendedExpiration) * 1000;
+    const actualExpiration = transaction.raw_data.expiration;
+
+    expect(actualExpiration).toBeGreaterThanOrEqual(expectedExpiration - buffer);
+    expect(actualExpiration).toBeLessThanOrEqual(expectedExpiration + buffer);
+  });
+
+  test("should create native TRX transfer with extended expiration and memo", async () => {
+    const toolbox = context.toolbox;
+    const beforeTimestamp = Date.now();
+
+    const transaction = await toolbox.createTransaction({
+      assetValue: AssetValue.from({
+        chain: Chain.Tron,
+        value: "1", // 1 TRX
+      }),
+      expiration: extendedExpiration,
+      memo,
+      recipient: toAddress,
+      sender: fromAddress,
+    });
+
+    expect(transaction.raw_data.expiration).toBeDefined();
+
+    const expectedExpiration = beforeTimestamp + (baseExpiration + extendedExpiration) * 1000;
+    const actualExpiration = transaction.raw_data.expiration;
+
+    expect(actualExpiration).toBeGreaterThanOrEqual(expectedExpiration - buffer);
+    expect(actualExpiration).toBeLessThanOrEqual(expectedExpiration + buffer);
+
+    expect(transaction.raw_data.data).toBeDefined();
+  });
+
+  test("should create token transfer with extended expiration", async () => {
+    const toolbox = context.toolbox;
+    const beforeTimestamp = Date.now();
+
+    const transaction = await toolbox.createTransaction({
+      assetValue: AssetValue.from({
+        asset: "TRON.USDT-TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t",
+        value: "100", // 100 USDT
+      }),
+      expiration: extendedExpiration,
+      recipient: toAddress,
+      sender: fromAddress,
+    });
+
+    expect(transaction.raw_data.expiration).toBeDefined();
+
+    const expectedExpiration = beforeTimestamp + (baseExpiration + extendedExpiration) * 1000;
+    const actualExpiration = transaction.raw_data.expiration;
+
+    // Allow 10 second tolerance for test execution time
+    expect(actualExpiration).toBeGreaterThanOrEqual(expectedExpiration - buffer);
+    expect(actualExpiration).toBeLessThanOrEqual(expectedExpiration + buffer);
+  });
+
+  test("should create token transfer with extended expiration and memo", async () => {
+    const toolbox = context.toolbox;
+    const beforeTimestamp = Date.now();
+
+    const transaction = await toolbox.createTransaction({
+      assetValue: AssetValue.from({
+        asset: "TRON.USDT-TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t",
+        value: "100", // 100 USDT
+      }),
+      expiration: extendedExpiration,
+      memo,
+      recipient: toAddress,
+      sender: fromAddress,
+    });
+
+    const expectedExpiration = beforeTimestamp + (baseExpiration + extendedExpiration) * 1000;
+    const actualExpiration = transaction.raw_data.expiration;
+
+    expect(actualExpiration).toBeGreaterThanOrEqual(expectedExpiration - buffer);
+    expect(actualExpiration).toBeLessThanOrEqual(expectedExpiration + buffer);
+    expect(transaction.raw_data).toMatchObject({ data: expect.any(String), expiration: expect.any(Number) });
+  });
+});

package/src/tron/helpers/trc20.abi.ts

@@ -0,0 +1,107 @@
+export const trc20ABI = [
+  {
+    constant: true,
+    inputs: [{ name: "_owner", type: "address" }],
+    name: "balanceOf",
+    outputs: [{ name: "balance", type: "uint256" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    constant: false,
+    inputs: [
+      { name: "_to", type: "address" },
+      { name: "_value", type: "uint256" },
+    ],
+    name: "transfer",
+    outputs: [{ name: "success", type: "bool" }],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: "decimals",
+    outputs: [{ name: "", type: "uint8" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: "symbol",
+    outputs: [{ name: "", type: "string" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: "name",
+    outputs: [{ name: "", type: "string" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    constant: true,
+    inputs: [
+      { name: "_owner", type: "address" },
+      { name: "_spender", type: "address" },
+    ],
+    name: "allowance",
+    outputs: [{ name: "remaining", type: "uint256" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    constant: false,
+    inputs: [
+      { name: "_spender", type: "address" },
+      { name: "_value", type: "uint256" },
+    ],
+    name: "approve",
+    outputs: [{ name: "success", type: "bool" }],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: "totalSupply",
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    constant: false,
+    inputs: [
+      { name: "_from", type: "address" },
+      { name: "_to", type: "address" },
+      { name: "_value", type: "uint256" },
+    ],
+    name: "transferFrom",
+    outputs: [{ name: "success", type: "bool" }],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, name: "_from", type: "address" },
+      { indexed: true, name: "_to", type: "address" },
+      { indexed: false, name: "_value", type: "uint256" },
+    ],
+    name: "Transfer",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, name: "_owner", type: "address" },
+      { indexed: true, name: "_spender", type: "address" },
+      { indexed: false, name: "_value", type: "uint256" },
+    ],
+    name: "Approval",
+    type: "event",
+  },
+] as const;

package/src/tron/helpers/trongrid.ts

@@ -0,0 +1,53 @@
+import { SwapKitError } from "@uswap/helpers";
+import type { TronGridAccountResponse } from "../types";
+
+const TRONGRID_API_BASE = "https://api.trongrid.io";
+
+/**
+ * Fetch account information including TRC20 balances from TronGrid API
+ */
+export async function fetchAccountFromTronGrid(address: string) {
+  const TW = await import("tronweb");
+  const TronWeb = TW.TronWeb ?? TW.default?.TronWeb;
+
+  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", {
+      address,
+      message: error instanceof Error ? error.message : "Unknown error",
+    });
+  }
+}

package/src/tron/index.ts

@@ -0,0 +1,21 @@
+export { trc20ABI } from "./helpers/trc20.abi";
+export {
+  createTronToolbox,
+  getTronAddressValidator,
+  getTronPrivateKeyFromMnemonic,
+} from "./toolbox";
+export type {
+  TronApprovedParams,
+  TronApproveParams,
+  TronContract,
+  TronCreateTransactionParams,
+  TronIsApprovedParams,
+  TronSignedTransaction,
+  TronSigner,
+  TronToolboxOptions,
+  TronTransaction,
+  TronTransferParams,
+} from "./types";
+
+import type { createTronToolbox } from "./toolbox";
+export type TronWallet = Awaited<ReturnType<typeof createTronToolbox>>;