@coinbase/cdp-sdk 1.38.3 → 1.38.5

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/types.ts

@@ -2,6 +2,7 @@
  * @module Actions
  */
 
+import { SendTransactionResult } from "./sendTransaction.js";
 import { TransferOptions } from "./transfer.js";
 import {
   RequestFaucetOptions,
@@ -10,15 +11,6 @@ import {
   SignMessageOptions,
   SignTransactionOptions,
 } from "../../client/solana/solana.types.js";
-import { SolanaQuote } from "../Quote.js";
-import { FundOperationResult } from "../types.js";
-import {
-  WaitForFundOperationOptions,
-  WaitForFundOperationResult,
-} from "../waitForFundOperationReceipt.js";
-import { SolanaFundOptions } from "./fund/fund.js";
-import { SolanaQuoteFundOptions } from "./fund/quoteFund.js";
-import { SendTransactionResult } from "./sendTransaction.js";
 
 import type { SignTransactionResult } from "./signTransaction.js";
 
@@ -166,65 +158,4 @@ export type AccountActions = {
    * ```
    */
   transfer: (options: Omit<TransferOptions, "from">) => Promise<SignatureResult>;
-
-  /**
-   * Gets a quote to fund a Solana account.
-   *
-   * @param options - The options for the quote fund.
-   * @param options.token - The token to fund the account with.
-   * @param options.amount - The amount of the token to fund represented as an atomic unit.
-   * It's common to use `parseUnits` utils from viem to convert to atomic units.
-   * Otherwise, you can pass atomic units directly.
-   *
-   * @returns A promise that resolves to a Quote object containing details about the funding operation.
-   *
-   * @example
-   * ```ts
-   * const quote = await account.quoteFund({
-   *   token: "usdc",
-   *   amount: 1000000n,
-   * });
-   * ```
-   */
-  quoteFund: (options: Omit<SolanaQuoteFundOptions, "address">) => Promise<SolanaQuote>;
-
-  /**
-   * Funds a Solana account with the specified token amount.
-   *
-   * @param options - The options for the fund operation.
-   * @param options.token - The token to fund the account with (e.g., 'usdc').
-   * @param options.amount - The amount of the token to fund represented as an atomic unit.
-   * It's common to use `parseUnits` utils from viem to convert to atomic units.
-   * Otherwise, you can pass atomic units directly.
-   *
-   * @returns A promise that resolves to the fund operation result containing the transfer details.
-   *
-   * @example
-   * ```ts
-   * const fundOperation = await account.fund({
-   *   token: "usdc",
-   *   amount: 1000000n,
-   * });
-   * ```
-   */
-  fund: (options: Omit<SolanaFundOptions, "address">) => Promise<FundOperationResult>;
-
-  /**
-   * Waits for a fund operation to complete and returns the transfer receipt.
-   *
-   * @param options - The options for the wait for fund operation.
-   * @param options.transferId - The ID of the transfer to wait for.
-   *
-   * @returns A promise that resolves to the completed transfer receipt containing details about the funding operation.
-   *
-   * @example
-   * ```ts
-   * const completedTransfer = await account.waitForFundOperationReceipt({
-   *   transferId: "transfer_123",
-   * });
-   * ```
-   */
-  waitForFundOperationReceipt(
-    options: WaitForFundOperationOptions,
-  ): Promise<WaitForFundOperationResult>;
 };

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/auth/utils/http.ts

@@ -3,6 +3,7 @@
  */
 
 import { generateWalletJwt, generateJwt } from "./jwt.js";
+import { UserInputValidationError } from "../../errors.js";
 import { version } from "../../version.js";
 
 /**
@@ -100,7 +101,7 @@ export async function getAuthHeaders(
   // Add wallet auth if needed
   if (requiresWalletAuth(options.requestMethod, options.requestPath)) {
     if (!options.walletSecret) {
-      throw new Error(
+      throw new UserInputValidationError(
         "Wallet Secret not configured. Please set the CDP_WALLET_SECRET environment variable, or pass it as an option to the CdpClient constructor.",
       );
     }
@@ -130,7 +131,9 @@ export async function getAuthHeaders(
  */
 function requiresWalletAuth(requestMethod: string, requestPath: string): boolean {
   return (
-    (requestPath?.includes("/accounts") || requestPath?.includes("/spend-permissions")) &&
+    (requestPath?.includes("/accounts") ||
+      requestPath?.includes("/spend-permissions") ||
+      requestPath?.includes("/user-operations/prepare-and-send")) &&
     (requestMethod === "POST" || requestMethod === "DELETE" || requestMethod === "PUT")
   );
 }

package/auth/utils/jwt.ts

@@ -138,7 +138,7 @@ export async function generateJwt(options: JwtOptions): Promise<string> {
   const claims: JWTPayload = {
     sub: options.apiKeyId,
     iss: "cdp",
-    aud: options.audience || ["cdp_service"],
+    aud: options.audience,
   };
 
   // Add the uris claim only for REST API requests

package/client/evm/evm.ts

@@ -25,6 +25,7 @@ import {
   ListServerAccountsOptions,
   ListSmartAccountResult,
   ListSmartAccountsOptions,
+  PrepareAndSendUserOperationOptions,
   PrepareUserOperationOptions,
   ServerAccount,
   SignatureResult,
@@ -58,6 +59,7 @@ import {
 } from "../../actions/evm/requestFaucet.js";
 import { sendTransaction } from "../../actions/evm/sendTransaction.js";
 import {
+  PrepareAndSendUserOperationReturnType,
   sendUserOperation,
   SendUserOperationOptions,
   SendUserOperationReturnType,
@@ -75,6 +77,7 @@ import { UserInputValidationError } from "../../errors.js";
 import { APIError } from "../../openapi-client/errors.js";
 import {
   CdpOpenApiClient,
+  EvmUserOperationStatus,
   EIP712Message as OpenAPIEIP712Message,
 } from "../../openapi-client/index.js";
 import { SPEND_PERMISSION_MANAGER_ADDRESS } from "../../spend-permissions/constants.js";
@@ -892,6 +895,7 @@ export class EvmClient implements EvmClientInterface {
         to: call.to as Address,
         value: call.value.toString(),
         data: call.data as Hex,
+        overrideGasLimit: call.overrideGasLimit,
       })),
       paymasterUrl: options.paymasterUrl,
     });
@@ -908,6 +912,63 @@ export class EvmClient implements EvmClientInterface {
     };
   }
 
+  /**
+   * Prepares and sends a user operation for a smart account.
+   *
+   * @param {PrepareAndSendUserOperationOptions} options - Parameters for preparing and sending the user operation.
+   * @param {SmartAccount} options.smartAccount - The smart account signing the user operation.
+   * @param {string} options.network - The network to prepare and send the user operation on.
+   * @param {EvmCall[]} options.calls - The calls to include in the user operation.
+   * @param {string} [options.paymasterUrl] - The optional paymaster URL to use for the user operation.
+   *
+   * @returns A promise that resolves to the smart account address, user operation hash, and status of the user operation.
+   *
+   * @example
+   * ```ts
+   * const { userOpHash } = await cdp.evm.prepareAndSendUserOperation({
+   *   smartAccount,
+   *   network: "base-sepolia",
+   *   calls: [
+   *     {
+   *       to: "0x1234567890123456789012345678901234567890",
+   *       value: parseEther("0.000001"),
+   *       data: "0x",
+   *     },
+   *   ],
+   * });
+   * ```
+   */
+  async prepareAndSendUserOperation(
+    options: PrepareAndSendUserOperationOptions,
+  ): Promise<PrepareAndSendUserOperationReturnType> {
+    Analytics.trackAction({
+      action: "prepare_and_send_user_operation",
+      properties: {
+        network: options.network,
+      },
+    });
+
+    const userOp = await CdpOpenApiClient.prepareAndSendUserOperation(
+      options.smartAccount.address,
+      {
+        network: options.network,
+        calls: options.calls.map(call => ({
+          to: call.to as Address,
+          value: call.value.toString(),
+          data: call.data as Hex,
+        })),
+        paymasterUrl: options.paymasterUrl,
+      },
+      options.idempotencyKey,
+    );
+
+    return {
+      smartAccountAddress: options.smartAccount.address as Address,
+      userOpHash: userOp.userOpHash as Hex,
+      status: userOp.status as typeof EvmUserOperationStatus.broadcast,
+    };
+  }
+
   /**
    * Requests funds from an EVM faucet.
    *

package/client/evm/evm.types.ts

@@ -18,6 +18,7 @@ import type {
   SendTransactionOptions,
 } from "../../actions/evm/sendTransaction.js";
 import type {
+  PrepareAndSendUserOperationReturnType,
   SendUserOperationOptions,
   SendUserOperationReturnType,
 } from "../../actions/evm/sendUserOperation.js";
@@ -61,6 +62,7 @@ export type EvmClientInterface = Omit<
   | "listEvmSmartAccounts" // mapped to listSmartAccounts
   | "listEvmTokenBalances" // mapped to listTokenBalances
   | "prepareUserOperation"
+  | "prepareAndSendUserOperation"
   | "requestEvmFaucet" // mapped to requestFaucet
   | "sendUserOperation"
   | "signEvmHash" // mapped to signHash
@@ -102,6 +104,9 @@ export type EvmClientInterface = Omit<
   sendUserOperation: (
     options: SendUserOperationOptions<unknown[]>,
   ) => Promise<SendUserOperationReturnType>;
+  prepareAndSendUserOperation: (
+    options: PrepareAndSendUserOperationOptions,
+  ) => Promise<PrepareAndSendUserOperationReturnType>;
   signHash: (options: SignHashOptions) => Promise<SignatureResult>;
   signMessage: (options: SignMessageOptions) => Promise<SignatureResult>;
   signTypedData: (options: SignTypedDataOptions) => Promise<SignatureResult>;
@@ -293,6 +298,22 @@ export interface PrepareUserOperationOptions {
   paymasterUrl?: string;
 }
 
+/**
+ * Options for preparing and sending a user operation.
+ */
+export interface PrepareAndSendUserOperationOptions {
+  /** The smart account. */
+  smartAccount: SmartAccount;
+  /** The network. */
+  network: EvmUserOperationNetwork;
+  /** The calls. */
+  calls: Calls<EvmCall[]>;
+  /** The paymaster URL. */
+  paymasterUrl?: string;
+  /** An optional idempotency key. */
+  idempotencyKey?: string;
+}
+
 /**
  * A call to be executed in a user operation.
  */
@@ -307,6 +328,8 @@ export interface EvmCall {
    * The call data to send. This is the hex-encoded data of the function call consisting of the method selector and the function arguments.
    */
   data: Hex;
+  /** The override gas limit. */
+  overrideGasLimit?: string;
 }
 
 /**

package/openapi-client/cdpApiClient.ts

@@ -5,6 +5,7 @@ import axiosRetry, { exponentialDelay } from "axios-retry";
 import { withAuth } from "../auth/hooks/axios/index.js";
 import { ERROR_DOCS_PAGE_URL } from "../constants.js";
 import { isOpenAPIError, APIError, UnknownError, NetworkError } from "./errors.js";
+import { UserInputValidationError } from "../errors.js";
 
 import type { Prettify } from "../types/utils.js";
 
@@ -132,6 +133,10 @@ export const cdpApiClient = async <T>(
     const response = await axiosInstance(configWithIdempotencyKey);
     return response.data as T;
   } catch (error) {
+    if (error instanceof UserInputValidationError) {
+      throw error;
+    }
+
     // eslint-disable-next-line import/no-named-as-default-member
     if (Axios.isAxiosError(error) && !error.response) {
       // Network-level errors (no response received)