@swapkit/toolboxes 1.0.0-beta.22 → 1.0.0-beta.24

package/src/evm/__tests__/address-validation.test.ts

@@ -0,0 +1,86 @@
+import { beforeAll, describe, expect, test } from "bun:test";
+import { Chain } from "@swapkit/helpers";
+import { getEvmToolbox } from "../toolbox";
+
+const context: {
+  validateAddress: (address: string) => boolean;
+} = {} as any;
+
+beforeAll(async () => {
+  // Get EVM toolbox for address validation
+  const toolbox = await getEvmToolbox(Chain.Ethereum);
+  context.validateAddress = toolbox.validateAddress;
+});
+
+describe("EVM Address Validation", () => {
+  test("should validate valid EVM addresses", () => {
+    const validAddresses = [
+      "0xa052Ddf1c1739419B90FB7bf722843AD3e63114B", // User provided address
+      "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC contract
+      "0x6d6e022eE439C8aB8B7a7dBb0576f8090319CDc6", // Test address
+      "0xE29E61479420Dd1029A9946710Ac31A0d140e77F", // Another valid address
+      "0x0000000000000000000000000000000000000000", // Zero address
+      "0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF", // Max address
+      "0x1234567890123456789012345678901234567890", // Mixed case
+    ];
+
+    for (const address of validAddresses) {
+      expect(context.validateAddress(address)).toBe(true);
+    }
+  });
+
+  test("should reject invalid EVM addresses", () => {
+    const invalidAddresses = [
+      "", // Empty string
+      "invalid", // Random string
+      "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t", // TRON address
+      "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa", // Bitcoin address
+      "cosmos1abc123", // Cosmos address
+      "0xa052Ddf1c1739419B90FB7bf722843AD3e63114", // Too short (missing 1 char)
+      "0xa052Ddf1c1739419B90FB7bf722843AD3e63114BB", // Too long (extra char)
+      "0XA052DDF1C1739419B90FB7BF722843AD3E63114B", // Uppercase 0X prefix
+      "0xG052Ddf1c1739419B90FB7bf722843AD3e63114B", // Invalid hex character
+      "0x", // Only prefix
+    ];
+
+    for (const address of invalidAddresses) {
+      expect(context.validateAddress(address)).toBe(false);
+    }
+  });
+
+  test("should handle case normalization properly", () => {
+    const address = "0xa052Ddf1c1739419B90FB7bf722843AD3e63114B"; // Proper checksum
+    const lowerCase = address.toLowerCase();
+
+    // Valid case variations should be accepted
+    expect(context.validateAddress(address)).toBe(true);
+    expect(context.validateAddress(lowerCase)).toBe(true);
+  });
+
+  test("should reject invalid checksum addresses", () => {
+    const invalidChecksumAddress = "0xA052dDF1C1739419b90fb7BF722843ad3E63114b"; // Invalid checksum
+
+    // Should reject mixed case with invalid checksum
+    expect(context.validateAddress(invalidChecksumAddress)).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);
+    }
+  });
+
+  test("should validate checksummed addresses", () => {
+    const checksummedAddresses = [
+      "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC with proper checksum
+      "0x6d6e022eE439C8aB8B7a7dBb0576f8090319CDc6", // Another checksummed address
+    ];
+
+    for (const address of checksummedAddresses) {
+      expect(context.validateAddress(address)).toBe(true);
+    }
+  });
+});

package/src/index.ts

