tessl/pypi-solders

Python bindings for Solana Rust tools providing high-performance blockchain development primitives, RPC functionality, and testing infrastructure.

—

Pending

Overview

Eval results

Files

RPC Functionality

Name: tessl/pypi-solders
Author: tessl

Comprehensive RPC client support with request/response handling, configuration options, and subscription capabilities for interacting with Solana networks. This provides type-safe access to all Solana JSON-RPC methods with proper serialization and error handling.

Capabilities

RPC Requests

Type-safe request classes for all Solana JSON-RPC methods with parameter validation and serialization.

Account Information

class GetAccountInfo:
    """
    Request account information including balance, data, and metadata.
    """
    def __init__(self, pubkey: Pubkey, config: Optional[RpcAccountInfoConfig] = None):
        """
        Create get account info request.
        
        Parameters:
        - pubkey: Pubkey, account to query
        - config: Optional[RpcAccountInfoConfig], request configuration
        """

class RpcAccountInfoConfig:
    """Configuration for account info requests."""
    def __init__(
        self,
        encoding: Optional[UiAccountEncoding] = None,
        data_slice: Optional[UiDataSliceConfig] = None,
        commitment: Optional[CommitmentConfig] = None,
        min_context_slot: Optional[int] = None
    ):
        """
        Configure account info request.
        
        Parameters:
        - encoding: Optional[UiAccountEncoding], data encoding format
        - data_slice: Optional[UiDataSliceConfig], slice of account data to return
        - commitment: Optional[CommitmentConfig], confirmation level
        - min_context_slot: Optional[int], minimum slot for response
        """

class GetBalance:
    """
    Request account balance in lamports.
    """
    def __init__(self, pubkey: Pubkey, config: Optional[CommitmentConfig] = None):
        """
        Create get balance request.
        
        Parameters:
        - pubkey: Pubkey, account to query
        - config: Optional[CommitmentConfig], confirmation level
        """

class GetMultipleAccounts:
    """
    Request information for multiple accounts in single call.
    """
    def __init__(self, pubkeys: List[Pubkey], config: Optional[RpcAccountInfoConfig] = None):
        """
        Create multiple accounts request.
        
        Parameters:
        - pubkeys: List[Pubkey], accounts to query (max 100)
        - config: Optional[RpcAccountInfoConfig], request configuration
        """

class GetProgramAccounts:
    """
    Request all accounts owned by specified program.
    """
    def __init__(self, program_id: Pubkey, config: Optional[RpcProgramAccountsConfig] = None):
        """
        Create program accounts request.
        
        Parameters:
        - program_id: Pubkey, program that owns accounts
        - config: Optional[RpcProgramAccountsConfig], filtering and encoding options
        """

class RpcProgramAccountsConfig:
    """Configuration for program accounts requests."""
    def __init__(
        self,
        encoding: Optional[UiAccountEncoding] = None,
        data_slice: Optional[UiDataSliceConfig] = None,
        filters: Optional[List[RpcFilterType]] = None,
        commitment: Optional[CommitmentConfig] = None,
        min_context_slot: Optional[int] = None,
        with_context: Optional[bool] = None
    ):
        """Configure program accounts filtering and encoding."""

Blockchain Information

class GetBlock:
    """
    Request block information and transactions.
    """
    def __init__(self, slot: int, config: Optional[RpcBlockConfig] = None):
        """
        Create get block request.
        
        Parameters:
        - slot: int, block slot number
        - config: Optional[RpcBlockConfig], block encoding and detail level
        """

class RpcBlockConfig:
    """Configuration for block requests."""
    def __init__(
        self,
        encoding: Optional[UiTransactionEncoding] = None,
        transaction_details: Optional[TransactionDetails] = None,
        rewards: Optional[bool] = None,
        commitment: Optional[CommitmentConfig] = None,
        max_supported_transaction_version: Optional[int] = None
    ):
        """Configure block response format and detail level."""

