@coinbase/cdp-sdk 1.7.0 → 1.8.0

package/_types/policies/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../policies/schema.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AACH,eAAO,MAAM,oBAAoB,yCAAuC,CAAC;AACzE;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAEpE;;GAEG;AACH,eAAO,MAAM,sBAAsB,6BAA2B,CAAC;AAC/D;;;GAGG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAExE;;GAEG;AACH,eAAO,MAAM,sBAAsB,6BAA2B,CAAC;AAC/D;;;GAGG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAExE;;GAEG;AACH,eAAO,MAAM,uBAAuB;IAClC,gFAAgF;;IAEhF;;;OAGG;;IAEH,8FAA8F;;;;;;;;;;EAE9F,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE;;GAEG;AACH,eAAO,MAAM,yBAAyB;IACpC,+EAA+E;;IAE/E;;;;OAIG;;IAEH;;;;OAIG;;;;;;;;;;EAEH,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E;;GAEG;AACH,eAAO,MAAM,yBAAyB;IACpC,kFAAkF;;IAElF;;;OAGG;;IAEH;;;;OAIG;;;;;;;;;;EAEH,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E;;GAEG;AACH,eAAO,MAAM,gCAAgC;IAxD3C,gFAAgF;;IAEhF;;;OAGG;;IAEH,8FAA8F;;;;;;;;;;;IAS9F,+EAA+E;;IAE/E;;;;OAIG;;IAEH;;;;OAIG;;;;;;;;;;aA+BI,CAAC;AACV;;;GAGG;AACH,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAC;AAE1F;;GAEG;AACH,eAAO,MAAM,gCAAgC;IAhC3C,kFAAkF;;IAElF;;;OAGG;;IAEH;;;;OAIG;;;;;;;;;;aAwBI,CAAC;AACV;;;GAGG;AACH,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAC;AAE1F;;GAEG;AACH,eAAO,MAAM,gBAAgB,mCAAiC,CAAC;AAC/D;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE5D;;GAEG;AACH,eAAO,MAAM,gBAAgB,mCAAiC,CAAC;AAC/D;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE5D;;GAEG;AACH,eAAO,MAAM,UAAU,iCAA+B,CAAC;AACvD;;;GAGG;AACH,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAEhD;;;GAGG;AACH,eAAO,MAAM,4BAA4B;IACvC;;;OAGG;;IAEH;;;OAGG;;IAEH;;;OAGG;;QA/HH,gFAAgF;;QAEhF;;;WAGG;;QAEH,8FAA8F;;;;;;;;;;;QAS9F,+EAA+E;;QAE/E;;;;WAIG;;QAEH;;;;WAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqGH,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAElF;;;GAGG;AACH,eAAO,MAAM,4BAA4B;IACvC;;;OAGG;;IAEH;;;OAGG;;IAEH;;;OAGG;;QAjHH,kFAAkF;;QAElF;;;WAGG;;QAEH;;;;WAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwGH,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAElF;;GAEG;AACH,eAAO,MAAM,UAAU;IA5CrB;;;OAGG;;IAEH;;;OAGG;;IAEH;;;OAGG;;QA/HH,gFAAgF;;QAEhF;;;WAGG;;QAEH,8FAA8F;;;;;;;;;;;QAS9F,+EAA+E;;QAE/E;;;;WAIG;;QAEH;;;;WAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA6GH;;;OAGG;;IAEH;;;OAGG;;IAEH;;;OAGG;;QAjHH,kFAAkF;;QAElF;;;WAGG;;QAEH;;;;WAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;IAiHH,CAAC;AAEH;;;GAGG;AACH,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAE9C;;GAEG;AACH,eAAO,MAAM,eAAe,mCAAiC,CAAC;AAC9D;;;GAGG;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAE1D;;GAEG;AACH,eAAO,MAAM,sBAAsB;IACjC;;;OAGG;;IAEH;;;OAGG;;IAKH;;;OAGG;;QArFH;;;WAGG;;QAEH;;;WAGG;;QAEH;;;WAGG;;YA/HH,gFAAgF;;YAEhF;;;eAGG;;YAEH,8FAA8F;;;;;;;;;;;YAS9F,+EAA+E;;YAE/E;;;;eAIG;;YAEH;;;;eAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA6GH;;;WAGG;;QAEH;;;WAGG;;QAEH;;;WAGG;;YAjHH,kFAAkF;;YAElF;;;eAGG;;YAEH;;;;eAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyJH,CAAC;AACH;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE,eAAO,MAAM,sBAAsB;IACjC;;;OAGG;;IAKH;;;OAGG;;QA1GH;;;WAGG;;QAEH;;;WAGG;;QAEH;;;WAGG;;YA/HH,gFAAgF;;YAEhF;;;eAGG;;YAEH,8FAA8F;;;;;;;;;;;YAS9F,+EAA+E;;YAE/E;;;;eAIG;;YAEH;;;;eAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA6GH;;;WAGG;;QAEH;;;WAGG;;QAEH;;;WAGG;;YAjHH,kFAAkF;;YAElF;;;eAGG;;YAEH;;;;eAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8KH,CAAC;AACH;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC"}

