@swapkit/toolboxes 1.0.0-beta.2 → 1.0.0-beta.20

package/src/ripple/index.ts

@@ -3,7 +3,6 @@ import {
   BaseDecimal,
   Chain,
   type ChainSigner,
-  type GenericCreateTransactionParams,
   type GenericTransferParams,
   SKConfig,
   SwapKitError,
@@ -14,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);
@@ -65,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;
 
@@ -82,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,
@@ -111,10 +112,7 @@ export const getRippleToolbox = async (params: RippleToolboxParams = {}) => {
     recipient,
     memo,
     sender,
-  }: Omit<GenericCreateTransactionParams, "feeRate">) => {
-    if (!signer) {
-      throw new SwapKitError({ errorKey: "toolbox_ripple_signer_not_found" });
-    }
+  }: { assetValue: AssetValue; recipient: string; sender?: string; memo?: string }) => {
     if (!rippleValidateAddress(recipient)) {
       throw new SwapKitError({ errorKey: "core_transaction_invalid_recipient_address" });
     }
@@ -152,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 },
     });
   };
 
@@ -181,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
@@ -198,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,79 @@ 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({
+        chain: Chain.Solana,
+        symbol,
+        address: mintAddress,
+        value: amount,
+        fromBaseDecimal: decimals,
+      }),
+    );
+  }
+
+  return balances;
+}
+
 export async function getSolanaAddressValidator() {
   const { PublicKey } = await import("@solana/web3.js");
 
@@ -68,7 +137,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/substrate.ts

@@ -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 });
   }
 }
 

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>>;

package/src/tron/toolbox.ts

