@coinbase/cdp-sdk 1.8.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

@@ -333,6 +333,125 @@ export type SignEvmTransactionCriteriaItem = EthValueCriterion | EvmAddressCrite
  */
 export type SignEvmTransactionCriteria = SignEvmTransactionCriteriaItem[];
 
+/**
+ * Whether matching the rule will cause the request to be rejected or accepted.
+ */
+export type SignEvmTransactionRuleAction =
+  (typeof SignEvmTransactionRuleAction)[keyof typeof SignEvmTransactionRuleAction];
+
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+export const SignEvmTransactionRuleAction = {
+  reject: "reject",
+  accept: "accept",
+} as const;
+
+/**
+ * The operation to which the rule applies. Every element of the `criteria` array must match the specified operation.
+ */
+export type SignEvmTransactionRuleOperation =
+  (typeof SignEvmTransactionRuleOperation)[keyof typeof SignEvmTransactionRuleOperation];
+
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+export const SignEvmTransactionRuleOperation = {
+  signEvmTransaction: "signEvmTransaction",
+} as const;
+
+export interface SignEvmTransactionRule {
+  /** Whether matching the rule will cause the request to be rejected or accepted. */
+  action: SignEvmTransactionRuleAction;
+  /** The operation to which the rule applies. Every element of the `criteria` array must match the specified operation. */
+  operation: SignEvmTransactionRuleOperation;
+  criteria: SignEvmTransactionCriteria;
+}
+
+/**
+ * The type of criterion to use. This should be `evmNetwork`.
+ */
+export type EvmNetworkCriterionType =
+  (typeof EvmNetworkCriterionType)[keyof typeof EvmNetworkCriterionType];
+
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+export const EvmNetworkCriterionType = {
+  evmNetwork: "evmNetwork",
+} as const;
+
+/**
+ * The network the transaction is for.
+ */
+export type EvmNetworkCriterionNetworksItem =
+  (typeof EvmNetworkCriterionNetworksItem)[keyof typeof EvmNetworkCriterionNetworksItem];
+
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+export const EvmNetworkCriterionNetworksItem = {
+  "base-sepolia": "base-sepolia",
+  base: "base",
+} as const;
+
+/**
+ * The operator to use for the comparison. The transaction's intended `network` will be on the left-hand side of the operator, and the `networks` field will be on the right-hand side.
+ */
+export type EvmNetworkCriterionOperator =
+  (typeof EvmNetworkCriterionOperator)[keyof typeof EvmNetworkCriterionOperator];
+
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+export const EvmNetworkCriterionOperator = {
+  in: "in",
+  not_in: "not in",
+} as const;
+
+/**
+ * A schema for specifying a criterion for the intended `network` of an EVM transaction.
+ */
+export interface EvmNetworkCriterion {
+  /** The type of criterion to use. This should be `evmNetwork`. */
+  type: EvmNetworkCriterionType;
+  /** A list of EVM network identifiers that the transaction's intended `network` should be compared to. */
+  networks: EvmNetworkCriterionNetworksItem[];
+  /** The operator to use for the comparison. The transaction's intended `network` will be on the left-hand side of the operator, and the `networks` field will be on the right-hand side. */
+  operator: EvmNetworkCriterionOperator;
+}
+
+export type SendEvmTransactionCriteriaItem =
+  | EthValueCriterion
+  | EvmAddressCriterion
+  | EvmNetworkCriterion;
+
+/**
+ * A schema for specifying the rejection criteria for the SignEvmTransaction operation.
+ */
+export type SendEvmTransactionCriteria = SendEvmTransactionCriteriaItem[];
+
+/**
+ * Whether matching the rule will cause the request to be rejected or accepted.
+ */
+export type SendEvmTransactionRuleAction =
+  (typeof SendEvmTransactionRuleAction)[keyof typeof SendEvmTransactionRuleAction];
+
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+export const SendEvmTransactionRuleAction = {
+  reject: "reject",
+  accept: "accept",
+} as const;
+
+/**
+ * The operation to which the rule applies. Every element of the `criteria` array must match the specified operation.
+ */
+export type SendEvmTransactionRuleOperation =
+  (typeof SendEvmTransactionRuleOperation)[keyof typeof SendEvmTransactionRuleOperation];
+
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+export const SendEvmTransactionRuleOperation = {
+  sendEvmTransaction: "sendEvmTransaction",
+} as const;
+
+export interface SendEvmTransactionRule {
+  /** Whether matching the rule will cause the request to be rejected or accepted. */
+  action: SendEvmTransactionRuleAction;
+  /** The operation to which the rule applies. Every element of the `criteria` array must match the specified operation. */
+  operation: SendEvmTransactionRuleOperation;
+  criteria: SendEvmTransactionCriteria;
+}
+
 /**
  * The type of criterion to use. This should be `solAddress`.
  */
