@coinbase/cdp-sdk 1.13.0 → 1.15.0

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

@@ -11,6 +11,8 @@ import { HttpResponse, delay, http } from "msw";
 
 import type {
   EvmAccount,
+  ExportEvmAccount200,
+  ExportEvmAccountByName200,
   ListEvmAccounts200,
   SendEvmTransaction200,
   SignEvmHash200,
@@ -157,6 +159,17 @@ export const getImportEvmAccountResponseMock = (
   ...overrideResponse,
 });
 
+export const getExportEvmAccountResponseMock = (
+  overrideResponse: Partial<ExportEvmAccount200> = {},
+): ExportEvmAccount200 => ({ encryptedPrivateKey: faker.string.alpha(20), ...overrideResponse });
+
+export const getExportEvmAccountByNameResponseMock = (
+  overrideResponse: Partial<ExportEvmAccountByName200> = {},
+): ExportEvmAccountByName200 => ({
+  encryptedPrivateKey: faker.string.alpha(20),
+  ...overrideResponse,
+});
+
 export const getListEvmAccountsMockHandler = (
   overrideResponse?:
     | ListEvmAccounts200
@@ -399,6 +412,52 @@ export const getImportEvmAccountMockHandler = (
     );
   });
 };
+
+export const getExportEvmAccountMockHandler = (
+  overrideResponse?:
+    | ExportEvmAccount200
+    | ((
+        info: Parameters<Parameters<typeof http.post>[1]>[0],
+      ) => Promise<ExportEvmAccount200> | ExportEvmAccount200),
+) => {
+  return http.post("*/v2/evm/accounts/:address/export", async info => {
+    await delay(0);
+
+    return new HttpResponse(
+      JSON.stringify(
+        overrideResponse !== undefined
+          ? typeof overrideResponse === "function"
+            ? await overrideResponse(info)
+            : overrideResponse
+          : getExportEvmAccountResponseMock(),
+      ),
+      { status: 200, headers: { "Content-Type": "application/json" } },
+    );
+  });
+};
+
+export const getExportEvmAccountByNameMockHandler = (
+  overrideResponse?:
+    | ExportEvmAccountByName200
+    | ((
+        info: Parameters<Parameters<typeof http.post>[1]>[0],
+      ) => Promise<ExportEvmAccountByName200> | ExportEvmAccountByName200),
+) => {
+  return http.post("*/v2/evm/accounts/export/by-name/:name", async info => {
+    await delay(0);
+
+    return new HttpResponse(
+      JSON.stringify(
+        overrideResponse !== undefined
+          ? typeof overrideResponse === "function"
+            ? await overrideResponse(info)
+            : overrideResponse
+          : getExportEvmAccountByNameResponseMock(),
+      ),
+      { status: 200, headers: { "Content-Type": "application/json" } },
+    );
+  });
+};
 export const getEvmAccountsMock = () => [
   getListEvmAccountsMockHandler(),
   getCreateEvmAccountMockHandler(),
@@ -411,4 +470,6 @@ export const getEvmAccountsMock = () => [
   getSignEvmMessageMockHandler(),
   getSignEvmTypedDataMockHandler(),
   getImportEvmAccountMockHandler(),
+  getExportEvmAccountMockHandler(),
+  getExportEvmAccountByNameMockHandler(),
 ];

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

@@ -9,6 +9,10 @@ import type {
   CreateEvmAccountBody,
   EIP712Message,
   EvmAccount,
+  ExportEvmAccount200,
+  ExportEvmAccountBody,
+  ExportEvmAccountByName200,
+  ExportEvmAccountByNameBody,
   ImportEvmAccountBody,
   ListEvmAccounts200,
   ListEvmAccountsParams,
@@ -242,6 +246,44 @@ export const importEvmAccount = (
     options,
   );
 };
+/**
+ * Export an existing EVM account's private key. It is important to store the private key in a secure place after it's exported.
+ * @summary Export an EVM account
+ */
+export const exportEvmAccount = (
+  address: string,
+  exportEvmAccountBody: ExportEvmAccountBody,
+  options?: SecondParameter<typeof cdpApiClient>,
+) => {
+  return cdpApiClient<ExportEvmAccount200>(
+    {
+      url: `/v2/evm/accounts/${address}/export`,
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      data: exportEvmAccountBody,
+    },
+    options,
+  );
+};
+/**
+ * Export an existing EVM account's private key by its name. It is important to store the private key in a secure place after it's exported.
+ * @summary Export an EVM account by name
+ */
+export const exportEvmAccountByName = (
+  name: string,
+  exportEvmAccountByNameBody: ExportEvmAccountByNameBody,
+  options?: SecondParameter<typeof cdpApiClient>,
+) => {
+  return cdpApiClient<ExportEvmAccountByName200>(
+    {
+      url: `/v2/evm/accounts/export/by-name/${name}`,
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      data: exportEvmAccountByNameBody,
+    },
+    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>>>;
@@ -255,3 +297,7 @@ export type SignEvmHashResult = NonNullable<Awaited<ReturnType<typeof signEvmHas
 export type SignEvmMessageResult = NonNullable<Awaited<ReturnType<typeof signEvmMessage>>>;
 export type SignEvmTypedDataResult = NonNullable<Awaited<ReturnType<typeof signEvmTypedData>>>;
 export type ImportEvmAccountResult = NonNullable<Awaited<ReturnType<typeof importEvmAccount>>>;
+export type ExportEvmAccountResult = NonNullable<Awaited<ReturnType<typeof exportEvmAccount>>>;
+export type ExportEvmAccountByNameResult = NonNullable<
+  Awaited<ReturnType<typeof exportEvmAccountByName>>
+>;

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

@@ -47,6 +47,20 @@ export const getCreateEvmSmartAccountResponseMock = (
   ...overrideResponse,
 });
 
+export const getGetEvmSmartAccountByNameResponseMock = (
+  overrideResponse: Partial<EvmSmartAccount> = {},
+): EvmSmartAccount => ({
+  address: faker.helpers.fromRegExp("^0x[0-9a-fA-F]{40}$"),
+  owners: Array.from({ length: faker.number.int({ min: 1, max: 10 }) }, (_, i) => i + 1).map(() =>
+    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,
+  ]),
+  ...overrideResponse,
+});
+
 export const getGetEvmSmartAccountResponseMock = (
   overrideResponse: Partial<EvmSmartAccount> = {},
 ): EvmSmartAccount => ({
@@ -179,6 +193,29 @@ export const getCreateEvmSmartAccountMockHandler = (
   });
 };
 
+export const getGetEvmSmartAccountByNameMockHandler = (
+  overrideResponse?:
+    | EvmSmartAccount
+    | ((
+        info: Parameters<Parameters<typeof http.get>[1]>[0],
+      ) => Promise<EvmSmartAccount> | EvmSmartAccount),
+) => {
+  return http.get("*/v2/evm/smart-accounts/by-name/:name", async info => {
+    await delay(0);
+
+    return new HttpResponse(
+      JSON.stringify(
+        overrideResponse !== undefined
+          ? typeof overrideResponse === "function"
+            ? await overrideResponse(info)
+            : overrideResponse
+          : getGetEvmSmartAccountByNameResponseMock(),
+      ),
+      { status: 200, headers: { "Content-Type": "application/json" } },
+    );
+  });
+};
+
 export const getGetEvmSmartAccountMockHandler = (
   overrideResponse?:
     | EvmSmartAccount
@@ -276,6 +313,7 @@ export const getSendUserOperationMockHandler = (
 export const getEvmSmartAccountsMock = () => [
   getListEvmSmartAccountsMockHandler(),
   getCreateEvmSmartAccountMockHandler(),
+  getGetEvmSmartAccountByNameMockHandler(),
   getGetEvmSmartAccountMockHandler(),
   getPrepareUserOperationMockHandler(),
   getGetUserOperationMockHandler(),

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

@@ -51,6 +51,19 @@ export const createEvmSmartAccount = (
     options,
   );
 };
+/**
+ * Gets a Smart Account by its name.
+ * @summary Get a Smart Account by name
+ */
+export const getEvmSmartAccountByName = (
+  name: string,
+  options?: SecondParameter<typeof cdpApiClient>,
+) => {
+  return cdpApiClient<EvmSmartAccount>(
+    { url: `/v2/evm/smart-accounts/by-name/${name}`, method: "GET" },
+    options,
+  );
+};
 /**
  * Gets a Smart Account by its address.
  * @summary Get a Smart Account by address
@@ -126,6 +139,9 @@ export type ListEvmSmartAccountsResult = NonNullable<
 export type CreateEvmSmartAccountResult = NonNullable<
   Awaited<ReturnType<typeof createEvmSmartAccount>>
 >;
+export type GetEvmSmartAccountByNameResult = NonNullable<
+  Awaited<ReturnType<typeof getEvmSmartAccountByName>>
+>;
 export type GetEvmSmartAccountResult = NonNullable<Awaited<ReturnType<typeof getEvmSmartAccount>>>;
 export type PrepareUserOperationResult = NonNullable<
   Awaited<ReturnType<typeof prepareUserOperation>>

package/openapi-client/generated/faucets/faucets.ts

@@ -19,7 +19,7 @@ type SecondParameter<T extends (...args: never) => unknown> = Parameters<T>[1];
 /**
  * Request funds from the CDP Faucet on supported EVM test networks.
 
-Faucets are available for ETH, USDC, EURC, and cbBTC on Base Sepolia and Ethereum Sepolia.
+Faucets are available for ETH, USDC, EURC, and cbBTC on Base Sepolia and Ethereum Sepolia, and for ETH only on Ethereum Hoodi.
 
 To prevent abuse, we enforce rate limits within a rolling 24-hour window to control the amount of funds that can be requested. 
 These limits are applied at both the CDP User level and the blockchain address level. 

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

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

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

@@ -10,6 +10,8 @@ import { faker } from "@faker-js/faker";
 import { HttpResponse, delay, http } from "msw";
 
 import type {
+  ExportSolanaAccount200,
+  ExportSolanaAccountByName200,
   ListSolanaAccounts200,
   SignSolanaMessage200,
   SignSolanaTransaction200,
@@ -115,6 +117,17 @@ export const getGetSolanaAccountByNameResponseMock = (
   ...overrideResponse,
 });
 
+export const getExportSolanaAccountResponseMock = (
+  overrideResponse: Partial<ExportSolanaAccount200> = {},
+): ExportSolanaAccount200 => ({ encryptedPrivateKey: faker.string.alpha(20), ...overrideResponse });
+
+export const getExportSolanaAccountByNameResponseMock = (
+  overrideResponse: Partial<ExportSolanaAccountByName200> = {},
+): ExportSolanaAccountByName200 => ({
+  encryptedPrivateKey: faker.string.alpha(20),
+  ...overrideResponse,
+});
+
 export const getSignSolanaTransactionResponseMock = (
   overrideResponse: Partial<SignSolanaTransaction200> = {},
 ): SignSolanaTransaction200 => ({ signedTransaction: faker.string.alpha(20), ...overrideResponse });
@@ -238,6 +251,52 @@ export const getGetSolanaAccountByNameMockHandler = (
   });
 };
 
+export const getExportSolanaAccountMockHandler = (
+  overrideResponse?:
+    | ExportSolanaAccount200
+    | ((
+        info: Parameters<Parameters<typeof http.post>[1]>[0],
+      ) => Promise<ExportSolanaAccount200> | ExportSolanaAccount200),
+) => {
+  return http.post("*/v2/solana/accounts/:address/export", async info => {
+    await delay(0);
+
+    return new HttpResponse(
+      JSON.stringify(
+        overrideResponse !== undefined
+          ? typeof overrideResponse === "function"
+            ? await overrideResponse(info)
+            : overrideResponse
+          : getExportSolanaAccountResponseMock(),
+      ),
+      { status: 200, headers: { "Content-Type": "application/json" } },
+    );
+  });
+};
+
+export const getExportSolanaAccountByNameMockHandler = (
+  overrideResponse?:
+    | ExportSolanaAccountByName200
+    | ((
+        info: Parameters<Parameters<typeof http.post>[1]>[0],
+      ) => Promise<ExportSolanaAccountByName200> | ExportSolanaAccountByName200),
+) => {
+  return http.post("*/v2/solana/accounts/export/by-name/:name", async info => {
+    await delay(0);
+
+    return new HttpResponse(
+      JSON.stringify(
+        overrideResponse !== undefined
+          ? typeof overrideResponse === "function"
+            ? await overrideResponse(info)
+            : overrideResponse
+          : getExportSolanaAccountByNameResponseMock(),
+      ),
+      { status: 200, headers: { "Content-Type": "application/json" } },
+    );
+  });
+};
+
 export const getSignSolanaTransactionMockHandler = (
   overrideResponse?:
     | SignSolanaTransaction200
@@ -289,6 +348,8 @@ export const getSolanaAccountsMock = () => [
   getGetSolanaAccountMockHandler(),
   getUpdateSolanaAccountMockHandler(),
   getGetSolanaAccountByNameMockHandler(),
+  getExportSolanaAccountMockHandler(),
+  getExportSolanaAccountByNameMockHandler(),
   getSignSolanaTransactionMockHandler(),
   getSignSolanaMessageMockHandler(),
 ];

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

@@ -7,6 +7,10 @@
  */
 import type {
   CreateSolanaAccountBody,
+  ExportSolanaAccount200,
+  ExportSolanaAccountBody,
+  ExportSolanaAccountByName200,
+  ExportSolanaAccountByNameBody,
   ListSolanaAccounts200,
   ListSolanaAccountsParams,
   SignSolanaMessage200,
@@ -100,6 +104,44 @@ export const getSolanaAccountByName = (
     options,
   );
 };
+/**
+ * Export an existing Solana account's private key. It is important to store the private key in a secure place after it's exported.
+ * @summary Export an Solana account
+ */
+export const exportSolanaAccount = (
+  address: string,
+  exportSolanaAccountBody: ExportSolanaAccountBody,
+  options?: SecondParameter<typeof cdpApiClient>,
+) => {
+  return cdpApiClient<ExportSolanaAccount200>(
+    {
+      url: `/v2/solana/accounts/${address}/export`,
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      data: exportSolanaAccountBody,
+    },
+    options,
+  );
+};
+/**
+ * Export an existing Solana account's private key by its name. It is important to store the private key in a secure place after it's exported.
+ * @summary Export a Solana account by name
+ */
+export const exportSolanaAccountByName = (
+  name: string,
+  exportSolanaAccountByNameBody: ExportSolanaAccountByNameBody,
+  options?: SecondParameter<typeof cdpApiClient>,
+) => {
+  return cdpApiClient<ExportSolanaAccountByName200>(
+    {
+      url: `/v2/solana/accounts/export/by-name/${name}`,
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      data: exportSolanaAccountByNameBody,
+    },
+    options,
+  );
+};
 /**
  * Signs a transaction with the given Solana account.
 The unsigned transaction should be serialized into a byte array and then encoded as base64.
@@ -160,6 +202,12 @@ export type UpdateSolanaAccountResult = NonNullable<
 export type GetSolanaAccountByNameResult = NonNullable<
   Awaited<ReturnType<typeof getSolanaAccountByName>>
 >;
+export type ExportSolanaAccountResult = NonNullable<
+  Awaited<ReturnType<typeof exportSolanaAccount>>
+>;
+export type ExportSolanaAccountByNameResult = NonNullable<
+  Awaited<ReturnType<typeof exportSolanaAccountByName>>
+>;
 export type SignSolanaTransactionResult = NonNullable<
   Awaited<ReturnType<typeof signSolanaTransaction>>
 >;

package/package.json

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

package/utils/export.ts

@@ -0,0 +1,89 @@
+import { generateKeyPair, privateDecrypt, constants, createPrivateKey } from "crypto";
+
+import { Keypair } from "@solana/web3.js";
+import bs58 from "bs58";
+
+/**
+ * Generates a new RSA key pair with 4096-bit private key.
+ * - Private key in PKCS1 DER format
+ * - Public key in PKIX/SPKI DER format
+ *
+ * @returns A promise that resolves to the generated key pair, or rejects with an error.
+ */
+export const generateExportEncryptionKeyPair = async () => {
+  return await new Promise<{
+    publicKey: string;
+    privateKey: string;
+  }>((resolve, reject) => {
+    generateKeyPair(
+      "rsa",
+      {
+        modulusLength: 4096,
+        publicKeyEncoding: {
+          type: "spki",
+          format: "der",
+        },
+        privateKeyEncoding: {
+          type: "pkcs1",
+          format: "der",
+        },
+      },
+      (err, publicKey, privateKey) => {
+        if (err) {
+          reject(err);
+        }
+        resolve({
+          publicKey: publicKey.toString("base64"),
+          privateKey: privateKey.toString("base64"),
+        });
+      },
+    );
+  });
+};
+
+/**
+ * Decrypts a ciphertext using RSA-OAEP-SHA256.
+ * - Parses PKCS1 private key
+ * - Uses RSA-OAEP-SHA256 for decryption
+ * - Returns hex-encoded result
+ *
+ * @param b64PrivateKey - The base64-encoded private key in PKCS1 DER format.
+ * @param b64Cipher - The base64-encoded ciphertext.
+ * @returns The decrypted key hex string, or throws an error if decryption fails.
+ */
+export const decryptWithPrivateKey = (b64PrivateKey: string, b64Cipher: string): string => {
+  try {
+    // Create a private key object from the PKCS1 DER format
+    const privateKey = createPrivateKey({
+      key: Buffer.from(b64PrivateKey, "base64"),
+      format: "der",
+      type: "pkcs1",
+    });
+
+    const decryptedBuffer = privateDecrypt(
+      {
+        key: privateKey,
+        padding: constants.RSA_PKCS1_OAEP_PADDING,
+        oaepHash: "sha256",
+      },
+      Buffer.from(b64Cipher, "base64"),
+    );
+
+    return decryptedBuffer.toString("hex");
+  } catch (error) {
+    throw new Error(`Decryption failed: ${String(error)}`);
+  }
+};
+
+/**
+ * Format a private key to a base58 string for easy import into Solana wallet apps.
+ *
+ * @param privateKey - The private key as a hex string
+ * @returns The formatted private key as a base58 string
+ */
+export const formatSolanaPrivateKey = (privateKey: string): string => {
+  const privateKeyBytes = Buffer.from(privateKey, "hex");
+  const keypair = Keypair.fromSeed(privateKeyBytes);
+  const fullKey = Buffer.concat([keypair.secretKey.subarray(0, 32), keypair.publicKey.toBytes()]);
+  return bs58.encode(fullKey);
+};

package/version.ts

@@ -1 +1 @@
-export const version = "1.13.0";
+export const version = "1.15.0";