package/_types/policies/types.d.ts

@@ -0,0 +1,19 @@
+import { PolicyScope, Rule } from "./schema.js";
+/**
+ * A single Policy that can be used to govern the behavior of projects and accounts.
+ */
+export type Policy = {
+    /** The unique identifier for the policy. */
+    id: string;
+    /** An optional human-readable description of the policy. */
+    description?: string;
+    /** The scope of the policy. Only one project-level policy can exist at any time. */
+    scope: PolicyScope;
+    /** A list of rules that comprise the policy. */
+    rules: Rule[];
+    /** The ISO 8601 timestamp at which the Policy was created. */
+    createdAt: string;
+    /** The ISO 8601 timestamp at which the Policy was last updated. */
+    updatedAt: string;
+};
+//# sourceMappingURL=types.d.ts.map

package/_types/policies/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../policies/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAEhD;;GAEG;AACH,MAAM,MAAM,MAAM,GAAG;IACnB,4CAA4C;IAC5C,EAAE,EAAE,MAAM,CAAC;IACX,4DAA4D;IAC5D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,oFAAoF;IACpF,KAAK,EAAE,WAAW,CAAC;IACnB,gDAAgD;IAChD,KAAK,EAAE,IAAI,EAAE,CAAC;IACd,8DAA8D;IAC9D,SAAS,EAAE,MAAM,CAAC;IAClB,mEAAmE;IACnE,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC"}

package/_types/types/misc.d.ts

@@ -38,4 +38,43 @@ export type TransactionRequestEIP1559 = {
     /** (Ignored) The transaction type is always `eip1559`. */
     type?: "eip1559" | undefined;
 };
+/**
+ * The domain of the EIP-712 typed data.
+ */
+export interface EIP712Domain {
+    /** The name of the DApp or protocol. */
+    name?: string;
+    /** The version of the DApp or protocol. */
+    version?: string;
+    /** The chain ID of the EVM network. */
+    chainId?: number;
+    /** The 0x-prefixed EVM address of the verifying smart contract. */
+    verifyingContract?: string;
+    /** The optional 32-byte 0x-prefixed hex salt for domain separation. */
+    salt?: string;
+}
+/**
+ * A mapping of struct names to an array of type objects (name + type).
+ * Each key corresponds to a type name (e.g., "`EIP712Domain`", "`PermitTransferFrom`").
+ */
+export interface EIP712Types {
+    [key: string]: unknown;
+}
+/**
+ * The message to sign. The structure of this message must match the `primaryType` struct in the `types` object.
+ */
+export type EIP712MessageMessage = {
+    [key: string]: unknown;
+};
+/**
+ * The message to sign using EIP-712.
+ */
+export interface EIP712Message {
+    domain: EIP712Domain;
+    types: EIP712Types;
+    /** 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: string;
+    /** The message to sign. The structure of this message must match the `primaryType` struct in the `types` object. */
+    message: EIP712MessageMessage;
+}
 //# sourceMappingURL=misc.d.ts.map