@@ -192,6 +192,7 @@ export async function getToolbox<T extends keyof Toolboxes>(
       Chain.Dogecoin,
       Chain.BitcoinCash,
       Chain.Bitcoin,
+      Chain.Zcash,
       async () => {
         const { getUtxoToolbox } = await import("@swapkit/toolboxes/utxo");
         const utxoToolbox = await getUtxoToolbox(

package/src/near/__tests__/core.test.ts

@@ -0,0 +1,80 @@
+import { beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { AssetValue, Chain, SKConfig } from "@swapkit/helpers";
+import { providers } from "near-api-js";
+import { getFullAccessPublicKey } from "../helpers/core";
+import { getNearToolbox } from "../toolbox";
+
+const accountId = "ea03292d08136cca439513a33c76af083e5204eceb4ce720320fff84071a447f";
+
+const context: {
+  provider: providers.JsonRpcProvider;
+  toolbox: Awaited<ReturnType<typeof getNearToolbox>>;
+} = {} as any;
+
+beforeAll(() => {
+  context.provider = new providers.JsonRpcProvider({
+    url: SKConfig.get("rpcUrls")[Chain.Near],
+  });
+});
+
+beforeEach(async () => {
+  context.toolbox = await getNearToolbox();
+});
+
+describe("NEAR createTransaction", () => {
+  test("should retrieve full access public key for valid account", async () => {
+    const toolbox = context.toolbox;
+
+    const transaction = await toolbox.createTransaction({
+      recipient: accountId, // Self transfer
+      assetValue: AssetValue.from({
+        chain: Chain.Near,
+        value: "0.001", // Small amount
+      }),
+      sender: accountId,
+      feeRate: 300000000000000, // 300 TGas
+    });
+
+    expect(transaction).toBeDefined();
+    expect(transaction.publicKey).toBeDefined();
+    expect(transaction.serialized).toBeDefined();
+  }, 30000);
+
+  test("should throw error for invalid account", async () => {
+    const provider = context.provider;
+    const invalidAccountId = "non-existent-account-12345.testnet";
+
+    await expect(async () => {
+      await getFullAccessPublicKey(provider, invalidAccountId);
+    }).toThrow();
+  }, 10000);
+
+  test("should handle network errors gracefully", async () => {
+    const invalidProvider = new providers.JsonRpcProvider({ url: "https://invalid-rpc-url.test" });
+
+    await expect(async () => {
+      await getFullAccessPublicKey(invalidProvider, "any-account.testnet");
+    }).toThrow();
+  }, 10000);
+
+  test("should work with contract function call transaction", async () => {
+    const toolbox = context.toolbox;
+    const provider = context.provider;
+
+    const contractTransaction = await toolbox.createContractFunctionCall({
+      sender: accountId,
+      contractId: "wrap.testnet", // Known testnet contract
+      methodName: "storage_deposit",
+      args: { account_id: accountId },
+      gas: "300000000000000", // 300 TGas
+      attachedDeposit: "1250000000000000000000", // 0.00125 NEAR for storage
+    });
+
+    expect(contractTransaction).toBeDefined();
+    expect(contractTransaction.publicKey).toBeDefined();
+
+    // Verify the public key can be retrieved directly
+    const { publicKey } = await getFullAccessPublicKey(provider, accountId);
+    expect(publicKey.toString()).toBe(contractTransaction.publicKey);
+  }, 30000);
+});

package/src/near/helpers/core.ts

@@ -82,5 +82,8 @@ export async function getFullAccessPublicKey(provider: Provider, accountId: stri
   }
 
   const { utils } = await import("near-api-js");
-  return utils.PublicKey.fromString(fullAccessKey.public_key);
+  const publicKey = utils.PublicKey.fromString(fullAccessKey.public_key);
+  const nonce = (fullAccessKey.access_key.nonce as number) || 0;
+
+  return { publicKey, nonce };
 }

package/src/near/toolbox.ts

@@ -50,9 +50,6 @@ export async function getNearToolbox(toolboxParams?: NearToolboxParams) {
   const provider = new providers.JsonRpcProvider({ url });
 
   async function getAccount(address?: string) {
-    if (!signer) {
-      throw new SwapKitError("toolbox_near_no_signer");
-    }
     const { Account } = await import("near-api-js");
 
     const _address = address || (await getAddress());
@@ -118,19 +115,31 @@ export async function getNearToolbox(toolboxParams?: NearToolboxParams) {
   }
 
   async function createTransaction(params: NearCreateTransactionParams) {
-    const { recipient, assetValue, memo, feeRate: gas, attachedDeposit, sender } = params;
+    const { recipient, assetValue, memo, feeRate: gas, attachedDeposit, sender: signerId } = params;
 
-    const signerId = sender || (await getAddress());
-    const publicKey = await getFullAccessPublicKey(provider, signerId);
-
-    const accessKey = await provider.query({
-      request_type: "view_access_key",
-      finality: "final",
-      account_id: signerId,
-    });
+    // Handle NEP-141 token transfers
+    if (!assetValue.isGasAsset) {
+      const contractId = assetValue.address;
+      if (!contractId) {
+        throw new SwapKitError("toolbox_near_missing_contract_address");
+      }
 
-    const nonce = (accessKey as any).nonce + 1;
+      return createContractFunctionCall({
+        sender: signerId,
+        contractId,
+        methodName: "ft_transfer",
+        args: {
+          receiver_id: recipient,
+          amount: assetValue.getBaseValue("string"),
+          memo: memo || null,
+        },
+        gas: gas.toString() || "100000000000000", // 100 TGas default
+        attachedDeposit: "1", // 1 yoctoNEAR required for NEP-141 transfers
+      });
+    }
 
+    // Native NEAR transfer
+    const { publicKey, nonce } = await getFullAccessPublicKey(provider, signerId);
     const baseAmount = assetValue.getBaseValue("bigint");
 
     const { SCHEMA } = await import("near-api-js/lib/transaction");
@@ -163,7 +172,7 @@ export async function getNearToolbox(toolboxParams?: NearToolboxParams) {
       serialized: serializedBase64,
       publicKey: publicKey.toString(),
       details: {
-        signerId: await getAddress(),
+        signerId,
         nonce: nonce,
         blockHash: utils.serialize.base_encode(blockHash),
       },
@@ -171,24 +180,16 @@ export async function getNearToolbox(toolboxParams?: NearToolboxParams) {
   }
 
   async function createContractFunctionCall(params: {
-    accountId: string;
+    sender: string;
     contractId: string;
     methodName: string;
     args: any;
     gas: string;
     attachedDeposit: string;
   }) {
-    const { accountId } = params;
+    const { sender: accountId } = params;
 
-    const publicKey = await getFullAccessPublicKey(provider, accountId);
-
-    const accessKey = await provider.query({
-      request_type: "view_access_key",
-      finality: "final",
-      account_id: accountId,
-      public_key: publicKey.toString(),
-    });
-    const nonce = (accessKey as any).nonce + 1;
+    const { publicKey, nonce } = await getFullAccessPublicKey(provider, accountId);
 
     const { SCHEMA } = await import("near-api-js/lib/transaction");
     const { transactions, utils } = await import("near-api-js");

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 = {
@@ -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__/address-validation.test.ts

@@ -0,0 +1,123 @@
+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 transaction with valid addresses", async () => {
+    const toolbox = context.toolbox;
+    const fromAddress = await toolbox.getAddress();
+    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,
+      assetValue: AssetValue.from({
+        chain: Chain.Tron,
+        value: "1", // 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/toolbox.ts

@@ -8,7 +8,6 @@ import {
   updateDerivationPath,
   warnOnce,
 } from "@swapkit/helpers";
-import { TronWeb } from "tronweb";
 import { P, match } from "ts-pattern";
 
 import { trc20ABI } from "./helpers/trc20.abi.js";
@@ -21,8 +20,11 @@ import type {
 } from "./types.js";
 
 export async function getTronAddressValidator() {
-  const { TronWeb } = await import("tronweb");
-  return (address: string) => TronWeb.isAddress(address);
+  const { TronWeb } = require("tronweb");
+
+  return (address: string) => {
+    return TronWeb.isAddress(address);
+  };
 }
 
 export async function getTronPrivateKeyFromMnemonic({
@@ -63,6 +65,7 @@ async function createKeysForPath({
 }) {
   const { HDKey } = await import("@scure/bip32");
   const { mnemonicToSeedSync } = await import("@scure/bip39");
+  const { TronWeb } = require("tronweb");
 
   const seed = mnemonicToSeedSync(phrase);
   const hdKey = HDKey.fromMasterSeed(seed);
@@ -93,6 +96,7 @@ async function createKeysForPath({
 }
 
 export const createTronToolbox = async (options: TronToolboxOptions = {}) => {
+  const { TronWeb } = await import("tronweb");
   // 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
@@ -122,10 +126,6 @@ export const createTronToolbox = async (options: TronToolboxOptions = {}) => {
     return await signer.getAddress();
   };
 
-  const validateAddress = (address: string) => {
-    return tronWeb.isAddress(address);
-  };
-
   const calculateFeeLimit = () => {
     return 100_000_000; // 100 TRX in SUN
   };
@@ -267,7 +267,7 @@ export const createTronToolbox = async (options: TronToolboxOptions = {}) => {
         return tronWeb.transactionBuilder.addUpdateData(transaction, memo, "utf8");
       }
 
-      return transaction.raw_data_hex;
+      return transaction;
     }
 
     // For TRC20, we would need to build the transaction manually
@@ -294,7 +294,7 @@ export const createTronToolbox = async (options: TronToolboxOptions = {}) => {
       from,
     );
 
-    return result.transaction.raw_data_hex;
+    return result.transaction;
   };
 
   const signTransaction = async (transaction: TronTransaction) => {
@@ -310,7 +310,7 @@ export const createTronToolbox = async (options: TronToolboxOptions = {}) => {
   return {
     tronWeb,
     getAddress,
-    validateAddress,
+    validateAddress: await getTronAddressValidator(),
     getBalance,
     transfer,
     estimateTransactionFee,