@coinbase/cdp-sdk 1.20.0 → 1.22.0

package/accounts/evm/types.ts

@@ -1,7 +1,50 @@
+import {
+  ListTokenBalancesNetworks,
+  RequestFaucetNetworks,
+  QuoteFundNetworks,
+  FundNetworks,
+  TransferNetworks,
+  QuoteSwapNetworks,
+  SwapNetworks,
+} from "./networkCapabilities.js";
+import { FundOptions } from "../../actions/evm/fund/fund.js";
+import { Quote } from "../../actions/evm/fund/Quote.js";
+import { QuoteFundOptions } from "../../actions/evm/fund/quoteFund.js";
+import { FundOperationResult } from "../../actions/evm/fund/types.js";
+import {
+  WaitForFundOperationOptions,
+  WaitForFundOperationResult,
+} from "../../actions/evm/fund/waitForFundOperationReceipt.js";
+import {
+  ListTokenBalancesOptions,
+  ListTokenBalancesResult,
+} from "../../actions/evm/listTokenBalances.js";
 import { RequestFaucetOptions, RequestFaucetResult } from "../../actions/evm/requestFaucet.js";
 import { TransactionResult, SendTransactionOptions } from "../../actions/evm/sendTransaction.js";
-import { TransferOptions } from "../../actions/evm/transfer/types.js";
+import {
+  SendUserOperationOptions,
+  SendUserOperationReturnType,
+} from "../../actions/evm/sendUserOperation.js";
+import {
+  AccountQuoteSwapOptions,
+  AccountQuoteSwapResult,
+  AccountSwapOptions,
+  AccountSwapResult,
+  SmartAccountQuoteSwapOptions,
+  SmartAccountQuoteSwapResult,
+  SmartAccountSwapOptions,
+  SmartAccountSwapResult,
+} from "../../actions/evm/swap/types.js";
+import {
+  WaitForUserOperationOptions,
+  WaitForUserOperationReturnType,
+} from "../../actions/evm/waitForUserOperation.js";
+import { GetUserOperationOptions, UserOperation } from "../../client/evm/evm.types.js";
 
+import type {
+  SmartAccountTransferOptions,
+  TransferOptions,
+} from "../../actions/evm/transfer/types.js";
 import type { AccountActions, SmartAccountActions } from "../../actions/evm/types.js";
 import type { Address, Hash, Hex } from "../../types/misc.js";
 import type { Prettify } from "../../types/utils.js";
@@ -38,6 +81,27 @@ export type EvmAccount = {
   policies?: string[];
 };
 
+/**
+ * Known EVM networks supported by the SDK.
+ */
+export type KnownEvmNetworks =
+  | "base"
+  | "base-sepolia"
+  | "ethereum"
+  | "ethereum-sepolia"
+  | "ethereum-hoodi"
+  | "polygon"
+  | "polygon-mumbai"
+  | "arbitrum"
+  | "arbitrum-sepolia"
+  | "optimism"
+  | "optimism-sepolia";
+
+/**
+ * Network input that accepts known networks or RPC URLs
+ */
+export type NetworkOrRpcUrl = KnownEvmNetworks | (string & {});
+
 /**
  * Server-managed ethereum account
  */
@@ -48,8 +112,23 @@ export type EvmServerAccount = Prettify<
       name?: string;
       /** Indicates this is a server-managed account. */
       type: "evm-server";
-      /** A function that returns a network-scoped server-managed account. */
-      useNetwork: (network: string) => Promise<NetworkScopedEvmServerAccount>;
+      /**
+       * A function that returns a network-scoped server-managed account.
+       *
+       * @param network - The network name or RPC URL
+       * @example
+       * // For known networks, type is inferred automatically:
+       * const baseAccount = await account.useNetwork("base");
+       *
+       * // For custom RPC URLs with type hints (requires casting):
+       * const typedAccount = await account.useNetwork<"base">("https://mainnet.base.org" as "base");
+       *
+       * // For custom RPC URLs without type hints (only sendTransaction and waitForTransactionReceipt methods available):
+       * const customAccount = await account.useNetwork("https://mainnet.base.org");
+       */
+      useNetwork: <Network extends NetworkOrRpcUrl>(
+        network: Network,
+      ) => Promise<NetworkScopedEvmServerAccount<Network>>;
     }
 >;
 
