@coinbase/cdp-sdk 1.38.5 → 1.39.0

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

@@ -133,7 +133,8 @@ function requiresWalletAuth(requestMethod: string, requestPath: string): boolean
   return (
     (requestPath?.includes("/accounts") ||
       requestPath?.includes("/spend-permissions") ||
-      requestPath?.includes("/user-operations/prepare-and-send")) &&
+      requestPath?.includes("/user-operations/prepare-and-send") ||
+      requestPath?.endsWith("/end-users")) &&
     (requestMethod === "POST" || requestMethod === "DELETE" || requestMethod === "PUT")
   );
 }

package/client/end-user/endUser.ts

@@ -1,11 +1,108 @@
-import { type ValidateAccessTokenOptions } from "./endUser.types.js";
+import { randomUUID } from "crypto";
+
+import {
+  type ValidateAccessTokenOptions,
+  type ListEndUsersOptions,
+  type CreateEndUserOptions,
+} 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 {
+  /**
+   * Creates an end user. An end user is an entity that can own CDP EVM accounts,
+   * EVM smart accounts, and/or Solana accounts.
+   *
+   * @param options - The options for creating an end user.
+   *
+   * @returns A promise that resolves to the created end user.
+   *
+   * @example **Create an end user with an email authentication method**
+   *          ```ts
+   *          const endUser = await cdp.endUser.createEndUser({
+   *            authenticationMethods: [
+   *              { type: "email", email: "user@example.com" }
+   *            ]
+   *          });
+   *          console.log(endUser.userId);
+   *          ```
+   *
+   * @example **Create an end user with an EVM EOA account**
+   *          ```ts
+   *          const endUser = await cdp.endUser.createEndUser({
+   *            authenticationMethods: [
+   *              { type: "email", email: "user@example.com" }
+   *            ],
+   *            evmAccount: { createSmartAccount: false }
+   *          });
+   *          ```
+   */
+  async createEndUser(options: CreateEndUserOptions): Promise<EndUser> {
+    Analytics.trackAction({
+      action: "create_end_user",
+    });
+
+    const userId = options.userId ?? randomUUID();
+
+    return CdpOpenApiClient.createEndUser({
+      ...options,
+      userId,
+    });
+  }
+
+  /**
+   * 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 { CreateEndUserBody, ListEndUsersParams } from "../../openapi-client/index.js";
+
 /**
  * The options for validating an access token.
  */
@@ -7,3 +9,13 @@ export interface ValidateAccessTokenOptions {
    */
   accessToken: string;
 }
+
+/**
+ * The options for listing end users.
+ */
+export type ListEndUsersOptions = ListEndUsersParams;
+
+/**
+ * The options for creating an end user.
+ */
+export type CreateEndUserOptions = CreateEndUserBody;

package/index.ts

@@ -9,7 +9,8 @@ export {
 } from "./policies/types.js";
 export { NetworkError } from "./openapi-client/errors.js";
 export type { SpendPermission, SpendPermissionInput } from "./spend-permissions/types.js";
-export type { SpendPermissionNetwork } from "./openapi-client/index.js";
+export type { SpendPermissionNetwork, ListEndUsers200, EndUser } from "./openapi-client/index.js";
+export type { ListEndUsersOptions } from "./client/end-user/endUser.types.js";
 export {
   SPEND_PERMISSION_MANAGER_ABI as spendPermissionManagerAbi,
   SPEND_PERMISSION_MANAGER_ADDRESS as spendPermissionManagerAddress,