@coinbase/cdp-sdk 1.19.0 → 1.21.0

package/accounts/evm/types.ts

@@ -1,6 +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 {
+  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";
@@ -37,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
  */
@@ -47,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>>;
     }
 >;
 
@@ -61,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>>;
 };
 
 /**
@@ -70,32 +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>;
-}>;
+/**
+ * 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/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/swap/types.ts

@@ -8,9 +8,13 @@ import type {
   SendEvmTransactionBodyNetwork,
   EvmUserOperationNetwork,
   EvmUserOperationStatus,
+  EvmSwapsNetwork,
 } from "../../../openapi-client/index.js";
 import type { Address, Hex } from "../../../types/misc.js";
 
+// Type representing networks that support both user operations and swaps.
+export type SmartAccountSwapNetwork = Extract<EvmSwapsNetwork, EvmUserOperationNetwork>;
+
 /**
  * Base options for sending a swap transaction.
  */
@@ -144,7 +148,10 @@ export type AccountSwapResult = SendSwapTransactionResult;
 /**
  * Options for creating a swap quote (smart account-level).
  */
-export type SmartAccountQuoteSwapOptions = Omit<CreateSwapQuoteOptions, "taker">;
+export type SmartAccountQuoteSwapOptions = Omit<CreateSwapQuoteOptions, "taker" | "network"> & {
+  /** The network to create a swap quote on. Smart accounts only support networks that support both user operations and swaps. */
+  network: SmartAccountSwapNetwork;
+};
 
 /**
  * Result of creating a swap quote (smart account-level).
@@ -176,9 +183,10 @@ interface SmartAccountQuoteBasedSwapOptions {
  */
 interface SmartAccountInlineSwapOptions {
   /**
-   * The network to execute the swap on (e.g., "ethereum", "base").
+   * The network to execute the swap on (e.g., "base").
+   * Smart accounts only support networks that support both user operations and swaps.
    */
-  network: SendEvmTransactionBodyNetwork;
+  network: SmartAccountSwapNetwork;
   /** The token to receive (destination token). */
   toToken: Address;
   /** The token to send (source token). */

package/actions/evm/transfer/smartAccountTransferStrategy.ts

@@ -5,14 +5,17 @@ import { sendUserOperation } from "../sendUserOperation.js";
 
 import type { TransferExecutionStrategy } from "./types.js";
 import type { EvmSmartAccount } from "../../../accounts/evm/types.js";
+import type { EvmUserOperationNetwork } from "../../../openapi-client/index.js";
 
 export const smartAccountTransferStrategy: TransferExecutionStrategy<EvmSmartAccount> = {
   executeTransfer: async ({ apiClient, from, to, value, token, network, paymasterUrl }) => {
+    const smartAccountNetwork = network as EvmUserOperationNetwork;
+
     if (token === "eth") {
       const result = await sendUserOperation(apiClient, {
         smartAccount: from,
         paymasterUrl,
-        network,
+        network: smartAccountNetwork,
         calls: [
           {
             to,
@@ -28,7 +31,7 @@ export const smartAccountTransferStrategy: TransferExecutionStrategy<EvmSmartAcc
       const result = await sendUserOperation(apiClient, {
         smartAccount: from,
         paymasterUrl,
-        network,
+        network: smartAccountNetwork,
         calls: [
           {
             to: erc20Address,

package/actions/evm/transfer/transfer.ts

@@ -1,3 +1,5 @@
+import { isValidNetworkForAccount } from "./types.js";
+
 import type {
   TransferExecutionStrategy,
   SmartAccountTransferOptions,
@@ -24,6 +26,12 @@ export async function transfer<T extends EvmAccount | EvmSmartAccount>(
   transferArgs: T extends EvmSmartAccount ? SmartAccountTransferOptions : TransferOptions,
   transferStrategy: TransferExecutionStrategy<T>,
 ): Promise<T extends EvmSmartAccount ? SendUserOperationReturnType : TransactionResult> {
+  if (!isValidNetworkForAccount(transferArgs.network, from)) {
+    throw new Error(
+      `Network "${transferArgs.network}" is not supported for the given account type.`,
+    );
+  }
+
   const to =
     typeof transferArgs.to === "string" ? transferArgs.to : (transferArgs.to.address as Address);
 

package/actions/evm/transfer/transferWithViem.ts

@@ -0,0 +1,66 @@
+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";
+import type { Hex } from "../../../types/misc.js";
+import type { TransactionResult } from "../sendTransaction.js";
+import type { Account, Chain, Transport, WalletClient } from "viem";
+
+/**
+ * Transfer an amount of a token from a network-scoped account to another account.
+ * This function is used for accounts that are scoped to a specific network and use
+ * a wallet client for transaction execution instead of the API client.
+ *
+ * @param walletClient - The wallet client to use for transaction execution.
+ * @param from - The account to send the transaction from.
+ * @param transferArgs - The transfer options.
+ * @returns The result of the transfer.
+ */
+export async function transferWithViem<T extends EvmAccount>(
+  walletClient: WalletClient<Transport, Chain, Account>,
+  from: T,
+  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;
+
+  if (token === "eth") {
+    const hash = await walletClient.sendTransaction({
+      account: from.address,
+      to,
+      value,
+    });
+    return { transactionHash: hash as Hex };
+  }
+
+  const network = mapChainToNetwork(walletClient.chain) as Network;
+  const erc20Address = getErc20Address(token, network);
+
+  // First approve the transfer
+  await walletClient.sendTransaction({
+    account: from.address,
+    to: erc20Address,
+    data: encodeFunctionData({
+      abi: erc20Abi,
+      functionName: "approve",
+      args: [to, value],
+    }),
+  });
+
+  // Then execute the transfer
+  const hash = await walletClient.sendTransaction({
+    account: from.address,
+    to: erc20Address,
+    data: encodeFunctionData({
+      abi: erc20Abi,
+      functionName: "transfer",
+      args: [to, value],
+    }),
+  });
+
+  return { transactionHash: hash as Hex };
+}

package/actions/evm/transfer/types.ts

@@ -1,8 +1,10 @@
+import { EvmUserOperationNetwork } from "../../../openapi-client/index.js";
+
 import type { EvmAccount, EvmSmartAccount } from "../../../accounts/evm/types.js";
 import type {
   CdpOpenApiClientType,
-  EvmUserOperationNetwork,
   SendEvmTransactionBodyNetwork,
+  EvmUserOperationNetwork as EvmUserOperationNetworkType,
 } from "../../../openapi-client/index.js";
 import type { TransactionResult } from "../sendTransaction.js";
 import type { SendUserOperationReturnType } from "../sendUserOperation.js";
@@ -64,3 +66,31 @@ export interface TransferExecutionStrategy<T extends EvmAccount | EvmSmartAccoun
     } & (T extends EvmSmartAccount ? { paymasterUrl?: string } : object),
   ): Promise<T extends EvmSmartAccount ? SendUserOperationReturnType : TransactionResult>;
 }
+
+/**
+ * Validates that the network is supported for the given account type.
+ *
+ * @param network - The network to validate
+ * @param account - The account to check network support for
+ * @returns true if the network is valid for the account type
+ */
+export function isValidNetworkForAccount(
+  network: Network,
+  account: EvmAccount | EvmSmartAccount,
+): boolean {
+  if (isSmartAccount(account)) {
+    return Object.values(EvmUserOperationNetwork).includes(network as EvmUserOperationNetworkType);
+  }
+
+  return true;
+}
+
+/**
+ * Type guard to check if an account is a smart account.
+ *
+ * @param account - The account to check.
+ * @returns true if the account is a smart account, false otherwise.
+ */
+export function isSmartAccount(account: EvmAccount | EvmSmartAccount): account is EvmSmartAccount {
+  return "type" in account && account.type === "evm-smart";
+}

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.
    *