@swapkit/toolboxes 1.0.0-beta.9 → 4.0.0-beta.36

package/src/ripple/index.ts

@@ -13,6 +13,12 @@ import { Client, type Payment, Wallet, isValidAddress, xrpToDrops } from "xrpl";
 
 export type RippleWallet = Awaited<ReturnType<typeof getRippleToolbox>>;
 
+export { hashes, type Transaction } from "xrpl";
+
+const RIPPLE_ERROR_CODES = {
+  ACCOUNT_NOT_FOUND: 19,
+} as const;
+
 // Note: Ripple seeds generate a single address, no derivation path/index support.
 function createSigner(phrase: string): ChainSigner<Transaction, { tx_blob: string; hash: string }> {
   const wallet = Wallet.fromMnemonic(phrase);
@@ -64,11 +70,7 @@ export const getRippleToolbox = async (params: RippleToolboxParams = {}) => {
     const addr = address || (await getAddress());
 
     try {
-      await client.connect();
-      const accountInfo = await client.request({
-        command: "account_info",
-        account: addr,
-      });
+      const accountInfo = await client.request({ command: "account_info", account: addr });
 
       const balance = accountInfo.result.account_data.Balance;
 
@@ -81,7 +83,7 @@ export const getRippleToolbox = async (params: RippleToolboxParams = {}) => {
       ];
     } catch (error) {
       // empty account
-      if ((error as any).data.error_code === 19) {
+      if ((error as any).data.error_code === RIPPLE_ERROR_CODES.ACCOUNT_NOT_FOUND) {
         return [
           AssetValue.from({
             chain: Chain.Ripple,
@@ -148,22 +150,15 @@ export const getRippleToolbox = async (params: RippleToolboxParams = {}) => {
 
   const broadcastTransaction = async (signedTxHex: string) => {
     const submitResult = await client.submitAndWait(signedTxHex);
-    // Cast result to any to bypass potential type mismatches in xrpl.js definitions
-    const result: any = submitResult.result;
+    const result = submitResult.result;
 
-    // Check engine_result directly on result
-    if (result.engine_result === "tesSUCCESS" || result.engine_result === "terQUEUED") {
-      // Access hash from tx_json if available, otherwise fallback to result.hash
-      return result.tx_json?.hash || result.hash;
+    if (result.validated) {
+      return result.hash;
     }
 
-    const message = result.engine_result_message || "Unknown error";
-    const code = result.engine_result || "Unknown code";
-
     throw new SwapKitError({
       errorKey: "toolbox_ripple_broadcast_error",
-      info: { chain: Chain.Ripple, message, code, result },
-      // Remove explicit message when using object format
+      info: { chain: Chain.Ripple },
     });
   };
 
@@ -177,9 +172,7 @@ export const getRippleToolbox = async (params: RippleToolboxParams = {}) => {
     return broadcastTransaction(signedTx.tx_blob);
   };
 
-  // Disconnect client on demand or handle elsewhere?
-  // For now, let's assume connection is managed outside or persists.
-  // const disconnect = () => client.disconnect();
+  const disconnect = () => client.disconnect();
 
   return {
     // Signer related
@@ -194,6 +187,6 @@ export const getRippleToolbox = async (params: RippleToolboxParams = {}) => {
     broadcastTransaction,
     transfer,
     estimateTransactionFee,
-    // disconnect, // Optional: expose disconnect
+    disconnect,
   };
 };

package/src/solana/toolbox.ts

@@ -22,10 +22,77 @@ import {
 import { P } from "ts-pattern";
 import { match } from "ts-pattern";
 import type { SolanaCreateTransactionParams, SolanaProvider, SolanaTransferParams } from ".";
-import { getBalance } from "../utils";
 
 type SolanaSigner = SolanaProvider | Signer;
 
+type TokenMetadata = {
+  name: string;
+  symbol: string;
+  decimals: number;
+  logoURI?: string;
+  tags?: string[];
+  daily_volume?: number;
+};
+
+async function fetchTokenMetaData(mintAddress: string): Promise<TokenMetadata | null> {
+  try {
+    const response = await fetch(`https://lite-api.jup.ag/tokens/v1/token/${mintAddress}`);
+    if (!response.ok) return null;
+    return await response.json();
+  } catch {
+    return null;
+  }
+}
+
+async function getSolanaBalance(address: string) {
+  const connection = await getConnection();
+  const { PublicKey } = await import("@solana/web3.js");
+  const { TOKEN_PROGRAM_ID } = await import("@solana/spl-token");
+  const publicKey = new PublicKey(address);
+
+  const balances: AssetValue[] = [];
+
+  // Get SOL balance
+  const solBalance = await connection.getBalance(publicKey);
+  if (solBalance > 0) {
+    balances.push(
+      AssetValue.from({
+        chain: Chain.Solana,
+        value: solBalance,
+        fromBaseDecimal: BaseDecimal[Chain.Solana],
+      }),
+    );
+  }
+
+  // Get token balances
+  const tokenAccounts = await connection.getParsedTokenAccountsByOwner(publicKey, {
+    programId: TOKEN_PROGRAM_ID,
+  });
+
+  for (const { account } of tokenAccounts.value) {
+    const tokenInfo = account.data.parsed.info;
+    const mintAddress = tokenInfo.mint;
+    const amount = tokenInfo.tokenAmount.amount;
+
+    if (Number(amount) === 0) continue;
+
+    // Fetch token metadata from Jupiter
+    const metadata = await fetchTokenMetaData(mintAddress);
+    const symbol = metadata?.symbol || "UNKNOWN";
+    const decimals = metadata?.decimals || tokenInfo.tokenAmount.decimals;
+
+    balances.push(
+      AssetValue.from({
+        asset: `${Chain.Solana}.${symbol}-${mintAddress}`,
+        value: amount,
+        fromBaseDecimal: decimals,
+      }),
+    );
+  }
+
+  return balances;
+}
+
 export async function getSolanaAddressValidator() {
   const { PublicKey } = await import("@solana/web3.js");
 
@@ -68,7 +135,11 @@ export async function getSolanaToolbox(
     getPubkeyFromAddress,
     createTransaction: createTransaction(getConnection),
     createTransactionFromInstructions,
-    getBalance: getBalance(Chain.Solana),
+    getBalance: (addressParam?: string) => {
+      const address = addressParam || getAddress();
+      if (!address) throw new SwapKitError("core_wallet_connection_not_found");
+      return getSolanaBalance(address);
+    },
     transfer: transfer(getConnection, signer),
     broadcastTransaction: broadcastTransaction(getConnection),
     getAddressValidator: getSolanaAddressValidator,

package/src/substrate/balance.ts

@@ -0,0 +1,92 @@
+import type { ApiPromise } from "@polkadot/api";
+import { AssetValue, Chain, SwapKitNumber } from "@swapkit/helpers";
+
+/**
+ * Get balance for standard Substrate chains (Polkadot, etc.)
+ * Uses api.query.system.account to query free and reserved balances
+ */
+export async function getSubstrateBalance(
+  api: ApiPromise,
+  gasAsset: AssetValue,
+  address: string,
+): Promise<AssetValue[]> {
+  try {
+    const account = await api.query.system?.account?.(address);
+
+    if (!account) {
+      return [gasAsset.set(0)];
+    }
+
+    const {
+      // @ts-expect-error
+      data: { free },
+    } = account;
+
+    // Convert the free balance to string using SwapKitNumber for proper decimal handling
+    const freeBalance = SwapKitNumber.fromBigInt(
+      BigInt(free.toString()),
+      gasAsset.decimal,
+    ).getValue("string");
+
+    return [gasAsset.set(freeBalance)];
+  } catch (error) {
+    console.error("Error fetching substrate balance:", error);
+    return [gasAsset.set(0)];
+  }
+}
+
+/**
+ * Get balance for Chainflip chain
+ * Uses api.query.flip.account to query FLIP balances
+ */
+export async function getChainflipBalance(
+  api: ApiPromise,
+  gasAsset: AssetValue,
+  address: string,
+): Promise<AssetValue[]> {
+  try {
+    // Chainflip uses a custom flip pallet for account balances
+    const flipAccount = await api.query.flip?.account?.(address);
+
+    if (!flipAccount) {
+      return [gasAsset.set(0)];
+    }
+
+    // Extract balance from the flip account structure
+    // The structure has a balance field directly
+    //@ts-expect-error
+    const balance = flipAccount.balance || flipAccount.data?.balance;
+
+    if (!balance || balance.isEmpty) {
+      return [gasAsset.set(0)];
+    }
+
+    // Convert balance to string using SwapKitNumber
+    const balanceStr = SwapKitNumber.fromBigInt(
+      BigInt(balance.toString()),
+      gasAsset.decimal,
+    ).getValue("string");
+
+    return [gasAsset.set(balanceStr)];
+  } catch (error) {
+    console.error("Error fetching chainflip balance:", error);
+    return [gasAsset.set(0)];
+  }
+}
+
+/**
+ * Factory function to create chain-specific balance getter
+ */
+export function createBalanceGetter(chain: Chain, api: ApiPromise) {
+  return function getBalance(address: string): Promise<AssetValue[]> {
+    const gasAsset = AssetValue.from({ chain });
+
+    switch (chain) {
+      case Chain.Chainflip:
+        return getChainflipBalance(api, gasAsset, address);
+
+      default:
+        return getSubstrateBalance(api, gasAsset, address);
+    }
+  };
+}

package/src/substrate/substrate.ts

@@ -19,7 +19,7 @@ import {
 } from "@swapkit/helpers";
 
 import { P, match } from "ts-pattern";
-import { getBalance } from "../utils";
+import { createBalanceGetter } from "./balance";
 import { SubstrateNetwork, type SubstrateTransferParams } from "./types";
 
 export const PolkadotToolbox = ({ generic = false, ...signerParams }: ToolboxParams = {}) => {
@@ -36,7 +36,7 @@ export const ChainflipToolbox = async ({
     ...signerParams,
   });
 
-  return { ...toolbox, getBalance: getBalance(Chain.Chainflip) };
+  return { ...toolbox };
 };
 
 export type SubstrateToolboxes = {
@@ -53,7 +53,7 @@ export function getSubstrateToolbox<T extends SubstrateChain>(chain: T, params?:
       return PolkadotToolbox(params);
     }
     default:
-      throw new Error(`Chain ${chain} is not supported`);
+      throw new SwapKitError("toolbox_substrate_not_supported", { chain });
   }
 }
 
@@ -208,11 +208,13 @@ export const BaseSubstrateToolbox = ({
   network,
   gasAsset,
   signer,
+  chain,
 }: {
   api: ApiPromise;
   network: SubstrateNetwork;
   gasAsset: AssetValue;
   signer?: IKeyringPair | Signer;
+  chain?: SubstrateChain;
 }) => ({
   api,
   network,
@@ -220,7 +222,7 @@ export const BaseSubstrateToolbox = ({
   decodeAddress,
   encodeAddress,
   convertAddress,
-  getBalance: getBalance(Chain.Polkadot),
+  getBalance: createBalanceGetter(chain || Chain.Polkadot, api),
   createKeyring: (phrase: string) => createKeyring(phrase, network.prefix),
   getAddress: (keyring?: IKeyringPair | Signer) => {
     const keyringPair = keyring || signer;
@@ -301,7 +303,7 @@ export async function createSubstrateToolbox({
     .with({ signer: P.any }, ({ signer }) => signer)
     .otherwise(() => undefined);
 
-  return BaseSubstrateToolbox({ api, signer, gasAsset, network });
+  return BaseSubstrateToolbox({ api, signer, gasAsset, network, chain });
 }
 
 export type ToolboxParams = {

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

@@ -0,0 +1,147 @@
+import { beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { AssetValue, Chain, SKConfig } from "@swapkit/helpers";
+import { createTronToolbox, getTronAddressValidator } from "../toolbox";
+
+// Test mnemonic for consistent testing
+const TEST_PHRASE =
+  "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about";
+
+const context: {
+  toolbox: Awaited<ReturnType<typeof createTronToolbox>>;
+  validateAddress: (address: string) => boolean;
+} = {} as any;
+
+beforeAll(async () => {
+  // Set up TRON mainnet configuration
+  SKConfig.set({
+    rpcUrls: {
+      [Chain.Tron]: "https://api.trongrid.io",
+    },
+  });
+
+  // Get the address validator
+  context.validateAddress = await getTronAddressValidator();
+});
+
+beforeEach(async () => {
+  context.toolbox = await createTronToolbox({ phrase: TEST_PHRASE });
+});
+
+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 = [
+      "", // Empty string
+      "invalid", // Random string
+      "0x742d35Cc6648C532F5e7c3d2a7a8E1e1e5b7c8D3", // Ethereum address
+      "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa", // Bitcoin address
+      "cosmos1abc123", // Cosmos address
+      "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6", // Too short
+      "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6tt", // Too long
+      "XR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t", // Wrong prefix
+      "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6O", // Invalid checksum
+    ];
+
+    for (const address of invalidAddresses) {
+      expect(context.validateAddress(address)).toBe(false);
+      expect(context.toolbox.validateAddress(address)).toBe(false);
+    }
+  });
+
+  test("should validate address from generated account", async () => {
+    const toolbox = context.toolbox;
+
+    // Get address from the toolbox
+    const address = await toolbox.getAddress();
+
+    expect(address).toBeDefined();
+    expect(typeof address).toBe("string");
+    expect(address.length).toBeGreaterThan(0);
+
+    // The generated address should be valid
+    expect(context.validateAddress(address)).toBe(true);
+    expect(toolbox.validateAddress(address)).toBe(true);
+
+    // Address should start with 'T'
+    expect(address.startsWith("T")).toBe(true);
+  });
+
+  test("should create TRON transaction with valid addresses", async () => {
+    const toolbox = context.toolbox;
+    const fromAddress = "TQn9Y2khEsLJW1ChVWFMSMeRDow5KcbLSE";
+    const toAddress = "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t"; // Valid TRON address
+
+    // Both addresses should be valid
+    expect(toolbox.validateAddress(fromAddress)).toBe(true);
+    expect(toolbox.validateAddress(toAddress)).toBe(true);
+
+    // Create a transaction
+    const transaction = await toolbox.createTransaction({
+      recipient: toAddress,
+      sender: fromAddress,
+      assetValue: AssetValue.from({
+        chain: Chain.Tron,
+        value: "1", // 1 TRX
+      }),
+    });
+
+    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"; // Valid TRON address
+
+    // Both addresses should be valid
+    expect(toolbox.validateAddress(fromAddress)).toBe(true);
+    expect(toolbox.validateAddress(toAddress)).toBe(true);
+
+    // Create a transaction
+    const transaction = await toolbox.createTransaction({
+      recipient: toAddress,
+      sender: fromAddress,
+      assetValue: AssetValue.from({
+        asset: "TRX.USDT-TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t",
+        value: "100", // 1 TRX
+      }),
+    });
+
+    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();
+
+    // TRON addresses are case sensitive - only the original should be valid
+    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) {
+      // Should not throw but return false for invalid inputs
+      expect(context.validateAddress(testCase as any)).toBe(false);
+      expect(context.toolbox.validateAddress(testCase as any)).toBe(false);
+    }
+  });
+});

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

@@ -0,0 +1,40 @@
+export const trc20ABI = [
+  {
+    constant: true,
+    inputs: [{ name: "_owner", type: "address" }],
+    name: "balanceOf",
+    outputs: [{ name: "balance", type: "uint256" }],
+    type: "function",
+  },
+  {
+    constant: false,
+    inputs: [
+      { name: "_to", type: "address" },
+      { name: "_value", type: "uint256" },
+    ],
+    name: "transfer",
+    outputs: [{ name: "success", type: "bool" }],
+    type: "function",
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: "decimals",
+    outputs: [{ name: "", type: "uint8" }],
+    type: "function",
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: "symbol",
+    outputs: [{ name: "", type: "string" }],
+    type: "function",
+  },
+  {
+    constant: true,
+    inputs: [],
+    name: "name",
+    outputs: [{ name: "", type: "string" }],
+    type: "function",
+  },
+] as const;

package/src/tron/index.ts

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