@coinbase/cdp-sdk 1.44.1 → 1.45.0

package/accounts/solana/toSolanaAccount.ts

@@ -43,22 +43,30 @@ export function toSolanaAccount(
         action: "request_faucet",
         accountType: "solana",
       });
-
-      return requestFaucet(apiClient, {
-        ...options,
-        address: account.address,
-      });
+      try {
+        return requestFaucet(apiClient, {
+          ...options,
+          address: account.address,
+        });
+      } catch (error) {
+        Analytics.trackError(error, "requestFaucet");
+        throw error;
+      }
     },
     async signMessage(options: Omit<SignMessageOptions, "address">): Promise<SignatureResult> {
       Analytics.trackAction({
         action: "sign_message",
         accountType: "solana",
       });
-
-      return signMessage(apiClient, {
-        ...options,
-        address: account.address,
-      });
+      try {
+        return signMessage(apiClient, {
+          ...options,
+          address: account.address,
+        });
+      } catch (error) {
+        Analytics.trackError(error, "signMessage");
+        throw error;
+      }
     },
     async signTransaction(
       options: Omit<SignTransactionOptions, "address">,
@@ -67,11 +75,15 @@ export function toSolanaAccount(
         action: "sign_transaction",
         accountType: "solana",
       });
-
-      return signTransaction(apiClient, {
-        ...options,
-        address: account.address,
-      });
+      try {
+        return signTransaction(apiClient, {
+          ...options,
+          address: account.address,
+        });
+      } catch (error) {
+        Analytics.trackError(error, "signTransaction");
+        throw error;
+      }
     },
     async sendTransaction(
       options: Omit<SendTransactionOptions, "address">,
@@ -80,10 +92,14 @@ export function toSolanaAccount(
         action: "send_transaction",
         accountType: "solana",
       });
-
-      return sendTransaction(apiClient, {
-        ...options,
-      });
+      try {
+        return sendTransaction(apiClient, {
+          ...options,
+        });
+      } catch (error) {
+        Analytics.trackError(error, "sendTransaction");
+        throw error;
+      }
     },
     async transfer(options: Omit<TransferOptions, "from">): Promise<SignatureResult> {
       Analytics.trackAction({
@@ -93,11 +109,15 @@ export function toSolanaAccount(
           network: options.network,
         },
       });
-
-      return transfer(apiClient, {
-        ...options,
-        from: account.address,
-      });
+      try {
+        return transfer(apiClient, {
+          ...options,
+          from: account.address,
+        });
+      } catch (error) {
+        Analytics.trackError(error, "transfer");
+        throw error;
+      }
     },
   };
 

package/actions/evm/waitForEvmEip7702DelegationStatus.ts

@@ -0,0 +1,57 @@
+import {
+  CdpOpenApiClientType,
+  EvmEip7702DelegationOperation,
+  EvmEip7702DelegationOperationStatus,
+} from "../../openapi-client/index.js";
+import { wait, WaitOptions } from "../../utils/wait.js";
+
+/**
+ * Options for waiting for an EIP-7702 delegation operation to complete.
+ */
+export type WaitForEvmEip7702DelegationOperationStatusOptions = {
+  /** The delegation operation ID returned by createEvmEip7702Delegation. */
+  delegationOperationId: string;
+  /** Optional options for the wait operation. */
+  waitOptions?: WaitOptions;
+};
+
+/**
+ * Polls getEvmEip7702DelegationOperationById until the status is COMPLETED or FAILED, or a timeout occurs.
+ *
+ * @example
+ * ```ts
+ * import { waitForEvmEip7702DelegationOperationStatus } from "@coinbase/cdp-sdk";
+ *
+ * const operation = await waitForEvmEip7702DelegationOperationStatus(client, {
+ *   delegationOperationId: "delegation-op-123",
+ *   waitOptions: {
+ *     timeoutSeconds: 60,
+ *   },
+ * });
+ * ```
+ *
+ * @param {CdpOpenApiClientType} client - The client to use.
+ * @param {WaitForEvmEip7702DelegationOperationStatusOptions} options - The options for the wait operation.
+ * @returns {Promise<EvmEip7702DelegationOperation>} The delegation operation once it reaches a terminal status.
+ */
+export async function waitForEvmEip7702DelegationOperationStatus(
+  client: CdpOpenApiClientType,
+  options: WaitForEvmEip7702DelegationOperationStatusOptions,
+): Promise<EvmEip7702DelegationOperation> {
+  const { delegationOperationId } = options;
+
+  const reload = async () => {
+    return client.getEvmEip7702DelegationOperationById(delegationOperationId);
+  };
+
+  const isTerminal = (operation: EvmEip7702DelegationOperation): boolean => {
+    return (
+      operation.status === EvmEip7702DelegationOperationStatus.COMPLETED ||
+      operation.status === EvmEip7702DelegationOperationStatus.FAILED
+    );
+  };
+
+  const waitOptions = options.waitOptions ?? { timeoutSeconds: 60 };
+
+  return await wait(reload, isTerminal, s => s, waitOptions);
+}

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/client/cdp.ts

@@ -132,13 +132,6 @@ 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();