package/_types/types/misc.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"misc.d.ts","sourceRoot":"","sources":["../../types/misc.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,GAAG,GAAG,KAAK,MAAM,EAAE,CAAC;AAChC,MAAM,MAAM,IAAI,GAAG,KAAK,MAAM,EAAE,CAAC;AACjC,MAAM,MAAM,OAAO,GAAG,KAAK,MAAM,EAAE,CAAC;AAEpC,MAAM,MAAM,UAAU,GAAG,SAAS;IAChC,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,EAAE,SAAS,GAAG,EAAE,CAAC;CAC7B,EAAE,CAAC;AAEJ,MAAM,MAAM,yBAAyB,GAAG;IACtC,yEAAyE;IACzE,EAAE,EAAE,OAAO,CAAC;IACZ,+DAA+D;IAC/D,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,2EAA2E;IAC3E,IAAI,CAAC,EAAE,GAAG,GAAG,SAAS,CAAC;IACvB,oDAAoD;IACpD,GAAG,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACzB;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC;;;OAGG;IACH,oBAAoB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1C,kDAAkD;IAClD,UAAU,CAAC,EAAE,UAAU,GAAG,SAAS,CAAC;IACpC,gFAAgF;IAChF,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,yFAAyF;IACzF,IAAI,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAC3B,0DAA0D;IAC1D,IAAI,CAAC,EAAE,SAAS,GAAG,SAAS,CAAC;CAC9B,CAAC"}
+{"version":3,"file":"misc.d.ts","sourceRoot":"","sources":["../../types/misc.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,GAAG,GAAG,KAAK,MAAM,EAAE,CAAC;AAChC,MAAM,MAAM,IAAI,GAAG,KAAK,MAAM,EAAE,CAAC;AACjC,MAAM,MAAM,OAAO,GAAG,KAAK,MAAM,EAAE,CAAC;AAEpC,MAAM,MAAM,UAAU,GAAG,SAAS;IAChC,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,EAAE,SAAS,GAAG,EAAE,CAAC;CAC7B,EAAE,CAAC;AAEJ,MAAM,MAAM,yBAAyB,GAAG;IACtC,yEAAyE;IACzE,EAAE,EAAE,OAAO,CAAC;IACZ,+DAA+D;IAC/D,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,2EAA2E;IAC3E,IAAI,CAAC,EAAE,GAAG,GAAG,SAAS,CAAC;IACvB,oDAAoD;IACpD,GAAG,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACzB;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC;;;OAGG;IACH,oBAAoB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1C,kDAAkD;IAClD,UAAU,CAAC,EAAE,UAAU,GAAG,SAAS,CAAC;IACpC,gFAAgF;IAChF,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,yFAAyF;IACzF,IAAI,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAC3B,0DAA0D;IAC1D,IAAI,CAAC,EAAE,SAAS,GAAG,SAAS,CAAC;CAC9B,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,wCAAwC;IACxC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,2CAA2C;IAC3C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,uCAAuC;IACvC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,mEAAmE;IACnE,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,uEAAuE;IACvE,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,CAAC;AAE9D;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,YAAY,CAAC;IACrB,KAAK,EAAE,WAAW,CAAC;IACnB,6HAA6H;IAC7H,WAAW,EAAE,MAAM,CAAC;IACpB,oHAAoH;IACpH,OAAO,EAAE,oBAAoB,CAAC;CAC/B"}

package/_types/version.d.ts

@@ -1,2 +1,2 @@
-export declare const version = "1.7.0";
+export declare const version = "1.8.0";
 //# sourceMappingURL=version.d.ts.map

package/accounts/evm/toEvmServerAccount.ts

@@ -18,7 +18,7 @@ import type { EvmServerAccount } from "./types.js";
 import type { SendTransactionOptions } from "../../actions/evm/sendTransaction.js";
 import type { TransferResult } from "../../actions/evm/transfer/types.js";
 import type { CdpOpenApiClientType, EvmAccount } from "../../openapi-client/index.js";
-import type { Address, Hash } from "../../types/misc.js";
+import type { Address, EIP712Message, Hash } from "../../types/misc.js";
 
 /**
  * Options for converting a pre-existing EvmAccount to a EvmServerAccount.
@@ -64,9 +64,11 @@ export function toEvmServerAccount(
       return result.signedTransaction as Hex;
     },
 
-    async signTypedData() {
-      throw new Error("Not implemented");
+    async signTypedData(message: EIP712Message) {
+      const result = await apiClient.signEvmTypedData(options.account.address, message);
+      return result.signature as Hex;
     },
+
     async transfer(transferArgs): Promise<TransferResult> {
       return transfer(apiClient, account, transferArgs, accountTransferStrategy);
     },
@@ -94,6 +96,7 @@ export function toEvmServerAccount(
     },
     name: options.account.name,
     type: "evm-server",
+    policies: options.account.policies,
   };
 
   return account;

package/accounts/evm/types.ts

@@ -1,9 +1,10 @@
-import { SignableMessage, TransactionSerializable, TypedData, TypedDataDefinition } from "viem";
+import { SignableMessage, TransactionSerializable } from "viem";
 
 import { Prettify } from "../../types/utils.js";
 
 import type { AccountActions, SmartAccountActions } from "../../actions/evm/types.js";
-import type { Hash, Hex, Address } from "../../types/misc.js";
+import type { EIP712Message } from "../../openapi-client/generated/coinbaseDeveloperPlatformAPIs.schemas.js";
+import type { Address, Hash, Hex } from "../../types/misc.js";
 
 /**
  * Base type for any Ethereum account with signing capabilities.
@@ -19,12 +20,9 @@ export type EvmAccount = {
   /** Signs a transaction and returns the signed transaction as a hex string. */
   signTransaction: (transaction: TransactionSerializable) => Promise<Hex>;
   /** Signs a typed data and returns the signature as a hex string. */
-  signTypedData: <
-    const typedData extends TypedData | Record<string, unknown>,
-    primaryType extends keyof typedData | "EIP712Domain" = keyof typedData,
-  >(
-    parameters: TypedDataDefinition<typedData, primaryType>,
-  ) => Promise<Hex>;
+  signTypedData: (message: EIP712Message) => Promise<Hex>;
+  /** A list of Policy ID's that apply to the account. */
+  policies?: string[];
 };
 
 /**

package/accounts/solana/toSolanaAccount.ts

@@ -53,6 +53,7 @@ export function toSolanaAccount(
         address: account.address,
       });
     },
+    policies: options.account.policies,
   };
 
   return account;

package/actions/evm/transfer/types.ts

@@ -25,7 +25,7 @@ export type Network = SendEvmTransactionBodyNetwork | EvmUserOperationNetwork;
 /**
  * The options for the transfer.
  */
-type TransferOptions = {
+export type TransferOptions = {
   /** The account to transfer the token to. */
   to: EvmAccount | Address;
   /**

package/analytics.ts

@@ -1,5 +1,7 @@
 import md5 from "md5";
 
+import { APIError } from "./openapi-client/errors.js";
+
 /**
  * The data in an error event
  */
@@ -22,24 +24,33 @@ 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,
@@ -80,10 +91,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 +108,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 +128,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.
    *