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

package/src/substrate/substrate.ts

@@ -1,320 +0,0 @@
-import type { ApiPromise } from "@polkadot/api";
-import type { SubmittableExtrinsic } from "@polkadot/api/types";
-import type { KeyringPair } from "@polkadot/keyring/types";
-import type { Callback, IKeyringPair, ISubmittableResult, Signer } from "@polkadot/types/types";
-import { hexToU8a, isHex, u8aToHex } from "@polkadot/util";
-import {
-  decodeAddress as decodePolkadotAddress,
-  encodeAddress as encodePolkadotAddress,
-} from "@polkadot/util-crypto";
-import {
-  AssetValue,
-  Chain,
-  type DerivationPathArray,
-  type GenericCreateTransactionParams,
-  SKConfig,
-  type SubstrateChain,
-  SwapKitError,
-  SwapKitNumber,
-} from "@swapkit/helpers";
-
-import { P, match } from "ts-pattern";
-import { createBalanceGetter } from "./balance";
-import { SubstrateNetwork, type SubstrateTransferParams } from "./types";
-
-export const PolkadotToolbox = ({ generic = false, ...signerParams }: ToolboxParams = {}) => {
-  return createSubstrateToolbox({ chain: Chain.Polkadot, generic, ...signerParams });
-};
-
-export const ChainflipToolbox = async ({
-  generic = false,
-  ...signerParams
-}: ToolboxParams = {}) => {
-  const toolbox = await createSubstrateToolbox({
-    chain: Chain.Chainflip,
-    generic,
-    ...signerParams,
-  });
-
-  return { ...toolbox };
-};
-
-export type SubstrateToolboxes = {
-  DOT: Awaited<ReturnType<typeof PolkadotToolbox>>;
-  FLIP: Awaited<ReturnType<typeof ChainflipToolbox>>;
-};
-
-export function getSubstrateToolbox<T extends SubstrateChain>(chain: T, params?: ToolboxParams) {
-  switch (chain) {
-    case Chain.Chainflip: {
-      return ChainflipToolbox(params);
-    }
-    case Chain.Polkadot: {
-      return PolkadotToolbox(params);
-    }
-    default:
-      throw new SwapKitError("toolbox_substrate_not_supported", { chain });
-  }
-}
-
-export function isKeyringPair(account: IKeyringPair | Signer): account is IKeyringPair {
-  return "address" in account;
-}
-
-export async function createKeyring(phrase: string, networkPrefix: number) {
-  const { Keyring } = await import("@polkadot/api");
-  const { cryptoWaitReady } = await import("@polkadot/util-crypto");
-  await cryptoWaitReady();
-
-  return new Keyring({ type: "sr25519", ss58Format: networkPrefix }).addFromUri(phrase);
-}
-
-const getNonce = (api: ApiPromise, address: string) => api.rpc.system.accountNextIndex(address);
-
-const validateAddress = (address: string, networkPrefix: number) => {
-  try {
-    const decodedAddress = decodeAddress(address, networkPrefix);
-
-    encodeAddress(decodedAddress, "ss58", networkPrefix);
-
-    return true;
-  } catch (_error) {
-    return false;
-  }
-};
-
-const createTransaction = (api: ApiPromise, { recipient, assetValue }: SubstrateTransferParams) =>
-  api.tx.balances?.transferAllowDeath?.(recipient, assetValue.getBaseValue("number"));
-
-const transfer = async (
-  api: ApiPromise,
-  signer: IKeyringPair | Signer,
-  { recipient, assetValue, sender }: SubstrateTransferParams,
-) => {
-  const transfer = createTransaction(api, {
-    recipient,
-    assetValue,
-  });
-
-  const isKeyring = isKeyringPair(signer);
-
-  if (!transfer) return;
-
-  const address = isKeyring ? (signer as IKeyringPair).address : sender;
-  if (!address) throw new SwapKitError("core_transaction_invalid_sender_address");
-
-  const nonce = await getNonce(api, address);
-
-  const tx = await transfer.signAndSend(isKeyring ? signer : address, {
-    signer: isKeyring ? undefined : signer,
-    nonce,
-  });
-
-  return tx?.toString();
-};
-
-const estimateTransactionFee = async (
-  api: ApiPromise,
-  signer: IKeyringPair | Signer,
-  gasAsset: AssetValue,
-  { recipient, assetValue, sender }: SubstrateTransferParams,
-) => {
-  const transfer = createTransaction(api, { recipient, assetValue });
-
-  const address = isKeyringPair(signer) ? signer.address : sender;
-  if (!address) return;
-
-  const paymentInfo = (await transfer?.paymentInfo(address, {
-    nonce: await getNonce(api, address),
-  })) || { partialFee: 0 };
-  return gasAsset.set(
-    SwapKitNumber.fromBigInt(BigInt(paymentInfo.partialFee.toString()), gasAsset.decimal).getValue(
-      "string",
-    ),
-  );
-};
-
-const broadcast = async (
-  tx: SubmittableExtrinsic<"promise">,
-  callback?: Callback<ISubmittableResult>,
-) => {
-  if (callback) return tx.send(callback);
-  const hash = await tx.send();
-  return hash.toString();
-};
-
-const sign = async (signer: IKeyringPair, tx: SubmittableExtrinsic<"promise">) => {
-  const signedTx = await tx.signAsync(signer);
-  return signedTx;
-};
-
-const signAndBroadcastKeyring = (
-  signer: IKeyringPair,
-  tx: SubmittableExtrinsic<"promise">,
-  callback?: Callback<ISubmittableResult>,
-) => {
-  if (callback) return tx.signAndSend(signer, callback);
-  const hash = tx.signAndSend(signer);
-  return hash.toString();
-};
-
-const signAndBroadcast = async ({
-  signer,
-  address,
-  tx,
-  callback,
-  api,
-}: {
-  signer: Signer;
-  address: string;
-  tx: SubmittableExtrinsic<"promise">;
-  api: ApiPromise;
-  callback?: Callback<ISubmittableResult>;
-}) => {
-  const nonce = await getNonce(api, address);
-  if (callback) {
-    tx.signAndSend(address, { nonce, signer }, callback);
-  }
-  const hash = tx.signAndSend(address, { nonce, signer });
-  return hash.toString();
-};
-
-function convertAddress(address: string, newPrefix: number) {
-  const decodedAddress = decodePolkadotAddress(address);
-  const convertedAddress = encodePolkadotAddress(decodedAddress, newPrefix);
-  return convertedAddress;
-}
-
-function decodeAddress(address: string, networkPrefix?: number) {
-  return isHex(address)
-    ? hexToU8a(address)
-    : decodePolkadotAddress(address, undefined, networkPrefix);
-}
-
-function encodeAddress(
-  address: Uint8Array,
-  encoding: "ss58" | "hex" = "ss58",
-  networkPrefix?: number,
-) {
-  if (encoding === "hex") {
-    return u8aToHex(address);
-  }
-
-  return encodePolkadotAddress(address, networkPrefix);
-}
-
-export const BaseSubstrateToolbox = ({
-  api,
-  network,
-  gasAsset,
-  signer,
-  chain,
-}: {
-  api: ApiPromise;
-  network: SubstrateNetwork;
-  gasAsset: AssetValue;
-  signer?: IKeyringPair | Signer;
-  chain?: SubstrateChain;
-}) => ({
-  api,
-  network,
-  gasAsset,
-  decodeAddress,
-  encodeAddress,
-  convertAddress,
-  getBalance: createBalanceGetter(chain || Chain.Polkadot, api),
-  createKeyring: (phrase: string) => createKeyring(phrase, network.prefix),
-  getAddress: (keyring?: IKeyringPair | Signer) => {
-    const keyringPair = keyring || signer;
-    if (!keyringPair) throw new SwapKitError("core_wallet_not_keypair_wallet");
-
-    return isKeyringPair(keyringPair) ? keyringPair.address : undefined;
-  },
-  createTransaction: (params: GenericCreateTransactionParams) => createTransaction(api, params),
-  validateAddress: (address: string) => validateAddress(address, network.prefix),
-  transfer: (params: SubstrateTransferParams) => {
-    if (!signer) throw new SwapKitError("core_wallet_not_keypair_wallet");
-    return transfer(api, signer, params);
-  },
-  estimateTransactionFee: (params: SubstrateTransferParams) => {
-    if (!signer) throw new SwapKitError("core_wallet_not_keypair_wallet");
-    return estimateTransactionFee(api, signer, gasAsset, params);
-  },
-  sign: (tx: SubmittableExtrinsic<"promise">) => {
-    if (!signer) throw new SwapKitError("core_wallet_not_keypair_wallet");
-    if (isKeyringPair(signer)) return sign(signer, tx);
-
-    throw new SwapKitError(
-      "core_wallet_not_keypair_wallet",
-      "Signer does not have keyring pair capabilities required for signing.",
-    );
-  },
-  broadcast,
-  signAndBroadcast: ({
-    tx,
-    callback,
-    address,
-  }: {
-    tx: SubmittableExtrinsic<"promise">;
-    callback?: Callback<ISubmittableResult>;
-    address?: string;
-  }) => {
-    if (!signer) throw new SwapKitError("core_wallet_not_keypair_wallet");
-    if (isKeyringPair(signer)) return signAndBroadcastKeyring(signer, tx, callback);
-
-    if (address) {
-      return signAndBroadcast({ signer, address, tx, callback, api });
-    }
-
-    throw new SwapKitError(
-      "core_wallet_not_keypair_wallet",
-      "Signer does not have keyring pair capabilities required for signing.",
-    );
-  },
-});
-
-export const substrateValidateAddress = ({
-  address,
-  chain,
-}: { address: string; chain: Chain.Polkadot | Chain.Chainflip }) => {
-  const { prefix } = chain === Chain.Polkadot ? SubstrateNetwork.DOT : SubstrateNetwork.FLIP;
-
-  return (
-    validateAddress(address, prefix) || validateAddress(address, SubstrateNetwork.GENERIC.prefix)
-  );
-};
-
-export async function createSubstrateToolbox({
-  generic,
-  chain,
-  ...signerParams
-}: ToolboxParams & { chain: SubstrateChain }) {
-  const { ApiPromise, WsProvider } = await import("@polkadot/api");
-
-  const provider = new WsProvider(SKConfig.get("rpcUrls")[chain]);
-  const api = await ApiPromise.create({ provider });
-  const gasAsset = AssetValue.from({ chain });
-  const network = generic ? SubstrateNetwork.GENERIC : SubstrateNetwork[chain];
-
-  const signer = await match(signerParams)
-    .with({ phrase: P.string }, ({ phrase }) =>
-      createKeyring(phrase, SubstrateNetwork[chain].prefix),
-    )
-    .with({ signer: P.any }, ({ signer }) => signer)
-    .otherwise(() => undefined);
-
-  return BaseSubstrateToolbox({ api, signer, gasAsset, network, chain });
-}
-
-export type ToolboxParams = {
-  generic?: boolean;
-} & (
-  | {
-      signer?: KeyringPair | Signer;
-    }
-  | {
-      phrase?: string;
-      derivationPath?: DerivationPathArray;
-      index?: number;
-    }
-);