@@ -62,8 +141,23 @@ type EvmSmartAccountProperties = {
   owners: EvmAccount[];
   /** Identifier for the smart account type. */
   type: "evm-smart";
-  /** Subject to breaking changes. A function that returns a network-scoped smart account. */
-  __experimental_useNetwork: (network: string) => Promise<NetworkScopedEvmSmartAccount>;
+  /**
+   * A function that returns a network-scoped smart account.
+   *
+   * @param network - The network name or RPC URL
+   * @example
+   * // For known networks, type is inferred automatically:
+   * const baseAccount = await smartAccount.useNetwork("base");
+   *
+   * // For custom RPC URLs with type hints (requires casting):
+   * const typedAccount = await smartAccount.useNetwork<"base">("https://mainnet.base.org" as "base");
+   *
+   * // For custom RPC URLs without type hints (only sendTransaction, transfer and waitForTransactionReceipt methods available):
+   * const customAccount = await smartAccount.useNetwork("https://mainnet.base.org");
+   */
+  useNetwork: <Network extends KnownEvmNetworks>(
+    network: Network,
+  ) => Promise<NetworkScopedEvmSmartAccount<Network>>;
 };
 
 /**
@@ -71,33 +165,167 @@ type EvmSmartAccountProperties = {
  */
 export type EvmSmartAccount = Prettify<EvmSmartAccountProperties & SmartAccountActions>;
 
-export type NetworkScopedEvmSmartAccount = Prettify<
-  Omit<EvmSmartAccountProperties, "__experimental_useNetwork"> & {
-    /** The network to scope the smart account object to. */
-    network: string;
-  }
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type DistributedOmit<T, K extends PropertyKey> = T extends any ? Omit<T, K> : never;
+
+/**
+ * Helper type for network-specific smart account actions
+ */
+type NetworkSpecificSmartAccountActions<Network extends string> = Prettify<
+  // Always include sendUserOperation, waitForUserOperation and getUserOperation
+  {
+    sendUserOperation: <const callData extends unknown[]>(
+      options: Omit<SendUserOperationOptions<callData>, "smartAccount" | "network">,
+    ) => Promise<SendUserOperationReturnType>;
+    waitForUserOperation: (
+      options: Omit<WaitForUserOperationOptions, "smartAccountAddress" | "network">,
+    ) => Promise<WaitForUserOperationReturnType>;
+    getUserOperation: (
+      options: Omit<GetUserOperationOptions, "smartAccount" | "network">,
+    ) => Promise<UserOperation>;
+  } & (Network extends TransferNetworks
+    ? {
+        transfer: (
+          options: Omit<SmartAccountTransferOptions, "network">,
+        ) => Promise<SendUserOperationReturnType>;
+      }
+    : EmptyObject) &
+    // Conditionally include listTokenBalances
+    (Network extends ListTokenBalancesNetworks
+      ? {
+          listTokenBalances: (
+            options: Omit<ListTokenBalancesOptions, "address" | "network">,
+          ) => Promise<ListTokenBalancesResult>;
+        }
+      : EmptyObject) &
+    // Conditionally include requestFaucet
+    (Network extends RequestFaucetNetworks
+      ? {
+          requestFaucet: (
+            options: Omit<RequestFaucetOptions, "address" | "network">,
+          ) => Promise<RequestFaucetResult>;
+        }
+      : EmptyObject) &
+    // Conditionally include quoteFund
+    (Network extends QuoteFundNetworks
+      ? {
+          quoteFund: (options: Omit<QuoteFundOptions, "address" | "network">) => Promise<Quote>;
+        }
+      : EmptyObject) &
+    // Conditionally include fund
+    (Network extends FundNetworks
+      ? {
+          fund: (options: Omit<FundOptions, "address" | "network">) => Promise<FundOperationResult>;
+          waitForFundOperationReceipt: (
+            options: Omit<WaitForFundOperationOptions, "network">,
+          ) => Promise<WaitForFundOperationResult>;
+        }
+      : EmptyObject) &
+    // Conditionally include quoteSwap
+    (Network extends QuoteSwapNetworks
+      ? {
+          quoteSwap: (
+            options: Omit<SmartAccountQuoteSwapOptions, "network">,
+          ) => Promise<SmartAccountQuoteSwapResult>;
+        }
+      : EmptyObject) &
+    // Conditionally include swap
+    (Network extends SwapNetworks
+      ? {
+          swap: (
+            options: DistributedOmit<SmartAccountSwapOptions, "network">,
+          ) => Promise<SmartAccountSwapResult>;
+        }
+      : EmptyObject)
+>;
+
+/**
+ * A network-scoped smart account
+ */
+export type NetworkScopedEvmSmartAccount<Network extends string = string> = Prettify<
+  Omit<EvmSmartAccountProperties, "useNetwork"> &
+    NetworkSpecificSmartAccountActions<Network> & {
+      /** The network this account is scoped to */
+      network: Network;
+    }
 >;
 
