@coinbase/cdp-sdk 1.13.0 → 1.14.0

package/actions/evm/listTokenBalances.ts

@@ -32,7 +32,7 @@ export interface EvmTokenAmount {
   /** The amount of the token in the smallest indivisible unit of the token. */
   amount: bigint;
   /** The number of decimals in the token. */
-  decimals: bigint;
+  decimals: number;
 }
 /**
  * An EVM token balance.
@@ -95,7 +95,7 @@ export async function listTokenBalances(
       },
       amount: {
         amount: BigInt(balance.amount.amount),
-        decimals: BigInt(balance.amount.decimals),
+        decimals: balance.amount.decimals,
       },
     };
   });

package/analytics.ts

@@ -1,6 +1,6 @@
 import md5 from "md5";
 
-import { APIError } from "./openapi-client/errors.js";
+import { APIError, HttpErrorType } from "./openapi-client/errors.js";
 import { version } from "./version.js";
 
 /**
@@ -184,7 +184,7 @@ function shouldTrackError(error: unknown): boolean {
     return false;
   }
 
-  if (error instanceof APIError) {
+  if (error instanceof APIError && error.errorType !== HttpErrorType.unexpected_error) {
     return false;
   }
 

package/client/evm/evm.ts

@@ -32,6 +32,7 @@ import {
   GetSwapPriceResult,
   CreateSwapQuoteResult,
   SwapUnavailableResult,
+  GetOrCreateSmartAccountOptions,
 } from "./evm.types.js";
 import { toEvmServerAccount } from "../../accounts/evm/toEvmServerAccount.js";
 import { toEvmSmartAccount } from "../../accounts/evm/toEvmSmartAccount.js";
@@ -261,6 +262,7 @@ export class EvmClient implements EvmClientInterface {
     const openApiSmartAccount = await CdpOpenApiClient.createEvmSmartAccount(
       {
         owners: [options.owner.address],
+        name: options.name,
       },
       options.idempotencyKey,
     );
@@ -326,7 +328,10 @@ export class EvmClient implements EvmClientInterface {
    * Gets a CDP EVM smart account.
    *
    * @param {GetSmartAccountOptions} options - Parameters for getting the smart account.
-   * @param {string} options.address - The address of the smart account to get.
+   * Either `address` or `name` must be provided.
+   * If both are provided, lookup will be done by `address` and `name` will be ignored.
+   * @param {string} [options.address] - The address of the smart account to get.
+   * @param {string} [options.name] - The name of the smart account to get.
    * @param {Account} options.owner - The owner of the smart account.
    * You must pass the signing-capable owner of the smart account so that the returned smart account
    * can be functional.
@@ -342,7 +347,14 @@ export class EvmClient implements EvmClientInterface {
    * ```
    */
   async getSmartAccount(options: GetSmartAccountOptions): Promise<SmartAccount> {
-    const openApiSmartAccount = await CdpOpenApiClient.getEvmSmartAccount(options.address);
+    const openApiSmartAccount = await (async () => {
+      if (options.address) {
+        return CdpOpenApiClient.getEvmSmartAccount(options.address);
+      } else if (options.name) {
+        return CdpOpenApiClient.getEvmSmartAccountByName(options.name);
+      }
+      throw new Error("Either address or name must be provided");
+    })();
 
     const smartAccount = toEvmSmartAccount(CdpOpenApiClient, {
       smartAccount: openApiSmartAccount,
@@ -395,6 +407,51 @@ export class EvmClient implements EvmClientInterface {
     }
   }
 
+  /**
+   * Gets a CDP EVM smart account, or creates one if it doesn't exist.
+   * This method first attempts to retrieve an existing smart account with the given parameters.
+   * If no account exists, it creates a new one with the specified owner.
+   *
+   * @param {GetOrCreateSmartAccountOptions} options - Configuration options for getting or creating the smart account.
+   * @param {string} [options.name] - The name of the smart account to get or create.
+   * @param {Account} options.owner - The owner of the smart account.
+   *
+   * @returns {Promise<SmartAccount>} A promise that resolves to the retrieved or newly created smart account.
+   *
+   * @example
+   * ```ts
+   * const smartAccount = await cdp.evm.getOrCreateSmartAccount({
+   *   name: "MySmartAccount",
+   *   owner: account,
+   * });
+   * ```
+   */
+  async getOrCreateSmartAccount(options: GetOrCreateSmartAccountOptions): Promise<SmartAccount> {
+    try {
+      const account = await this.getSmartAccount(options);
+      return account;
+    } catch (error) {
+      // If it failed because the account doesn't exist, create it
+      const doesAccountNotExist = error instanceof APIError && error.statusCode === 404;
+      if (doesAccountNotExist) {
+        try {
+          const account = await this.createSmartAccount(options);
+          return account;
+        } catch (error) {
+          // If it failed because the account already exists, throw an error
+          const doesAccountAlreadyExist = error instanceof APIError && error.statusCode === 409;
+          if (doesAccountAlreadyExist) {
+            const account = await this.getSmartAccount(options);
+            return account;
+          }
+          throw error;
+        }
+      }
+
+      throw error;
+    }
+  }
+
   /**
    * Gets the price for a swap between two tokens on an EVM network.
    *

package/client/evm/evm.types.ts

@@ -39,6 +39,7 @@ export type EvmClientInterface = Omit<
   | "getEvmAccount" // mapped to getAccount
   | "getEvmAccountByName" // mapped to getAccount
   | "getEvmSmartAccount" // mapped to getSmartAccount
+  | "getEvmSmartAccountByName" // mapped to getSmartAccount
   | "getEvmSwapPrice" // mapped to getSwapPrice
   | "createEvmSwapQuote" // mapped to createSwapQuote
   | "getUserOperation"
@@ -56,6 +57,8 @@ export type EvmClientInterface = Omit<
   | "sendEvmTransaction" // mapped to sendTransaction
   | "signEvmTypedData" // mapped to signTypedData
   | "updateEvmAccount" // mapped to updateAccount
+  | "exportEvmAccount"
+  | "exportEvmAccountByName"
 > & {
   createAccount: (options: CreateServerAccountOptions) => Promise<ServerAccount>;
   createSmartAccount: (options: CreateSmartAccountOptions) => Promise<SmartAccount>;
@@ -336,9 +339,11 @@ export interface GetServerAccountOptions {
  */
 export interface GetSmartAccountOptions {
   /** The address of the account. */
-  address: Address;
+  address?: Address;
   /** The owner of the account. */
   owner: Account;
+  /** The name of the account. */
+  name?: string;
 }
 
 /**
@@ -349,6 +354,16 @@ export interface GetOrCreateServerAccountOptions {
   name: string;
 }
 
+/**
+ * Options for getting an EVM account, or creating one if it doesn't exist.
+ */
+export interface GetOrCreateSmartAccountOptions {
+  /** The name of the account. */
+  name: string;
+  /** The owner of the account. */
+  owner: Account;
+}
+
 /**
  * Options for listing EVM accounts.
  */
@@ -426,6 +441,8 @@ export interface CreateSmartAccountOptions {
   owner: Account;
   /** The idempotency key. */
   idempotencyKey?: string;
+  /** The name of the account. */
+  name?: string;
 }
 
 /**

package/client/solana/solana.types.ts

@@ -15,6 +15,8 @@ export type SolanaClientInterface = Omit<
   | "signSolanaMessage" // mapped to signMessage
   | "signSolanaTransaction" // mapped to signTransaction
   | "updateSolanaAccount" // mapped to updateAccount
+  | "exportSolanaAccount"
+  | "exportSolanaAccountByName"
 > & {
   createAccount: (options: CreateAccountOptions) => Promise<Account>;
   getAccount: (options: GetAccountOptions) => Promise<Account>;

package/openapi-client/cdpApiClient.ts

@@ -180,15 +180,30 @@ export const cdpApiClient = async <T>(
               `${ERROR_DOCS_PAGE_URL}`,
               error.cause,
             );
-          default:
+          default: {
+            let errorText = "";
+
+            if (error.response.data) {
+              try {
+                errorText = JSON.stringify(error.response.data);
+              } catch {
+                errorText = String(error.response.data);
+              }
+            }
+
+            const errorMessage = errorText
+              ? `An unexpected error occurred: ${errorText}`
+              : "An unexpected error occurred.";
+
             throw new APIError(
               statusCode,
               HttpErrorType.unexpected_error,
-              "An unexpected error occurred.",
+              errorMessage,
               undefined,
               `${ERROR_DOCS_PAGE_URL}`,
               error.cause,
             );
+          }
         }
       }
     }

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

@@ -1258,8 +1258,8 @@ Account names must be unique across all EVM accounts in the developer's CDP Proj
    */
   name?: string;
   /**
-   * The ID of the account-level policy to apply to the account.
-   * @pattern ^[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}$
+   * The ID of the account-level policy to apply to the account, or an empty string to unset attached policy.
+   * @pattern (^[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}$)|(^$)
    */
   accountPolicy?: string;
 };
@@ -1344,6 +1344,13 @@ export type ListEvmSmartAccounts200 = ListEvmSmartAccounts200AllOf & ListRespons
 export type CreateEvmSmartAccountBody = {
   /** Today, only a single owner can be set for a Smart Account, but this is an array to allow setting multiple owners in the future. */
   owners: 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;
 };
 
 export type ImportEvmAccountBody = {
@@ -1358,6 +1365,26 @@ Account names must be unique across all EVM accounts in the developer's CDP Proj
   name?: string;
 };
 
+export type ExportEvmAccountBody = {
+  /** The base64-encoded, public part of the RSA key in DER format used to encrypt the account private key. */
+  exportEncryptionKey: string;
+};
+
+export type ExportEvmAccount200 = {
+  /** The base64-encoded, encrypted private key of the EVM account which is a 32 byte raw private key. The private key is encrypted in transport using the exportEncryptionKey in the request. */
+  encryptedPrivateKey: string;
+};
+
+export type ExportEvmAccountByNameBody = {
+  /** The base64-encoded, public part of the RSA key in DER format used to encrypt the account private key. */
+  exportEncryptionKey: string;
+};
+
+export type ExportEvmAccountByName200 = {
+  /** The base64-encoded, encrypted private key of the EVM account which is a 32 byte raw private key. The private key is encrypted in transport using the exportEncryptionKey in the request. */
+  encryptedPrivateKey: string;
+};
+
 /**
  * The network to prepare the user operation for.
  */
@@ -1463,6 +1490,7 @@ export type RequestEvmFaucetBodyNetwork =
 export const RequestEvmFaucetBodyNetwork = {
   "base-sepolia": "base-sepolia",
   "ethereum-sepolia": "ethereum-sepolia",
+  "ethereum-hoodi": "ethereum-hoodi",
 } as const;
 
 /**
@@ -1604,12 +1632,32 @@ Account names must be unique across all Solana accounts in the developer's CDP P
    */
   name?: string;
   /**
-   * The ID of the account-level policy to apply to the account.
-   * @pattern ^[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}$
+   * The ID of the account-level policy to apply to the account, or an empty string to unset attached policy.
+   * @pattern (^[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}$)|(^$)
    */
   accountPolicy?: string;
 };
 
+export type ExportSolanaAccountBody = {
+  /** The base64-encoded, public part of the RSA key in DER format used to encrypt the account private key. */
+  exportEncryptionKey: string;
+};
+
+export type ExportSolanaAccount200 = {
+  /** The base64-encoded, encrypted private key of the Solana account which is a 32 byte raw private key. The private key is encrypted in transport using the exportEncryptionKey in the request. */
+  encryptedPrivateKey: string;
+};
+
+export type ExportSolanaAccountByNameBody = {
+  /** The base64-encoded, public part of the RSA key in DER format used to encrypt the account private key. */
+  exportEncryptionKey: string;
+};
+
+export type ExportSolanaAccountByName200 = {
+  /** The base64-encoded, encrypted private key of the Solana account which is a 32 byte raw private key. The private key is encrypted in transport using the exportEncryptionKey in the request. */
+  encryptedPrivateKey: string;
+};
+
 export type SignSolanaTransactionBody = {
   /** The base64 encoded transaction to sign. */
   transaction: string;

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(),
 ];