@coinbase/cdp-sdk 1.38.4 → 1.38.6

package/actions/evm/types.ts

@@ -2,14 +2,8 @@
  * @module Actions
  */
 
-import { FundOperationResult } from "../types.js";
-import {
-  WaitForFundOperationOptions,
-  WaitForFundOperationResult,
-} from "../waitForFundOperationReceipt.js";
-import { EvmFundOptions } from "./fund/fund.js";
-import { EvmQuoteFundOptions } from "./fund/quoteFund.js";
 import { SendUserOperationOptions, SendUserOperationReturnType } from "./sendUserOperation.js";
+import { UseSpendPermissionOptions } from "./spend-permissions/types.js";
 import { KnownEvmNetworks } from "../../accounts/evm/types.js";
 import {
   GetUserOperationOptions,
@@ -17,8 +11,6 @@ import {
   UserOperation,
 } from "../../client/evm/evm.types.js";
 import { Hex } from "../../types/misc.js";
-import { EvmQuote } from "../Quote.js";
-import { UseSpendPermissionOptions } from "./spend-permissions/types.js";
 
 import type { ListTokenBalancesOptions, ListTokenBalancesResult } from "./listTokenBalances.js";
 import type { RequestFaucetOptions, RequestFaucetResult } from "./requestFaucet.js";
@@ -78,71 +70,6 @@ export type Actions = {
    * ```
    */
   requestFaucet: (options: Omit<RequestFaucetOptions, "address">) => Promise<RequestFaucetResult>;
-
-  /**
-   * Gets a quote to fund an EVM account.
-   *
-   * @param options - The options for the quote fund.
-   * @param options.network - The network to fund the account on.
-   * @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({
-   *   network: "base",
-   *   token: "usdc",
-   *   amount: 1000000n,
-   * });
-   * ```
-   */
-  quoteFund: (options: Omit<EvmQuoteFundOptions, "address">) => Promise<EvmQuote>;
-
-  /**
-   * Funds an EVM account with the specified token amount.
-   *
-   * @param options - The options for the fund operation.
-   * @param options.network - The network to fund the account on.
-   * @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({
-   *   network: "base",
-   *   token: "usdc",
-   *   amount: 1000000n,
-   * });
-   * ```
-   */
-  fund: (options: Omit<EvmFundOptions, "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>;
 };
 
 export type AccountActions = Actions & {

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

@@ -50,6 +50,9 @@ 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";
 
@@ -61,6 +64,23 @@ export const Analytics = {
   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,
+};
+
 /**
  * Sends an analytics event to the default endpoint
  *
@@ -150,6 +170,129 @@ 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.
+ *
+ * @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.
+ */
+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);
+  };
+}
+
+/**
+ * Executes a method with recursion protection by tracking executing instances.
+ *
+ * @param executingInstances - A WeakSet tracking instances that are currently executing.
+ * @param originalMethod - The original method to execute.
+ * @param context - The context (this) to bind the method to.
+ * @param args - The arguments to pass to the method.
+ * @returns The result of executing the original method.
+ */
+async function executeWithRecursionProtection<T>(
+  executingInstances: WeakSet<object>,
+  originalMethod: (this: unknown, ...args: unknown[]) => Promise<T>,
+  context: unknown,
+  args: unknown[],
+): Promise<T> {
+  if (executingInstances.has(context as object)) {
+    return args[0] as T;
+  }
+  executingInstances.add(context as object);
+  try {
+    return await originalMethod.apply(context, args);
+  } finally {
+    executingInstances.delete(context as object);
+  }
+}
+
+/**
+ * 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;
+  }
+
+  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.
+ *
+ * @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);
+
+    try {
+      const result = await executeWithRecursionProtection(
+        executingInstances,
+        originalMethod,
+        this,
+        args,
+      );
+      setMethod(previousMethod);
+      return result;
+    } catch (error) {
+      setMethod(previousMethod);
+      return handleMethodError(error, methodName);
+    }
+  };
+}
+
 /**
  * Wraps all methods of a class with error tracking.
  *
@@ -165,6 +308,83 @@ function wrapClassWithErrorTracking(ClassToWrap: any): void {
     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[]) {
@@ -195,10 +415,14 @@ function wrapClassWithErrorTracking(ClassToWrap: any): void {
 /**
  * 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 wrapObjectMethodsWithErrorTracking(object: any): void {
+function wrapObjectMethodsWithErrorTrackingDeprecated(object: any): void {
   if (process.env.DISABLE_CDP_ERROR_REPORTING === "true") {
     return;
   }

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/end-user/endUser.ts

@@ -1,11 +1,61 @@
-import { type ValidateAccessTokenOptions } from "./endUser.types.js";
+import { type ValidateAccessTokenOptions, type ListEndUsersOptions } from "./endUser.types.js";
 import { Analytics } from "../../analytics.js";
-import { CdpOpenApiClient, type EndUser } from "../../openapi-client/index.js";
+import {
+  CdpOpenApiClient,
+  type EndUser,
+  type ListEndUsers200,
+} from "../../openapi-client/index.js";
 
 /**
  * The CDP end user client.
  */
 export class CDPEndUserClient {
+  /**
+   * Lists end users belonging to the developer's CDP Project.
+   * By default, the response is sorted by creation date in ascending order and paginated to 20 users per page.
+   *
+   * @param options - The options for listing end users.
+   *
+   * @returns A promise that resolves to a paginated list of end users.
+   *
+   * @example **List all end users**
+   *          ```ts
+   *          const result = await cdp.endUsers.listEndUsers();
+   *          console.log(result.endUsers);
+   *          ```
+   *
+   * @example **With pagination**
+   *          ```ts
+   *          let page = await cdp.endUsers.listEndUsers({ pageSize: 10 });
+   *
+   *          while (page.nextPageToken) {
+   *            page = await cdp.endUsers.listEndUsers({
+   *              pageSize: 10,
+   *              pageToken: page.nextPageToken
+   *            });
+   *          }
+   *          ```
+   *
+   * @example **With sorting**
+   *          ```ts
+   *          const result = await cdp.endUsers.listEndUsers({
+   *            sort: ['createdAt=desc']
+   *          });
+   *          ```
+   */
+  async listEndUsers(options: ListEndUsersOptions = {}): Promise<ListEndUsers200> {
+    Analytics.trackAction({
+      action: "list_end_users",
+    });
+
+    const params = {
+      ...options,
+      ...(options.sort && { sort: options.sort.join(",") }),
+    };
+
+    return CdpOpenApiClient.listEndUsers(params as ListEndUsersOptions);
+  }
+
   /**
    * Validates an end user's access token. Throws an error if the access token is invalid.
    *

package/client/end-user/endUser.types.ts

@@ -1,3 +1,5 @@
+import type { ListEndUsersParams } from "../../openapi-client/index.js";
+
 /**
  * The options for validating an access token.
  */
@@ -7,3 +9,8 @@ export interface ValidateAccessTokenOptions {
    */
   accessToken: string;
 }
+
+/**
+ * The options for listing end users.
+ */
+export type ListEndUsersOptions = ListEndUsersParams;

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.
    *