@coinbase/cdp-sdk 1.6.0 → 1.8.0

package/client/evm/evm.ts

@@ -21,9 +21,12 @@ import {
   ListSmartAccountResult,
   ListSmartAccountsOptions,
   GetOrCreateServerAccountOptions,
+  SignTypedDataOptions,
+  UpdateEvmAccountOptions,
 } from "./evm.types.js";
 import { toEvmServerAccount } from "../../accounts/evm/toEvmServerAccount.js";
 import { toEvmSmartAccount } from "../../accounts/evm/toEvmSmartAccount.js";
+import { getUserOperation } from "../../actions/evm/getUserOperation.js";
 import {
   listTokenBalances,
   ListTokenBalancesResult,
@@ -44,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";
@@ -52,6 +56,7 @@ import type {
   TransactionResult,
   SendTransactionOptions,
 } from "../../actions/evm/sendTransaction.js";
+
 /**
  * The namespace containing all EVM methods.
  */
@@ -91,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;
   }
 
   /**
@@ -149,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;
   }
 
   /**
@@ -188,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);
       }
@@ -200,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;
   }
 
   /**
@@ -225,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;
   }
 
   /**
@@ -292,22 +313,7 @@ export class EvmClient implements EvmClientInterface {
    * ```
    */
   async getUserOperation(options: GetUserOperationOptions): Promise<UserOperation> {
-    const userOp = await CdpOpenApiClient.getUserOperation(
-      options.smartAccount.address,
-      options.userOpHash,
-    );
-
-    return {
-      calls: userOp.calls.map(call => ({
-        to: call.to as Address,
-        value: BigInt(call.value),
-        data: call.data as Hex,
-      })),
-      network: userOp.network,
-      status: userOp.status,
-      transactionHash: userOp.transactionHash as Hex | undefined,
-      userOpHash: userOp.userOpHash as Hex,
-    };
+    return getUserOperation(CdpOpenApiClient, options);
   }
 
   /**
@@ -341,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,
     };
   }
@@ -660,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.
    *
@@ -704,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

@@ -2,7 +2,7 @@ import type {
   EvmAccount as Account,
   EvmServerAccount as ServerAccount,
   EvmSmartAccount as SmartAccount,
-} from "../../accounts/types.js";
+} from "../../accounts/evm/types.js";
 import type {
   ListTokenBalancesOptions,
   ListTokenBalancesResult,
@@ -16,14 +16,15 @@ import type {
   SendUserOperationOptions,
   SendUserOperationReturnType,
 } from "../../actions/evm/sendUserOperation.js";
-import type { Actions } from "../../actions/evm/types.js";
+import type { SmartAccountActions } from "../../actions/evm/types.js";
 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>;
 };
 
@@ -181,11 +188,24 @@ export interface ListServerAccountsOptions {
 /**
  * A smart account that only contains the owner address.
  */
