SolanaClient

new SolanaClient(): SolanaClient;

createAccount(options?: CreateAccountOptions): Promise<{
  requestFaucet: (options: Omit<RequestFaucetOptions, "address">) => Promise<SignatureResult>;
  sendTransaction: (options: Omit<SendTransactionOptions, "address">) => Promise<SendTransactionResult>;
  signMessage: (options: Omit<SignMessageOptions, "address">) => Promise<SignatureResult>;
  signTransaction: (options: Omit<SignTransactionOptions, "address">) => Promise<SignTransactionResult>;
  signX402Payment: (paymentRequired: PaymentRequired, acceptedIndex: number) => Promise<PaymentPayload>;
  transfer: (options: Omit<TransferOptions, "from">) => Promise<SignatureResult>;
}>;

         const account = await cdp.solana.createAccount();

         const account = await cdp.solana.createAccount({ name: "MyAccount" });

         const idempotencyKey = uuidv4();

         // First call
         await cdp.solana.createAccount({ idempotencyKey });

         // Second call with the same idempotency key will return the same account
         await cdp.solana.createAccount({ idempotencyKey });

SolanaClientInterface.createAccount

exportAccount(options: ExportAccountOptions): Promise<string>;

const privateKey = await cdp.solana.exportAccount({
  address: "1234567890123456789012345678901234567890",
});

const privateKey = await cdp.solana.exportAccount({
  name: "MyAccount",
});

SolanaClientInterface.exportAccount

getAccount(options: GetAccountOptions): Promise<{
  requestFaucet: (options: Omit<RequestFaucetOptions, "address">) => Promise<SignatureResult>;
  sendTransaction: (options: Omit<SendTransactionOptions, "address">) => Promise<SendTransactionResult>;
  signMessage: (options: Omit<SignMessageOptions, "address">) => Promise<SignatureResult>;
  signTransaction: (options: Omit<SignTransactionOptions, "address">) => Promise<SignTransactionResult>;
  signX402Payment: (paymentRequired: PaymentRequired, acceptedIndex: number) => Promise<PaymentPayload>;
  transfer: (options: Omit<TransferOptions, "from">) => Promise<SignatureResult>;
}>;

         const account = await cdp.solana.getAccount({
           address: "1234567890123456789012345678901234567890",
         });

         const account = await cdp.solana.getAccount({
           name: "MyAccount",
         });

SolanaClientInterface.getAccount

getOrCreateAccount(options: GetOrCreateAccountOptions): Promise<{
  requestFaucet: (options: Omit<RequestFaucetOptions, "address">) => Promise<SignatureResult>;
  sendTransaction: (options: Omit<SendTransactionOptions, "address">) => Promise<SendTransactionResult>;
  signMessage: (options: Omit<SignMessageOptions, "address">) => Promise<SignatureResult>;
  signTransaction: (options: Omit<SignTransactionOptions, "address">) => Promise<SignTransactionResult>;
  signX402Payment: (paymentRequired: PaymentRequired, acceptedIndex: number) => Promise<PaymentPayload>;
  transfer: (options: Omit<TransferOptions, "from">) => Promise<SignatureResult>;
}>;

const account = await cdp.solana.getOrCreateAccount({
  name: "MyAccount",
});

SolanaClientInterface.getOrCreateAccount

importAccount(options: ImportAccountOptions): Promise<{
  requestFaucet: (options: Omit<RequestFaucetOptions, "address">) => Promise<SignatureResult>;
  sendTransaction: (options: Omit<SendTransactionOptions, "address">) => Promise<SendTransactionResult>;
  signMessage: (options: Omit<SignMessageOptions, "address">) => Promise<SignatureResult>;
  signTransaction: (options: Omit<SignTransactionOptions, "address">) => Promise<SignTransactionResult>;
  signX402Payment: (paymentRequired: PaymentRequired, acceptedIndex: number) => Promise<PaymentPayload>;
  transfer: (options: Omit<TransferOptions, "from">) => Promise<SignatureResult>;
}>;

         const account = await cdp.solana.importAccount({
           privateKey: "3Kzj...",
         });

         const account = await cdp.solana.importAccount({
           privateKey: "3Kzj...",
           name: "ImportedAccount",
         });

         const idempotencyKey = uuidv4();

         const account = await cdp.solana.importAccount({
           privateKey: "3Kzj...",
           name: "ImportedAccount",
           idempotencyKey,
         });

SolanaClientInterface.importAccount

