RPC Communication

/**
 * Create a Solana RPC client for standard HTTP requests
 * @param url - RPC endpoint URL
 * @param config - Optional configuration
 * @returns RPC client instance with all Solana methods
 */
function createSolanaRpc<TCluster = void>(
  url: string,
  config?: RpcConfig
): Rpc<SolanaRpcMethods> & { '~cluster'?: TCluster };

/**
 * Create a Solana RPC subscriptions client for WebSocket connections
 * @param url - WebSocket RPC endpoint URL  
 * @param config - Optional configuration
 * @returns Subscriptions client for real-time data
 */
function createSolanaRpcSubscriptions<TCluster = void>(
  url: string,
  config?: RpcSubscriptionsConfig
): RpcSubscriptions<SolanaRpcSubscriptionsMethods> & { '~cluster'?: TCluster };

import { createSolanaRpc, createSolanaRpcSubscriptions } from "@solana/web3.js";

// Create RPC client
const rpc = createSolanaRpc("https://api.devnet.solana.com");

// Create subscriptions client
const rpcSubscriptions = createSolanaRpcSubscriptions("wss://api.devnet.solana.com");

// Use with cluster typing
const mainnetRpc = createSolanaRpc<"mainnet">("https://api.mainnet-beta.solana.com");

/**
 * Get account information for a specific address
 */
interface GetAccountInfoApi {
  getAccountInfo(
    address: Address,
    config?: GetAccountInfoConfig
  ): RpcRequest<AccountInfo | null>;
}

/**
 * Get multiple accounts in a single request
 */
interface GetMultipleAccountsApi {
  getMultipleAccounts(
    addresses: Address[],
    config?: GetMultipleAccountsConfig
  ): RpcRequest<(AccountInfo | null)[]>;
}

/**
 * Get program accounts that match specified criteria
 */
interface GetProgramAccountsApi {
  getProgramAccounts<T>(
    programId: Address,
    config?: GetProgramAccountsConfig
  ): RpcRequest<RpcProgramAccount<T>[]>;
}

import { createSolanaRpc, address } from "@solana/web3.js";

const rpc = createSolanaRpc("https://api.devnet.solana.com");

// Get single account
const accountInfo = await rpc
  .getAccountInfo(address("11111111111111111111111111111112"))
  .send();

// Get multiple accounts  
const multipleAccounts = await rpc
  .getMultipleAccounts([
    address("11111111111111111111111111111112"),
    address("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA")
  ])
  .send();

// Get program accounts
const tokenAccounts = await rpc
  .getProgramAccounts(
    address("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"),
    {
      filters: [
        { dataSize: 165 }, // Token account size
        { memcmp: { offset: 32, bytes: "your-owner-address" } }
      ]
    }
  )
  .send();

/**
 * Get the SOL balance of an account
 */
interface GetBalanceApi {
  getBalance(
    address: Address,
    config?: CommitmentConfig
  ): RpcRequest<Lamports>;
}

/**
 * Get token account balance for an SPL Token account
 */
interface GetTokenAccountBalanceApi {
  getTokenAccountBalance(
    address: Address,
    config?: CommitmentConfig
  ): RpcRequest<RpcTokenAccountBalance>;
}

/**
 * Get token accounts by owner
 */
interface GetTokenAccountsByOwnerApi {
  getTokenAccountsByOwner(
    owner: Address,
    filter: TokenAccountsFilter,
    config?: GetTokenAccountsConfig
  ): RpcRequest<RpcTokenAccount[]>;
}

/**
 * Get token accounts by delegate
 */
interface GetTokenAccountsByDelegateApi {
  getTokenAccountsByDelegate(
    delegate: Address,
    filter: TokenAccountsFilter,
    config?: GetTokenAccountsConfig
  ): RpcRequest<RpcTokenAccount[]>;
}

import { createSolanaRpc, address } from "@solana/web3.js";

const rpc = createSolanaRpc("https://api.devnet.solana.com");

// Get SOL balance
const balance = await rpc.getBalance(address("your-address")).send();
console.log("Balance:", balance.value);

// Get token accounts by owner
const tokenAccounts = await rpc.getTokenAccountsByOwner(
  address("owner-address"),
  { programId: address("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA") }
).send();

/**
 * Get latest blockhash for transaction creation
 */
interface GetLatestBlockhashApi {
  getLatestBlockhash(config?: CommitmentConfig): RpcRequest<{
    blockhash: Blockhash;
    lastValidBlockHeight: bigint;
  }>;
}

/**
 * Get block information by slot
 */
