@uswap/toolboxes 4.3.6

package/src/solana/toolbox.ts

@@ -0,0 +1,415 @@
+import type {
+  Connection,
+  PublicKey,
+  Signer,
+  Transaction,
+  TransactionInstruction,
+  VersionedTransaction,
+} from "@solana/web3.js";
+import {
+  AssetValue,
+  Chain,
+  DerivationPath,
+  type DerivationPathArray,
+  derivationPathToString,
+  type GenericCreateTransactionParams,
+  getChainConfig,
+  getRPCUrl,
+  NetworkDerivationPath,
+  SwapKitError,
+  updateDerivationPath,
+} from "@uswap/helpers";
+import { match, P } from "ts-pattern";
+import type { SolanaCreateTransactionParams, SolanaProvider, SolanaTransferParams } from "./index";
+
+type SolanaSigner = SolanaProvider | Signer;
+
+type TokenMetadata = {
+  name: string;
+  symbol: string;
+  decimals: number;
+  logoURI?: string;
+  tags?: string[];
+  daily_volume?: number;
+  id: string; // mint address
+};
+
+export async function fetchTokenMetaData(mintAddress: string): Promise<TokenMetadata | null> {
+  const assetValue = AssetValue.from({ address: mintAddress, chain: Chain.Solana });
+  if (assetValue.symbol !== "UNKNOWN") {
+    return {
+      decimals: assetValue.decimal || 0,
+      id: mintAddress,
+      logoURI: assetValue.getIconUrl(),
+      name: assetValue.symbol,
+      symbol: assetValue.ticker,
+    };
+  }
+
+  const url = `https://lite-api.jup.ag/tokens/v2/search?query=${encodeURIComponent(mintAddress)}`;
+
+  try {
+    const res = await fetch(url);
+    if (!res.ok) return null;
+
+    const arr = (await res.json()) as TokenMetadata[];
+    if (!Array.isArray(arr) || arr.length === 0) return null;
+
+    const exact = arr.find((t) => t.id === mintAddress);
+    return exact || null;
+  } 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) {
+    const { baseDecimal } = getChainConfig(Chain.Solana);
+    balances.push(AssetValue.from({ chain: Chain.Solana, fromBaseDecimal: baseDecimal, value: solBalance }));
+  }
+
+  // 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;
+
+    const metadata = await fetchTokenMetaData(mintAddress);
+    const ticker = metadata?.symbol || "UNKNOWN";
+    const decimals = metadata?.decimals || tokenInfo.tokenAmount.decimals;
+
+    balances.push(
+      AssetValue.from({ asset: `${Chain.Solana}.${ticker}-${mintAddress}`, fromBaseDecimal: decimals, value: amount }),
+    );
+  }
+
+  return balances;
+}
+
+export async function getSolanaAddressValidator() {
+  const { PublicKey } = await import("@solana/web3.js");
+
+  return (address: string) => {
+    try {
+      const pubkey = new PublicKey(address);
+      return PublicKey.isOnCurve(pubkey.toBytes());
+    } catch {
+      return false;
+    }
+  };
+}
+
+export async function getSolanaToolbox(
+  toolboxParams?: { signer?: SolanaSigner } | { phrase?: string; index?: number; derivationPath?: DerivationPathArray },
+) {
+  const index = toolboxParams && "index" in toolboxParams ? toolboxParams.index || 0 : 0;
+  const derivationPath = derivationPathToString(
+    toolboxParams && "derivationPath" in toolboxParams && toolboxParams.derivationPath
+      ? toolboxParams.derivationPath
+      : updateDerivationPath(NetworkDerivationPath[Chain.Solana], { index }),
+  );
+
+  const signer = await match(toolboxParams)
+    .with({ phrase: P.string }, ({ phrase }) => createKeysForPath({ derivationPath, phrase }))
+    .with({ signer: P.any }, ({ signer }) => signer)
+    .otherwise(() => undefined);
+
+  function getAddress() {
+    return signer?.publicKey ? getAddressFromPubKey(signer.publicKey) : "";
+  }
+
+  function getBalance(addressParam?: string) {
+    const address = addressParam || getAddress();
+    if (!address) throw new SwapKitError("core_wallet_connection_not_found");
+    return getSolanaBalance(address);
+  }
+
+  return {
+    broadcastTransaction: broadcastTransaction(getConnection),
+    createKeysForPath,
+    createTransaction: createTransaction(getConnection),
+    createTransactionFromInstructions,
+    estimateTransactionFee: estimateTransactionFee(getConnection),
+    getAddress,
+    getAddressFromPubKey,
+    getAddressValidator: getSolanaAddressValidator,
+    getBalance,
+    getConnection,
+    getPubkeyFromAddress,
+    signTransaction: signTransaction(getConnection, signer),
+    transfer: transfer(getConnection, signer),
+  };
+}
+
+function estimateTransactionFee(getConnection: () => Promise<Connection>) {
+  return async ({
+    recipient,
+    assetValue,
+    memo,
+    isProgramDerivedAddress,
+    sender,
+  }: Omit<GenericCreateTransactionParams, "feeRate"> & { isProgramDerivedAddress?: boolean }) => {
+    const connection = await getConnection();
+
+    const transaction = await createTransaction(getConnection)({
+      assetValue,
+      isProgramDerivedAddress,
+      memo,
+      recipient,
+      sender,
+    });
+
+    const message = transaction.compileMessage();
+    const feeInLamports = await connection.getFeeForMessage(message);
+
+    if (feeInLamports.value === null) {
+      throw new SwapKitError("toolbox_solana_fee_estimation_failed", "Could not estimate Solana fee.");
+    }
+
+    const { baseDecimal } = getChainConfig(Chain.Solana);
+
+    return AssetValue.from({ chain: Chain.Solana, fromBaseDecimal: baseDecimal, value: feeInLamports.value });
+  };
+}
+
+async function getConnection() {
+  const { Connection } = await import("@solana/web3.js");
+  const rpcUrl = await getRPCUrl(Chain.Solana);
+  return new Connection(rpcUrl, "confirmed");
+}
+
+function createAssetTransaction(getConnection: () => Promise<Connection>) {
+  return async ({ assetValue, recipient, sender, isProgramDerivedAddress }: SolanaCreateTransactionParams) => {
+    const connection = await getConnection();
+    const fromPubkey = await getPubkeyFromAddress(sender);
+
+    if (assetValue.isGasAsset) {
+      const { Transaction, SystemProgram, PublicKey } = await import("@solana/web3.js");
+
+      return new Transaction().add(
+        SystemProgram.transfer({
+          fromPubkey: fromPubkey,
+          lamports: assetValue.getBaseValue("number"),
+          toPubkey: new PublicKey(recipient),
+        }),
+      );
+    }
+
+    if (assetValue.address) {
+      return createSolanaTokenTransaction({
+        amount: assetValue.getBaseValue("number"),
+        connection,
+        decimals: assetValue.decimal as number,
+        from: fromPubkey,
+        isProgramDerivedAddress,
+        recipient,
+        tokenAddress: assetValue.address,
+      });
+    }
+
+    return undefined;
+  };
+}
+
+async function createSolanaTokenTransaction({
+  tokenAddress,
+  recipient,
+  from,
+  connection,
+  amount,
+  decimals,
+  isProgramDerivedAddress,
+}: {
+  tokenAddress: string;
+  recipient: string;
+  from: PublicKey;
+  connection: Connection;
+  amount: number;
+  decimals: number;
+  isProgramDerivedAddress?: boolean;
+}) {
+  const {
+    getAssociatedTokenAddress,
+    getAccount,
+    createAssociatedTokenAccountInstruction,
+    createTransferCheckedInstruction,
+  } = await import("@solana/spl-token");
+  const { Transaction, PublicKey } = await import("@solana/web3.js");
+
+  const transaction = new Transaction();
+  const tokenPublicKey = new PublicKey(tokenAddress);
+  const fromSPLAddress = await getAssociatedTokenAddress(tokenPublicKey, from);
+
+  const recipientPublicKey = new PublicKey(recipient);
+  const recipientSPLAddress = await getAssociatedTokenAddress(
+    tokenPublicKey,
+    recipientPublicKey,
+    isProgramDerivedAddress,
+  );
+
+  let recipientAccountExists = false;
+  try {
+    await getAccount(connection, recipientSPLAddress);
+    recipientAccountExists = true;
+  } catch {
+    // Recipient's associated token account doesn't exist
+  }
+
+  if (!recipientAccountExists) {
+    transaction.add(
+      createAssociatedTokenAccountInstruction(from, recipientSPLAddress, recipientPublicKey, tokenPublicKey),
+    );
+  }
+
+  transaction.add(
+    createTransferCheckedInstruction(fromSPLAddress, tokenPublicKey, recipientSPLAddress, from, amount, decimals),
+  );
+
+  return transaction;
+}
+
+function createTransaction(getConnection: () => Promise<Connection>) {
+  return async ({ recipient, assetValue, memo, isProgramDerivedAddress, sender }: SolanaCreateTransactionParams) => {
+    const { createMemoInstruction } = await import("@solana/spl-memo");
+
+    const fromPubkey = await getPubkeyFromAddress(sender);
+    const validateAddress = await getSolanaAddressValidator();
+
+    if (!(isProgramDerivedAddress || validateAddress(recipient))) {
+      throw new SwapKitError("core_transaction_invalid_recipient_address");
+    }
+
+    const connection = await getConnection();
+    const transaction = await createAssetTransaction(getConnection)({
+      assetValue,
+      isProgramDerivedAddress,
+      recipient,
+      sender,
+    });
+
+    if (!transaction) {
+      throw new SwapKitError("core_transaction_invalid_sender_address");
+    }
+
+    if (memo) transaction.add(createMemoInstruction(memo));
+
+    const blockHash = await connection.getLatestBlockhash();
+    transaction.recentBlockhash = blockHash.blockhash;
+    transaction.feePayer = fromPubkey;
+
+    return transaction;
+  };
+}
+
+async function createTransactionFromInstructions({
+  instructions,
+}: {
+  instructions: TransactionInstruction[];
+  isProgramDerivedAddress?: boolean;
+}) {
+  const { Transaction } = await import("@solana/web3.js");
+  const transaction = new Transaction().add(...instructions);
+
+  if (!transaction) {
+    throw new SwapKitError("core_transaction_invalid_sender_address");
+  }
+
+  return transaction;
+}
+
+function transfer(getConnection: () => Promise<Connection>, signer?: SolanaSigner) {
+  return async ({ recipient, assetValue, memo, isProgramDerivedAddress }: SolanaTransferParams) => {
+    if (!signer) {
+      throw new SwapKitError("core_transaction_invalid_sender_address");
+    }
+
+    const sender = signer.publicKey?.toString() ?? (await (signer as SolanaProvider).connect()).publicKey.toString();
+
+    const transaction = await createTransaction(getConnection)({
+      assetValue,
+      isProgramDerivedAddress,
+      memo,
+      recipient,
+      sender,
+    });
+
+    if ("signTransaction" in signer) {
+      const signedTransaction = await signer.signTransaction(transaction);
+      return broadcastTransaction(getConnection)(signedTransaction);
+    }
+
+    transaction.sign(signer);
+
+    return broadcastTransaction(getConnection)(transaction);
+  };
+}
+
+function broadcastTransaction(getConnection: () => Promise<Connection>) {
+  return async (transaction: Transaction | VersionedTransaction) => {
+    const connection = await getConnection();
+    return connection.sendRawTransaction(transaction.serialize());
+  };
+}
+
+function signTransaction(getConnection: () => Promise<Connection>, signer?: SolanaSigner) {
+  return async (transaction: Transaction | VersionedTransaction) => {
+    const { VersionedTransaction } = await import("@solana/web3.js");
+    if (!signer) {
+      throw new SwapKitError("toolbox_solana_no_signer");
+    }
+
+    if (!(transaction instanceof VersionedTransaction)) {
+      const connection = await getConnection();
+
+      const blockHash = await connection.getLatestBlockhash();
+      transaction.recentBlockhash = blockHash.blockhash;
+      transaction.feePayer = signer.publicKey || undefined;
+    }
+
+    if ("connect" in signer) {
+      const signedTransaction = await signer.signTransaction(transaction);
+      return signedTransaction;
+    }
+
+    await transaction.sign([signer] as Signer & Signer[]);
+    return transaction;
+  };
+}
+
+export async function createKeysForPath({
+  phrase,
+  derivationPath = DerivationPath.SOL,
+}: {
+  phrase: string;
+  derivationPath?: string;
+}) {
+  const { HDKey } = await import("micro-key-producer/slip10.js");
+  const { mnemonicToSeedSync } = await import("@scure/bip39");
+  const { Keypair } = await import("@solana/web3.js");
+  const seed = mnemonicToSeedSync(phrase);
+  const hdKey = HDKey.fromMasterSeed(seed);
+
+  return Keypair.fromSeed(hdKey.derive(derivationPath, true).privateKey);
+}
+
+function getAddressFromPubKey(publicKey: PublicKey) {
+  return publicKey.toString();
+}
+
+async function getPubkeyFromAddress(address: string) {
+  const { PublicKey } = await import("@solana/web3.js");
+  return new PublicKey(address);
+}

package/src/substrate/balance.ts

@@ -0,0 +1,88 @@
+import type { ApiPromise } from "@polkadot/api";
+import { AssetValue, Chain, SwapKitNumber } from "@uswap/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) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error(`Error fetching substrate balance: ${errorMessage}`);
+    return [];
+  }
+}
+
+/**
+ * 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) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error(`Error fetching chainflip balance: ${errorMessage}`);
+    return [];
+  }
+}
+
+/**
+ * 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/index.ts

@@ -0,0 +1,2 @@
+export * from "./substrate";
+export * from "./types";