-type NetworkScopedAccountActions = Prettify<{
-  requestFaucet: (
-    options: Omit<RequestFaucetOptions, "address" | "network">,
-  ) => Promise<RequestFaucetResult>;
-  sendTransaction: (
-    options: Omit<SendTransactionOptions, "address" | "network">,
-  ) => Promise<TransactionResult>;
-  waitForTransactionReceipt: (
-    options: WaitForTransactionReceiptParameters | TransactionResult,
-  ) => Promise<TransactionReceipt>;
-  transfer: (options: Omit<TransferOptions, "address" | "network">) => Promise<TransactionResult>;
-}>;
+/**
+ * Helper type to surface a TypeError when calling a method that doesn't exist based on the network
+ */
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+type EmptyObject = {};
+
+/**
+ * Conditional account actions based on network
+ */
+type NetworkSpecificAccountActions<Network extends string> = Prettify<
+  // Always include sendTransaction, transfer and waitForTransactionReceipt
+  {
+    sendTransaction: (
+      options: Omit<SendTransactionOptions, "address" | "network">,
+    ) => Promise<TransactionResult>;
+    transfer: (options: Omit<TransferOptions, "address" | "network">) => Promise<TransactionResult>;
+    waitForTransactionReceipt: (
+      options: WaitForTransactionReceiptParameters | TransactionResult,
+    ) => Promise<TransactionReceipt>;
+  } & (Network extends ListTokenBalancesNetworks // Conditionally include listTokenBalances
+    ? {
+        listTokenBalances: (
+          options: Omit<ListTokenBalancesOptions, "address" | "network">,
+        ) => Promise<ListTokenBalancesResult>;
+      }
+    : EmptyObject) &
+    // Conditionally include requestFaucet
+    (Network extends RequestFaucetNetworks
+      ? {
+          requestFaucet: (
+            options: Omit<RequestFaucetOptions, "address" | "network">,
+          ) => Promise<RequestFaucetResult>;
+        }
+      : EmptyObject) &
+    // Conditionally include quoteFund
+    (Network extends QuoteFundNetworks
+      ? {
+          quoteFund: (options: Omit<QuoteFundOptions, "address">) => Promise<Quote>;
+        }
+      : EmptyObject) &
+    // Conditionally include fund
+    (Network extends FundNetworks
+      ? {
+          fund: (options: Omit<FundOptions, "address">) => Promise<FundOperationResult>;
+          waitForFundOperationReceipt: (
+            options: WaitForFundOperationOptions,
+          ) => Promise<WaitForFundOperationResult>;
+        }
+      : EmptyObject) &
+    // Conditionally include transfer
+    (Network extends TransferNetworks
+      ? {
+          transfer: (options: TransferOptions) => Promise<{ transactionHash: Hex }>;
+        }
+      : EmptyObject) &
+    // Conditionally include quoteSwap
+    (Network extends QuoteSwapNetworks
+      ? {
+          quoteSwap: (options: AccountQuoteSwapOptions) => Promise<AccountQuoteSwapResult>;
+        }
+      : EmptyObject) &
+    // Conditionally include swap
+    (Network extends SwapNetworks
+      ? {
+          swap: (options: AccountSwapOptions) => Promise<AccountSwapResult>;
+        }
+      : EmptyObject)
+>;
 
 /**
  * A network-scoped server-managed ethereum account
  */
