@coinbase/cdp-sdk 1.7.0 → 1.8.0

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";

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>;
+  }
+}

package/client/policies/policies.types.ts

@@ -0,0 +1,109 @@
+import { OpenApiPoliciesMethods } from "../../openapi-client/index.js";
+import { CreatePolicyBody, PolicyScope, UpdatePolicyBody } from "../../policies/schema.js";
+import { Policy } from "../../policies/types.js";
+
+/**
+ * The PoliciesClient type, where all OpenApiPoliciesMethods methods are wrapped.
+ */
+export type PoliciesClientInterface = Omit<
+  typeof OpenApiPoliciesMethods,
+  | "createPolicy" // mapped to createPolicy
+  | "listPolicies" // mapped to listPolicies
+  | "getPolicyById" // mapped to getPolicyById
+  | "deletePolicy" // mapped to deletePolicy
+  | "updatePolicy" // mapped to updatePolicy
+> & {
+  listPolicies: (options: ListPoliciesOptions) => Promise<ListPoliciesResult>;
+  createPolicy: (options: CreatePolicyOptions) => Promise<Policy>;
+  getPolicyById: (options: GetPolicyByIdOptions) => Promise<Policy>;
+  deletePolicy: (options: DeletePolicyOptions) => Promise<void>;
+  updatePolicy: (options: UpdatePolicyOptions) => Promise<Policy>;
+};
+
+export interface ListPoliciesOptions {
+  /** The page size to paginate through the accounts. */
+  pageSize?: number;
+  /** The page token to paginate through the accounts. */
+  pageToken?: string;
+  /**
+   * The scope of the policies to return. If `project`, the response will include exactly one policy, which is the project-level policy. If `account`, the response will include all account-level policies for the developer's CDP Project.
+   */
+  scope?: PolicyScope;
+}
+
+/**
+ * The result of listing policies.
+ */
+export interface ListPoliciesResult {
+  /** The list of policies matching the query parameters. */
+  policies: Policy[];
+  /**
+   * The next page token to paginate through the policies.
+   * If undefined, there are no more policies to paginate through.
+   */
+  nextPageToken?: string;
+}
+
+/**
+ * Options for creating a Policy.
+ */
+export interface CreatePolicyOptions {
+  /**
+   * The idempotency key to ensure the request is processed exactly once.
+   * Used to safely retry requests without accidentally performing the same operation twice.
+   */
+  idempotencyKey?: string;
+  /**
+   * The policy definition to create.
+   * Contains the scope, description, and rules for the policy.
+   */
+  policy: CreatePolicyBody;
+}
+
+/**
+ * Options for retrieving a Policy by ID.
+ */
+export interface GetPolicyByIdOptions {
+  /**
+   * The unique identifier of the policy to retrieve.
+   * This is a UUID that's generated when the policy is created.
+   */
+  id: string;
+}
+
+/**
+ * Options for deleting a Policy.
+ */
+export interface DeletePolicyOptions {
+  /**
+   * The unique identifier of the policy to delete.
+   * This is a UUID that's generated when the policy is created.
+   */
+  id: string;
+  /**
+   * The idempotency key to ensure the request is processed exactly once.
+   * Used to safely retry requests without accidentally performing the same operation twice.
+   */
+  idempotencyKey?: string;
+}
+
+/**
+ * Options for updating a Policy.
+ */
+export interface UpdatePolicyOptions {
+  /**
+   * The unique identifier of the policy to update.
+   * This is a UUID that's generated when the policy is created.
+   */
+  id: string;
+  /**
+   * The updated policy definition.
+   * Contains the description and rules for the policy.
+   */
+  policy: UpdatePolicyBody;
+  /**
+   * The idempotency key to ensure the request is processed exactly once.
+   * Used to safely retry requests without accidentally performing the same operation twice.
+   */
+  idempotencyKey?: string;
+}

package/client/solana/solana.ts