class GetBlockHeight:
    """Request current block height."""
    def __init__(self, config: Optional[CommitmentConfig] = None):
        """Create block height request."""

class GetBlockTime:
    """Request estimated production time of a block."""
    def __init__(self, slot: int):
        """
        Create block time request.
        
        Parameters:
        - slot: int, block slot number
        """

class GetBlocks:
    """Request list of confirmed blocks."""
    def __init__(self, start_slot: int, end_slot: Optional[int] = None, config: Optional[CommitmentConfig] = None):
        """
        Create blocks request.
        
        Parameters:
        - start_slot: int, first slot to return
        - end_slot: Optional[int], last slot to return (default: latest)
        - config: Optional[CommitmentConfig], confirmation level
        """

class GetBlocksWithLimit:
    """Request limited number of confirmed blocks."""
    def __init__(self, start_slot: int, limit: int, config: Optional[CommitmentConfig] = None):
        """
        Create blocks with limit request.
        
        Parameters:
        - start_slot: int, first slot to return
        - limit: int, maximum number of blocks to return
        - config: Optional[CommitmentConfig], confirmation level
        """

class GetLatestBlockhash:
    """Request most recent blockhash."""
    def __init__(self, config: Optional[CommitmentConfig] = None):
        """Create latest blockhash request."""

Transaction Operations

class GetTransaction:
    """
    Request transaction details by signature.
    """
    def __init__(self, signature: Signature, config: Optional[RpcTransactionConfig] = None):
        """
        Create get transaction request.
        
        Parameters:
        - signature: Signature, transaction signature to look up
        - config: Optional[RpcTransactionConfig], encoding and detail options
        """

class RpcTransactionConfig:
    """Configuration for transaction requests."""
    def __init__(
        self,
        encoding: Optional[UiTransactionEncoding] = None,
        commitment: Optional[CommitmentConfig] = None,
        max_supported_transaction_version: Optional[int] = None
    ):
        """Configure transaction response format."""

class GetSignatureStatuses:
    """
    Request confirmation status of multiple transaction signatures.
    """
    def __init__(self, signatures: List[Signature], config: Optional[RpcSignatureStatusConfig] = None):
        """
        Create signature statuses request.
        
        Parameters:
        - signatures: List[Signature], transaction signatures to check (max 256)
        - config: Optional[RpcSignatureStatusConfig], status search options
        """

class GetSignaturesForAddress:
    """
    Request transaction signatures for an address.
    """
    def __init__(self, address: Pubkey, config: Optional[RpcSignaturesForAddressConfig] = None):
        """
        Create signatures for address request.
        
        Parameters:
        - address: Pubkey, account address to search
        - config: Optional[RpcSignaturesForAddressConfig], search parameters
        """

class RpcSignaturesForAddressConfig:
    """Configuration for signature history requests."""
    def __init__(
        self,
        limit: Optional[int] = None,
        before: Optional[Signature] = None,
        until: Optional[Signature] = None,
        commitment: Optional[CommitmentConfig] = None,
        min_context_slot: Optional[int] = None
    ):
        """
        Configure signature search parameters.
        
        Parameters:
        - limit: Optional[int], maximum signatures to return (default 1000, max 1000)
        - before: Optional[Signature], start search before this signature
        - until: Optional[Signature], stop search at this signature
        - commitment: Optional[CommitmentConfig], confirmation level
        - min_context_slot: Optional[int], minimum context slot
        """

class GetFeeForMessage:
    """Request transaction fee for a message."""
    def __init__(self, message: VersionedMessage, config: Optional[CommitmentConfig] = None):
        """
        Create fee calculation request.
        
        Parameters:
        - message: VersionedMessage, transaction message to estimate
        - config: Optional[CommitmentConfig], confirmation level
        """

Network and Validator Information

class GetEpochInfo:
    """Request current epoch information."""
    def __init__(self, config: Optional[CommitmentConfig] = None):
        """Create epoch info request."""

class GetEpochSchedule:
    """Request epoch schedule configuration."""
    def __init__(self):
        """Create epoch schedule request."""

