Quick reference for the Solana node client transition from Solana Labs to Agave, covering deprecated methods, renamed endpoints, and migration steps.
TLDR:
Agave v2.0, with an October 21, 2024 upgrade deadline for nodes, removed several outdated RPC methods. Solana nodes on Chainstack return -32601 Method not found for them.
The code examples illustrate how to switch from confirmTransaction to getSignatureStatuses in both JavaScript and Python.
In brief
Agave is the Rust-based Solana node client that is also a fork of the original Solana Labs client.The primary purpose of Agave replacing the original Solana Labs client is to make the network multi-client. The multi-client part mostly means the introduction of another node client — the C-based Firedancer.The Agave v2.0 release schedule set October 21, 2024 as the upgrade deadline for nodes.Agave v2.0 removed the methods listed in Methods: deprecated and replaced, and later Agave releases don’t serve them either. Solana nodes on Chainstack return -32601 Method not found for each of them.See:
Replacing confirmTransaction with getSignatureStatuses
import { Connection, Transaction, SendOptions } from '@solana/web3.js';async function sendAndConfirmTransaction( connection: Connection, transaction: Transaction, timeout: number = 30000, // 30 seconds default timeout options?: SendOptions): Promise<string> { // Send the transaction const signature = await connection.sendTransaction(transaction, options?.signers || [], { ...options, skipPreflight: options?.skipPreflight || false }); // Create a promise that will reject after the timeout const timeoutPromise = new Promise((_, reject) => { setTimeout(() => { reject(new Error(`Transaction confirmation timeout after ${timeout}ms`)); }, timeout); }); // Create the confirmation promise const confirmationPromise = (async () => { let done = false; while (!done) { // Get the status of the transaction const response = await connection.getSignatureStatuses([signature]); const status = response.value[0]; if (status) { if (status.err) { throw new Error(`Transaction failed: ${status.err.toString()}`); } // Check if we have enough confirmations if (status.confirmationStatus === 'finalized') { done = true; return signature; } } // Wait a bit before checking again await new Promise(resolve => setTimeout(resolve, 1000)); } })(); // Race between timeout and confirmation try { return await Promise.race([confirmationPromise, timeoutPromise]); } catch (error) { // If it's a timeout error, we should still return the signature if (error.message.includes('timeout')) { return signature; } throw error; }}// Example usageasync function example() { const connection = new Connection('CHAINSTACK_NODE'); const transaction = new Transaction(); // ... add your transaction instructions here ... try { const signature = await sendAndConfirmTransaction(connection, transaction, 60000, { skipPreflight: false, // ... other options }); console.log('Transaction confirmed:', signature); } catch (error) { console.error('Transaction failed:', error); }}
from solana.rpc.async_api import AsyncClientfrom solana.rpc.commitment import Commitmentfrom solana.rpc.models import TxOptsfrom solders.transaction import VersionedTransactionfrom solders.transaction_status import TransactionConfirmationStatusfrom typing import Optional, List, Unionimport timeimport asynciofrom concurrent.futures import TimeoutErrorclass TransactionConfirmationError(Exception): """Custom exception for transaction confirmation errors""" passasync def send_and_confirm_transaction( client: AsyncClient, transaction: VersionedTransaction, signers: List, timeout: int = 30, # timeout in seconds commitment: Union[str, Commitment] = "finalized") -> str: """ Send and confirm a transaction using getSignatureStatuses Args: client: Solana client instance transaction: Signed transaction to send signers: List of signers for the transaction timeout: Maximum time to wait for confirmation in seconds commitment: Commitment level to use Returns: Transaction signature Raises: TransactionConfirmationError: If transaction fails or times out """ # Send the transaction try: response = await client.send_transaction( transaction, opts=TxOpts( skip_preflight=False, preflight_commitment=commitment ) ) signature = response.value except Exception as e: raise TransactionConfirmationError(f"Failed to send transaction: {str(e)}") # Start time for timeout tracking start_time = time.time() async def confirm_transaction() -> str: while True: try: # Check if we've exceeded timeout if time.time() - start_time > timeout: raise TimeoutError(f"Transaction confirmation timeout after {timeout} seconds") # Get transaction status response = await client.get_signature_statuses([signature]) if response.value[0] is None: # Transaction not yet processed, wait and retry await asyncio.sleep(1) continue status = response.value[0] # Check if transaction failed if status.err: raise TransactionConfirmationError( f"Transaction failed: {status.err}" ) # Check confirmation status conf_status = status.confirmation_status if conf_status == TransactionConfirmationStatus.Finalized: return str(signature) # Wait before checking again await asyncio.sleep(1) except TimeoutError: # Return signature even on timeout return str(signature) except Exception as e: if not isinstance(e, TimeoutError): raise TransactionConfirmationError(f"Confirmation failed: {str(e)}") try: return await confirm_transaction() except Exception as e: raise TransactionConfirmationError(str(e))# Example usageasync def example(): # Initialize client async with AsyncClient("CHAINSTACK_NODE") as client: # Build and sign your transaction transaction = ... # a VersionedTransaction with your instructions and signers try: signature = await send_and_confirm_transaction( client=client, transaction=transaction, signers=[], # Add your signers here timeout=60, # 60 seconds timeout commitment="finalized" ) print(f"Transaction confirmed: {signature}") except TransactionConfirmationError as e: print(f"Transaction failed: {str(e)}")# Run the exampleif __name__ == "__main__": asyncio.run(example())