@@ -0,0 +1,328 @@
+import {
+  AssetValue,
+  Chain,
+  NetworkDerivationPath,
+  SKConfig,
+  SwapKitError,
+  derivationPathToString,
+  updateDerivationPath,
+  warnOnce,
+} from "@swapkit/helpers";
+import { TronWeb } from "tronweb";
+import { P, match } from "ts-pattern";
+
+import { trc20ABI } from "./helpers/trc20.abi.js";
+import type {
+  TronSignedTransaction,
+  TronSigner,
+  TronToolboxOptions,
+  TronTransaction,
+  TronTransferParams,
+} from "./types.js";
+
+export async function getTronAddressValidator() {
+  const { TronWeb } = await import("tronweb");
+  return (address: string) => TronWeb.isAddress(address);
+}
+
+export async function getTronPrivateKeyFromMnemonic({
+  phrase,
+  derivationPath: customPath,
+  index,
+}: {
+  phrase: string;
+  derivationPath?: string;
+  index?: number;
+}) {
+  const derivationPathToUse =
+    customPath ||
+    derivationPathToString(
+      updateDerivationPath(NetworkDerivationPath[Chain.Tron], { index: index || 0 }),
+    );
+
+  const { HDKey } = await import("@scure/bip32");
+  const { mnemonicToSeedSync } = await import("@scure/bip39");
+
+  const seed = mnemonicToSeedSync(phrase);
+  const hdKey = HDKey.fromMasterSeed(seed);
+  const derived = hdKey.derive(derivationPathToUse);
+
+  if (!derived.privateKey) {
+    throw new SwapKitError("toolbox_tron_no_signer");
+  }
+
+  return Buffer.from(derived.privateKey).toString("hex");
+}
+
+async function createKeysForPath({
+  phrase,
+  derivationPath,
+}: {
+  phrase: string;
+  derivationPath: string;
+}): Promise<TronSigner> {
+  const { HDKey } = await import("@scure/bip32");
+  const { mnemonicToSeedSync } = await import("@scure/bip39");
+
+  const seed = mnemonicToSeedSync(phrase);
+  const hdKey = HDKey.fromMasterSeed(seed);
+  const derived = hdKey.derive(derivationPath);
+
+  if (!derived.privateKey) {
+    throw new SwapKitError("toolbox_tron_no_signer");
+  }
+
+  // Convert private key to hex string for TronWeb
+  const privateKeyHex = Buffer.from(derived.privateKey).toString("hex");
+
+  // Create TronWeb instance with the derived private key
+  const tronWebWithKey = new TronWeb({
+    fullHost: SKConfig.get("rpcUrls")[Chain.Tron],
+    privateKey: privateKeyHex,
+  });
+
+  const address = tronWebWithKey.address.fromPrivateKey(privateKeyHex);
+
+  return {
+    getAddress: () => Promise.resolve(typeof address === "string" ? address : ""),
+    signTransaction: async (transaction: TronTransaction) => {
+      const signedTx = await tronWebWithKey.trx.sign(transaction, privateKeyHex);
+      return signedTx;
+    },
+  };
+}
+
+export const createTronToolbox = async (options: TronToolboxOptions = {}) => {
+  // Always get configuration from SKConfig
+  const rpcUrl = SKConfig.get("rpcUrls")[Chain.Tron];
+  // Note: TRON API key support can be added to SKConfig apiKeys when needed
+  const headers = undefined; // No API key needed for basic TronGrid access
+
+  const tronWeb = new TronWeb({
+    fullHost: rpcUrl,
+    headers,
+  });
+
+  // Handle derivation path and index
+  const index = "index" in options ? options.index || 0 : 0;
+  const derivationPath = derivationPathToString(
+    "derivationPath" in options && options.derivationPath
+      ? options.derivationPath
+      : updateDerivationPath(NetworkDerivationPath[Chain.Tron], { index }),
+  );
+
+  // Create signer based on options using pattern matching
+  const signer: TronSigner | undefined = await match(options)
+    .with({ phrase: P.string }, async ({ phrase }) => createKeysForPath({ phrase, derivationPath }))
+    .with({ signer: P.any }, ({ signer }) => Promise.resolve(signer as TronSigner))
+    .otherwise(() => Promise.resolve(undefined));
+
+  const getAddress = async () => {
+    if (!signer) throw new SwapKitError("toolbox_tron_no_signer");
+    return await signer.getAddress();
+  };
+
+  const validateAddress = (address: string) => {
+    return tronWeb.isAddress(address);
+  };
+
+  const getContractAddress = (assetValue: AssetValue) => {
+    // Use asset.address for TRC20 contracts instead of parsing string
+    return assetValue.address;
+  };
+
+  const calculateFeeLimit = () => {
+    return 100_000_000; // 100 TRX in SUN
+  };
+
+  const getBalance = async (address: string, scamFilter = true) => {
+    const { getBalance: getBalanceFromApi } = await import("../utils.js");
+
+    try {
+      // Use SwapKit API for comprehensive balance fetching (includes TRX + TRC20 tokens)
+      const apiBalances = await getBalanceFromApi(Chain.Tron)(address, scamFilter);
+
+      // If API returns balances, use those
+      if (apiBalances.length > 0) {
+        return apiBalances;
+      }
+
+      // 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
+        }),
+      ];
+    } catch (error) {
+      warnOnce(
+        true,
+        `Failed to get Tron balance for ${address}: ${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 [
+          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 transfer = async ({ recipient, assetValue, memo }: TronTransferParams) => {
+    if (!signer) throw new SwapKitError("toolbox_tron_no_signer");
+
+    const from = await getAddress();
+    const isNative = assetValue.isGasAsset;
+
+    if (isNative) {
+      // Native TRX Transfer (amount in SUN - base units)
+      const transaction = await tronWeb.transactionBuilder.sendTrx(
+        recipient,
+        assetValue.getBaseValue("number"),
+        from,
+      );
+
+      // Add memo if provided
+      if (memo) {
+        const transactionWithMemo = await tronWeb.transactionBuilder.addUpdateData(
+          transaction,
+          memo,
+          "utf8",
+        );
+        const signedTx = await signer.signTransaction(transactionWithMemo);
+        const { txid } = await tronWeb.trx.sendRawTransaction(signedTx);
+        return txid;
+      }
+
+      const signedTx = await signer.signTransaction(transaction);
+      const { txid } = await tronWeb.trx.sendRawTransaction(signedTx);
+      return txid;
+    }
+
+    // TRC20 Token Transfer
+    const contractAddress = getContractAddress(assetValue);
+    if (!contractAddress) {
+      throw new SwapKitError("toolbox_tron_invalid_token_identifier", {
+        identifier: assetValue.toString(),
+      });
+    }
+
+    const feeLimit = calculateFeeLimit();
+    const contract = await tronWeb.contract(trc20ABI, contractAddress);
+
+    if (!contract.methods?.transfer) {
+      throw new SwapKitError("toolbox_tron_token_transfer_failed");
+    }
+
+    const txid = await contract.methods
+      .transfer(recipient, assetValue.getBaseValue("string"))
+      .send({
+        from,
+        feeLimit,
+        callValue: 0,
+      });
+
+    if (!txid) {
+      throw new SwapKitError("toolbox_tron_token_transfer_failed");
+    }
+
+    return txid;
+  };
+
+  const estimateTransactionFee = ({ assetValue }: TronTransferParams) => {
+    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
+    }
+
+    // TRC20 transfers consume energy, estimate higher fee
+    return AssetValue.from({ chain: Chain.Tron, value: 10 }); // 10 TRX
+  };
+
+  const createTransaction = async (params: TronTransferParams) => {
+    if (!signer) throw new SwapKitError("toolbox_tron_no_signer");
+
+    const { recipient, assetValue, memo } = params;
+    const from = await getAddress();
+    const isNative = assetValue.isGasAsset;
+
+    if (isNative) {
+      const transaction = await tronWeb.transactionBuilder.sendTrx(
+        recipient,
+        assetValue.getBaseValue("number"),
+        from,
+      );
+
+      if (memo) {
+        return tronWeb.transactionBuilder.addUpdateData(transaction, memo, "utf8");
+      }
+
+      return transaction;
+    }
+
+    // For TRC20, we would need to build the transaction manually
+    // This is a simplified version - in practice, you'd build the contract call transaction
+    const contractAddress = getContractAddress(assetValue);
+    if (!contractAddress) {
+      throw new SwapKitError("toolbox_tron_invalid_token_identifier", {
+        identifier: assetValue.toString(),
+      });
+    }
+
+    // Build TRC20 transfer transaction
+    const functionSelector = "transfer(address,uint256)";
+    const parameter = [
+      { type: "address", value: recipient },
+      { type: "uint256", value: assetValue.getBaseValue("string") },
+    ];
+
+    const result = await tronWeb.transactionBuilder.triggerSmartContract(
+      contractAddress,
+      functionSelector,
+      {},
+      parameter,
+      from,
+    );
+
+    return result.transaction;
+  };
+
+  const signTransaction = async (transaction: TronTransaction) => {
+    if (!signer) throw new SwapKitError("toolbox_tron_no_signer");
+    return await signer.signTransaction(transaction);
+  };
+
+  const broadcastTransaction = async (signedTx: TronSignedTransaction) => {
+    const { txid } = await tronWeb.trx.sendRawTransaction(signedTx);
+    return txid;
+  };
+
+  return {
+    tronWeb,
+    getAddress,
+    validateAddress,
+    getBalance,
+    transfer,
+    estimateTransactionFee,
+    createTransaction,
+    signTransaction,
+    broadcastTransaction,
+  };
+};

package/src/tron/types.ts

@@ -0,0 +1,22 @@
+import type { DerivationPathArray, GenericTransferParams } from "@swapkit/helpers";
+import type { Contract, Types } from "tronweb";
+
+// Re-export TronWeb types for convenience
+export type TronTransaction = Types.Transaction;
+export type TronContract = Contract;
+export type TronSignedTransaction = Types.SignedTransaction;
+
+// Signer interface compatible with TronWeb and wallet implementations
+export interface TronSigner {
+  getAddress(): Promise<string>;
+  signTransaction(transaction: TronTransaction): Promise<TronSignedTransaction>;
+}
+
+export type TronToolboxOptions =
+  | { signer?: TronSigner }
+  | { phrase?: string; derivationPath?: DerivationPathArray; index?: number }
+  | {};
+
+export interface TronTransferParams extends GenericTransferParams {
+  // No additional fields needed - all inherited from GenericTransferParams
+}