class GetSlot:
    """Request current slot number."""
    def __init__(self, config: Optional[CommitmentConfig] = None):
        """Create slot request."""

class GetSlotLeader:
    """Request current slot leader."""
    def __init__(self, config: Optional[CommitmentConfig] = None):
        """Create slot leader request."""

class GetSlotLeaders:
    """Request slot leaders for range of slots."""
    def __init__(self, start_slot: int, limit: int):
        """
        Create slot leaders request.
        
        Parameters:
        - start_slot: int, first slot to query
        - limit: int, number of slots to query
        """

class GetLeaderSchedule:
    """Request leader schedule for an epoch."""
    def __init__(self, slot: Optional[int] = None, config: Optional[RpcLeaderScheduleConfig] = None):
        """
        Create leader schedule request.
        
        Parameters:
        - slot: Optional[int], slot to get schedule for (default: current epoch)
        - config: Optional[RpcLeaderScheduleConfig], identity filter
        """

class GetVoteAccounts:
    """Request current vote accounts."""
    def __init__(self, config: Optional[RpcGetVoteAccountsConfig] = None):
        """Create vote accounts request."""

class GetClusterNodes:
    """Request information about cluster nodes."""
    def __init__(self):
        """Create cluster nodes request."""

Token-Specific Requests

class GetTokenAccountBalance:
    """Request SPL token account balance."""
    def __init__(self, account: Pubkey, config: Optional[CommitmentConfig] = None):
        """
        Create token balance request.
        
        Parameters:
        - account: Pubkey, token account to query
        - config: Optional[CommitmentConfig], confirmation level
        """

class GetTokenSupply:
    """Request total supply of SPL token."""
    def __init__(self, mint: Pubkey, config: Optional[CommitmentConfig] = None):
        """
        Create token supply request.
        
        Parameters:
        - mint: Pubkey, token mint to query
        - config: Optional[CommitmentConfig], confirmation level
        """

class GetTokenAccountsByOwner:
    """Request all token accounts owned by address."""
    def __init__(
        self, 
        owner: Pubkey, 
        filter: Union[RpcTokenAccountsFilterMint, RpcTokenAccountsFilterProgramId],
        config: Optional[RpcAccountInfoConfig] = None
    ):
        """
        Create token accounts by owner request.
        
        Parameters:
        - owner: Pubkey, token account owner
        - filter: Union filter by mint or program ID
        - config: Optional[RpcAccountInfoConfig], encoding options
        """

class RpcTokenAccountsFilterMint:
    """Filter token accounts by mint."""
    def __init__(self, mint: Pubkey):
        """Filter by specific token mint."""

class RpcTokenAccountsFilterProgramId:
    """Filter token accounts by program ID."""
    def __init__(self, program_id: Pubkey):
        """Filter by token program (SPL Token vs Token-2022)."""

class GetTokenAccountsByDelegate:
    """Request all token accounts with specific delegate."""
    def __init__(
        self,
        delegate: Pubkey,
        filter: Union[RpcTokenAccountsFilterMint, RpcTokenAccountsFilterProgramId],
        config: Optional[RpcAccountInfoConfig] = None
    ):
        """Create token accounts by delegate request."""

class GetTokenLargestAccounts:
    """Request largest token accounts for mint."""
    def __init__(self, mint: Pubkey, config: Optional[CommitmentConfig] = None):
        """
        Create largest token accounts request.
        
        Parameters:
        - mint: Pubkey, token mint to query
        - config: Optional[CommitmentConfig], confirmation level
        """

RPC Subscriptions

Real-time data streaming through WebSocket subscriptions.

class AccountSubscribe:
    """
    Subscribe to account changes.
    """
    def __init__(self, account: Pubkey, config: Optional[RpcAccountInfoConfig] = None):
        """
        Create account subscription.
        
        Parameters:
        - account: Pubkey, account to monitor
        - config: Optional[RpcAccountInfoConfig], encoding and commitment options
        """