-export interface ReadonlySmartAccount extends Omit<SmartAccount, "owners" | keyof Actions> {
+export interface ReadonlySmartAccount
+  extends Omit<SmartAccount, "owners" | keyof SmartAccountActions> {
   /** The owners of the smart account. */
   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.
  */
@@ -258,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";

package/client/policies/policies.ts

@@ -0,0 +1,246 @@
+import {
+  PoliciesClientInterface,
+  CreatePolicyOptions,
+  ListPoliciesOptions,
+  ListPoliciesResult,
+  GetPolicyByIdOptions,
+  DeletePolicyOptions,
+  UpdatePolicyOptions,
+} from "./policies.types.js";
+import { CdpOpenApiClient } from "../../openapi-client/index.js";
+import { CreatePolicyBodySchema, UpdatePolicyBodySchema } from "../../policies/schema.js";
+import { Policy } from "../../policies/types.js";
+
+/**
+ * The namespace containing all Policy methods.
+ */
+export class PoliciesClient implements PoliciesClientInterface {
+  /**
+   * Lists policies belonging to the developer's CDP Project.
+   * Can be filtered by scope (project or account).
+   *
+   * @param {ListPoliciesOptions} [options] - Options for filtering and paginating the results
+   * @param {string} [options.scope] - Filter policies by scope ('project' or 'account')
+   * @param {number} [options.pageSize] - Maximum number of policies to return
+   * @param {string} [options.pageToken] - Pagination cursor for fetching next page of results
+   *
+   * @returns {Promise<ListPoliciesResult>} A paginated list of policies
+   *
+   * @example **List all policies**
+   *          ```ts
+   *          const { policies } = await cdp.policies.listPolicies();
+   *          ```
+   *
+   * @example **Filter by scope**
+   *          ```ts
+   *          const { policies } = await cdp.policies.listPolicies({
+   *            scope: 'project'
+   *          });
+   *          ```
+   *
+   * @example **With pagination**
+   *          ```ts
+   *          // Get first page
+   *          const firstPage = await cdp.policies.listPolicies({
+   *            pageSize: 10
+   *          });
+   *
+   *          // Get next page using cursor
+   *          const nextPage = await cdp.policies.listPolicies({
+   *            pageSize: 10,
+   *            pageToken: firstPage.pageToken
+   *          });
+   *          ```
+   */
+  async listPolicies(options: ListPoliciesOptions = {}): Promise<ListPoliciesResult> {
+    return CdpOpenApiClient.listPolicies(options) as Promise<ListPoliciesResult>;
+  }
+
+  /**
+   * Creates a new policy that can be used to govern the behavior of projects and accounts.
+   *
+   * @param {CreatePolicyOptions} options - Options for creating the policy
+   * @param {CreatePolicyBody} options.policy - The policy configuration to create
+   * @param {string} [options.policy.description] - Description of the policy's purpose
+   * @param {Rule[]} options.policy.rules - Rules that define the policy behavior
+   * @param {string} [options.idempotencyKey] - An idempotency key to prevent duplicate policy creation
+   *
+   * @returns {Promise<Policy>} The created policy
+   * @throws {ZodError<typeof CreatePolicyBodySchema>} When the policy is invalid
+   *
+   * @example **Creating a new policy**
+   *          ```ts
+   *          const policy = await cdp.policies.createPolicy({
+   *            policy: {
+   *              scope: "account",
+   *              description: "Limits the amount of ETH in transaction",
+   *              rules: [
+   *                {
+   *                  action: "reject",
+   *                  operation: "signEvmTransaction",
+   *                  criteria: [
+   *                    {
+   *                      type: "ethValue",
+   *                      ethValue: "1000000000000000000",
+   *                      operator: ">",
+   *                    },
+   *                  ],
+   *                },
+   *              ],
+   *            }
+   *          });
+   *          ```
+   *
+   * @example **With idempotency key**
+   *          ```ts
+   *          const idempotencyKey = uuidv4();
+   *
+   *          // First call creates the policy
+   *          const policy = await cdp.policies.createPolicy({
+   *            policy: {
+   *              scope: "account",
+   *              description: "Limits the amount of ETH in transaction",
+   *              rules: [
+   *                {
+   *                  action: "reject",
+   *                  operation: "signEvmTransaction",
+   *                  criteria: [
+   *                    {
+   *                      type: "ethValue",
+   *                      ethValue: "1000000000000000000",
+   *                      operator: ">",
+   *                    },
+   *                  ],
+   *                },
+   *              ],
+   *            },
+   *            idempotencyKey
+   *          });
+   *
+   *          // Second call with same key returns the same policy
+   *          const samePolicy = await cdp.policies.createPolicy({
+   *            policy: { ... },
+   *            idempotencyKey
+   *          });
+   *          ```
+   */
+  async createPolicy(options: CreatePolicyOptions): Promise<Policy> {
+    CreatePolicyBodySchema.parse(options.policy);
+    return CdpOpenApiClient.createPolicy(options.policy, options.idempotencyKey) as Promise<Policy>;
+  }
+
+  /**
+   * Retrieves a policy by its unique identifier.
+   *
+   * @param {GetPolicyByIdOptions} options - Options containing the policy ID to retrieve
+   * @param {string} options.id - The unique identifier of the policy to retrieve
+   *
+   * @returns {Promise<Policy>} The requested policy
+   *
+   * @example **Retrieving a policy by ID**
+   *          ```ts
+   *          const policy = await cdp.policies.getPolicyById({
+   *            id: "__ID__"
+   *          });
+   *
+   *          console.log(policy.name);
+   *          console.log(policy.rules);
+   *          ```
+   */
+  async getPolicyById(options: GetPolicyByIdOptions): Promise<Policy> {
+    return CdpOpenApiClient.getPolicyById(options.id) as Promise<Policy>;
+  }
+
+  /**
+   * Deletes a policy by its unique identifier.
+   * If a policy is referenced by an active project or account, this operation will fail.
+   *
+   * @param {DeletePolicyOptions} options - Options containing the policy ID to delete
+   * @param {string} options.id - The unique identifier of the policy to delete
+   * @param {string} [options.idempotencyKey] - An idempotency key to prevent duplicate deletion
+   *
+   * @returns {Promise<void>} Void on successful deletion
+   *
+   * @example **Deleting a policy**
+   *          ```ts
+   *          await cdp.policies.deletePolicy({
+   *            id: "__ID__"
+   *          });
+   *          ```
+   *
+   * @example **With idempotency key**
+   *          ```ts
+   *          const idempotencyKey = uuidv4();
+   *
+   *          // This operation is idempotent with the key
+   *          await cdp.policies.deletePolicy({
+   *            id: "__ID__",
+   *            idempotencyKey
+   *          });
+   *          ```
+   */
+  async deletePolicy(options: DeletePolicyOptions): Promise<void> {
+    return CdpOpenApiClient.deletePolicy(options.id, options.idempotencyKey);
+  }
+
+  /**
+   * Updates an existing policy by its unique identifier.
+   * This will apply the updated policy to any project or accounts that are currently using it.
+   *
+   * @param {UpdatePolicyOptions} options - Options containing the policy ID and updated policy data
+   * @param {string} options.id - The unique identifier of the policy to update
+   * @param {UpdatePolicyBody} options.policy - The updated policy configuration
+   * @param {string} [options.policy.description] - Updated description of the policy's purpose
+   * @param {Rule[]} [options.policy.rules] - Updated rules that define the policy behavior
+   * @param {string} [options.idempotencyKey] - An idempotency key to prevent duplicate updates
+   *
+   * @returns {Promise<Policy>} The updated policy
+   * @throws {ZodError<typeof UpdatePolicyBodySchema>} When the updated policy is invalid
+   *
+   * @example **Updating a policy**
+   *          ```ts
+   *          const updatedPolicy = await cdp.policies.updatePolicy({
+   *            id: "__ID__",
+   *            policy: {
+   *              description: "Now with lower transaction limits",
+   *              rules: [
+   *                {
+   *                  action: "reject",
+   *                  operation: "signEvmTransaction",
+   *                  criteria: [
+   *                    {
+   *                      type: "ethValue",
+   *                      ethValue: "1000000000",
+   *                      operator: ">",
+   *                    },
+   *                  ],
+   *                },
+   *              ],
+   *            },
+   *          });
+   *          ```
+   *
+   * @example **With idempotency key**
+   *          ```ts
+   *          const idempotencyKey = uuidv4();
+   *
+   *          // This operation is idempotent with the key
+   *          await cdp.policies.updatePolicy({
+   *            id: "__ID__",
+   *            policy: {
+   *              description: "Modified Policy",
+   *              rules: { ... }
+   *            },
+   *            idempotencyKey
+   *          });
+   *          ```
+   */
+  async updatePolicy(options: UpdatePolicyOptions): Promise<Policy> {
+    UpdatePolicyBodySchema.parse(options.policy);
+    return CdpOpenApiClient.updatePolicy(
+      options.id,
+      options.policy,
+      options.idempotencyKey,
+    ) as Promise<Policy>;
+  }
+}