interface GetBlockApi {
  getBlock(
    slot: Slot,
    config?: GetBlockConfig
  ): RpcRequest<Block | null>;
}

/**
 * Get transaction details by signature
 */
interface GetTransactionApi {
  getTransaction(
    signature: Signature,
    config?: GetTransactionConfig
  ): RpcRequest<Transaction | null>;
}

/**
 * Get signature statuses for multiple transactions
 */
interface GetSignatureStatusesApi {
  getSignatureStatuses(
    signatures: Signature[],
    config?: { searchTransactionHistory?: boolean }
  ): RpcRequest<(SignatureStatus | null)[]>;
}

/**
 * Send a transaction to the network
 */
interface SendTransactionApi {
  sendTransaction(
    transaction: string | Uint8Array,
    config?: SendTransactionConfig
  ): RpcRequest<Signature>;
}

/**
 * Simulate a transaction before sending
 */
interface SimulateTransactionApi {
  simulateTransaction(
    transaction: string | Uint8Array,
    config?: SimulateTransactionConfig
  ): RpcRequest<SimulateTransactionResult>;
}

import { 
  createSolanaRpc, 
  compileTransaction,
  createTransactionMessage
} from "@solana/web3.js";

const rpc = createSolanaRpc("https://api.devnet.solana.com");

// Get recent blockhash
const { value: { blockhash } } = await rpc.getLatestBlockhash().send();

// Create and send transaction
const transaction = compileTransaction(
  createTransactionMessage({
    version: 0,
    feePayer: myAddress,
    blockhash,
    instructions: [/* your instructions */]
  })
);

// Simulate first
const simulation = await rpc.simulateTransaction(transaction).send();
if (simulation.value.err) {
  console.error("Transaction would fail:", simulation.value.err);
  return;
}

// Send transaction
const signature = await rpc.sendTransaction(transaction).send();
console.log("Transaction sent:", signature);

/**
 * Get information about the current epoch
 */
interface GetEpochInfoApi {
  getEpochInfo(config?: CommitmentConfig): RpcRequest<RpcEpochInfo>;
}

/**
 * Get the cluster nodes information
 */
interface GetClusterNodesApi {
  getClusterNodes(): RpcRequest<RpcClusterNode[]>;
}

/**
 * Get the health status of the node
 */
interface GetHealthApi {
  getHealth(): RpcRequest<"ok">;
}

/**
 * Get the current version of the node
 */
interface GetVersionApi {
  getVersion(): RpcRequest<RpcVersionInfo>;
}

/**
 * Get current slot the node is processing
 */
interface GetSlotApi {
  getSlot(config?: CommitmentConfig): RpcRequest<Slot>;
}

/**
 * Get the current slot leader
 */
interface GetSlotLeaderApi {
  getSlotLeader(config?: CommitmentConfig): RpcRequest<Address>;
}

import { createSolanaRpc } from "@solana/web3.js";

const rpc = createSolanaRpc("https://api.devnet.solana.com");

// Get current epoch information
const epochInfo = await rpc.getEpochInfo().send();
console.log("Current epoch:", epochInfo.value.epoch);

// Check node health
const health = await rpc.getHealth().send();
console.log("Node health:", health.value); // "ok"

// Get current slot
const slot = await rpc.getSlot().send();
console.log("Current slot:", slot.value);

/**
 * Get fee for a transaction message
 */
interface GetFeeForMessageApi {
  getFeeForMessage(
    message: TransactionMessage,
    config?: CommitmentConfig
  ): RpcRequest<Lamports | null>;
}

/**
 * Get recent prioritization fees
 */
interface GetRecentPrioritizationFeesApi {
  getRecentPrioritizationFees(
    addresses?: Address[]
  ): RpcRequest<RpcPrioritizationFee[]>;
}

/**
 * Get minimum balance for rent exemption
 */
interface GetMinimumBalanceForRentExemptionApi {
  getMinimumBalanceForRentExemption(
    dataLength: number,
    config?: CommitmentConfig
  ): RpcRequest<Lamports>;
}

import { createSolanaRpc } from "@solana/web3.js";

const rpc = createSolanaRpc("https://api.devnet.solana.com");

// Get recent prioritization fees
const fees = await rpc.getRecentPrioritizationFees().send();
console.log("Recent fees:", fees.value);

// Get rent exemption minimum
const rentExemption = await rpc.getMinimumBalanceForRentExemption(0).send();
console.log("Rent exemption for 0 bytes:", rentExemption.value);

/**
 * Subscribe to account changes
 */