@@ -9,12 +9,14 @@ import {
   SignMessageOptions,
   SignTransactionOptions,
   SolanaClientInterface,
+  UpdateSolanaAccountOptions,
 } from "./solana.types.js";
 import { toSolanaAccount } from "../../accounts/solana/toSolanaAccount.js";
 import { SolanaAccount } from "../../accounts/solana/types.js";
 import { requestFaucet } from "../../actions/solana/requestFaucet.js";
 import { signMessage } from "../../actions/solana/signMessage.js";
 import { signTransaction } from "../../actions/solana/signTransaction.js";
+import { Analytics } from "../../analytics.js";
 import { APIError } from "../../openapi-client/errors.js";
 import { CdpOpenApiClient } from "../../openapi-client/index.js";
 
@@ -53,11 +55,18 @@ export class SolanaClient implements SolanaClientInterface {
    *          ```
    */
   async createAccount(options: CreateAccountOptions = {}): Promise<SolanaAccount> {
-    const account = await CdpOpenApiClient.createSolanaAccount(options, options.idempotencyKey);
+    const openApiAccount = await CdpOpenApiClient.createSolanaAccount(
+      options,
+      options.idempotencyKey,
+    );
 
-    return toSolanaAccount(CdpOpenApiClient, {
-      account,
+    const account = toSolanaAccount(CdpOpenApiClient, {
+      account: openApiAccount,
     });
+
+    Analytics.wrapObjectMethodsWithErrorTracking(account);
+
+    return account;
   }
 
   /**
@@ -86,21 +95,25 @@ export class SolanaClient implements SolanaClientInterface {
    *          ```
    */
   async getAccount(options: GetAccountOptions): Promise<SolanaAccount> {
-    if (options.address) {
-      const account = await CdpOpenApiClient.getSolanaAccount(options.address);
-      return toSolanaAccount(CdpOpenApiClient, {
-        account,
-      });
-    }
+    const openApiAccount = await (() => {
+      if (options.address) {
+        return CdpOpenApiClient.getSolanaAccount(options.address);
+      }
 
-    if (options.name) {
-      const account = await CdpOpenApiClient.getSolanaAccountByName(options.name);
-      return toSolanaAccount(CdpOpenApiClient, {
-        account,
-      });
-    }
+      if (options.name) {
+        return CdpOpenApiClient.getSolanaAccountByName(options.name);
+      }
+
+      throw new Error("Either address or name must be provided");
+    })();
+
+    const account = toSolanaAccount(CdpOpenApiClient, {
+      account: openApiAccount,
+    });
+
+    Analytics.wrapObjectMethodsWithErrorTracking(account);
 
-    throw new Error("Either address or name must be provided");
+    return account;
   }
 
   /**
@@ -179,11 +192,15 @@ export class SolanaClient implements SolanaClientInterface {
     });
 
     return {
-      accounts: solAccounts.accounts.map(account =>
-        toSolanaAccount(CdpOpenApiClient, {
+      accounts: solAccounts.accounts.map(account => {
+        const solanaAccount = toSolanaAccount(CdpOpenApiClient, {
           account,
-        }),
-      ),
+        });
+
+        Analytics.wrapObjectMethodsWithErrorTracking(solanaAccount);
+
+        return solanaAccount;
+      }),
       nextPageToken: solAccounts.nextPageToken,
     };
   }
@@ -272,4 +289,61 @@ export class SolanaClient implements SolanaClientInterface {
   async signTransaction(options: SignTransactionOptions): Promise<SignatureResult> {
     return signTransaction(CdpOpenApiClient, options);
   }
+
+  /**
+   * Updates a CDP Solana account.
+   *
+   * @param {UpdateSolanaAccountOptions} [options] - Optional parameters for creating the account.
+   * @param {string} options.address - The address of the account to update
+   * @param {UpdateSolanaAccountBody} 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.sol.updateAccount({ address: "...", update: { name: "New Name" } });
+   *          ```
+   *
+   * @example **With an account policy**
+   *          ```ts
+   *          const account = await cdp.sol.updateAccount({ address: "...", update: { accountPolicy: "73bcaeeb-d7af-4615-b064-42b5fe83a31e" } });
+   *          ```
+   *
+   * @example **With an idempotency key**
+   *          ```ts
+   *          const idempotencyKey = uuidv4();
+   *
+   *          // First call
+   *          await cdp.sol.updateAccount({
+   *            address: "0x...",
+   *            update: { accountPolicy: "73bcaeeb-d7af-4615-b064-42b5fe83a31e" },
+   *            idempotencyKey,
+   *          });
+   *
+   *          // Second call with the same idempotency key will not update
+   *          await cdp.sol.updateAccount({
+   *            address: '0x...',
+   *            update: { name: "" },
+   *            idempotencyKey,
+   *          });
+   *          ```
+   */
+  async updateAccount(options: UpdateSolanaAccountOptions): Promise<SolanaAccount> {
+    const openApiAccount = await CdpOpenApiClient.updateSolanaAccount(
+      options.address,
+      options.update,
+      options.idempotencyKey,
+    );
+
+    const account = toSolanaAccount(CdpOpenApiClient, {
+      account: openApiAccount,
+    });
+
+    Analytics.wrapObjectMethodsWithErrorTracking(account);
+
+    return account;
+  }
 }

