@coinbase/cdp-sdk 1.44.1 → 1.46.0

package/actions/solana/types.ts

@@ -75,18 +75,44 @@ export type AccountActions = {
    * // Create a Solana account
    * const account = await cdp.solana.createAccount();
    *
-   * // Add your transaction instructions here
-   * const transaction = new Transaction()
-   *
-   * // Make sure to set requireAllSignatures to false, since signing will be done through the API
-   * const serializedTransaction = transaction.serialize({
-   *   requireAllSignatures: false,
-   * });
-   *
-   * // Base64 encode the serialized transaction
-   * const transaction = Buffer.from(serializedTransaction).toString("base64");
-   *
-   * // When you want to sign a transaction, you can do so by address and base64 encoded transaction
+   * // Build your transaction using @solana/kit
+   * import {
+   *   address as solanaAddress,
+   *   appendTransactionMessageInstructions,
+   *   compileTransaction,
+   *   createNoopSigner,
+   *   createSolanaRpc,
+   *   createTransactionMessage,
+   *   getBase64EncodedWireTransaction,
+   *   pipe,
+   *   setTransactionMessageFeePayer,
+   *   setTransactionMessageLifetimeUsingBlockhash,
+   * } from "@solana/kit";
+   * import { getTransferSolInstruction } from "@solana-program/system";
+   *
+   * const rpc = createSolanaRpc("https://api.devnet.solana.com");
+   * const { value: { blockhash, lastValidBlockHeight } } = await rpc.getLatestBlockhash().send();
+   *
+   * const txMsg = pipe(
+   *   createTransactionMessage({ version: 0 }),
+   *   (tx) => setTransactionMessageFeePayer(solanaAddress(account.address), tx),
+   *   (tx) => setTransactionMessageLifetimeUsingBlockhash(
+   *     { blockhash, lastValidBlockHeight },
+   *     tx,
+   *   ),
+   *   (tx) => appendTransactionMessageInstructions([
+   *     getTransferSolInstruction({
+   *       source: createNoopSigner(solanaAddress(account.address)),
+   *       destination: solanaAddress("3KzDtddx4i53FBkvCzuDmRbaMozTZoJBb1TToWhz3JfE"),
+   *       amount: 10000n,
+   *     }),
+   *   ], tx),
+   * );
+   *
+   * // Base64 encode the compiled transaction
+   * const transaction = getBase64EncodedWireTransaction(compileTransaction(txMsg));
+   *
+   * // Sign the transaction via the CDP API
    * const { signedTransaction } = await account.signTransaction({
    *   transaction,
    * });
@@ -111,18 +137,44 @@ export type AccountActions = {
    * // Create a Solana account
    * const account = await cdp.solana.createAccount();
    *
-   * // Add your transaction instructions here
-   * const transaction = new Transaction()
-   *
-   * // Make sure to set requireAllSignatures to false, since signing will be done through the API
-   * const serializedTransaction = transaction.serialize({
-   *   requireAllSignatures: false,
-   * });
-   *
-   * // Base64 encode the serialized transaction
-   * const transaction = Buffer.from(serializedTransaction).toString("base64");
-   *
-   * // When you want to sign a transaction, you can do so by address and base64 encoded transaction
+   * // Build your transaction using @solana/kit
+   * import {
+   *   address as solanaAddress,
+   *   appendTransactionMessageInstructions,
+   *   compileTransaction,
+   *   createNoopSigner,
+   *   createSolanaRpc,
+   *   createTransactionMessage,
+   *   getBase64EncodedWireTransaction,
+   *   pipe,
+   *   setTransactionMessageFeePayer,
+   *   setTransactionMessageLifetimeUsingBlockhash,
+   * } from "@solana/kit";
+   * import { getTransferSolInstruction } from "@solana-program/system";
+   *
+   * const rpc = createSolanaRpc("https://api.devnet.solana.com");
+   * const { value: { blockhash, lastValidBlockHeight } } = await rpc.getLatestBlockhash().send();
+   *
+   * const txMsg = pipe(
+   *   createTransactionMessage({ version: 0 }),
+   *   (tx) => setTransactionMessageFeePayer(solanaAddress(account.address), tx),
+   *   (tx) => setTransactionMessageLifetimeUsingBlockhash(
+   *     { blockhash, lastValidBlockHeight },
+   *     tx,
+   *   ),
+   *   (tx) => appendTransactionMessageInstructions([
+   *     getTransferSolInstruction({
+   *       source: createNoopSigner(solanaAddress(account.address)),
+   *       destination: solanaAddress("3KzDtddx4i53FBkvCzuDmRbaMozTZoJBb1TToWhz3JfE"),
+   *       amount: 10000n,
+   *     }),
+   *   ], tx),
+   * );
+   *
+   * // Base64 encode the compiled transaction
+   * const transaction = getBase64EncodedWireTransaction(compileTransaction(txMsg));
+   *
+   * // Send the transaction via the CDP API
    * const { transactionSignature } = await account.sendTransaction({
    *   transaction,
    * });
@@ -138,20 +190,18 @@ export type AccountActions = {
    * @param {TransferOptions} options - Parameters for the transfer.
    * @param {string} options.to - The base58 encoded Solana address of the destination account.
    * @param {sol|usdc|string} options.token - The token to transfer ("sol" or "usdc"), or mint address of the SPL token to transfer.
-   * @param {bigint} options.amount - The amount to transfer in atomic units of the token. For example, 0.01 * LAMPORTS_PER_SOL would transfer 0.01 SOL.
-   * @param {string | Connection} options.network - The network identifier to use, or a Solana Connection object.
+   * @param {bigint} options.amount - The amount to transfer in atomic units of the token. For example, 1 SOL = 1_000_000_000 lamports.
+   * @param {string | SolanaRpcClient} options.network - The network identifier ("mainnet" or "devnet") to use, or an existing Solana RPC client.
    *
    * @returns A promise that resolves to the transaction signature, which can be used to wait for the transaction result.
    *
    * @example
    * ```ts
-   * import { LAMPORTS_PER_SOL } from "@solana/web3.js";
-   *
    * const account = await cdp.solana.getAccount({ name: "Account" });
    *
    * const { signature } = await account.transfer({
    *   token: "sol",
-   *   amount: 5 * LAMPORTS_PER_SOL,
+   *   amount: 5_000_000_000n, // 5 SOL in lamports
    *   to: "3KzDtddx4i53FBkvCzuDmRbaMozTZoJBb1TToWhz3JfE",
    *   network: "devnet",
    * });

package/actions/solana/utils.ts

@@ -1,4 +1,4 @@
-import { Connection } from "@solana/web3.js";
+import { createSolanaRpc } from "@solana/kit";
 
 import {
   GENESIS_HASH_MAINNET,
@@ -9,27 +9,29 @@ import {
 
 export type Network = "mainnet" | "devnet";
 
+export type SolanaRpcClient = ReturnType<typeof createSolanaRpc>;
+
 type GetOrCreateConnectionOptions = {
-  networkOrConnection: Network | Connection;
+  networkOrConnection: Network | SolanaRpcClient;
 };
 
 /**
- * Get a connection for the Solana network
+ * Get a Solana RPC client for the given network or return the provided one
  *
  * @param options - The options for the connection
  *
- * @param options.networkOrConnection - The network to use or a connection
+ * @param options.networkOrConnection - The network to use or an existing RPC client
  *
- * @returns The connection
+ * @returns The RPC client
  */
 export function getOrCreateConnection({
   networkOrConnection,
-}: GetOrCreateConnectionOptions): Connection {
+}: GetOrCreateConnectionOptions): SolanaRpcClient {
   if (typeof networkOrConnection !== "string") {
     return networkOrConnection;
   }
 
-  return new Connection(
+  return createSolanaRpc(
     networkOrConnection === "mainnet"
       ? "https://api.mainnet-beta.solana.com"
       : "https://api.devnet.solana.com",
@@ -37,13 +39,13 @@ export function getOrCreateConnection({
 }
 
 /**
- * Legacy function for compatibility during migration
+ * Determine the network from the RPC client by checking the genesis hash
  *
- * @param connection - The Solana Connection instance
+ * @param rpc - The Solana RPC client
  * @returns The network type (mainnet or devnet)
  */
-export async function getConnectedNetwork(connection: Connection): Promise<Network> {
-  const genesisHash = await connection.getGenesisHash();
+export async function getConnectedNetwork(rpc: SolanaRpcClient): Promise<Network> {
+  const genesisHash = await rpc.getGenesisHash().send();
 
   if (genesisHash === GENESIS_HASH_MAINNET) {
     return "mainnet";

package/analytics.ts

@@ -50,35 +50,14 @@ type ActionEventData = {
 
 type EventData = ErrorEventData | ActionEventData;
 
-// Symbol to store the original method on wrapped functions
-const ORIGINAL_METHOD = Symbol("originalMethod");
-
 // This is a public client id for the analytics service
 const publicClientId = "54f2ee2fb3d2b901a829940d70fbfc13";
 
 export const Analytics = {
   identifier: "", // set in cdp.ts
-  wrapClassWithErrorTracking,
-  wrapObjectMethodsWithErrorTracking,
-  sendEvent,
-  trackAction,
-};
-
-/*
- * Deprecated implementation - kept for test compatibility
- * Shares the same identifier reference as Analytics
- */
-export const AnalyticsDeprecated = {
-  get identifier() {
-    return Analytics.identifier;
-  },
-  set identifier(value: string) {
-    Analytics.identifier = value;
-  },
-  wrapClassWithErrorTracking: wrapClassWithErrorTrackingDeprecated,
-  wrapObjectMethodsWithErrorTracking: wrapObjectMethodsWithErrorTrackingDeprecated,
   sendEvent,
   trackAction,
+  trackError,
 };
 
 /**
@@ -171,281 +150,16 @@ function trackAction(params: {
 }
 
 /**
- * Gets the original method from a wrapped method, or returns the method itself if it's not wrapped.
- *
- * @param method - The method to get the original version of.
- * @returns The original unwrapped method, or the method itself if it's not wrapped.
- */
-function getOriginalMethod(
-  method: (this: unknown, ...args: unknown[]) => Promise<unknown>,
-): (this: unknown, ...args: unknown[]) => Promise<unknown> {
-  return (
-    (method as { [ORIGINAL_METHOD]?: (this: unknown, ...args: unknown[]) => Promise<unknown> })[
-      ORIGINAL_METHOD
-    ] || method
-  );
-}
-
-/**
- * Creates an interceptor function that prevents recursive calls by checking if the instance is already executing.
+ * Track an error that occurred in a method
  *
- * @param executingInstances - A WeakSet tracking instances that are currently executing.
- * @param fallbackMethod - The method to call if recursion is not detected.
- * @returns A function that intercepts calls and prevents recursion.
+ * @param error - The error to track
+ * @param method - The method name where the error occurred
  */
-function createRecursiveInterceptor(
-  executingInstances: WeakSet<object>,
-  fallbackMethod: (...args: unknown[]) => Promise<unknown>,
-): (...args: unknown[]) => Promise<unknown> {
-  return function (this: unknown, ...callArgs: unknown[]) {
-    if (executingInstances.has(this as object)) {
-      return Promise.resolve(callArgs[0]);
-    }
-    return fallbackMethod.apply(this, callArgs);
-  };
-}
-/**
- * Handles an error that occurred in a method by sending an analytics event and rethrowing the error.
- *
- * @param error - The error that occurred.
- * @param methodName - The name of the method where the error occurred.
- */
-async function handleMethodError(error: unknown, methodName: string): Promise<void> {
-  if (!shouldTrackError(error)) {
-    throw error;
-  }
-
+function trackError(error: unknown, method: string): void {
+  if (process.env.DISABLE_CDP_ERROR_REPORTING === "true") return;
+  if (!shouldTrackError(error)) return;
   const { message, stack } = error as Error;
-  sendEvent({
-    method: methodName,
-    message,
-    stack,
-    name: "error",
-  }).catch(() => {
-    // ignore error
-  });
-
-  throw error;
-}
-
-/**
- * Creates a wrapper function that adds error tracking and recursion protection to a method.
- *
- * The recursion protection works by temporarily replacing the method with an interceptor
- * during the synchronous phase of execution. Any recursive calls (e.g., a method calling
- * itself via `this.method()` or `Class.prototype.method()`) happen synchronously and will
- * hit the interceptor. After the synchronous phase completes (i.e., `originalMethod.apply()`
- * returns a Promise), the method is immediately restored so that concurrent calls arriving
- * after an `await` suspension go through the full wrapper instead of being intercepted.
- *
- * @param originalMethod - The original method to wrap.
- * @param methodName - The name of the method being wrapped.
- * @param executingInstances - A WeakSet tracking instances that are currently executing.
- * @param setMethod - A function to set the method implementation.
- * @param getMethod - A function to get the current method implementation.
- * @returns A wrapped version of the method with error tracking and recursion protection.
- */
-function createErrorTrackingWrapper(
-  originalMethod: (this: unknown, ...args: unknown[]) => Promise<unknown>,
-  methodName: string,
-  executingInstances: WeakSet<object>,
-  setMethod: (method: (...args: unknown[]) => Promise<unknown>) => void,
-  getMethod: () => (...args: unknown[]) => Promise<unknown>,
-): (this: unknown, ...args: unknown[]) => Promise<unknown> {
-  return async function (this: unknown, ...args: unknown[]) {
-    const previousMethod = getMethod();
-    const recursiveInterceptor = createRecursiveInterceptor(executingInstances, previousMethod);
-    setMethod(recursiveInterceptor);
-    executingInstances.add(this as object);
-
-    try {
-      /*
-       * Start executing the original method. The synchronous portion runs immediately.
-       * Any recursive calls (e.g., this.method() or Class.prototype.method()) during
-       * this synchronous phase will hit the recursiveInterceptor.
-       */
-      const resultPromise = originalMethod.apply(this, args);
-
-      /*
-       * Restore the method immediately after the synchronous phase completes.
-       * This ensures concurrent calls (arriving after an await suspension) go through
-       * the full wrapper chain instead of being short-circuited by the interceptor.
-       */
-      setMethod(previousMethod);
-      executingInstances.delete(this as object);
-
-      return await resultPromise;
-    } catch (error) {
-      setMethod(previousMethod);
-      executingInstances.delete(this as object);
-      return handleMethodError(error, methodName);
-    }
-  };
-}
-
-/**
- * Wraps all methods of a class with error tracking.
- *
- * @param ClassToWrap - The class whose prototype methods should be wrapped.
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function wrapClassWithErrorTracking(ClassToWrap: any): void {
-  if (process.env.DISABLE_CDP_ERROR_REPORTING === "true") {
-    return;
-  }
-
-  const methods = Object.getOwnPropertyNames(ClassToWrap.prototype).filter(
-    name => name !== "constructor" && typeof ClassToWrap.prototype[name] === "function",
-  );
-
-  for (const method of methods) {
-    const currentMethod = ClassToWrap.prototype[method];
-    const originalMethod = getOriginalMethod(currentMethod);
-    const executingInstances = new WeakSet<object>();
-
-    const wrappedMethod = createErrorTrackingWrapper(
-      originalMethod,
-      method,
-      executingInstances,
-      newMethod => {
-        ClassToWrap.prototype[method] = newMethod as (
-          this: unknown,
-          ...args: unknown[]
-        ) => Promise<unknown>;
-      },
-      () => ClassToWrap.prototype[method] as (...args: unknown[]) => Promise<unknown>,
-    );
-
-    (wrappedMethod as unknown as { [ORIGINAL_METHOD]: unknown })[ORIGINAL_METHOD] = originalMethod;
-    ClassToWrap.prototype[method] = wrappedMethod;
-  }
-}
-
-/**
- * Wraps all methods of an object with error tracking.
- *
- * @param object - The object whose methods should be wrapped.
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function wrapObjectMethodsWithErrorTracking(object: any): void {
-  if (process.env.DISABLE_CDP_ERROR_REPORTING === "true") {
-    return;
-  }
-
-  const methods = Object.getOwnPropertyNames(object).filter(
-    name => name !== "constructor" && typeof object[name] === "function",
-  );
-
-  for (const method of methods) {
-    const currentMethod = object[method];
-    const originalMethod = getOriginalMethod(currentMethod);
-    const executingInstances = new WeakSet<object>();
-
-    const wrappedMethod = createErrorTrackingWrapper(
-      originalMethod,
-      method,
-      executingInstances,
-      newMethod => {
-        object[method] = newMethod;
-      },
-      () => object[method] as (...args: unknown[]) => Promise<unknown>,
-    );
-
-    (wrappedMethod as unknown as { [ORIGINAL_METHOD]: unknown })[ORIGINAL_METHOD] = originalMethod;
-    object[method] = wrappedMethod;
-  }
-}
-
-/**
- * Wraps all methods of a class with error tracking.
- *
- * @deprecated This is the old implementation that has a bug with methods calling themselves via prototype.
- * Use Analytics.wrapClassWithErrorTracking instead.
- * Kept for test compatibility.
- *
- * @param ClassToWrap - The class whose prototype methods should be wrapped.
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function wrapClassWithErrorTrackingDeprecated(ClassToWrap: any): void {
-  if (process.env.DISABLE_CDP_ERROR_REPORTING === "true") {
-    return;
-  }
-
-  const methods = Object.getOwnPropertyNames(ClassToWrap.prototype).filter(
-    name => name !== "constructor" && typeof ClassToWrap.prototype[name] === "function",
-  );
-
-  for (const method of methods) {
-    const originalMethod = ClassToWrap.prototype[method];
-    ClassToWrap.prototype[method] = async function (...args: unknown[]) {
-      try {
-        return await originalMethod.apply(this, args);
-      } catch (error) {
-        if (!shouldTrackError(error)) {
-          throw error;
-        }
-
-        const { message, stack } = error as Error;
-
-        sendEvent({
-          method,
-          message,
-          stack,
-          name: "error",
-        }).catch(() => {
-          // ignore error
-        });
-
-        throw error;
-      }
-    };
-  }
-}
-
-/**
- * Wraps all methods of an object with error tracking.
- *
- * @deprecated This is the old implementation that has a bug with methods calling themselves via object property.
- * Use Analytics.wrapObjectMethodsWithErrorTracking instead.
- * Kept for test compatibility.
- *
- * @param object - The object whose methods should be wrapped.
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function wrapObjectMethodsWithErrorTrackingDeprecated(object: any): void {
-  if (process.env.DISABLE_CDP_ERROR_REPORTING === "true") {
-    return;
-  }
-
-  const methods = Object.getOwnPropertyNames(object).filter(
-    name => name !== "constructor" && typeof object[name] === "function",
-  );
-
-  for (const method of methods) {
-    const originalMethod = object[method];
-    object[method] = async function (...args: unknown[]) {
-      try {
-        return await originalMethod.apply(this, args);
-      } catch (error) {
-        if (!shouldTrackError(error)) {
-          throw error;
-        }
-
-        const { message, stack } = error as Error;
-
-        sendEvent({
-          method,
-          message,
-          stack,
-          name: "error",
-        }).catch(() => {
-          // ignore error
-        });
-
-        throw error;
-      }
-    };
-  }
+  sendEvent({ method, message, stack, name: "error" }).catch(() => {});
 }
 
 /**

package/auth/utils/http.ts

@@ -134,6 +134,7 @@ function requiresWalletAuth(requestMethod: string, requestPath: string): boolean
     (requestPath?.includes("/accounts") ||
       requestPath?.includes("/spend-permissions") ||
       requestPath?.includes("/user-operations/prepare-and-send") ||
+      requestPath?.includes("/embedded-wallet-api/") ||
       requestPath?.endsWith("/end-users") ||
       requestPath?.endsWith("/end-users/import") ||
       /\/end-users\/[^/]+\/evm$/.test(requestPath) ||

package/client/cdp.ts

@@ -13,6 +13,8 @@ export interface CdpClientOptions {
   apiKeySecret?: string;
   /** The wallet secret. */
   walletSecret?: string;
+  /** The CDP project ID. Required for end-user delegation operations (signing, sending). */
+  projectId?: string;
   /** Whether to enable debugging. */
   debugging?: boolean;
   /** The host URL to connect to. */
@@ -50,6 +52,7 @@ export class CdpClient {
    * CDP_API_KEY_ID=your-api-key-id
    * CDP_API_KEY_SECRET=your-api-key-secret
    * CDP_WALLET_SECRET=your-wallet-secret
+   * CDP_PROJECT_ID=your-project-id
    * ```
    *
    * Or passed as options to the constructor:
@@ -59,6 +62,7 @@ export class CdpClient {
    *   apiKeyId: "your-api-key-id",
    *   apiKeySecret: "your-api-key-secret",
    *   walletSecret: "your-wallet-secret",
+   *   projectId: "your-project-id",
    * });
    * ```
    *
@@ -83,6 +87,7 @@ We recommend using https://github.com/Schniz/fnm for managing your Node.js versi
     const apiKeyId = options.apiKeyId ?? process.env.CDP_API_KEY_ID ?? process.env.CDP_API_KEY_NAME;
     const apiKeySecret = options.apiKeySecret ?? process.env.CDP_API_KEY_SECRET;
     const walletSecret = options.walletSecret ?? process.env.CDP_WALLET_SECRET;
+    const projectId = options.projectId ?? process.env.CDP_PROJECT_ID;
 
     if (!apiKeyId || !apiKeySecret) {
       throw new Error(`
@@ -132,16 +137,9 @@ For more information, see: https://github.com/coinbase/cdp-sdk/blob/main/typescr
       Analytics.identifier = apiKeyId;
     }
 
-    if (process.env.DISABLE_CDP_ERROR_REPORTING !== "true") {
-      Analytics.wrapClassWithErrorTracking(CdpClient);
-      Analytics.wrapClassWithErrorTracking(EvmClient);
-      Analytics.wrapClassWithErrorTracking(SolanaClient);
-      Analytics.wrapClassWithErrorTracking(PoliciesClient);
-    }
-
     this.evm = new EvmClient();
     this.solana = new SolanaClient();
     this.policies = new PoliciesClient();
-    this.endUser = new CDPEndUserClient();
+    this.endUser = new CDPEndUserClient(projectId);
   }
 }