@coinbase/cdp-sdk 1.9.0 → 1.10.0

package/client/evm/evm.ts

@@ -1,5 +1,8 @@
+import { publicEncrypt, constants } from "crypto";
+
 import { Address } from "viem";
 
+import { ImportEvmAccountPublicRSAKey } from "./constants.js";
 import {
   CreateServerAccountOptions,
   GetServerAccountOptions,
@@ -23,6 +26,7 @@ import {
   GetOrCreateServerAccountOptions,
   SignTypedDataOptions,
   UpdateEvmAccountOptions,
+  ImportServerAccountOptions,
 } from "./evm.types.js";
 import { toEvmServerAccount } from "../../accounts/evm/toEvmServerAccount.js";
 import { toEvmSmartAccount } from "../../accounts/evm/toEvmSmartAccount.js";
@@ -112,6 +116,92 @@ export class EvmClient implements EvmClientInterface {
     return account;
   }
 
+  /**
+   * Imports a CDP EVM account from an external source.
+   *
+   * @param {ImportServerAccountOptions} options - Parameters for importing the account.
+   * @param {string} options.privateKey - The private key of the account to import.
+   * @param {string} [options.name] - A name for the account to import.
+   * @param {string} [options.idempotencyKey] - An idempotency key.
+   *
+   * @returns A promise that resolves to the imported account.
+   *
+   * @example **Without arguments**
+   *          ```ts
+   *          const account = await cdp.evm.importAccount({
+   *            privateKey: "0x123456"
+   *          });
+   *          ```
+   *
+   * @example **With a name**
+   *          ```ts
+   *          const account = await cdp.evm.importAccount({
+   *            privateKey: "0x123456",
+   *            name: "MyAccount"
+   *          });
+   *          ```
+   *
+   * @example **With an idempotency key**
+   *          ```ts
+   *          const idempotencyKey = uuidv4();
+   *
+   *          // First call
+   *          await cdp.evm.importAccount({
+   *            privateKey: "0x123456",
+   *            idempotencyKey,
+   *          });
+   *
+   *          // Second call with the same idempotency key will return the same account
+   *          await cdp.evm.importAccount({
+   *            privateKey: "0x123456"
+   *            idempotencyKey,
+   *          });
+   *          ```
+   */
+  async importAccount(options: ImportServerAccountOptions): Promise<ServerAccount> {
+    const privateKeyHex = options.privateKey.startsWith("0x")
+      ? options.privateKey.slice(2)
+      : options.privateKey;
+
+    if (!/^[0-9a-fA-F]+$/.test(privateKeyHex)) {
+      throw new Error("Private key must be a valid hexadecimal string");
+    }
+
+    try {
+      const privateKeyBytes = Buffer.from(privateKeyHex, "hex");
+
+      const encryptedPrivateKey = publicEncrypt(
+        {
+          key: ImportEvmAccountPublicRSAKey,
+          padding: constants.RSA_PKCS1_OAEP_PADDING,
+          oaepHash: "sha256",
+        },
+        privateKeyBytes,
+      );
+
+      const openApiAccount = await CdpOpenApiClient.importEvmAccount(
+        {
+          name: options.name,
+          encryptedPrivateKey: encryptedPrivateKey.toString("base64"),
+        },
+        options.idempotencyKey,
+      );
+
+      const account = toEvmServerAccount(CdpOpenApiClient, {
+        account: openApiAccount,
+      });
+
+      Analytics.wrapObjectMethodsWithErrorTracking(account);
+
+      return account;
+    } catch (error) {
+      if (error instanceof APIError) {
+        throw error;
+      }
+      throw new Error(`Failed to import account: ${String(error)}`);
+    }
+  }
+
   /**
    * Creates a new CDP EVM smart account.
    *

package/client/evm/evm.types.ts

@@ -34,6 +34,7 @@ export type EvmClientInterface = Omit<
   typeof OpenApiEvmMethods,
   | "createEvmAccount" // mapped to createAccount
   | "createEvmSmartAccount" // mapped to createSmartAccount
+  | "importEvmAccount" // mapped to importAccount
   | "getEvmAccount" // mapped to getAccount
   | "getEvmAccountByName" // mapped to getAccount
   | "getEvmSmartAccount" // mapped to getSmartAccount
@@ -55,6 +56,7 @@ export type EvmClientInterface = Omit<
 > & {
   createAccount: (options: CreateServerAccountOptions) => Promise<ServerAccount>;
   createSmartAccount: (options: CreateSmartAccountOptions) => Promise<SmartAccount>;
+  importAccount: (options: ImportServerAccountOptions) => Promise<ServerAccount>;
   getAccount: (options: GetServerAccountOptions) => Promise<ServerAccount>;
   getSmartAccount: (options: GetSmartAccountOptions) => Promise<SmartAccount>;
   getOrCreateAccount: (options: GetOrCreateServerAccountOptions) => Promise<ServerAccount>;
@@ -147,6 +149,18 @@ export interface CreateServerAccountOptions {
   idempotencyKey?: string;
 }
 
+/**
+ * Options for importing an EVM server account.
+ */
+export interface ImportServerAccountOptions {
+  /** The name of the account. */
+  name?: string;
+  /** The idempotency key. */
+  idempotencyKey?: string;
+  /** The private key of the account. */
+  privateKey: Hex;
+}
+
 /**
  * Options for getting an EVM account.
  */

package/openapi-client/generated/coinbaseDeveloperPlatformAPIs.schemas.ts

@@ -744,6 +744,18 @@ export type CreateEvmSmartAccountBody = {
   owners: string[];
 };
 
+export type ImportEvmAccountBody = {
+  /** The base64-encoded, encrypted private key of the EVM account. The private key must be encrypted using the CDP SDK's encryption scheme. */
+  encryptedPrivateKey: string;
+  /**
+   * An optional name for the account.
+Account names can consist of alphanumeric characters and hyphens, and be between 2 and 36 characters long.
+Account names must be unique across all EVM accounts in the developer's CDP Project.
+   * @pattern ^[A-Za-z0-9][A-Za-z0-9-]{0,34}[A-Za-z0-9]$
+   */
+  name?: string;
+};
+
 /**
  * The network to prepare the user operation for.
  */

package/openapi-client/generated/evm-accounts/evm-accounts.msw.ts

@@ -138,6 +138,25 @@ export const getSignEvmTypedDataResponseMock = (
   overrideResponse: Partial<SignEvmTypedData200> = {},
 ): SignEvmTypedData200 => ({ signature: faker.string.alpha(20), ...overrideResponse });
 
+export const getImportEvmAccountResponseMock = (
+  overrideResponse: Partial<EvmAccount> = {},
+): EvmAccount => ({
+  address: faker.helpers.fromRegExp("^0x[0-9a-fA-F]{40}$"),
+  name: faker.helpers.arrayElement([
+    faker.helpers.fromRegExp("^[A-Za-z0-9][A-Za-z0-9-]{0,34}[A-Za-z0-9]$"),
+    undefined,
+  ]),
+  policies: faker.helpers.arrayElement([
+    Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() =>
+      faker.helpers.fromRegExp(
+        "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$",
+      ),
+    ),
+    undefined,
+  ]),
+  ...overrideResponse,
+});
+
 export const getListEvmAccountsMockHandler = (
   overrideResponse?:
     | ListEvmAccounts200
@@ -359,6 +378,27 @@ export const getSignEvmTypedDataMockHandler = (
     );
   });
 };