class AccountUnsubscribe:
    """
    Unsubscribe from account changes.
    """
    def __init__(self, subscription_id: int):
        """
        Create account unsubscription.
        
        Parameters:
        - subscription_id: int, subscription ID to cancel
        """

class BlockSubscribe:
    """
    Subscribe to block updates.
    """
    def __init__(self, config: Optional[RpcBlockSubscribeConfig] = None):
        """
        Create block subscription.
        
        Parameters:
        - config: Optional[RpcBlockSubscribeConfig], block filter and encoding
        """

class RpcBlockSubscribeConfig:
    """Configuration for block subscriptions."""
    def __init__(
        self,
        filter: Optional[RpcBlockSubscribeFilter] = None,
        encoding: Optional[UiTransactionEncoding] = None,
        transaction_details: Optional[TransactionDetails] = None,
        show_rewards: Optional[bool] = None,
        commitment: Optional[CommitmentConfig] = None,
        max_supported_transaction_version: Optional[int] = None
    ):
        """Configure block subscription parameters."""

class BlockUnsubscribe:
    """
    Unsubscribe from block updates.
    """
    def __init__(self, subscription_id: int):
        """Cancel block subscription."""

class ProgramSubscribe:
    """
    Subscribe to program account changes.
    """
    def __init__(self, program_id: Pubkey, config: Optional[RpcProgramAccountsConfig] = None):
        """
        Create program subscription.
        
        Parameters:
        - program_id: Pubkey, program to monitor
        - config: Optional[RpcProgramAccountsConfig], filtering options
        """

class SignatureSubscribe:
    """
    Subscribe to signature confirmations.
    """
    def __init__(self, signature: Signature, config: Optional[RpcSignatureSubscribeConfig] = None):
        """
        Create signature subscription.
        
        Parameters:
        - signature: Signature, transaction signature to monitor
        - config: Optional[RpcSignatureSubscribeConfig], commitment level
        """

Transaction Simulation

class SimulateTransaction:
    """
    Simulate transaction execution without committing.
    """
    def __init__(
        self,
        transaction: Union[Transaction, VersionedTransaction],
        config: Optional[RpcSimulateTransactionConfig] = None
    ):
        """
        Create transaction simulation request.
        
        Parameters:
        - transaction: Union transaction to simulate
        - config: Optional[RpcSimulateTransactionConfig], simulation options
        """

class RpcSimulateTransactionConfig:
    """Configuration for transaction simulation."""
    def __init__(
        self,
        sig_verify: Optional[bool] = None,
        replace_recent_blockhash: Optional[bool] = None,
        commitment: Optional[CommitmentConfig] = None,
        encoding: Optional[UiTransactionEncoding] = None,
        accounts: Optional[RpcSimulateTransactionAccountsConfig] = None,
        min_context_slot: Optional[int] = None,
        inner_instructions: Optional[bool] = None
    ):
        """
        Configure simulation parameters.
        
        Parameters:
        - sig_verify: Optional[bool], whether to verify signatures (default: false)
        - replace_recent_blockhash: Optional[bool], replace with latest blockhash
        - commitment: Optional[CommitmentConfig], confirmation level for simulation
        - encoding: Optional[UiTransactionEncoding], response encoding
        - accounts: Optional config for returning account states
        - min_context_slot: Optional[int], minimum context slot
        - inner_instructions: Optional[bool], include inner instructions in response
        """

class RpcSimulateTransactionAccountsConfig:
    """Configuration for simulation account returns."""
    def __init__(
        self,
        encoding: UiAccountEncoding,
        addresses: List[Pubkey]
    ):
        """
        Configure which accounts to return after simulation.
        
        Parameters:
        - encoding: UiAccountEncoding, account data encoding
        - addresses: List[Pubkey], accounts to return
        """

Network Configuration