package/src/substrate/types.ts

@@ -1,120 +0,0 @@
-import type { Signer as InjectedSigner } from "@polkadot/api/types";
-import type { ProviderInterface } from "@polkadot/rpc-provider/types";
-import type { ExtDef } from "@polkadot/types/extrinsic/signedExtensions/types";
-import type { KeypairType } from "@polkadot/util-crypto/types";
-import type { GenericTransferParams, SubstrateChain } from "@swapkit/helpers";
-
-const polkadotNetwork = {
-  prefix: 0,
-  network: "polkadot",
-  displayName: "Polkadot Relay Chain",
-  symbols: ["DOT"],
-  decimals: [10],
-  standardAccount: "*25519",
-  website: "https://polkadot.network",
-};
-
-const chainflipNetwork = {
-  prefix: 2112,
-  network: "chainflip",
-  displayName: "Chainflip",
-  symbols: ["FLIP"],
-  decimals: [18],
-  standardAccount: "*25519",
-  website: "https://chainflip.io/",
-};
-
-const subtrateNetwork = {
-  prefix: 42,
-  network: "substrate",
-  displayName: "Substrate",
-  symbols: [],
-  decimals: [],
-  standardAccount: "*25519",
-  website: "https://substrate.io/",
-};
-
-export const SubstrateNetwork: Record<SubstrateChain | "GENERIC", SubstrateNetwork> = {
-  DOT: polkadotNetwork,
-  FLIP: chainflipNetwork,
-  GENERIC: subtrateNetwork,
-};
-
-export type SubstrateNetwork =
-  | typeof polkadotNetwork
-  | typeof chainflipNetwork
-  | typeof subtrateNetwork;
-
-export type SubstrateTransferParams = GenericTransferParams & {
-  sender?: string;
-};
-
-type Unsubcall = () => void;
-
-interface InjectedAccount {
-  address: string;
-  genesisHash?: string | null;
-  name?: string;
-  type?: KeypairType;
-}
-
-interface InjectedAccounts {
-  get: (anyType?: boolean) => Promise<InjectedAccount[]>;
-  subscribe: (cb: (accounts: InjectedAccount[]) => void | Promise<void>) => Unsubcall;
-}
-interface InjectedExtensionInfo {
-  name: string;
-  version: string;
-}
-interface ProviderMeta {
-  network: string;
-  node: "full" | "light";
-  source: string;
-  transport: string;
-}
-interface MetadataDefBase {
-  chain: string;
-  genesisHash: string;
-  icon: string;
-  ss58Format: number;
-  chainType?: "substrate" | "ethereum";
-}
-interface MetadataDef extends MetadataDefBase {
-  color?: string;
-  specVersion: number;
-  tokenDecimals: number;
-  tokenSymbol: string;
-  types: Record<string, Record<string, string> | string>;
-  metaCalls?: string;
-  userExtensions?: ExtDef;
-}
-interface InjectedMetadataKnown {
-  genesisHash: string;
-  specVersion: number;
-}
-interface InjectedMetadata {
-  get: () => Promise<InjectedMetadataKnown[]>;
-  provide: (definition: MetadataDef) => Promise<boolean>;
-}
-type ProviderList = Record<string, ProviderMeta>;
-
-interface InjectedProvider extends ProviderInterface {
-  listProviders: () => Promise<ProviderList>;
-  startProvider: (key: string) => Promise<ProviderMeta>;
-}
-
-type InjectedWalletData = {
-  accounts: InjectedAccounts;
-  metadata?: InjectedMetadata;
-  provider?: InjectedProvider;
-  signer: InjectedSigner;
-};
-
-export type SubstrateInjectedExtension = Record<
-  string,
-  {
-    connect?: (origin: string) => Promise<InjectedExtensionInfo & InjectedWalletData>;
-    enable?: (origin: string) => Promise<InjectedWalletData>;
-    version?: string;
-  }
->;

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

@@ -1,147 +0,0 @@
-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

@@ -1,107 +0,0 @@
-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;