+
+export const getImportEvmAccountMockHandler = (
+  overrideResponse?:
+    | EvmAccount
+    | ((info: Parameters<Parameters<typeof http.post>[1]>[0]) => Promise<EvmAccount> | EvmAccount),
+) => {
+  return http.post("*/v2/evm/accounts/import", async info => {
+    await delay(0);
+
+    return new HttpResponse(
+      JSON.stringify(
+        overrideResponse !== undefined
+          ? typeof overrideResponse === "function"
+            ? await overrideResponse(info)
+            : overrideResponse
+          : getImportEvmAccountResponseMock(),
+      ),
+      { status: 201, headers: { "Content-Type": "application/json" } },
+    );
+  });
+};
 export const getEvmAccountsMock = () => [
   getListEvmAccountsMockHandler(),
   getCreateEvmAccountMockHandler(),
@@ -370,4 +410,5 @@ export const getEvmAccountsMock = () => [
   getSignEvmHashMockHandler(),
   getSignEvmMessageMockHandler(),
   getSignEvmTypedDataMockHandler(),
+  getImportEvmAccountMockHandler(),
 ];

package/openapi-client/generated/evm-accounts/evm-accounts.ts

@@ -9,6 +9,7 @@ import type {
   CreateEvmAccountBody,
   EIP712Message,
   EvmAccount,
+  ImportEvmAccountBody,
   ListEvmAccounts200,
   ListEvmAccountsParams,
   SendEvmTransaction200,
@@ -223,6 +224,24 @@ export const signEvmTypedData = (
     options,
   );
 };
+/**
+ * Import an existing EVM account into the developer's CDP Project. This API should be called from the [CDP SDK](https://github.com/coinbase/cdp-sdk) to ensure that the associated private key is properly encrypted.
+ * @summary Import an EVM account
+ */
+export const importEvmAccount = (
+  importEvmAccountBody: ImportEvmAccountBody,
+  options?: SecondParameter<typeof cdpApiClient>,
+) => {
+  return cdpApiClient<EvmAccount>(
+    {
+      url: `/v2/evm/accounts/import`,
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      data: importEvmAccountBody,
+    },
+    options,
+  );
+};
 export type ListEvmAccountsResult = NonNullable<Awaited<ReturnType<typeof listEvmAccounts>>>;
 export type CreateEvmAccountResult = NonNullable<Awaited<ReturnType<typeof createEvmAccount>>>;
 export type GetEvmAccountResult = NonNullable<Awaited<ReturnType<typeof getEvmAccount>>>;
@@ -235,3 +254,4 @@ export type SignEvmTransactionResult = NonNullable<Awaited<ReturnType<typeof sig
 export type SignEvmHashResult = NonNullable<Awaited<ReturnType<typeof signEvmHash>>>;
 export type SignEvmMessageResult = NonNullable<Awaited<ReturnType<typeof signEvmMessage>>>;
 export type SignEvmTypedDataResult = NonNullable<Awaited<ReturnType<typeof signEvmTypedData>>>;
+export type ImportEvmAccountResult = NonNullable<Awaited<ReturnType<typeof importEvmAccount>>>;

package/openapi-client/generated/index.msw.ts

@@ -1,6 +1,6 @@
-export * from "./faucets/faucets.msw.js";
-export * from "./policy-engine/policy-engine.msw.js";
 export * from "./evm-accounts/evm-accounts.msw.js";
-export * from "./evm-smart-accounts/evm-smart-accounts.msw.js";
 export * from "./evm-token-balances/evm-token-balances.msw.js";
+export * from "./evm-smart-accounts/evm-smart-accounts.msw.js";
+export * from "./faucets/faucets.msw.js";
+export * from "./policy-engine/policy-engine.msw.js";
 export * from "./solana-accounts/solana-accounts.msw.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coinbase/cdp-sdk",
-  "version": "1.9.0",
+  "version": "1.10.0",
   "description": "SDK for interacting with the Coinbase Developer Platform Wallet API",
   "main": "./_cjs/index.js",
   "module": "./_esm/index.js",

package/version.ts

@@ -1 +1 @@
-export const version = "1.9.0";
+export const version = "1.10.0";