-export type NetworkScopedEvmServerAccount = Prettify<
+export type NetworkScopedEvmServerAccount<Network extends string = string> = Prettify<
   Omit<EvmServerAccount, keyof AccountActions | "useNetwork"> &
-    NetworkScopedAccountActions & {
+    NetworkSpecificAccountActions<Network> & {
       /** The network this account is scoped to */
-      network: string;
+      network: Network;
     }
 >;

package/actions/evm/fund/fund.ts

@@ -14,7 +14,7 @@ export interface FundOptions {
   /** The address of the account. */
   address: string;
   /** The network to request funds from. */
-  network: "base";
+  network: "base" | "ethereum";
   /** The amount to fund the account with, in atomic units (wei) of the token. */
   amount: bigint;
   /** The token to request funds for. */

package/actions/evm/fund/quoteFund.ts

@@ -14,7 +14,7 @@ export interface QuoteFundOptions {
   /** The address of the account. */
   address: string;
   /** The network to request funds from. */
-  network: "base";
+  network: "base" | "ethereum";
   /** The amount to fund the account with, in atomic units (wei) of the token. */
   amount: bigint;
   /** The token to request funds for. */

package/actions/evm/sendUserOperation.ts

@@ -1,5 +1,6 @@
 import { encodeFunctionData } from "viem";
 
+import { getBaseNodeRpcUrl } from "../../accounts/evm/getBaseNodeRpcUrl.js";
 import {
   EvmUserOperationNetwork,
   EvmUserOperationStatus,
@@ -106,7 +107,14 @@ export async function sendUserOperation<T extends readonly unknown[]>(
   client: CdpOpenApiClientType,
   options: SendUserOperationOptions<T>,
 ): Promise<SendUserOperationReturnType> {
-  const { calls, network, paymasterUrl } = options;
+  const { calls, network, paymasterUrl: _paymasterUrl } = options;
+
+  const paymasterUrl = await (async () => {
+    if (!_paymasterUrl && network === "base") {
+      return getBaseNodeRpcUrl("base");
+    }
+    return _paymasterUrl;
+  })();
 
   if (calls.length === 0) {
     throw new Error("Calls array is empty");

package/actions/evm/transfer/transferWithViem.ts

@@ -1,6 +1,7 @@
 import { encodeFunctionData, erc20Abi } from "viem";
 
 import { getErc20Address } from "./utils.js";
+import { mapChainToNetwork } from "../../../accounts/evm/chainToNetworkMapper.js";
 
 import type { Network, TransferOptions } from "./types.js";
 import type { EvmAccount } from "../../../accounts/evm/types.js";
@@ -21,12 +22,11 @@ import type { Account, Chain, Transport, WalletClient } from "viem";
 export async function transferWithViem<T extends EvmAccount>(
   walletClient: WalletClient<Transport, Chain, Account>,
   from: T,
-  transferArgs: TransferOptions,
+  transferArgs: Omit<TransferOptions, "address" | "network">,
 ): Promise<TransactionResult> {
   const token = transferArgs.token;
   const to = typeof transferArgs.to === "string" ? transferArgs.to : transferArgs.to.address;
   const value = transferArgs.amount;
-  const network = transferArgs.network;
 
   if (token === "eth") {
     const hash = await walletClient.sendTransaction({
@@ -37,7 +37,8 @@ export async function transferWithViem<T extends EvmAccount>(
     return { transactionHash: hash as Hex };
   }
 
-  const erc20Address = getErc20Address(token, network as Network);
+  const network = mapChainToNetwork(walletClient.chain) as Network;
+  const erc20Address = getErc20Address(token, network);
 
   // First approve the transfer
   await walletClient.sendTransaction({

package/auth/utils/hash.ts

@@ -0,0 +1,13 @@
+import { subtle } from "uncrypto";
+
+/**
+ * Auth-specific hash function using uncrypto for Edge runtime compatibility.
+ * Computes SHA-256 hash of the given data.
+ *
+ * @param data - The data to hash
+ * @returns Promise that resolves to the hex-encoded hash
+ */
+export const authHash = async (data: Buffer): Promise<string> => {
+  const hashBuffer = await subtle.digest("SHA-256", data);
+  return Buffer.from(hashBuffer).toString("hex");
+};

package/auth/utils/jwt.ts

@@ -1,9 +1,7 @@
-import * as crypto from "crypto";
-import { createPrivateKey } from "crypto";
-
 import { SignJWT, importPKCS8, importJWK, JWTPayload } from "jose";
+import { getRandomValues } from "uncrypto";
 
-import { hash } from "../../utils/hash.js";
+import { authHash } from "./hash.js";
 import { sortKeys } from "../../utils/sortKeys.js";
 import { InvalidWalletSecretFormatError, UndefinedWalletSecretError } from "../errors.js";
 
@@ -147,7 +145,7 @@ export async function generateJwt(options: JwtOptions): Promise<string> {
   const randomNonce = nonce();
 
   // Determine if we're using EC or Edwards key based on the key format
-  if (isValidECKey(options.apiKeySecret)) {
+  if (await isValidECKey(options.apiKeySecret)) {
     return await buildECJWT(
       options.apiKeySecret,
       options.apiKeyId,
@@ -193,16 +191,18 @@ export async function generateWalletJwt(options: WalletJwtOptions): Promise<stri
 
   if (Object.keys(options.requestData).length > 0) {
     const sortedData = sortKeys(options.requestData);
-    claims.reqHash = hash(Buffer.from(JSON.stringify(sortedData)));
+    claims.reqHash = await authHash(Buffer.from(JSON.stringify(sortedData)));
   }
 
   try {
-    const ecKey = createPrivateKey({
-      key: options.walletSecret,
-      format: "der",
-      type: "pkcs8",
-      encoding: "base64",
-    });
+    // Convert base64 DER to PEM format for jose
+    const derBuffer = Buffer.from(options.walletSecret, "base64");
+    const pemKey = `-----BEGIN PRIVATE KEY-----\n${derBuffer
+      .toString("base64")
+      .match(/.{1,64}/g)
+      ?.join("\n")}\n-----END PRIVATE KEY-----`;
+
+    const ecKey = await importPKCS8(pemKey, "ES256");
 
     return await new SignJWT(claims)
       .setProtectedHeader({ alg: "ES256", typ: "JWT" })
@@ -236,12 +236,11 @@ function isValidEd25519Key(str: string): boolean {
  * @param str - The string to test
  * @returns True if the string is a valid EC private key in PEM format
  */
-function isValidECKey(str: string): boolean {
+async function isValidECKey(str: string): Promise<boolean> {
   try {
-    // Attempt to create a private key object - will throw if invalid
-    const key = createPrivateKey(str);
-    // Check if it's an EC key by examining its asymmetric key type
-    return key.asymmetricKeyType === "ec";
+    // Try to import the key with jose - if it works, it's a valid EC key
+    await importPKCS8(str, "ES256");
+    return true;
   } catch {
     return false;
   }
@@ -268,12 +267,8 @@ async function buildECJWT(
   nonce: string,
 ): Promise<string> {
   try {
-    // Convert to PKCS8 format
-    const keyObj = createPrivateKey(privateKey);
-    const pkcs8Key = keyObj.export({ type: "pkcs8", format: "pem" }).toString();
-
-    // Import the key for signing
-    const ecKey = await importPKCS8(pkcs8Key, "ES256");
+    // Import the key directly with jose
+    const ecKey = await importPKCS8(privateKey, "ES256");
 
     // Sign and return the JWT
     return await new SignJWT(claims)
@@ -346,5 +341,7 @@ async function buildEdwardsJWT(
  * @returns {string} The generated nonce.
  */
 function nonce(): string {
-  return crypto.randomBytes(16).toString("hex");
+  const bytes = new Uint8Array(16);
+  getRandomValues(bytes);
+  return Buffer.from(bytes).toString("hex");
 }

package/client/cdp.ts

@@ -67,6 +67,15 @@ export class CdpClient {
    * @param {CdpClientOptions} [options] - Configuration options for the CdpClient.
    */
   constructor(options: CdpClientOptions = {}) {
+    if (Number(process.versions.node.split(".")[0]) < 19) {
+      throw new Error(
+        `
+Node.js version ${process.versions.node} is not supported. CDP SDK requires Node.js version 19 or higher. Please upgrade your Node.js version to use the CDP SDK.
+We recommend using https://github.com/Schniz/fnm for managing your Node.js version.
+        `,
+      );
+    }
+
     const apiKeyId = options.apiKeyId ?? process.env.CDP_API_KEY_ID ?? process.env.CDP_API_KEY_NAME;
     const apiKeySecret = options.apiKeySecret ?? process.env.CDP_API_KEY_SECRET;
     const walletSecret = options.walletSecret ?? process.env.CDP_WALLET_SECRET;

package/client/evm/evm.ts

@@ -2,7 +2,6 @@ import { constants, publicEncrypt } from "crypto";
 
 import { type Address, getTypesForEIP712Domain } from "viem";
 
-import { ImportEvmAccountPublicRSAKey } from "./constants.js";
 import {
   CreateServerAccountOptions,
   CreateSmartAccountOptions,
@@ -61,6 +60,7 @@ import {
   WaitForUserOperationReturnType,
 } from "../../actions/evm/waitForUserOperation.js";
 import { Analytics } from "../../analytics.js";
+import { ImportAccountPublicRSAKey } from "../../constants.js";
 import { APIError } from "../../openapi-client/errors.js";
 import {
   CdpOpenApiClient,
@@ -173,7 +173,7 @@ export class EvmClient implements EvmClientInterface {
    *          ```
    */
   async importAccount(options: ImportServerAccountOptions): Promise<ServerAccount> {
-    const encryptionPublicKey = options.encryptionPublicKey || ImportEvmAccountPublicRSAKey;
+    const encryptionPublicKey = options.encryptionPublicKey || ImportAccountPublicRSAKey;
 
     const privateKeyHex = options.privateKey.startsWith("0x")
       ? options.privateKey.slice(2)

package/client/evm/evm.types.ts

@@ -405,7 +405,7 @@ export interface ListServerAccountsOptions {
  * A smart account that only contains the owner address.
  */
 export interface ReadonlySmartAccount
-  extends Omit<SmartAccount, "owners" | keyof SmartAccountActions | "__experimental_useNetwork"> {
+  extends Omit<SmartAccount, "owners" | keyof SmartAccountActions | "useNetwork"> {
   /** The owners of the smart account. */
   owners: Address[];
 }

package/client/solana/solana.ts

@@ -1,8 +1,13 @@
+import { constants, publicEncrypt } from "crypto";
+
+import bs58 from "bs58";
+
 import {
   CreateAccountOptions,
   ExportAccountOptions,
   GetAccountOptions,
   GetOrCreateAccountOptions,
+  ImportAccountOptions,
   ListAccountsOptions,
   ListAccountsResult,
   RequestFaucetOptions,
@@ -18,6 +23,7 @@ import { requestFaucet } from "../../actions/solana/requestFaucet.js";
 import { signMessage } from "../../actions/solana/signMessage.js";
 import { signTransaction } from "../../actions/solana/signTransaction.js";
 import { Analytics } from "../../analytics.js";
+import { ImportAccountPublicRSAKey } from "../../constants.js";
 import { APIError } from "../../openapi-client/errors.js";
 import { CdpOpenApiClient } from "../../openapi-client/index.js";
 import {
@@ -133,6 +139,89 @@ export class SolanaClient implements SolanaClientInterface {
     return formatSolanaPrivateKey(decryptedPrivateKey);
   }
 
+  /**
+   * Imports a Solana account using a private key.
+   * The private key will be encrypted before being stored securely.
+   *
+   * @param {ImportAccountOptions} options - Parameters for importing the Solana account.
+   * @param {string} options.privateKey - The private key to import (32 or 64 bytes). Can be a base58 encoded string or raw bytes.
+   * @param {string} [options.name] - The name of the account.
+   * @param {string} [options.encryptionPublicKey] - The RSA public key for encrypting the private key.
+   * @param {string} [options.idempotencyKey] - An idempotency key.
+   *
+   * @returns A promise that resolves to the imported account.
+   *
+   * @example **Import with private key only**
+   *          ```ts
+   *          const account = await cdp.solana.importAccount({
+   *            privateKey: "3Kzjw8qSxx8bQkV7EHrVFWYiPyNLbBVxtVe1Q5h2zKZY8DdcuT2dKxyz9kU5vQrP",
+   *          });
+   *          ```
+   *
+   * @example **Import with name**
+   *          ```ts
+   *          const account = await cdp.solana.importAccount({
+   *            privateKey: "3Kzjw8qSxx8bQkV7EHrVFWYiPyNLbBVxtVe1Q5h2zKZY8DdcuT2dKxyz9kU5vQrP",
+   *            name: "ImportedAccount",
+   *          });
+   *          ```
+   *
+   * @example **Import with idempotency key**
+   *          ```ts
+   *          const idempotencyKey = uuidv4();
+   *
+   *          const account = await cdp.solana.importAccount({
+   *            privateKey: "3Kzjw8qSxx8bQkV7EHrVFWYiPyNLbBVxtVe1Q5h2zKZY8DdcuT2dKxyz9kU5vQrP",
+   *            name: "ImportedAccount",
+   *            idempotencyKey,
+   *          });
+   *          ```
+   */
+  async importAccount(options: ImportAccountOptions): Promise<SolanaAccount> {
+    let privateKeyBytes: Uint8Array = new Uint8Array();
+
+    if (typeof options.privateKey === "string") {
+      privateKeyBytes = bs58.decode(options.privateKey);
+    } else {
+      privateKeyBytes = options.privateKey;
+    }
+
+    if (privateKeyBytes.length !== 32 && privateKeyBytes.length !== 64) {
+      throw new Error("Invalid private key length");
+    }
+
+    if (privateKeyBytes.length === 64) {
+      privateKeyBytes = privateKeyBytes.subarray(0, 32);
+    }
+
+    const encryptionPublicKey = options.encryptionPublicKey || ImportAccountPublicRSAKey;
+
+    const encryptedPrivateKey = publicEncrypt(
+      {
+        key: encryptionPublicKey,
+        padding: constants.RSA_PKCS1_OAEP_PADDING,
+        oaepHash: "sha256",
+      },
+      privateKeyBytes,
+    );
+
+    const openApiAccount = await CdpOpenApiClient.importSolanaAccount(
+      {
+        encryptedPrivateKey: encryptedPrivateKey.toString("base64"),
+        name: options.name,
+      },
+      options.idempotencyKey,
+    );
+
+    const account = toSolanaAccount(CdpOpenApiClient, {
+      account: openApiAccount,
+    });
+
+    Analytics.wrapObjectMethodsWithErrorTracking(account);
+
+    return account;
+  }
+
   /**
    * Gets a Solana account by its address.
    *