class RpcSendTransactionConfig:
    """Configuration for sending transactions."""
    def __init__(
        self,
        skip_preflight: Optional[bool] = None,
        preflight_commitment: Optional[CommitmentLevel] = None,
        encoding: Optional[UiTransactionEncoding] = None,
        max_retries: Optional[int] = None,
        min_context_slot: Optional[int] = None
    ):
        """
        Configure transaction sending.
        
        Parameters:
        - skip_preflight: Optional[bool], skip preflight validation
        - preflight_commitment: Optional[CommitmentLevel], commitment for preflight
        - encoding: Optional[UiTransactionEncoding], transaction encoding
        - max_retries: Optional[int], maximum retry attempts
        - min_context_slot: Optional[int], minimum context slot
        """

Usage Examples

Basic Account Queries

from solders.rpc.requests import GetAccountInfo, GetBalance, GetMultipleAccounts
from solders.rpc.config import RpcAccountInfoConfig
from solders.account_decoder import UiAccountEncoding
from solders.commitment_config import CommitmentConfig
from solders.pubkey import Pubkey

# Single account info
account = Pubkey.from_string("7dHbWXmci3dT8UFYWYZweBLXgycu7Y3iL6trKn1Y7ARj")

# Basic account info request
account_info_request = GetAccountInfo(account)

# Account info with configuration
config = RpcAccountInfoConfig(
    encoding=UiAccountEncoding.Base64,
    commitment=CommitmentConfig.confirmed()
)
configured_request = GetAccountInfo(account, config)

# Account balance
balance_request = GetBalance(account, CommitmentConfig.finalized())

# Multiple accounts at once
accounts = [
    Pubkey.from_string("7dHbWXmci3dT8UFYWYZweBLXgycu7Y3iL6trKn1Y7ARj"),
    Pubkey.from_string("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"),
    Pubkey.from_string("11111111111111111111111111111112")
]
multi_account_request = GetMultipleAccounts(accounts, config)

Program Account Filtering

from solders.rpc.requests import GetProgramAccounts
from solders.rpc.config import RpcProgramAccountsConfig
from solders.rpc.filter import RpcFilterType, MemcmpFilter

# Get all token accounts (SPL Token program)
token_program = Pubkey.from_string("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA")

# Basic program accounts request
program_accounts_request = GetProgramAccounts(token_program)

# Filter for specific mint (offset 0, 32 bytes)
mint_filter = MemcmpFilter(
    offset=0,
    bytes=bytes(Pubkey.from_string("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"))  # USDC mint
)

# Filter for specific owner (offset 32, 32 bytes)
owner_filter = MemcmpFilter(
    offset=32,
    bytes=bytes(Pubkey.from_string("7dHbWXmci3dT8UFYWYZweBLXgycu7Y3iL6trKn1Y7ARj"))
)

filtered_config = RpcProgramAccountsConfig(
    encoding=UiAccountEncoding.JsonParsed,
    filters=[mint_filter, owner_filter],
    commitment=CommitmentConfig.confirmed()
)

filtered_request = GetProgramAccounts(token_program, filtered_config)

Transaction Operations

from solders.rpc.requests import GetTransaction, GetSignatureStatuses, SimulateTransaction
from solders.rpc.config import RpcTransactionConfig, RpcSimulateTransactionConfig
from solders.transaction_status import UiTransactionEncoding
from solders.signature import Signature

# Get transaction details
tx_signature = Signature.from_string("signature_string_here")

tx_config = RpcTransactionConfig(
    encoding=UiTransactionEncoding.Json,
    commitment=CommitmentConfig.confirmed(),
    max_supported_transaction_version=0
)

tx_request = GetTransaction(tx_signature, tx_config)

# Check multiple signature statuses
signatures = [
    Signature.from_string("sig1"),
    Signature.from_string("sig2"),
    Signature.from_string("sig3")
]

status_request = GetSignatureStatuses(signatures)

# Simulate transaction before sending
simulation_config = RpcSimulateTransactionConfig(
    sig_verify=False,  # Skip signature verification for speed
    replace_recent_blockhash=True,
    commitment=CommitmentConfig.processed(),
    inner_instructions=True
)

