@coinbase/cdp-sdk 1.7.0 → 1.9.0

package/analytics.ts

@@ -1,5 +1,8 @@
 import md5 from "md5";
 
+import { APIError } from "./openapi-client/errors.js";
+import { version } from "./version.js";
+
 /**
  * The data in an error event
  */
@@ -22,30 +25,40 @@ type ErrorEventData = {
   name: "error";
 };
 
-type EventData = ErrorEventData & {
-  apiKeyId: string;
-};
+type EventData = ErrorEventData;
 
 // This is a public client id for the analytics service
 const publicClientId = "54f2ee2fb3d2b901a829940d70fbfc13";
 
+export const Analytics = {
+  identifier: "", // set in cdp.ts
+  wrapClassWithErrorTracking,
+  wrapObjectMethodsWithErrorTracking,
+  sendEvent,
+};
+
 /**
  * Sends an analytics event to the default endpoint
  *
  * @param event - The event data containing event-specific fields
  * @returns Promise that resolves when the event is sent
  */
-export async function sendEvent(event: EventData): Promise<void> {
+async function sendEvent(event: EventData): Promise<void> {
+  if (process.env.DISABLE_CDP_ERROR_REPORTING === "true") {
+    return;
+  }
+
   const timestamp = Date.now();
 
   const enhancedEvent = {
-    user_id: event.apiKeyId,
+    user_id: Analytics.identifier,
     event_type: event.name,
     platform: "server",
     timestamp,
     event_properties: {
       project_name: "cdp-sdk",
       cdp_sdk_language: "typescript",
+      version,
       ...event,
     },
   };
@@ -80,10 +93,13 @@ export async function sendEvent(event: EventData): Promise<void> {
  * Wraps all methods of a class with error tracking.
  *
  * @param ClassToWrap - The class whose prototype methods should be wrapped.
- * @param apiKeyId - The API key ID to use for the error tracking.
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function wrapClassWithErrorTracking(ClassToWrap: any, apiKeyId: string): void {
+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",
   );
@@ -94,14 +110,13 @@ export function wrapClassWithErrorTracking(ClassToWrap: any, apiKeyId: string):
       try {
         return await originalMethod.apply(this, args);
       } catch (error) {
-        if (!(error instanceof Error)) {
-          return;
+        if (!shouldTrackError(error)) {
+          throw error;
         }
 
-        const { message, stack } = error;
+        const { message, stack } = error as Error;
 
         sendEvent({
-          apiKeyId,
           method,
           message,
           stack,
@@ -115,3 +130,63 @@ export function wrapClassWithErrorTracking(ClassToWrap: any, apiKeyId: string):
     };
   }
 }
+
+/**
+ * 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 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;
+      }
+    };
+  }
+}
+
+/**
+ * Filters out non-errors and API errors
+ *
+ * @param error - The error to check.
+ * @returns True if the error should be tracked, false otherwise.
+ */
+function shouldTrackError(error: unknown): boolean {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+
+  if (error instanceof APIError) {
+    return false;
+  }
+
+  return true;
+}

package/client/cdp.ts

@@ -1,7 +1,8 @@
-import { wrapClassWithErrorTracking } from "../analytics.js";
+import { Analytics } from "../analytics.js";
 import { CdpOpenApiClient } from "../openapi-client/index.js";
 import { version } from "../version.js";
 import { EvmClient } from "./evm/evm.js";
+import { PoliciesClient } from "./policies/policies.js";
 import { SolanaClient } from "./solana/solana.js";
 
 interface CdpClientOptions {
@@ -27,6 +28,9 @@ export class CdpClient {
   /** Namespace containing all Solana methods. */
   public solana: SolanaClient;
 
+  /** Namespace containing all Policies methods. */
+  public policies: PoliciesClient;
+
   /**
    * The CdpClient is the main class for interacting with the CDP API.
    *
@@ -109,12 +113,15 @@ For more information, see: https://github.com/coinbase/cdp-sdk/blob/main/typescr
     });
 
     if (process.env.DISABLE_CDP_ERROR_REPORTING !== "true") {
-      wrapClassWithErrorTracking(CdpClient, apiKeyId);
-      wrapClassWithErrorTracking(EvmClient, apiKeyId);
-      wrapClassWithErrorTracking(SolanaClient, apiKeyId);
+      Analytics.identifier = apiKeyId;
+      Analytics.wrapClassWithErrorTracking(CdpClient);
+      Analytics.wrapClassWithErrorTracking(EvmClient);
+      Analytics.wrapClassWithErrorTracking(SolanaClient);
+      Analytics.wrapClassWithErrorTracking(PoliciesClient);
     }
 
     this.evm = new EvmClient();
     this.solana = new SolanaClient();
+    this.policies = new PoliciesClient();
   }
 }

package/client/evm/evm.ts

@@ -21,6 +21,8 @@ import {
   ListSmartAccountResult,
   ListSmartAccountsOptions,
   GetOrCreateServerAccountOptions,
+  SignTypedDataOptions,
+  UpdateEvmAccountOptions,
 } from "./evm.types.js";
 import { toEvmServerAccount } from "../../accounts/evm/toEvmServerAccount.js";
 import { toEvmSmartAccount } from "../../accounts/evm/toEvmSmartAccount.js";
@@ -45,6 +47,7 @@ import {
   waitForUserOperation,
   WaitForUserOperationReturnType,
 } from "../../actions/evm/waitForUserOperation.js";
+import { Analytics } from "../../analytics.js";
 import { APIError } from "../../openapi-client/errors.js";
 import { CdpOpenApiClient } from "../../openapi-client/index.js";
 import { Hex } from "../../types/misc.js";
@@ -93,16 +96,20 @@ export class EvmClient implements EvmClientInterface {
    *          ```
    */
   async createAccount(options: CreateServerAccountOptions = {}): Promise<ServerAccount> {
-    const account = await CdpOpenApiClient.createEvmAccount(
+    const openApiAccount = await CdpOpenApiClient.createEvmAccount(
       {
         name: options.name,
       },
       options.idempotencyKey,
     );
 
-    return toEvmServerAccount(CdpOpenApiClient, {
-      account,
+    const account = toEvmServerAccount(CdpOpenApiClient, {
+      account: openApiAccount,
     });
+
+    Analytics.wrapObjectMethodsWithErrorTracking(account);
+
+    return account;
   }
 
   /**
@@ -151,17 +158,21 @@ export class EvmClient implements EvmClientInterface {
    *          ```
    */
   async createSmartAccount(options: CreateSmartAccountOptions): Promise<SmartAccount> {
-    const smartAccount = await CdpOpenApiClient.createEvmSmartAccount(
+    const openApiSmartAccount = await CdpOpenApiClient.createEvmSmartAccount(
       {
         owners: [options.owner.address],
       },
       options.idempotencyKey,
     );
 
-    return toEvmSmartAccount(CdpOpenApiClient, {
-      smartAccount,
+    const smartAccount = toEvmSmartAccount(CdpOpenApiClient, {
+      smartAccount: openApiSmartAccount,
       owner: options.owner,
     });
+
+    Analytics.wrapObjectMethodsWithErrorTracking(smartAccount);
+
+    return smartAccount;
   }
 
   /**
@@ -190,7 +201,7 @@ export class EvmClient implements EvmClientInterface {
    *          ```
    */
   async getAccount(options: GetServerAccountOptions): Promise<ServerAccount> {
-    const account = await (() => {
+    const openApiAccount = await (() => {
       if (options.address) {
         return CdpOpenApiClient.getEvmAccount(options.address);
       }
@@ -202,9 +213,13 @@ export class EvmClient implements EvmClientInterface {
       throw new Error("Either address or name must be provided");
     })();
 
-    return toEvmServerAccount(CdpOpenApiClient, {
-      account,
+    const account = toEvmServerAccount(CdpOpenApiClient, {
+      account: openApiAccount,
     });
+
+    Analytics.wrapObjectMethodsWithErrorTracking(account);
+
+    return account;
   }
 
   /**
@@ -227,12 +242,16 @@ export class EvmClient implements EvmClientInterface {
    * ```
    */
   async getSmartAccount(options: GetSmartAccountOptions): Promise<SmartAccount> {
-    const smartAccount = await CdpOpenApiClient.getEvmSmartAccount(options.address);
+    const openApiSmartAccount = await CdpOpenApiClient.getEvmSmartAccount(options.address);
 
-    return toEvmSmartAccount(CdpOpenApiClient, {
-      smartAccount,
+    const smartAccount = toEvmSmartAccount(CdpOpenApiClient, {
+      smartAccount: openApiSmartAccount,
       owner: options.owner,
     });
+
+    Analytics.wrapObjectMethodsWithErrorTracking(smartAccount);
+
+    return smartAccount;
   }
 
   /**
@@ -328,11 +347,15 @@ export class EvmClient implements EvmClientInterface {
     });
 
     return {
-      accounts: ethAccounts.accounts.map(account =>
-        toEvmServerAccount(CdpOpenApiClient, {
-          account: account,
-        }),
-      ),
+      accounts: ethAccounts.accounts.map(account => {
+        const evmAccount = toEvmServerAccount(CdpOpenApiClient, {
+          account,
+        });
+
+        Analytics.wrapObjectMethodsWithErrorTracking(evmAccount);
+
+        return evmAccount;
+      }),
       nextPageToken: ethAccounts.nextPageToken,
     };
   }
@@ -647,6 +670,68 @@ export class EvmClient implements EvmClientInterface {
     };
   }
 
+  /**
+   * Signs an EIP-712 message.
+   *
+   * @param {SignTypedDataOptions} options - Parameters for signing the EIP-712 message.
+   * @returns A promise that resolves to the signature.
+   *
+   * @example
+   * ```ts
+   * const signature = await cdp.evm.signTypedData({
+   *   address: account.address,
+   *   domain: {
+   *     name: "Permit2",
+   *     chainId: 1,
+   *     verifyingContract: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
+   *   },
+   *   types: {
+   *     EIP712Domain: [
+   *       { name: "name", type: "string" },
+   *       { name: "chainId", type: "uint256" },
+   *       { name: "verifyingContract", type: "address" },
+   *     ],
+   *     PermitTransferFrom: [
+   *       { name: "permitted", type: "TokenPermissions" },
+   *       { name: "spender", type: "address" },
+   *       { name: "nonce", type: "uint256" },
+   *       { name: "deadline", type: "uint256" },
+   *     ],
+   *     TokenPermissions: [
+   *       { name: "token", type: "address" },
+   *       { name: "amount", type: "uint256" },
+   *     ],
+   *   },
+   *   primaryType: "PermitTransferFrom",
+   *   message: {
+   *     permitted: {
+   *       token: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+   *       amount: "1000000",
+   *     },
+   *     spender: "0xFfFfFfFFfFFfFFfFFfFFFFFffFFFffffFfFFFfFf",
+   *     nonce: "0",
+   *     deadline: "1717123200",
+   *   },
+   * });
+   * ```
+   */
+  async signTypedData(options: SignTypedDataOptions): Promise<SignatureResult> {
+    const signature = await CdpOpenApiClient.signEvmTypedData(
+      options.address,
+      {
+        domain: options.domain,
+        types: options.types,
+        primaryType: options.primaryType,
+        message: options.message,
+      },
+      options.idempotencyKey,
+    );
+
+    return {
+      signature: signature.signature as Hex,
+    };
+  }
+
   /**
    * Signs an EVM transaction.
    *
@@ -691,6 +776,63 @@ export class EvmClient implements EvmClientInterface {
     };
   }
 
+  /**
+   * Updates a CDP EVM account.
+   *
+   * @param {UpdateEvmAccountOptions} [options] - Optional parameters for creating the account.
+   * @param {string} options.address - The address of the account to update
+   * @param {UpdateEvmAccountBody} options.update - An object containing account fields to update.
+   * @param {string} [options.update.name] - The new name for the account.
+   * @param {string} [options.update.accountPolicy] - The ID of a Policy to apply to the account.
+   * @param {string} [options.idempotencyKey] - An idempotency key.
+   *
+   * @returns A promise that resolves to the updated account.
+   *
+   * @example **With a name**
+   *          ```ts
+   *          const account = await cdp.evm.updateAccount({ address: "0x...", update: { name: "New Name" } });
+   *          ```
+   *
+   * @example **With an account policy**
+   *          ```ts
+   *          const account = await cdp.evm.updateAccount({ address: "0x...", update: { accountPolicy: "73bcaeeb-d7af-4615-b064-42b5fe83a31e" } });
+   *          ```
+   *
+   * @example **With an idempotency key**
+   *          ```ts
+   *          const idempotencyKey = uuidv4();
+   *
+   *          // First call
+   *          await cdp.evm.updateAccount({
+   *            address: "0x...",
+   *            update: { accountPolicy: "73bcaeeb-d7af-4615-b064-42b5fe83a31e" },
+   *            idempotencyKey,
+   *          });
+   *
+   *          // Second call with the same idempotency key will not update
+   *          await cdp.evm.updateAccount({
+   *            address: '0x...',
+   *            update: { name: "" },
+   *            idempotencyKey,
+   *          });
+   *          ```
+   */
+  async updateAccount(options: UpdateEvmAccountOptions): Promise<ServerAccount> {
+    const openApiAccount = await CdpOpenApiClient.updateEvmAccount(
+      options.address,
+      options.update,
+      options.idempotencyKey,
+    );
+
+    const account = toEvmServerAccount(CdpOpenApiClient, {
+      account: openApiAccount,
+    });
+
+    Analytics.wrapObjectMethodsWithErrorTracking(account);
+
+    return account;
+  }
+
   /**
    * Waits for a user operation to complete or fail.
    *

package/client/evm/evm.types.ts

@@ -21,9 +21,10 @@ import type {
   EvmUserOperationNetwork,
   EvmUserOperationStatus,
   OpenApiEvmMethods,
+  UpdateEvmAccountBody,
 } from "../../openapi-client/index.js";
 import type { Calls } from "../../types/calls.js";
-import type { Address, Hex } from "../../types/misc.js";
+import type { Address, EIP712Message, Hex } from "../../types/misc.js";
 import type { WaitOptions } from "../../utils/wait.js";
 
 /**
@@ -37,6 +38,7 @@ export type EvmClientInterface = Omit<
   | "getEvmAccountByName" // mapped to getAccount
   | "getEvmSmartAccount" // mapped to getSmartAccount
   | "getUserOperation"
+  | "updateEvmAccount" // mapped to updateAccount
   | "listEvmAccounts" // mapped to listAccounts
   | "listEvmSmartAccounts" // mapped to listSmartAccounts
   | "listEvmTokenBalances" // mapped to listTokenBalances
@@ -46,7 +48,10 @@ export type EvmClientInterface = Omit<
   | "signEvmHash" // mapped to signHash
   | "signEvmMessage" // mapped to signMessage
   | "signEvmTransaction" // mapped to signTransaction
+  | "signEvmTypedData" // mapped to signTypedData
   | "sendEvmTransaction" // mapped to sendTransaction
+  | "signEvmTypedData" // mapped to signTypedData
+  | "updateEvmAccount" // mapped to updateAccount
 > & {
   createAccount: (options: CreateServerAccountOptions) => Promise<ServerAccount>;
   createSmartAccount: (options: CreateSmartAccountOptions) => Promise<SmartAccount>;
@@ -54,6 +59,7 @@ export type EvmClientInterface = Omit<
   getSmartAccount: (options: GetSmartAccountOptions) => Promise<SmartAccount>;
   getOrCreateAccount: (options: GetOrCreateServerAccountOptions) => Promise<ServerAccount>;
   getUserOperation: (options: GetUserOperationOptions) => Promise<UserOperation>;
+  updateAccount: (options: UpdateEvmAccountOptions) => Promise<ServerAccount>;
   listAccounts: (options: ListServerAccountsOptions) => Promise<ListServerAccountResult>;
   listSmartAccounts: (options: ListSmartAccountsOptions) => Promise<ListSmartAccountResult>;
   listTokenBalances: (options: ListTokenBalancesOptions) => Promise<ListTokenBalancesResult>;
@@ -65,6 +71,7 @@ export type EvmClientInterface = Omit<
   ) => Promise<SendUserOperationReturnType>;
   signHash: (options: SignHashOptions) => Promise<SignatureResult>;
   signMessage: (options: SignMessageOptions) => Promise<SignatureResult>;
+  signTypedData: (options: SignTypedDataOptions) => Promise<SignatureResult>;
   signTransaction: (options: SignTransactionOptions) => Promise<SignatureResult>;
 };
 
@@ -187,6 +194,18 @@ export interface ReadonlySmartAccount
   owners: Address[];
 }
 
+/**
+ * Options for creating an EVM server account.
+ */
+export interface UpdateEvmAccountOptions {
+  /** The address of the account. */
+  address: string;
+  /** The updates to apply to the account */
+  update: UpdateEvmAccountBody;
+  /** The idempotency key. */
+  idempotencyKey?: string;
+}
+
 /**
  * The result of listing EVM smart accounts.
  */
@@ -259,6 +278,24 @@ export interface SignMessageOptions {
   idempotencyKey?: string;
 }
 
+/**
+ * Options for signing an EVM message.
+ */
+export interface SignTypedDataOptions {
+  /** The address of the account. */
+  address: Address;
+  /** The domain of the message. */
+  domain: EIP712Message["domain"];
+  /** The types of the message. */
+  types: EIP712Message["types"];
+  /** The primary type of the message. This is the name of the struct in the `types` object that is the root of the message. */
+  primaryType: EIP712Message["primaryType"];
+  /** The message to sign. The structure of this message must match the `primaryType` struct in the `types` object. */
+  message: EIP712Message["message"];
+  /** The idempotency key. */
+  idempotencyKey?: string;
+}
+
 /**
  * Options for signing an EVM transaction.
  */

package/client/policies/index.ts

@@ -0,0 +1 @@
+export { PoliciesClient } from "./policies.js";