listAccounts(options?: ListAccountsOptions): Promise<ListAccountsResult>;

         const accounts = await cdp.solana.listAccounts();

         let page = await cdp.solana.listAccounts();

         while (page.nextPageToken) {
           page = await cdp.solana.listAccounts({ pageToken: page.nextPageToken });
         }

         page.accounts.forEach(account => console.log(account));

#### Implementation of

```ts
SolanaClientInterface.listAccounts

listTokenBalances(options: ListTokenBalancesOptions): Promise<ListTokenBalancesResult>;

const balances = await cdp.solana.listTokenBalances({ address: "...", network: "solana-devnet" });

SolanaClientInterface.listTokenBalances

requestFaucet(options: RequestFaucetOptions): Promise<SignatureResult>;

         const signature = await cdp.solana.requestFaucet({
           address: "1234567890123456789012345678901234567890",
           token: "sol",
         });

SolanaClientInterface.requestFaucet

sendTransaction(options: SendTransactionOptions): Promise<SendTransactionResult>;

const signature = await cdp.solana.sendTransaction({
  network: "solana-devnet",
  transaction: "...",
  useCdpSponsor: true,
});

SolanaClientInterface.sendTransaction

signMessage(options: SignMessageOptions): Promise<SignatureResult>;

// Create a Solana account
const account = await cdp.solana.createAccount();

// When you want to sign a message, you can do so by address
const signature = await cdp.solana.signMessage({
  address: account.address,
  message: "Hello, world!",
});

SolanaClientInterface.signMessage

signTransaction(options: SignTransactionOptions): Promise<SignTransactionResult>;

// Create a Solana account
const account = await cdp.solana.createAccount();

// Build your transaction using @solana/kit
import {
  address as solanaAddress,
  appendTransactionMessageInstructions,
  compileTransaction,
  createNoopSigner,
  createSolanaRpc,
  createTransactionMessage,
  getBase64EncodedWireTransaction,
  pipe,
  setTransactionMessageFeePayer,
  setTransactionMessageLifetimeUsingBlockhash,
} from "@solana/kit";
import { getTransferSolInstruction } from "@solana-program/system";

const rpc = createSolanaRpc("https://api.devnet.solana.com");
const { value: { blockhash, lastValidBlockHeight } } = await rpc.getLatestBlockhash().send();

const txMsg = pipe(
  createTransactionMessage({ version: 0 }),
  (tx) => setTransactionMessageFeePayer(solanaAddress(account.address), tx),
  (tx) => setTransactionMessageLifetimeUsingBlockhash(
    { blockhash, lastValidBlockHeight },
    tx,
  ),
  (tx) => appendTransactionMessageInstructions([
    getTransferSolInstruction({
      source: createNoopSigner(solanaAddress(account.address)),
      destination: solanaAddress("3KzDtddx4i53FBkvCzuDmRbaMozTZoJBb1TToWhz3JfE"),
      amount: 10000n,
    }),
  ], tx),
);

// Base64 encode the compiled transaction
const transaction = getBase64EncodedWireTransaction(compileTransaction(txMsg));

// Sign the transaction via the CDP API
const signature = await cdp.solana.signTransaction({
  address: account.address,
  transaction,
});

SolanaClientInterface.signTransaction

updateAccount(options?: UpdateSolanaAccountOptions): Promise<{
  requestFaucet: (options: Omit<RequestFaucetOptions, "address">) => Promise<SignatureResult>;
  sendTransaction: (options: Omit<SendTransactionOptions, "address">) => Promise<SendTransactionResult>;
  signMessage: (options: Omit<SignMessageOptions, "address">) => Promise<SignatureResult>;
  signTransaction: (options: Omit<SignTransactionOptions, "address">) => Promise<SignTransactionResult>;
  signX402Payment: (paymentRequired: PaymentRequired, acceptedIndex: number) => Promise<PaymentPayload>;
  transfer: (options: Omit<TransferOptions, "from">) => Promise<SignatureResult>;
}>;

         const account = await cdp.sol.updateAccount({ address: "...", update: { name: "New Name" } });

         const account = await cdp.sol.updateAccount({ address: "...", update: { accountPolicy: "73bcaeeb-d7af-4615-b064-42b5fe83a31e" } });

         const idempotencyKey = uuidv4();

         // First call
         await cdp.sol.updateAccount({
           address: "0x...",
           update: { accountPolicy: "73bcaeeb-d7af-4615-b064-42b5fe83a31e" },
           idempotencyKey,
         });

         // Second call with the same idempotency key will not update
         await cdp.sol.updateAccount({
           address: '0x...',
           update: { name: "" },
           idempotencyKey,
         });

SolanaClientInterface.updateAccount