@@ -376,10 +495,11 @@ export type SignSolTransactionCriteria = SolAddressCriterion[];
 /**
  * Whether matching the rule will cause the request to be rejected or accepted.
  */
-export type RuleAction = (typeof RuleAction)[keyof typeof RuleAction];
+export type SignSolTransactionRuleAction =
+  (typeof SignSolTransactionRuleAction)[keyof typeof SignSolTransactionRuleAction];
 
 // eslint-disable-next-line @typescript-eslint/no-redeclare
-export const RuleAction = {
+export const SignSolTransactionRuleAction = {
   reject: "reject",
   accept: "accept",
 } as const;
@@ -387,30 +507,26 @@ export const RuleAction = {
 /**
  * The operation to which the rule applies. Every element of the `criteria` array must match the specified operation.
  */
-export type RuleOperation = (typeof RuleOperation)[keyof typeof RuleOperation];
+export type SignSolTransactionRuleOperation =
+  (typeof SignSolTransactionRuleOperation)[keyof typeof SignSolTransactionRuleOperation];
 
 // eslint-disable-next-line @typescript-eslint/no-redeclare
-export const RuleOperation = {
-  signEvmTransaction: "signEvmTransaction",
+export const SignSolTransactionRuleOperation = {
   signSolTransaction: "signSolTransaction",
 } as const;
 
-/**
- * The set of criteria for the rule. There is a limit of 10 criteria per rule.
- */
-export type RuleCriteria = SignEvmTransactionCriteria | SignSolTransactionCriteria;
+export interface SignSolTransactionRule {
+  /** Whether matching the rule will cause the request to be rejected or accepted. */
+  action: SignSolTransactionRuleAction;
+  /** The operation to which the rule applies. Every element of the `criteria` array must match the specified operation. */
+  operation: SignSolTransactionRuleOperation;
+  criteria: SignSolTransactionCriteria;
+}
 
 /**
  * A rule that limits the behavior of an account.
  */
-export interface Rule {
-  /** Whether matching the rule will cause the request to be rejected or accepted. */
-  action: RuleAction;
-  /** The operation to which the rule applies. Every element of the `criteria` array must match the specified operation. */
-  operation: RuleOperation;
-  /** The set of criteria for the rule. There is a limit of 10 criteria per rule. */
-  criteria: RuleCriteria;
-}
+export type Rule = SignEvmTransactionRule | SendEvmTransactionRule | SignSolTransactionRule;
 
 /**
  * The scope of the policy. Only one project-level policy can exist at any time.
@@ -430,7 +546,7 @@ export interface Policy {
    */
   id: string;
   /**
-   * An optional human-readable description of the policy. 
+   * An optional human-readable description of the policy.
 Policy descriptions can consist of alphanumeric characters, spaces, commas, and periods, and be 50 characters or less.
    * @pattern ^[A-Za-z0-9 ,.]{1,50}$
    */
@@ -628,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>>>;