simulate_request = SimulateTransaction(transaction, simulation_config)

Block and Network Queries

from solders.rpc.requests import (
    GetBlock, GetBlockHeight, GetLatestBlockhash, GetEpochInfo, GetSlotLeaders
)
from solders.rpc.config import RpcBlockConfig
from solders.transaction_status import TransactionDetails

# Get current block height
block_height_request = GetBlockHeight(CommitmentConfig.finalized())

# Get latest blockhash for transactions
blockhash_request = GetLatestBlockhash(CommitmentConfig.finalized())

# Get block with full transaction details
block_config = RpcBlockConfig(
    encoding=UiTransactionEncoding.Json,
    transaction_details=TransactionDetails.Full,
    rewards=True,
    max_supported_transaction_version=0
)

block_request = GetBlock(slot_number, block_config)

# Get current epoch information
epoch_request = GetEpochInfo(CommitmentConfig.confirmed())

# Get slot leaders for next 100 slots
current_slot = 100000000  # Would get from GetSlot request
leaders_request = GetSlotLeaders(current_slot, 100)

Token-Specific Queries

from solders.rpc.requests import (
    GetTokenAccountBalance, GetTokenSupply, GetTokenAccountsByOwner, 
    GetTokenLargestAccounts
)
from solders.rpc.config import RpcTokenAccountsFilterMint

# Token account balance
token_account = Pubkey.from_string("token_account_address")
balance_request = GetTokenAccountBalance(token_account, CommitmentConfig.confirmed())

# Token total supply
usdc_mint = Pubkey.from_string("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v")
supply_request = GetTokenSupply(usdc_mint, CommitmentConfig.finalized())

# All USDC accounts for a user
owner = Pubkey.from_string("user_wallet_address")
mint_filter = RpcTokenAccountsFilterMint(usdc_mint)

accounts_config = RpcAccountInfoConfig(
    encoding=UiAccountEncoding.JsonParsed,
    commitment=CommitmentConfig.confirmed()
)

owner_accounts_request = GetTokenAccountsByOwner(owner, mint_filter, accounts_config)

# Largest USDC holders
largest_request = GetTokenLargestAccounts(usdc_mint, CommitmentConfig.confirmed())

Real-Time Subscriptions

from solders.rpc.requests import AccountSubscribe, BlockSubscribe, SignatureSubscribe
from solders.rpc.config import RpcBlockSubscribeConfig

# Subscribe to account changes
account_to_watch = Pubkey.from_string("account_address")
sub_config = RpcAccountInfoConfig(
    encoding=UiAccountEncoding.Base64,
    commitment=CommitmentConfig.confirmed()
)

account_subscription = AccountSubscribe(account_to_watch, sub_config)

# Subscribe to new blocks
block_config = RpcBlockSubscribeConfig(
    encoding=UiTransactionEncoding.Json,
    transaction_details=TransactionDetails.Full,
    show_rewards=True,
    commitment=CommitmentConfig.confirmed()
)

block_subscription = BlockSubscribe(block_config)

# Subscribe to signature confirmation
pending_signature = Signature.from_string("pending_tx_signature")
signature_subscription = SignatureSubscribe(
    pending_signature,
    RpcSignatureSubscribeConfig(commitment=CommitmentConfig.confirmed())
)

# Note: Actual subscription handling would require WebSocket client implementation
# These request objects define the subscription parameters

Transaction Sending and Monitoring

from solders.rpc.requests import SendTransaction
from solders.rpc.config import RpcSendTransactionConfig

# Configure transaction sending
send_config = RpcSendTransactionConfig(
    skip_preflight=False,  # Run preflight checks
    preflight_commitment=CommitmentLevel.Processed,
    encoding=UiTransactionEncoding.Base64,
    max_retries=3,
    min_context_slot=None
)

# Send transaction (this would be handled by RPC client)
# send_request = SendTransaction(signed_transaction, send_config)