interface AccountNotificationsApi {
  accountNotifications(
    address: Address,
    config?: AccountNotificationsConfig
  ): RpcSubscription<AccountNotification>;
}

/**
 * Subscribe to signature status changes
 */
interface SignatureNotificationsApi {
  signatureNotifications(
    signature: Signature,
    config?: SignatureNotificationsConfig
  ): RpcSubscription<SignatureNotification>;
}

/**
 * Subscribe to slot changes
 */
interface SlotNotificationsApi {
  slotNotifications(): RpcSubscription<SlotNotification>;
}

/**
 * Subscribe to program account changes
 */
interface ProgramNotificationsApi {
  programNotifications(
    programId: Address,
    config?: ProgramNotificationsConfig
  ): RpcSubscription<ProgramAccountNotification>;
}

import { createSolanaRpcSubscriptions, address } from "@solana/web3.js";

const rpcSubscriptions = createSolanaRpcSubscriptions("wss://api.devnet.solana.com");

// Subscribe to account changes
const accountSubscription = await rpcSubscriptions
  .accountNotifications(address("your-address-here"))
  .subscribe();

// Process notifications
for await (const notification of accountSubscription) {
  console.log("Account updated:", notification);
}

// Subscribe to signature confirmations
const signatureSubscription = await rpcSubscriptions
  .signatureNotifications("your-signature-here")
  .subscribe();

for await (const notification of signatureSubscription) {
  if (notification.err) {
    console.error("Transaction failed:", notification.err);
  } else {
    console.log("Transaction confirmed!");
  }
  break; // Exit after first notification
}

/**
 * Request an airdrop of SOL to an address
 */
interface RequestAirdropApi {
  requestAirdrop(
    address: Address,
    lamports: Lamports,
    config?: CommitmentConfig
  ): RpcRequest<Signature>;
}

/**
 * Get default RPC URL for a cluster
 * @param cluster - Target cluster
 * @returns RPC endpoint URL
 */
function getDefaultRpcUrl(cluster: "mainnet" | "testnet" | "devnet"): string;

/**
 * Get default WebSocket URL for a cluster  
 * @param cluster - Target cluster
 * @returns WebSocket endpoint URL
 */
function getDefaultRpcSubscriptionsUrl(cluster: "mainnet" | "testnet" | "devnet"): string;

/**
 * Create cluster-specific RPC client
 * @param cluster - Target cluster
 * @param config - Optional configuration
 * @returns Configured RPC client
 */
function createSolanaRpcFromCluster(
  cluster: "mainnet" | "testnet" | "devnet",
  config?: RpcConfig
): Rpc<SolanaRpcMethods>;

import { 
  createSolanaRpcFromCluster,
  getDefaultRpcUrl 
} from "@solana/web3.js";

// Use pre-configured cluster endpoints
const devnetRpc = createSolanaRpcFromCluster("devnet");
const mainnetRpc = createSolanaRpcFromCluster("mainnet");

// Get cluster URLs
const devnetUrl = getDefaultRpcUrl("devnet");
console.log("Devnet URL:", devnetUrl);

/**
 * Base RPC configuration
 */
interface RpcConfig {
  /**
   * Request timeout in milliseconds
   * @default 30000
   */
  timeout?: number;
  
  /**
   * HTTP headers to include with requests
   */
  headers?: Record<string, string>;
  
  /**
   * Custom request transformer
   */
  requestTransformer?: RpcRequestTransformer;
  
  /**
   * Custom response transformer
   */
  responseTransformer?: RpcResponseTransformer;
}

/**
 * WebSocket subscriptions configuration
 */
interface RpcSubscriptionsConfig {
  /**
   * Connection timeout in milliseconds
   * @default 30000
   */
  timeout?: number;
  
  /**
   * Whether to auto-reconnect on disconnect
   * @default true
   */
  autoReconnect?: boolean;
  
  /**
   * Maximum reconnection attempts
   * @default 5
   */
  maxReconnectAttempts?: number;
}

/**
 * Commitment configuration for RPC requests
 */
interface CommitmentConfig {
  /**
   * Commitment level
   * @default "finalized"
   */
  commitment?: Commitment;
}

/**
 * Account information query configuration
 */
interface GetAccountInfoConfig extends CommitmentConfig {
  /**
   * Data encoding format
   * @default "base64"
   */
  encoding?: "base58" | "base64" | "jsonParsed";
  
  /**
   * Data slice to return
   */
  dataSlice?: {
    offset: number;
    length: number;
  };
}