@coinbase/cdp-sdk 1.38.3 → 1.38.4

package/actions/solana/transfer.ts

@@ -1,18 +1,28 @@
 import {
-  getMint,
-  getAssociatedTokenAddress,
-  getAccount,
-  createAssociatedTokenAccountInstruction,
-  createTransferCheckedInstruction,
-} from "@solana/spl-token";
+  pipe,
+  createTransactionMessage,
+  setTransactionMessageLifetimeUsingBlockhash,
+  appendTransactionMessageInstructions,
+  Instruction,
+  createSolanaRpc,
+  address,
+  compileTransaction,
+  setTransactionMessageFeePayer,
+  createNoopSigner,
+  getBase64EncodedWireTransaction,
+} from "@solana/kit";
+import { Connection } from "@solana/web3.js";
+import { getTransferSolInstruction } from "@solana-program/system";
 import {
-  Connection,
-  PublicKey,
-  SystemProgram,
-  SYSVAR_RECENT_BLOCKHASHES_PUBKEY,
-  Transaction,
-} from "@solana/web3.js";
-
+  findAssociatedTokenPda,
+  getCreateAssociatedTokenInstructionAsync,
+  getTransferCheckedInstruction,
+  fetchToken,
+  fetchMint,
+  TOKEN_PROGRAM_ADDRESS,
+} from "@solana-program/token";
+
+import { createRpcClient } from "./rpc.js";
 import { sendTransaction } from "./sendTransaction.js";
 import {
   getConnectedNetwork,
@@ -42,7 +52,7 @@ export interface TransferOptions {
    */
   token: "sol" | "usdc" | string;
   /**
-   * The network to use which will be used to create a Connection, otherwise a Connection can be provided.
+   * The network to use which will be used to create an RPC client, otherwise an RPC client can be provided.
    */
   network: Network | Connection;
 }
@@ -61,16 +71,18 @@ export async function transfer(
 ): Promise<SignatureResult> {
   const connection = getOrCreateConnection({ networkOrConnection: options.network });
   const connectedNetwork = await getConnectedNetwork(connection);
+  const rpc = createRpcClient(connectedNetwork);
 
-  const tx =
+  const base64Transaction =
     options.token === "sol"
-      ? await getNativeTransfer({
+      ? await getNativeTransferBase64Transaction({
+          rpc,
           from: options.from,
           to: options.to,
           amount: options.amount,
         })
-      : await getSplTransfer({
-          connection,
+      : await getSplTransferBase64Transaction({
+          rpc,
           from: options.from,
           to: options.to,
           mintAddress:
@@ -78,59 +90,63 @@ export async function transfer(
           amount: options.amount,
         });
 
-  const serializedTx = Buffer.from(tx.serialize({ requireAllSignatures: false })).toString(
-    "base64",
-  );
-
   const signature = await sendTransaction(apiClient, {
     network: connectedNetwork === "mainnet" ? "solana" : "solana-devnet",
-    transaction: serializedTx,
+    transaction: base64Transaction,
   });
 
   return signature;
 }
 
-type GetNativeTransferOptions = Omit<TransferOptions, "token" | "network">;
+type GetNativeTransferOptions = Omit<TransferOptions, "token" | "network"> & {
+  rpc: ReturnType<typeof createSolanaRpc>;
+};
 
 /**
- * Gets the transaction for a native SOL transfer
+ * Gets the transaction for a SOL transfer
  *
- * @param options - The options for the native SOL transfer
+ * @param options - The options for the SOL transfer
  *
+ * @param options.rpc - The Solana RPC client
  * @param options.from - The source address
  * @param options.to - The destination address
- * @param options.amount - The amount to transfer
+ * @param options.amount - The amount in lamports to transfer
  *
- * @returns The native SOL transfer transaction
+ * @returns The SOL transfer transaction
  */
-async function getNativeTransfer({
+export async function getNativeTransferBase64Transaction({
+  rpc,
   from,
   to,
   amount,
-}: GetNativeTransferOptions): Promise<Transaction> {
-  const transaction = new Transaction();
-  transaction.add(
-    SystemProgram.transfer({
-      fromPubkey: new PublicKey(from),
-      toPubkey: new PublicKey(to),
-      lamports: amount,
+}: GetNativeTransferOptions): Promise<string> {
+  const fromAddr = address(from);
+  const toAddr = address(to);
+
+  const instructions: Instruction[] = [
+    getTransferSolInstruction({
+      source: createNoopSigner(fromAddr),
+      destination: toAddr,
+      amount,
     }),
+  ];
+
+  const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();
+
+  const txMsg = pipe(
+    createTransactionMessage({ version: 0 }),
+    tx => setTransactionMessageFeePayer(fromAddr, tx),
+    tx => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx),
+    tx => appendTransactionMessageInstructions(instructions, tx),
   );
-  transaction.recentBlockhash = SYSVAR_RECENT_BLOCKHASHES_PUBKEY.toBase58();
-  transaction.feePayer = new PublicKey(from);
 
-  return transaction;
+  const compiledTransaction = compileTransaction(txMsg);
+  return getBase64EncodedWireTransaction(compiledTransaction);
 }
 
-type GetSplTransferOptions = Omit<TransferOptions, "token" | "network"> & {
-  /**
-   * The mint address of the token
-   */
+type GetSplTokenTransferOptions = Omit<TransferOptions, "network" | "token"> & {
   mintAddress: string;
-  /**
-   * The connection to the Solana network.
-   */
-  connection: Connection;
+  rpc: ReturnType<typeof createSolanaRpc>;
 };
 
 /**
@@ -138,63 +154,78 @@ type GetSplTransferOptions = Omit<TransferOptions, "token" | "network"> & {
  *
  * @param options - The options for the SPL token transfer
  *
- * @param options.connection - The Solana connection
+ * @param options.rpc - The Solana RPC client
  * @param options.from - The source address
  * @param options.to - The destination address
  * @param options.mintAddress - The mint address of the token
- * @param options.amount - The amount to transfer
+ * @param options.amount - The amount in units of the token to transfer
  *
  * @returns The SPL token transfer transaction
  */
-async function getSplTransfer({
-  connection,
+export async function getSplTransferBase64Transaction({
+  rpc,
   from,
   to,
   mintAddress,
   amount,
-}: GetSplTransferOptions): Promise<Transaction> {
-  const fromPubkey = new PublicKey(from);
-  const toPubkey = new PublicKey(to);
-  const mintPubkey = new PublicKey(mintAddress);
+}: GetSplTokenTransferOptions): Promise<string> {
+  const fromAddr = address(from);
+  const toAddr = address(to);
+  const mintAddr = address(mintAddress);
 
-  let mintInfo: Awaited<ReturnType<typeof getMint>>;
-  try {
-    mintInfo = await getMint(connection, mintPubkey);
-  } catch (error) {
-    throw new Error(`Failed to fetch mint info for mint address ${mintAddress}. Error: ${error}`);
-  }
-
-  const sourceAta = await getAssociatedTokenAddress(mintPubkey, fromPubkey);
-  const destinationAta = await getAssociatedTokenAddress(mintPubkey, toPubkey);
+  const mintInfo = await fetchMint(rpc, mintAddr);
 
-  const transaction = new Transaction();
+  const [sourceAta] = await findAssociatedTokenPda({
+    mint: mintAddr,
+    owner: fromAddr,
+    tokenProgram: TOKEN_PROGRAM_ADDRESS,
+  });
+  const [destAta] = await findAssociatedTokenPda({
+    mint: mintAddr,
+    owner: toAddr,
+    tokenProgram: TOKEN_PROGRAM_ADDRESS,
+  });
 
-  const sourceAccount = await getAccount(connection, sourceAta);
-  if (sourceAccount.amount < amount) {
-    throw new Error(`Insufficient token balance. Have ${sourceAccount.amount}, need ${amount}`);
+  const sourceAcct = await fetchToken(rpc, sourceAta);
+  if (sourceAcct.data.amount < amount) {
+    throw new Error(`Insufficient token balance: have ${sourceAcct.data.amount}, need ${amount}`);
   }
 
-  // Check if destination account exists, if not create it
+  const instructions: Instruction[] = [];
+
+  // If destination ATA does not exist, add create instruction
   try {
-    await getAccount(connection, destinationAta);
+    await fetchToken(rpc, destAta);
   } catch {
-    transaction.add(
-      createAssociatedTokenAccountInstruction(fromPubkey, destinationAta, toPubkey, mintPubkey),
-    );
+    const createDestIx = await getCreateAssociatedTokenInstructionAsync({
+      payer: createNoopSigner(fromAddr),
+      owner: toAddr,
+      ata: destAta,
+      mint: mintAddr,
+    });
+    instructions.push(createDestIx);
   }
 
-  transaction.add(
-    createTransferCheckedInstruction(
-      sourceAta,
-      mintPubkey,
-      destinationAta,
-      fromPubkey,
+  instructions.push(
+    getTransferCheckedInstruction({
+      source: sourceAta,
+      mint: mintAddr,
+      destination: destAta,
+      authority: fromAddr,
       amount,
-      mintInfo.decimals,
-    ),
+      decimals: mintInfo.data.decimals,
+    }),
+  );
+
+  const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();
+
+  const txMsg = pipe(
+    createTransactionMessage({ version: 0 }),
+    tx => setTransactionMessageFeePayer(fromAddr, tx),
+    tx => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx),
+    tx => appendTransactionMessageInstructions(instructions, tx),
   );
-  transaction.recentBlockhash = SYSVAR_RECENT_BLOCKHASHES_PUBKEY.toBase58();
-  transaction.feePayer = new PublicKey(from);
 
-  return transaction;
+  const compiledTransaction = compileTransaction(txMsg);
+  return getBase64EncodedWireTransaction(compiledTransaction);
 }

package/actions/solana/utils.ts

@@ -14,7 +14,7 @@ type GetOrCreateConnectionOptions = {
 };
 
 /**
- * Get a connection to the Solana network
+ * Get a connection for the Solana network
  *
  * @param options - The options for the connection
  *
@@ -37,12 +37,10 @@ export function getOrCreateConnection({
 }
 
 /**
- * Get the network of the connected Solana node
+ * Legacy function for compatibility during migration
  *
- * @param connection - The connection to the Solana network
- * @throws {Error} If the network is not mainnet or devnet
- *
- * @returns The network of the connected Solana node
+ * @param connection - The Solana Connection instance
+ * @returns The network type (mainnet or devnet)
  */
 export async function getConnectedNetwork(connection: Connection): Promise<Network> {
   const genesisHash = await connection.getGenesisHash();

package/actions/waitForFundOperationReceipt.ts

@@ -53,6 +53,7 @@ export type WaitForFundOperationResult = FailedFundOperation | CompletedFundOper
 /**
  * Waits for a fund operation to complete or fail.
  *
+ * @deprecated This method will be removed in a future version. Consider using our Onramp API instead. See https://docs.cdp.coinbase.com/api-reference/v2/rest-api/onramp/create-an-onramp-order.
  * @example
  * ```ts
  * import { waitForFundOperation } from "@coinbase/cdp-sdk";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coinbase/cdp-sdk",
-  "version": "1.38.3",
+  "version": "1.38.4",
   "description": "SDK for interacting with the Coinbase Developer Platform Wallet API",
   "main": "./_cjs/index.js",
   "module": "./_esm/index.js",
@@ -18,7 +18,9 @@
     }
   },
   "dependencies": {
-    "@solana/spl-token": "^0.4.13",
+    "@solana/kit": "^3.0.3",
+    "@solana-program/token": "^0.6.0",
+    "@solana-program/system": "^0.8.0",
     "@solana/web3.js": "^1.98.1",
     "abitype": "1.0.6",
     "axios": "^1.12.2",
@@ -43,8 +45,5 @@
     "cdp sdk",
     "sdk",
     "api"
-  ],
-  "overrides": {
-    "bigint-buffer": "npm:bigint-buffer-fixed@^1.1.6"
-  }
+  ]
 }

package/version.ts

@@ -1 +1 @@
-export const version = "1.38.3";
+export const version = "1.38.4";