@coinbase/cdp-sdk 1.43.1 → 1.44.0

package/client/end-user/endUser.ts

@@ -8,15 +8,19 @@ import {
   type CreateEndUserOptions,
   type GetEndUserOptions,
   type ImportEndUserOptions,
+  type AddEndUserEvmAccountOptions,
+  type AddEndUserEvmAccountResult,
+  type AddEndUserEvmSmartAccountOptions,
+  type AddEndUserEvmSmartAccountResult,
+  type AddEndUserSolanaAccountOptions,
+  type AddEndUserSolanaAccountResult,
+  type EndUserAccount,
 } from "./endUser.types.js";
+import { toEndUserAccount } from "./toEndUserAccount.js";
 import { Analytics } from "../../analytics.js";
 import { ImportAccountPublicRSAKey } from "../../constants.js";
 import { UserInputValidationError } from "../../errors.js";
-import {
-  CdpOpenApiClient,
-  type EndUser,
-  type ListEndUsers200,
-} from "../../openapi-client/index.js";
+import { CdpOpenApiClient, type ListEndUsers200 } from "../../openapi-client/index.js";
 
 /**
  * The CDP end user client.
@@ -50,17 +54,19 @@ export class CDPEndUserClient {
    *          });
    *          ```
    */
-  async createEndUser(options: CreateEndUserOptions): Promise<EndUser> {
+  async createEndUser(options: CreateEndUserOptions): Promise<EndUserAccount> {
     Analytics.trackAction({
       action: "create_end_user",
     });
 
     const userId = options.userId ?? randomUUID();
 
-    return CdpOpenApiClient.createEndUser({
+    const endUser = await CdpOpenApiClient.createEndUser({
       ...options,
       userId,
     });
+
+    return toEndUserAccount(CdpOpenApiClient, { endUser });
   }
 
   /**
@@ -124,14 +130,109 @@ export class CDPEndUserClient {
    *          console.log(endUser.userId);
    *          ```
    */
-  async getEndUser(options: GetEndUserOptions): Promise<EndUser> {
+  async getEndUser(options: GetEndUserOptions): Promise<EndUserAccount> {
     Analytics.trackAction({
       action: "get_end_user",
     });
 
     const { userId } = options;
 
-    return CdpOpenApiClient.getEndUser(userId);
+    const endUser = await CdpOpenApiClient.getEndUser(userId);
+
+    return toEndUserAccount(CdpOpenApiClient, { endUser });
+  }
+
+  /**
+   * Adds an EVM EOA (Externally Owned Account) to an existing end user. End users can have up to 10 EVM accounts.
+   *
+   * @param options - The options for adding an EVM account.
+   *
+   * @returns A promise that resolves to the newly created EVM EOA account.
+   *
+   * @example **Add an EVM EOA account to an existing end user**
+   *          ```ts
+   *          const result = await cdp.endUser.addEndUserEvmAccount({
+   *            userId: "user-123"
+   *          });
+   *          console.log(result.evmAccount.address);
+   *          ```
+   */
+  async addEndUserEvmAccount(
+    options: AddEndUserEvmAccountOptions,
+  ): Promise<AddEndUserEvmAccountResult> {
+    Analytics.trackAction({
+      action: "add_end_user_evm_account",
+    });
+
+    const { userId } = options;
+
+    return CdpOpenApiClient.addEndUserEvmAccount(userId, {});
+  }
+
+  /**
+   * Adds an EVM smart account to an existing end user. This also creates a new EVM EOA account to serve as the owner of the smart account.
+   *
+   * @param options - The options for adding an EVM smart account.
+   *
+   * @returns A promise that resolves to the newly created EVM smart account.
+   *
+   * @example **Add an EVM smart account to an existing end user**
+   *          ```ts
+   *          const result = await cdp.endUser.addEndUserEvmSmartAccount({
+   *            userId: "user-123",
+   *            enableSpendPermissions: false
+   *          });
+   *          console.log(result.evmSmartAccount.address);
+   *          ```
+   *
+   * @example **Add an EVM smart account with spend permissions enabled**
+   *          ```ts
+   *          const result = await cdp.endUser.addEndUserEvmSmartAccount({
+   *            userId: "user-123",
+   *            enableSpendPermissions: true
+   *          });
+   *          console.log(result.evmSmartAccount.address);
+   *          ```
+   */
+  async addEndUserEvmSmartAccount(
+    options: AddEndUserEvmSmartAccountOptions,
+  ): Promise<AddEndUserEvmSmartAccountResult> {
+    Analytics.trackAction({
+      action: "add_end_user_evm_smart_account",
+    });
+
+    const { userId, enableSpendPermissions } = options;
+
+    return CdpOpenApiClient.addEndUserEvmSmartAccount(userId, {
+      enableSpendPermissions,
+    });
+  }
+
+  /**
+   * Adds a Solana account to an existing end user. End users can have up to 10 Solana accounts.
+   *
+   * @param options - The options for adding a Solana account.
+   *
+   * @returns A promise that resolves to the newly created Solana account.
+   *
+   * @example **Add a Solana account to an existing end user**
+   *          ```ts
+   *          const result = await cdp.endUser.addEndUserSolanaAccount({
+   *            userId: "user-123"
+   *          });
+   *          console.log(result.solanaAccount.address);
+   *          ```
+   */
+  async addEndUserSolanaAccount(
+    options: AddEndUserSolanaAccountOptions,
+  ): Promise<AddEndUserSolanaAccountResult> {
+    Analytics.trackAction({
+      action: "add_end_user_solana_account",
+    });
+
+    const { userId } = options;
+
+    return CdpOpenApiClient.addEndUserSolanaAccount(userId, {});
   }
 
   /**
@@ -141,16 +242,18 @@ export class CDPEndUserClient {
    *
    * @returns The end user object if the access token is valid.
    */
-  async validateAccessToken(options: ValidateAccessTokenOptions): Promise<EndUser> {
+  async validateAccessToken(options: ValidateAccessTokenOptions): Promise<EndUserAccount> {
     Analytics.trackAction({
       action: "validate_access_token",
     });
 
     const { accessToken } = options;
 
-    return CdpOpenApiClient.validateEndUserAccessToken({
+    const endUser = await CdpOpenApiClient.validateEndUserAccessToken({
       accessToken,
     });
+
+    return toEndUserAccount(CdpOpenApiClient, { endUser });
   }
 
   /**
@@ -182,7 +285,7 @@ export class CDPEndUserClient {
    *          });
    *          ```
    */
-  async importEndUser(options: ImportEndUserOptions): Promise<EndUser> {
+  async importEndUser(options: ImportEndUserOptions): Promise<EndUserAccount> {
     Analytics.trackAction({
       action: "import_end_user",
     });
@@ -232,11 +335,13 @@ export class CDPEndUserClient {
       privateKeyBytes,
     );
 
-    return CdpOpenApiClient.importEndUser({
+    const endUser = await CdpOpenApiClient.importEndUser({
       userId,
       authenticationMethods: options.authenticationMethods,
       encryptedPrivateKey: encryptedPrivateKey.toString("base64"),
       keyType: options.keyType,
     });
+
+    return toEndUserAccount(CdpOpenApiClient, { endUser });
   }
 }

package/client/end-user/endUser.types.ts

@@ -3,7 +3,12 @@ import type {
   ListEndUsersParams,
   ImportEndUserBodyKeyType,
   AuthenticationMethods,
+  AddEndUserEvmAccount201,
+  AddEndUserEvmSmartAccount201,
+  AddEndUserSolanaAccount201,
+  EndUser as OpenAPIEndUser,
 } from "../../openapi-client/index.js";
+import type { Prettify } from "../../types/utils.js";
 
 /**
  * The options for validating an access token.
@@ -35,6 +40,55 @@ export type ListEndUsersOptions = ListEndUsersParams;
  */
 export type CreateEndUserOptions = CreateEndUserBody;
 
+/**
+ * The options for adding an EVM account to an end user.
+ */
+export interface AddEndUserEvmAccountOptions {
+  /**
+   * The unique identifier of the end user.
+   */
+  userId: string;
+}
+
+/**
+ * The result of adding an EVM account to an end user.
+ */
+export type AddEndUserEvmAccountResult = AddEndUserEvmAccount201;
+
+/**
+ * The options for adding an EVM smart account to an end user.
+ */
+export interface AddEndUserEvmSmartAccountOptions {
+  /**
+   * The unique identifier of the end user.
+   */
+  userId: string;
+  /**
+   * If true, enables spend permissions for the EVM smart account.
+   */
+  enableSpendPermissions: boolean;
+}
+
+/**
+ * The result of adding an EVM smart account to an end user.
+ */
+export type AddEndUserEvmSmartAccountResult = AddEndUserEvmSmartAccount201;
+
+/**
+ * The options for adding a Solana account to an end user.
+ */
+export interface AddEndUserSolanaAccountOptions {
+  /**
+   * The unique identifier of the end user.
+   */
+  userId: string;
+}
+
+/**
+ * The result of adding a Solana account to an end user.
+ */
+export type AddEndUserSolanaAccountResult = AddEndUserSolanaAccount201;
+
 /**
  * The options for importing an end user.
  */
@@ -65,3 +119,84 @@ export interface ImportEndUserOptions {
    */
   encryptionPublicKey?: string;
 }
+
+/**
+ * The options for adding an EVM smart account to an EndUser object.
+ */
+export interface AddEvmSmartAccountOptions {
+  /**
+   * If true, enables spend permissions for the EVM smart account.
+   */
+  enableSpendPermissions: boolean;
+}
+
+/**
+ * Actions that can be performed on an EndUser object.
+ */
+export type EndUserAccountActions = {
+  /**
+   * Adds an EVM EOA (Externally Owned Account) to this end user.
+   * End users can have up to 10 EVM accounts.
+   *
+   * @returns A promise that resolves to the newly created EVM EOA account.
+   *
+   * @example
+   * ```ts
+   * const endUser = await cdp.endUser.createEndUser({
+   *   authenticationMethods: [{ type: "email", email: "user@example.com" }]
+   * });
+   *
+   * const result = await endUser.addEvmAccount();
+   * console.log(result.evmAccount.address);
+   * ```
+   */
+  addEvmAccount: () => Promise<AddEndUserEvmAccountResult>;
+
+  /**
+   * Adds an EVM smart account to this end user.
+   * This also creates a new EVM EOA account to serve as the owner of the smart account.
+   *
+   * @param options - The options for adding the EVM smart account.
+   *
+   * @returns A promise that resolves to the newly created EVM smart account.
+   *
+   * @example
+   * ```ts
+   * const endUser = await cdp.endUser.createEndUser({
+   *   authenticationMethods: [{ type: "email", email: "user@example.com" }]
+   * });
+   *
+   * const result = await endUser.addEvmSmartAccount({ enableSpendPermissions: true });
+   * console.log(result.evmSmartAccount.address);
+   * ```
+   */
+  addEvmSmartAccount: (
+    options: AddEvmSmartAccountOptions,
+  ) => Promise<AddEndUserEvmSmartAccountResult>;
+
+  /**
+   * Adds a Solana account to this end user.
+   * End users can have up to 10 Solana accounts.
+   *
+   * @returns A promise that resolves to the newly created Solana account.
+   *
+   * @example
+   * ```ts
+   * const endUser = await cdp.endUser.createEndUser({
+   *   authenticationMethods: [{ type: "email", email: "user@example.com" }]
+   * });
+   *
+   * const result = await endUser.addSolanaAccount();
+   * console.log(result.solanaAccount.address);
+   * ```
+   */
+  addSolanaAccount: () => Promise<AddEndUserSolanaAccountResult>;
+};
+
+/**
+ * An end user with actions that can be performed directly on the object.
+ *
+ * @see {@link OpenAPIEndUser}
+ * @see {@link EndUserAccountActions}
+ */
+export type EndUserAccount = Prettify<OpenAPIEndUser & EndUserAccountActions>;

package/client/end-user/toEndUserAccount.ts

@@ -0,0 +1,80 @@
+import { Analytics } from "../../analytics.js";
+
+import type {
+  EndUserAccount,
+  AddEndUserEvmAccountResult,
+  AddEndUserEvmSmartAccountResult,
+  AddEndUserSolanaAccountResult,
+  AddEvmSmartAccountOptions,
+} from "./endUser.types.js";
+import type {
+  CdpOpenApiClientType,
+  EndUser as OpenAPIEndUser,
+} from "../../openapi-client/index.js";
+
+/**
+ * Options for converting an OpenAPI EndUser to an EndUserAccount with actions.
+ */
+export type ToEndUserAccountOptions = {
+  /** The end user from the API response. */
+  endUser: OpenAPIEndUser;
+};
+
+/**
+ * Creates an EndUserAccount instance with actions from an existing OpenAPI EndUser.
+ * This wraps the raw API response and adds convenience methods for adding accounts.
+ *
+ * @param apiClient - The API client.
+ * @param options - Configuration options.
+ * @param options.endUser - The end user from the API response.
+ * @returns An EndUserAccount instance with action methods.
+ */
+export function toEndUserAccount(
+  apiClient: CdpOpenApiClientType,
+  options: ToEndUserAccountOptions,
+): EndUserAccount {
+  const endUserAccount: EndUserAccount = {
+    // Pass through all properties from the OpenAPI EndUser
+    userId: options.endUser.userId,
+    authenticationMethods: options.endUser.authenticationMethods,
+    mfaMethods: options.endUser.mfaMethods,
+    evmAccounts: options.endUser.evmAccounts,
+    evmAccountObjects: options.endUser.evmAccountObjects,
+    evmSmartAccounts: options.endUser.evmSmartAccounts,
+    evmSmartAccountObjects: options.endUser.evmSmartAccountObjects,
+    solanaAccounts: options.endUser.solanaAccounts,
+    solanaAccountObjects: options.endUser.solanaAccountObjects,
+    createdAt: options.endUser.createdAt,
+
+    // Add action methods
+    async addEvmAccount(): Promise<AddEndUserEvmAccountResult> {
+      Analytics.trackAction({
+        action: "end_user_add_evm_account",
+      });
+
+      return apiClient.addEndUserEvmAccount(options.endUser.userId, {});
+    },
+
+    async addEvmSmartAccount(
+      smartAccountOptions: AddEvmSmartAccountOptions,
+    ): Promise<AddEndUserEvmSmartAccountResult> {
+      Analytics.trackAction({
+        action: "end_user_add_evm_smart_account",
+      });
+
+      return apiClient.addEndUserEvmSmartAccount(options.endUser.userId, {
+        enableSpendPermissions: smartAccountOptions.enableSpendPermissions,
+      });
+    },
+
+    async addSolanaAccount(): Promise<AddEndUserSolanaAccountResult> {
+      Analytics.trackAction({
+        action: "end_user_add_solana_account",
+      });
+
+      return apiClient.addEndUserSolanaAccount(options.endUser.userId, {});
+    },
+  };
+
+  return endUserAccount;
+}

package/index.ts

@@ -10,7 +10,7 @@ export {
 export { NetworkError } from "./openapi-client/errors.js";
 export type { SpendPermission, SpendPermissionInput } from "./spend-permissions/types.js";
 export type { SpendPermissionNetwork, ListEndUsers200, EndUser } from "./openapi-client/index.js";
-export type { ListEndUsersOptions } from "./client/end-user/endUser.types.js";
+export type { ListEndUsersOptions, EndUserAccount } from "./client/end-user/endUser.types.js";
 export {
   SPEND_PERMISSION_MANAGER_ABI as spendPermissionManagerAbi,
   SPEND_PERMISSION_MANAGER_ADDRESS as spendPermissionManagerAddress,