package/client/solana/solana.types.ts

@@ -1,5 +1,5 @@
 import { Account, SolanaAccount } from "../../accounts/solana/types.js";
-import { OpenApiSolanaMethods } from "../../openapi-client/index.js";
+import { OpenApiSolanaMethods, UpdateSolanaAccountBody } from "../../openapi-client/index.js";
 
 /**
  * The SolanaClient type, where all OpenApiSolanaMethods methods are wrapped.
@@ -9,14 +9,17 @@ export type SolanaClientInterface = Omit<
   | "createSolanaAccount" // mapped to createAccount
   | "getSolanaAccount" // mapped to getAccount
   | "getSolanaAccountByName" // mapped to getAccount
+  | "updateSolanaAccount" // mapped to updateAccount
   | "listSolanaAccounts" // mapped to listAccounts
   | "requestSolanaFaucet" // mapped to requestFaucet
   | "signSolanaMessage" // mapped to signMessage
   | "signSolanaTransaction" // mapped to signTransaction
+  | "updateSolanaAccount" // mapped to updateAccount
 > & {
   createAccount: (options: CreateAccountOptions) => Promise<Account>;
   getAccount: (options: GetAccountOptions) => Promise<Account>;
   getOrCreateAccount: (options: GetOrCreateAccountOptions) => Promise<Account>;
+  updateAccount: (options: UpdateSolanaAccountOptions) => Promise<Account>;
   listAccounts: (options: ListAccountsOptions) => Promise<ListAccountsResult>;
   requestFaucet: (options: RequestFaucetOptions) => Promise<SignatureResult>;
   signMessage: (options: SignMessageOptions) => Promise<SignatureResult>;
@@ -59,6 +62,18 @@ export interface GetOrCreateAccountOptions {
   name: string;
 }
 
+/**
+ * Options for creating a SOL server account.
+ */
+export interface UpdateSolanaAccountOptions {
+  /** The address of the account. */
+  address: string;
+  /** The updates to apply to the account */
+  update: UpdateSolanaAccountBody;
+  /** The idempotency key. */
+  idempotencyKey?: string;
+}
+
 /**
  * Options for listing Solana accounts.
  */

package/index.ts

@@ -1,2 +1,9 @@
 export { CdpClient } from "./client/cdp.js";
 export type { EvmServerAccount, EvmSmartAccount } from "./accounts/evm/types.js";
+export type { Policy } from "./policies/types.js";
+export {
+  CreatePolicyBodySchema,
+  UpdatePolicyBodySchema,
+  type CreatePolicyBody,
+  type UpdatePolicyBody,
+} from "./policies/schema.js";