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

package/src/solana/toolbox.ts

@@ -1,16 +1,32 @@
-import type { TokenInfo } from "@solana/spl-token-registry";
-import type { Connection, Keypair, PublicKey, Transaction } from "@solana/web3.js";
+import type {
+  Connection,
+  PublicKey,
+  Signer,
+  Transaction,
+  TransactionInstruction,
+  VersionedTransaction,
+} from "@solana/web3.js";
 import {
   AssetValue,
+  BaseDecimal,
   Chain,
   DerivationPath,
+  type DerivationPathArray,
+  type GenericCreateTransactionParams,
+  NetworkDerivationPath,
   SKConfig,
   SwapKitError,
-  SwapKitNumber,
-  type WalletTxParams,
+  derivationPathToString,
+  updateDerivationPath,
 } from "@swapkit/helpers";
+import { P } from "ts-pattern";
+import { match } from "ts-pattern";
+import type { SolanaCreateTransactionParams, SolanaProvider, SolanaTransferParams } from ".";
+import { getBalance } from "../utils";
 
-export async function getAddressValidator() {
+type SolanaSigner = SolanaProvider | Signer;
+
+export async function getSolanaAddressValidator() {
   const { PublicKey } = await import("@solana/web3.js");
 
   return (address: string) => {
@@ -23,13 +39,132 @@ export async function getAddressValidator() {
   };
 }
 
-export async function createSolanaTokenTransaction({
+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({ phrase, derivationPath }))
+    .with({ signer: P.any }, ({ signer }) => signer)
+    .otherwise(() => undefined);
+
+  function getAddress() {
+    return signer?.publicKey ? getAddressFromPubKey(signer.publicKey) : "";
+  }
+
+  return {
+    getConnection,
+    getAddress,
+    createKeysForPath,
+    getAddressFromPubKey,
+    getPubkeyFromAddress,
+    createTransaction: createTransaction(getConnection),
+    createTransactionFromInstructions,
+    getBalance: getBalance(Chain.Solana),
+    transfer: transfer(getConnection, signer),
+    broadcastTransaction: broadcastTransaction(getConnection),
+    getAddressValidator: getSolanaAddressValidator,
+    signTransaction: signTransaction(getConnection, signer),
+    estimateTransactionFee: estimateTransactionFee(getConnection),
+  };
+}
+
+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)({
+      recipient,
+      assetValue,
+      memo,
+      isProgramDerivedAddress,
+      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.",
+      );
+    }
+
+    return AssetValue.from({
+      chain: Chain.Solana,
+      value: feeInLamports.value,
+      fromBaseDecimal: BaseDecimal[Chain.Solana],
+    });
+  };
+}
+
+async function getConnection() {
+  const { Connection } = await import("@solana/web3.js");
+  return new Connection(SKConfig.get("rpcUrls").SOL, "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,
+        recipient,
+        tokenAddress: assetValue.address,
+        isProgramDerivedAddress,
+      });
+    }
+
+    return undefined;
+  };
+}
+
+async function createSolanaTokenTransaction({
   tokenAddress,
   recipient,
   from,
   connection,
   amount,
   decimals,
+  isProgramDerivedAddress,
 }: {
   tokenAddress: string;
   recipient: string;
@@ -37,6 +172,7 @@ export async function createSolanaTokenTransaction({
   connection: Connection;
   amount: number;
   decimals: number;
+  isProgramDerivedAddress?: boolean;
 }) {
   const {
     getAssociatedTokenAddress,
@@ -51,7 +187,11 @@ export async function createSolanaTokenTransaction({
   const fromSPLAddress = await getAssociatedTokenAddress(tokenPublicKey, from);
 
   const recipientPublicKey = new PublicKey(recipient);
-  const recipientSPLAddress = await getAssociatedTokenAddress(tokenPublicKey, recipientPublicKey);
+  const recipientSPLAddress = await getAssociatedTokenAddress(
+    tokenPublicKey,
+    recipientPublicKey,
+    isProgramDerivedAddress,
+  );
 
   let recipientAccountExists = false;
   try {
@@ -86,64 +226,30 @@ export async function createSolanaTokenTransaction({
   return transaction;
 }
 
-export const SOLToolbox = () => {
-  async function getConnection() {
-    const { Connection } = await import("@solana/web3.js");
-    return new Connection(SKConfig.get("rpcUrls").SOL, "confirmed");
-  }
-
-  return {
-    getConnection,
-    createKeysForPath,
-    getAddressFromKeys,
-    createSolanaTransaction: createSolanaTransaction(getConnection),
-    getBalance: getBalance(getConnection),
-    transfer: transfer(getConnection),
-    broadcastTransaction: broadcastTransaction(getConnection),
-    getAddressValidator,
-  };
-};
-
-function createSolanaTransaction(getConnection: () => Promise<Connection>) {
+function createTransaction(getConnection: () => Promise<Connection>) {
   return async ({
     recipient,
     assetValue,
-    fromPublicKey,
     memo,
     isProgramDerivedAddress,
-  }: WalletTxParams & {
-    assetValue: AssetValue;
-    fromPublicKey: PublicKey;
-    isProgramDerivedAddress?: boolean;
-  }) => {
+    sender,
+  }: SolanaCreateTransactionParams) => {
     const { createMemoInstruction } = await import("@solana/spl-memo");
-    const { Transaction, PublicKey, SystemProgram } = await import("@solana/web3.js");
-    const validateAddress = await getAddressValidator();
+
+    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 = assetValue.isGasAsset
-      ? new Transaction().add(
-          SystemProgram.transfer({
-            fromPubkey: fromPublicKey,
-            lamports: assetValue.getBaseValue("number"),
-            toPubkey: new PublicKey(recipient),
-          }),
-        )
-      : assetValue.address
-        ? await createSolanaTokenTransaction({
-            amount: assetValue.getBaseValue("number"),
-            connection,
-            decimals: assetValue.decimal as number,
-            from: fromPublicKey,
-            recipient,
-            tokenAddress: assetValue.address,
-          })
-        : undefined;
+    const transaction = await createAssetTransaction(getConnection)({
+      assetValue,
+      recipient,
+      sender,
+      isProgramDerivedAddress,
+    });
 
     if (!transaction) {
       throw new SwapKitError("core_transaction_invalid_sender_address");
@@ -153,47 +259,87 @@ function createSolanaTransaction(getConnection: () => Promise<Connection>) {
 
     const blockHash = await connection.getLatestBlockhash();
     transaction.recentBlockhash = blockHash.blockhash;
-    transaction.feePayer = fromPublicKey;
+    transaction.feePayer = fromPubkey;
 
     return transaction;
   };
 }
 
-function transfer(getConnection: () => Promise<Connection>) {
-  return async ({
-    recipient,
-    assetValue,
-    fromKeypair,
-    memo,
-    isProgramDerivedAddress,
-  }: WalletTxParams & {
-    assetValue: AssetValue;
-    fromKeypair: Keypair;
-    isProgramDerivedAddress?: boolean;
-  }) => {
-    const { sendAndConfirmTransaction } = await import("@solana/web3.js");
-    const connection = await getConnection();
+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 createSolanaTransaction(getConnection)({
+    const transaction = await createTransaction(getConnection)({
       recipient,
       assetValue,
       memo,
-      fromPublicKey: fromKeypair.publicKey,
       isProgramDerivedAddress,
+      sender,
     });
 
-    return sendAndConfirmTransaction(connection, transaction, [fromKeypair]);
+    if ("connect" 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) => {
+  return async (transaction: Transaction | VersionedTransaction) => {
     const connection = await getConnection();
     return connection.sendRawTransaction(transaction.serialize());
   };
 }
 
-async function createKeysForPath({
+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 }) {
@@ -206,67 +352,11 @@ async function createKeysForPath({
   return Keypair.fromSeed(hdKey.derive(derivationPath, true).privateKey);
 }
 
-function getAddressFromKeys(keypair: Keypair) {
-  return keypair.publicKey.toString();
+function getAddressFromPubKey(publicKey: PublicKey) {
+  return publicKey.toString();
 }
 
-async function getTokenBalances({
-  connection,
-  address,
-}: { connection: Connection; address: string }) {
+async function getPubkeyFromAddress(address: string) {
   const { PublicKey } = await import("@solana/web3.js");
-  const { TOKEN_PROGRAM_ID } = await import("@solana/spl-token");
-  const { TokenListProvider } = await import("@solana/spl-token-registry");
-
-  const tokenAccounts = await connection.getParsedTokenAccountsByOwner(new PublicKey(address), {
-    programId: TOKEN_PROGRAM_ID,
-  });
-  const tokenListProvider = new TokenListProvider();
-  const tokenListContainer = await tokenListProvider.resolve();
-  const tokenList = tokenListContainer.filterByChainId(101).getList();
-
-  // Group token balances by mint address
-  const tokenBalanceMap = new Map<string, { amount: bigint; decimal: number; symbol: string }>();
-
-  for await (const tokenAccountInfo of tokenAccounts.value) {
-    const accountInfo = tokenAccountInfo.account.data.parsed.info;
-    const mintAddress = accountInfo.mint;
-    const decimal = accountInfo.tokenAmount.decimals;
-    const amount = BigInt(accountInfo.tokenAmount.amount);
-
-    if (amount <= BigInt(0)) continue;
-
-    const tokenInfo = tokenList.find((token: TokenInfo) => token.address === mintAddress);
-    const tokenSymbol = tokenInfo?.symbol ?? "UNKNOWN";
-    const existing = tokenBalanceMap.get(mintAddress);
-
-    tokenBalanceMap.set(mintAddress, {
-      amount: existing ? existing.amount + amount : amount,
-      decimal,
-      symbol: tokenSymbol,
-    });
-  }
-
-  // Convert grouped balances to AssetValue array
-  const tokenBalances: AssetValue[] = Array.from(tokenBalanceMap.entries()).map(
-    ([mintAddress, { amount, decimal, symbol }]) =>
-      new AssetValue({
-        value: SwapKitNumber.fromBigInt(amount, decimal),
-        decimal,
-        identifier: `${Chain.Solana}.${symbol}${mintAddress ? `-${mintAddress.toString()}` : ""}`,
-      }),
-  );
-
-  return tokenBalances;
-}
-
-function getBalance(getConnection: () => Promise<Connection>) {
-  return async (address: string) => {
-    const { PublicKey } = await import("@solana/web3.js");
-    const connection = await getConnection();
-    const SOLBalance = await connection.getBalance(new PublicKey(address));
-    const tokenBalances = await getTokenBalances({ connection, address });
-
-    return [AssetValue.from({ chain: Chain.Solana, value: BigInt(SOLBalance) }), ...tokenBalances];
-  };
+  return new PublicKey(address);
 }

package/src/substrate/index.ts

@@ -1,3 +1,2 @@
-export * from "./toolbox/baseSubstrateToolbox";
-export * from "./toolbox";
-export * from "./types/index";
+export * from "./substrate";
+export * from "./types";