@swapkit/toolboxes 4.0.0-beta.50 → 4.0.0-beta.52

package/src/tron/types.ts

@@ -1,120 +0,0 @@
-import type {
-  DerivationPathArray,
-  FeeOption,
-  GenericCreateTransactionParams,
-  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
-}
-
-export interface TronCreateTransactionParams
-  extends Omit<GenericCreateTransactionParams, "feeRate"> {
-  // No additional fields needed - all inherited from GenericCreateTransactionParams
-}
-
-// Same as EVM types for consistency
-export type ApproveParams = {
-  assetAddress: string;
-  spenderAddress: string;
-  feeOptionKey?: FeeOption;
-  amount?: bigint | string | number; // BigNumberish equivalent for Tron
-  from?: string;
-  gasLimitFallback?: bigint | string | number;
-  nonce?: number;
-};
-
-export type ApprovedParams = {
-  assetAddress: string;
-  spenderAddress: string;
-  from: string;
-};
-
-export type IsApprovedParams = ApprovedParams & {
-  amount?: bigint | string | number;
-};
-
-// 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/src/utils.ts

@@ -1,27 +0,0 @@
-import { AssetValue, BaseDecimal, type Chain } from "@swapkit/helpers";
-import { SwapKitApi } from "@swapkit/helpers/api";
-
-const pid = typeof process !== "undefined" && process.pid ? process.pid.toString(36) : "";
-
-let last = 0;
-export function uniqid() {
-  function now() {
-    const time = Date.now();
-    const lastTime = last || time;
-    last = lastTime;
-
-    return time > last ? time : lastTime + 1;
-  }
-
-  return pid + now().toString(36);
-}
-
-export function getBalance<T extends Chain>(chain: T) {
-  return async function getBalance(address: string, scamFilter = true) {
-    const balances = await SwapKitApi.getChainBalance({ chain, address, scamFilter });
-
-    return balances.map(({ identifier, value, decimal }) => {
-      return new AssetValue({ decimal: decimal || BaseDecimal[chain], value, identifier });
-    });
-  };
-}

package/src/utxo/__tests__/zcash-integration.test.ts

@@ -1,114 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { Chain, DerivationPath } from "@swapkit/helpers";
-import { getUtxoToolbox } from "../toolbox";
-
-describe("UTXO Toolbox Zcash Integration", () => {
-  const testPhrase =
-    "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about";
-
-  it("should create Zcash toolbox through main UTXO toolbox factory", async () => {
-    const toolbox = await getUtxoToolbox(Chain.Zcash);
-
-    expect(toolbox).toBeDefined();
-    expect(typeof toolbox.validateAddress).toBe("function");
-    expect(typeof toolbox.getBalance).toBe("function");
-    expect(typeof toolbox.getFeeRates).toBe("function");
-    expect(typeof toolbox.broadcastTx).toBe("function");
-    expect(typeof toolbox.createTransaction).toBe("function");
-    expect(typeof toolbox.transfer).toBe("function");
-  });
-
-  it("should create Zcash toolbox with phrase", async () => {
-    const toolbox = await getUtxoToolbox(Chain.Zcash, {
-      phrase: testPhrase,
-    });
-
-    expect(toolbox).toBeDefined();
-    expect(() => toolbox.getAddress()).not.toThrow();
-  });
-
-  it("should generate valid Zcash addresses", async () => {
-    const toolbox = await getUtxoToolbox(Chain.Zcash, {
-      phrase: testPhrase,
-    });
-
-    const address = await toolbox.getAddress();
-    expect(address).toBeDefined();
-    expect(typeof address).toBe("string");
-    expect(address?.startsWith("t1")).toBe(true); // Zcash mainnet addresses start with t1
-    expect(toolbox.validateAddress(address || "")).toBe(true);
-  });
-
-  it("should validate Zcash addresses correctly", async () => {
-    const toolbox = await getUtxoToolbox(Chain.Zcash);
-
-    // Valid Zcash mainnet address format
-    expect(toolbox.validateAddress("t1XVXWCvpMgBvUaed4XDqWtgQgJSu1Ghz7F")).toBe(true);
-
-    // Invalid addresses
-    expect(toolbox.validateAddress("1BvBMSEYstWetqTFn5Au4m4GFg7xJaNVN2")).toBe(false); // Bitcoin address
-    expect(toolbox.validateAddress("zcash:qr5agtachyxvrwxu76vzszan5pnvuzy8dm")).toBe(false); // Wrong format
-    expect(toolbox.validateAddress("")).toBe(false); // Empty string
-    expect(toolbox.validateAddress("invalid")).toBe(false); // Invalid string
-  });
-
-  it("should reject shielded addresses", async () => {
-    const toolbox = await getUtxoToolbox(Chain.Zcash);
-
-    // Test z-address (shielded) - should be rejected with warning
-    const originalWarn = console.warn;
-    let warnCalled = false;
-    let warnMessage = "";
-
-    console.warn = (message: string) => {
-      warnCalled = true;
-      warnMessage = message;
-    };
-
-    const isValid = toolbox.validateAddress(
-      "zs1z7rejlpsa98s2rrrfkwmaxu2xldqmfq5nj2m3hq6s7r8qjq8eqqqq9p4e7x",
-    );
-
-    expect(isValid).toBe(false);
-    expect(warnCalled).toBe(true);
-    expect(warnMessage).toBe(
-      "Shielded Zcash addresses (z-addresses) are not supported. Use transparent addresses (t1/t3) only.",
-    );
-
-    console.warn = originalWarn;
-  });
-
-  it("should create keys for derivation path", async () => {
-    const toolbox = await getUtxoToolbox(Chain.Zcash, {
-      phrase: testPhrase,
-    });
-
-    const keys = await toolbox.createKeysForPath({
-      phrase: testPhrase,
-      derivationPath: DerivationPath.ZEC,
-    });
-
-    expect(keys).toBeDefined();
-    expect(keys.publicKey).toBeDefined();
-    expect(keys.privateKey).toBeDefined();
-    expect(typeof keys.toWIF).toBe("function");
-
-    const address = await toolbox.getAddress();
-    expect(address).toBeDefined();
-    expect(address?.startsWith("t1")).toBe(true);
-  });
-
-  it("should get WIF private key from mnemonic", async () => {
-    const toolbox = await getUtxoToolbox(Chain.Zcash, {
-      phrase: testPhrase,
-    });
-
-    const wif = await toolbox.getPrivateKeyFromMnemonic({
-      phrase: testPhrase,
-      derivationPath: DerivationPath.ZEC,
-    });
-
-    expect(typeof wif).toBe("string");
-    expect(wif.length).toBeGreaterThan(50); // WIF keys are typically 51-52 characters
-  });
-});