Sending and Confirming Transactions

Submitting a transaction to Solana is never a single step. When sendTransaction returns a signature it means only that https://solana.therpc.io/YOUR_API_KEY accepted the bytes and forwarded them to the leader — not that the transaction landed in a block or succeeded. Acceptance and settlement are two distinct phases, and treating the returned signature as proof of success is the most common way developers lose money or ship double-spends. This guide walks through a send-and-confirm loop that holds up under network congestion: simulate first, attach a priority fee, submit, then poll the signature's status until it reaches your target commitment or the blockhash expires.

The Send Flow

• Get a fresh blockhash. Call getLatestBlockhash and keep both the blockhash and the lastValidBlockHeight it returns — the latter is the expiry deadline you will check against later.
• Simulate (recommended). Run simulateTransaction to catch program errors before paying any fee and to size the compute units the transaction will actually consume.
• Add a priority fee. Read recent fee levels with getRecentPrioritizationFees and attach a compute-unit price so your transaction competes for block space when the cluster is busy.
• Submit. Send the signed bytes with sendTransaction. The signature you get back means accepted for forwarding — never confirmed.
• Confirm. Poll getSignatureStatuses for that signature, or subscribe once with signatureSubscribe over WebSocket, until it reaches confirmed or finalized.
• Know when to stop. Once getBlockHeight passes the lastValidBlockHeight you saved, the blockhash has expired and the transaction can never land — stop retrying and rebuild with a new blockhash.

Send and Confirm

1import { Connection } from '@solana/web3.js';
2 
3const connection = new Connection('https://solana.therpc.io/YOUR_API_KEY', 'confirmed');
4 
5async function sendAndConfirm(signedTx) {
6  // Simulate first to catch errors before paying
7  const sim = await connection.simulateTransaction(signedTx);
8  if (sim.value.err) throw new Error('Simulation failed: ' + JSON.stringify(sim.value.err));
9 
10  const signature = await connection.sendTransaction(signedTx, {
11    skipPreflight: false,
12    preflightCommitment: 'confirmed',
13    maxRetries: 5,
14  });
15 
16  // Poll until confirmed or the blockhash window closes
17  for (let i = 0; i < 30; i++) {
18    const { value } = await connection.getSignatureStatuses([signature]);
19    const status = value[0];
20    if (status?.err) throw new Error('Transaction failed: ' + JSON.stringify(status.err));
21    if (status?.confirmationStatus === 'confirmed' || status?.confirmationStatus === 'finalized') {
22      return signature;
23    }
24    await new Promise((r) => setTimeout(r, 1000));
25  }
26  throw new Error('Transaction not confirmed before timeout');
27}

Best Practices

• Fetch the blockhash late. A blockhash is only valid for roughly 150 blocks, so grab it right before signing — fetching it early wastes part of the window and risks expiry before you even submit.
• Always poll after submitting. Treat the signature from sendTransaction as a receipt, not a result. Poll getSignatureStatuses (or use signatureSubscribe) every step; never assume acceptance equals confirmation.
• Read the simulation on failure. When preflight fails, inspect the returned simulation results — the logs and error tell you whether to fix the instruction or rebuild, instead of blindly resending the same doomed transaction.
• Pay to land during congestion. When slots are full, raise your compute-unit price based on getRecentPrioritizationFees so your transaction is picked up rather than dropped.
• Encode and retry sensibly. Send wire bytes as base64 and pair sendTransaction with a matching maxRetries so a transient drop is re-broadcast while the blockhash is still valid.

See also

• sendTransaction - Submit a signed transaction
• simulateTransaction - Dry-run before sending
• getSignatureStatuses - Poll for confirmation
• getRecentPrioritizationFees - Size a priority fee