# Monitor confirmation with signature subscription
confirmation_subscription = SignatureSubscribe(
    transaction.signatures[0],  # First signature is transaction ID
    RpcSignatureSubscribeConfig(commitment=CommitmentConfig.finalized())
)

Error Handling

RPC Request Validation

from solders.rpc.errors import RpcError

def validate_rpc_request(request) -> bool:
    """Validate RPC request before sending."""
    try:
        if isinstance(request, GetMultipleAccounts):
            if len(request.pubkeys) > 100:
                raise ValueError("Too many accounts requested (max 100)")
        
        elif isinstance(request, GetSignatureStatuses):
            if len(request.signatures) > 256:
                raise ValueError("Too many signatures requested (max 256)")
        
        elif isinstance(request, GetBlocks):
            if request.end_slot and (request.end_slot - request.start_slot) > 500000:
                raise ValueError("Slot range too large (max 500,000)")
        
        return True
    except Exception as e:
        print(f"Request validation failed: {e}")
        return False

Commitment Level Handling

from solders.commitment_config import CommitmentLevel, CommitmentConfig

def choose_commitment_level(use_case: str) -> CommitmentConfig:
    """Choose appropriate commitment level based on use case."""
    if use_case == "realtime_trading":
        return CommitmentConfig(CommitmentLevel.Processed)  # Fastest, least secure
    elif use_case == "user_interface":
        return CommitmentConfig(CommitmentLevel.Confirmed)  # Balance of speed and security
    elif use_case == "settlement":
        return CommitmentConfig(CommitmentLevel.Finalized)  # Slowest, most secure
    else:
        return CommitmentConfig(CommitmentLevel.Confirmed)  # Safe default

Response Processing

Handling RPC Responses

def process_account_info_response(response_data: dict) -> Optional[Account]:
    """Process GetAccountInfo response."""
    try:
        if response_data.get("value") is None:
            return None  # Account doesn't exist
        
        account_data = response_data["value"]
        
        # Parse account from RPC response
        account = Account(
            lamports=account_data["lamports"],
            data=base64.b64decode(account_data["data"][0]),  # Assuming base64 encoding
            owner=Pubkey.from_string(account_data["owner"]),
            executable=account_data["executable"],
            rent_epoch=account_data["rentEpoch"]
        )
        
        return account
    except Exception as e:
        print(f"Failed to process account info response: {e}")
        return None

def process_transaction_response(response_data: dict) -> Optional[dict]:
    """Process GetTransaction response."""
    try:
        if response_data.get("value") is None:
            return None  # Transaction not found
        
        tx_data = response_data["value"]
        
        # Extract useful information
        return {
            "slot": tx_data["slot"],
            "block_time": tx_data.get("blockTime"),
            "fee": tx_data["meta"]["fee"],
            "status": "success" if tx_data["meta"]["err"] is None else "failed",
            "error": tx_data["meta"]["err"],
            "log_messages": tx_data["meta"]["logMessages"]
        }
    except Exception as e:
        print(f"Failed to process transaction response: {e}")
        return None

Configuration Best Practices

Optimal Request Configuration

# For user interfaces - balance responsiveness and reliability
UI_CONFIG = RpcAccountInfoConfig(
    encoding=UiAccountEncoding.Base64,
    commitment=CommitmentConfig.confirmed()
)

# For token operations - parse token data automatically
TOKEN_CONFIG = RpcAccountInfoConfig(
    encoding=UiAccountEncoding.JsonParsed,
    commitment=CommitmentConfig.confirmed()
)

# For trading applications - prioritize speed
TRADING_CONFIG = RpcAccountInfoConfig(
    encoding=UiAccountEncoding.Base64,
    commitment=CommitmentConfig.processed()
)

# For settlement - prioritize finality
SETTLEMENT_CONFIG = RpcAccountInfoConfig(
    encoding=UiAccountEncoding.Base64,
    commitment=CommitmentConfig.finalized()
)

Install with Tessl CLI