A Solana transaction can report an instruction error, charge a fee, and still remain valid for submission because execution outcome and transaction lifetime are separate. The failed instructions are rolled back, but the signed message may still be inside its recent-blockhash processing window. Treating an error or a missing confirmation as permission to immediately build and sign another transaction can create duplicate transfers, confusing wallet prompts, or an AlreadyProcessed response.
The safe rule is simple: keep the original signature, monitor that exact signature and its saved lastValidBlockHeight, and wait for confirmation or blockhash expiry before deciding whether to retry. When you do retry, rebuild the message and collect every required signature again.
As an Amazon Associate I earn from qualifying purchases.
Execution failure and expiration are different events
Solana handles a transaction in stages. First, the cluster validates the message and determines whether it can be processed. Then it executes the instructions. Separately, the recent blockhash gives the signed message a finite period during which validators may accept it.
An instruction can fail during execution while the message is still inside that validity period. In that case, state changes made by the transaction’s instructions are reverted, but the transaction fee is still charged. The failure therefore answers, “What happened when this transaction executed?” It does not answer, “Can this signed message still be accepted?”
#1 Best Overall
- Effortlessly build your crypto portfolio via the all in one Ledger Wallet app: buy, sell, send, receive, swap, stake and more across popular blockchains. 15,000+ coins & tokens in a single dashboard. Keep a close eye on the market. Compare service providers. Track performance. Get timely alerts. Build your portfolio with confidence.
- Enjoy Bluetooth connectivity, iOS access, and hours of battery use with this mobile-first, secure backup signer. Freedom you can depend on.
- Genuine Check: confirm your signer is authentic during setup with the Ledger Wallet app.
- Protect your signer: keep it in mint condition at all times with a bespoke Pod or Case to avoid scratches and everyday wear and tear.
This distinction explains the apparently contradictory wallet experience: an explorer may show an error and a fee deduction, while the transaction’s blockhash has not yet expired. A replacement submitted immediately afterward is not automatically safe, because the original message might still be accepted by the cluster or may already have been processed by another path.
What a failed execution means
- The transaction reached instruction execution.
- Instruction state changes were rolled back when an instruction returned an error.
- The fee for the processed transaction remains charged.
- The original signed message retains its normal blockhash lifetime unless another rule, such as nonce handling, applies.
The base fee listed in the current Solana transactions reference is 5,000 lamports per signature. Fee schedules can change, and additional fee rules may apply, so treat that figure as the documentation’s listed base fee rather than a permanent price.
What expiration means
Expiration is a lifetime decision. A recent blockhash is accepted only while it remains within Solana’s processing-age limit. The transactions reference identifies that limit as 150 slots. A slot is not a fixed number of seconds, so converting 150 slots into a wall-clock timer is unreliable. Use the transaction’s block-height limit instead.
Do these 3 things before closing this tab:
1Repair Windows errors before they cause bigger problems2Fix the driver behind crashes, sound loss and screen glitches3Clear out junk files and repair common Windows errorsHow the recent-blockhash lifetime works
When an application requests a recent blockhash, the response includes the blockhash and a corresponding lastValidBlockHeight. The blockhash is part of the bytes that signers authorize. The height is the boundary the application uses to determine whether that particular message has expired.
Save both values with the user’s operation. The blockhash identifies what was signed; lastValidBlockHeight identifies how long the message can remain processable. Do not discard the height after constructing the transaction, and do not substitute an estimate based on seconds.
The 150-slot limit is not a countdown in seconds
Slot production can vary. Network conditions, validator performance, and cluster activity affect how quickly block height advances. “150 slots” is therefore a protocol processing-age limit, not a promise that every transaction expires after one universal number of seconds.
For the same reason, a short client-side timeout is not an expiry proof. A request can time out locally while the cluster is still processing the original message. Conversely, a transaction can become unprocessable even though a user interface has not refreshed.
Quick wins for a faster PC:
Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Clear out junk files and repair common Windows errorsFree Scan →Rank #2
- Proven security at scale: Over 9 years and millions of cards issued with no known remote hacks, while military‑grade EAL6+ security keeps your private keys locked inside the chip. Your cryptocurrencies stay strongly protected from online attackers.
- Tap once to manage your entire crypto wallet across 90 blockchains - no USB cables or Bluetooth, no batteries, no setup. Access 14,100+ coins & tokens, DeFi, NFTs, and staking instantly from your phone
- Smart backup: Use your second Tangem Wallet as your Backup keys with end‑to‑end encryption; no more papers, pictures. If one card is lost, the remaining can still restore full access, with an optional seed phrase available for advanced users.
- Engineered to last up to 25 years: Waterproof (IP69K), shockproof and tested for extreme temperatures from −25°C to 50°C. A durable cold wallet with long‑term protection and independently audited security.
- Trusted by 6 million users worldwide (4.9 App Store, 4.8 Google Play) - buy, sell, swap, stake, and spend cryptocurrency directly. The secure offline storage wallet designed for how people actually use crypto wallets
Status checks answer a different question from retry decisions
Query the status of the signature you actually submitted. Solana’s getSignatureStatuses RPC method reports what the cluster currently knows about that signature at the commitment level selected by the application.
A status result is evidence about cluster observation; it is not, by itself, a replacement policy. A temporarily missing status can mean that the transaction has not reached the node you queried, that the node has not observed it yet, or that it is no longer retained in the node’s status cache. None of those possibilities proves that the signed message cannot still land.
Use one commitment policy consistently
Choose the confirmation commitment your application requires and use it consistently when checking status and when deciding that an outcome is final enough for the user. Mixing commitment levels can make one component report success while another still reports uncertainty.
Keep the original signature associated with the user’s action in your database or operation state. If the interface is closed, the backend should still be able to continue checking that signature and its lifetime rather than creating a second signing request when the user returns.
Free tools Windows power users keep installed
One-click scans. No signup required.
A safe retry sequence for an ordinary transaction
The following sequence separates submission, observation, and retry. It is suitable for a transaction that uses a normal recent blockhash rather than a durable nonce.
- Fetch a blockhash and its height limit. Request the latest blockhash and retain both the returned blockhash and
lastValidBlockHeight. - Build the complete message. Include the fee payer, account list, instruction order, instruction data, and blockhash before asking any signer to approve it.
- Collect signatures once. Obtain all required signatures for those exact message bytes and retain the signed transaction or serialized message as an operation record.
- Submit once and save the signature. Record the signature returned by submission. Do not create a replacement merely because the submission call timed out or the first status query is empty.
- Poll the same signature. Call
getSignatureStatusesusing the application’s chosen commitment. If it reports success, finish the operation. If it reports an execution error, show the error and fee consequence, but continue tracking the original lifetime. - Check block height for an unconfirmed result. Poll
getBlockHeightat the commitment your application uses for expiry decisions. Compare the returned height with the savedlastValidBlockHeight. - Wait until the height passes the limit. Treat the transaction as expired only when the observed block height exceeds the saved
lastValidBlockHeight, following the official expiry-check pattern. A missing status before that point is not enough. - Rebuild after expiry. Fetch a fresh blockhash, construct a new message, and collect every required signature again. Submit the new transaction as a new attempt with its own signature and height limit.
For an asynchronous withdrawal, Solana’s exchange integration guidance specifically advises waiting for blockhash expiry before retrying a transfer that does not appear confirmed or finalized. That rule protects against a delayed original becoming effective after a replacement has already been sent.
Why the original signature must stay attached to the operation
The signature is the identifier for the exact signed message that was submitted. Replacing it with a newly generated client-side identifier loses the ability to distinguish “still pending,” “failed during execution,” “expired,” and “retried successfully.” Store at least the original signature, blockhash, last-valid block height, current status, and the user’s intended operation identifier.
Rank #3
- Seedless by design, nothing to steal: Your private key is generated inside the EAL6+ chip and never leaves it. No seed phrase is shown or typed at setup, so a tampered device, keylogger, or phishing site has nothing to capture. 9+ years, millions of card.
- Tap once to manage your entire crypto wallet across 90 blockchains - no USB cables or Bluetooth, no batteries, no setup. Access 16,100+ coins & tokens, DeFi, NFTs, and staking instantly from your phone
- Backup without a seed phrase: Your wallet is copied to 2 backup cards with end-to-end encryption, so there are no words on paper to lose or leak. Keep them in separate places; if one card is lost, the others restore full access. Optional seed phrase for advanced users.
- Engineered to last up to 25 years: Waterproof (IP69K), shockproof and tested for extreme temperatures from −25°C to 50°C. A durable cold wallet with long‑term protection and independently audited security.
- Trusted by 6 million users worldwide - buy, sell, swap, stake, and spend cryptocurrency directly. The secure offline storage wallet designed for how people actually use crypto wallets
Why changing a transaction requires new signatures
A Solana signature authorizes message bytes, not an abstract intention such as “send these tokens whenever convenient.” The message includes fields such as the fee payer, recent blockhash, account list, instruction order, and instruction data.
Changing any of those fields creates a different message. Solana’s partial-signing documentation states: “Changing the fee payer, blockhash, instruction order, account list, or any instruction data produces a different message and invalidates every signature already collected.” The practical consequence is that a fresh blockhash is not a harmless edit to an existing signed transaction; it requires a new signing flow.
Changes that invalidate prior signatures
- Replacing the blockhash after expiry.
- Changing the fee payer.
- Adding, removing, or reordering accounts.
- Changing instruction order.
- Changing instruction data, including an amount or destination.
When a retry is necessary, make the new message explicit in the user interface and request signatures again from every required signer. Never assume that a signature from the first attempt authorizes the rebuilt bytes.
How to prevent a second signing prompt in an application
The protocol cannot know whether two wallet prompts represent one user action or two intentional actions. Idempotency and prompt suppression are application responsibilities.
Use an operation record
Create one internal operation ID for the user’s intended action before signing. Associate that ID with the first message, all signatures, the submitted signature, blockhash metadata, and the current lifecycle state. A page reload or process restart should resume that operation instead of creating a second one.
Recommended Free Tools
Separate lifecycle states
Use distinct states rather than a single Boolean such as “failed.” A useful model is:
- Awaiting signature: no complete signature set exists.
- Signed: the message is fully signed but not yet submitted.
- Submitted: a signature has been returned and is being tracked.
- Execution failed: the cluster reported an instruction error; the original lifetime is still tracked.
- Confirmed: the chosen commitment reports the required result.
- Expired: observed block height exceeded the saved limit without a final result.
- Retrying: a new message is being built after expiry and requires new signatures.
Only the transition to Expired should normally enable an ordinary recent-blockhash retry. An execution error should usually end the operation as a failed attempt, but it should not be treated as proof that a replacement can be signed while the original message remains live.
Rank #4
- EAL5+ CERTIFIED SECURE ELEMENT + FINGERPRINT PROTECTION — Your private keys stay encrypted offline on a certified EAL5+ chip, the same security tier used in EMV bank cards. Built by DCENT, securing crypto since 2018. Fingerprint authentication adds a second layer no PIN-only wallet can match.
- 10,000+ ASSETS NATIVE ON 100+ BLOCKCHAINS — Hold Bitcoin, Ethereum, XRP, Solana, Cardano, popular stablecoins (USDT, USDC), and NFTs in one wallet. No third-party apps, no fragmented setup — every supported asset works straight out of the box.
- TAP-TO-SIGN MOBILE EXPERIENCE — Pair your wallet with the DCENT mobile app over Bluetooth. Manage tokens, review transactions, and access in-app swap features directly from your phone — no cables, no desktop required.
- WEB3 & dAPP ACCESS VIA METAMASK — Connect to MetaMask and other browser extension wallets to manage NFTs, claim airdrops, and access dApps. A large screen and intuitive 4-button interface keep every transaction clearly visible before you sign.
- SEAMLESS FIRMWARE UPDATES & 30-DAY MONEY-BACK GUARANTEE — Apply security updates without resetting your wallet or migrating funds. Backed by Amazon's 30-day money-back guarantee — your purchase is risk-free.
Make submission and retry idempotent
Guard the retry path with the operation ID and a server-side lock or equivalent concurrency control. Two browser tabs, a webhook, and a background worker should not all decide independently that a transaction needs a replacement. This is an implementation practice, not a guarantee provided by the Solana protocol, so it must be enforced in the application that coordinates signing and submission.
Durable nonce transactions have a different lifetime
A durable nonce stores a nonce value in an on-chain nonce account. It is designed for delayed or offline signing and does not use the ordinary recent-blockhash expiry window in the same way. The lifetime question is therefore different, but the “sign only once for one message” rule still applies.
| Lifecycle question | Recent-blockhash transaction | Durable-nonce transaction |
|---|---|---|
| Lifetime | Limited by the recent-blockhash processing-age window; retain and evaluate lastValidBlockHeight. |
Uses a stored nonce, allowing delayed or offline signing instead of relying on the ordinary recent-blockhash window. |
| What an instruction failure does | Instruction state changes revert and the transaction fee is charged. | The nonce advancement and fee remain committed even when a later instruction fails. |
| Safe next attempt | Wait for confirmation or expiry; after expiry, rebuild with a fresh blockhash and collect signatures again. | Refetch the updated nonce, build a new message, and start a fresh signing flow. |
| Main caution | A missing or late confirmation is not the same as expiry. | Do not reuse a nonce transaction whose nonce was consumed; nonce validation failures and post-validation execution failures have different fee behavior. |
Nonce advancement happens before instruction execution
For a valid durable-nonce transaction, the nonce advances before the transaction’s other instructions execute. If one of those instructions then fails, the failed state changes are not applied, but the nonce advancement and transaction fee are still committed. Reusing the old signed bytes would therefore attempt to use a consumed nonce.
After processing a nonce transaction, inspect or refetch the nonce account. If another attempt is required, obtain the updated nonce and create a new message with new signatures.
Nonce validation failure is a separate case
A transaction can be rejected before execution when the nonce has already been used, the nonce account is missing or invalid, or the required nonce-authority signature is absent. In that validation-failure case, the documented behavior is no fee and no state changes. Do not confuse it with a nonce transaction that passed validation and later failed an instruction; those two cases have different consequences.
Solana’s durable-nonce documentation currently warns that durable nonces may be deprecated in a future release. Check the current protocol status before designing new architecture around them.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Recognizing common errors without misclassifying them
Instruction execution error
This indicates that execution reached an instruction and that the transaction’s instruction state changes were rolled back. The fee remains charged. The message may still be within its recent-blockhash lifetime, so the error does not authorize an immediate replacement.
Best Value
- Dual-chip architecture for maximum protection: The next-gen, fully auditable TROPIC01 chip works alongside a certified EAL6+ Secure Element—completely NDA-free—to deliver radically transparent, industry-leading defense against physical attacks.
- Quantum-ready security: Get protection against future threats with the first-ever hardware wallet designed with quantum-ready architecture.
- See every detail with confidence: Our largest high-resolution color touchscreen makes it easy to navigate your assets, review transactions and manage your coins with clarity.
- Wireless freedom with encrypted Bluetooth control: Manage, buy, swap and stake securely using Trezor Suite on desktop or mobile. Qi2-compatible wireless charging keeps your Trezor powered up. No cables required—security meets convenience.
- Works seamlessly with Android, iOS and desktop: Connect wirelessly or via USB-C to your phone or computer. Manage your crypto anywhere with our companion Trezor Suite app.
AlreadyProcessed
The transaction pipeline keeps a status cache keyed to the message hash and rejects a message that is already present there. This duplicate check is separate from the earlier instruction failure. Seeing AlreadyProcessed is not evidence that an application’s retry logic was safe; it is evidence that the same message hash was recognized as already processed.
BlockhashNotFound
This means the blockhash is absent from the recent queue and the transaction is not a valid durable-nonce transaction. It is a blockhash-lifetime or validity problem, not an instruction-level result. Build a new message with a current blockhash and collect the required signatures again.
Nonce validation failure
Used or invalid nonce data, a missing nonce account, or a missing authority signature can cause rejection before execution. Because execution did not begin, the documented behavior is no fee and no state changes for this validation-failure case.
Example polling logic
The exact SDK wrapper varies, but the decision logic can be represented as follows. The important details are that the code retains the original signature and height limit, checks status for that signature, and does not retry until the observed height passes the saved limit.
const { blockhash, lastValidBlockHeight } = await getLatestBlockhash();
const message = buildMessage({ blockhash, operation });
const signed = await collectAllSignatures(message);
const signature = await sendTransaction(signed);
while (true) {
const status = await getSignatureStatuses([signature]);
if (status?.err) {
recordExecutionFailure(signature, status.err);
// Keep tracking lifetime; do not sign a replacement here.
}
if (status?.confirmationStateIsSufficient) {
markConfirmed(signature);
break;
}
const height = await getBlockHeight();
if (height > lastValidBlockHeight) {
markExpired(signature);
break;
}
await waitBeforePollingAgain();
}
// Only after expiry:
const fresh = await getLatestBlockhash();
const replacementMessage = buildMessage({
blockhash: fresh.blockhash,
operation
});
const replacementSigned = await collectAllSignatures(replacementMessage);
const replacementSignature = await sendTransaction(replacementSigned);This is deliberately a control-flow example, not a promise that every client library uses these property names. Preserve the same semantics when adapting it: one operation record, one original signature, block-height-based expiry, and a complete re-signing flow for changed bytes.
What users should see in the interface
A clear status message prevents the user from interpreting every error as a request to sign again. Explain whether the cluster reported an execution error, whether the transaction is still being tracked, and whether the message has expired.
- After an execution error: state that the instruction failed, state changes were reverted, and the fee was charged; do not immediately present a second signing prompt.
- While status is unknown but the blockhash is live: state that confirmation is still being checked and that the original signed transaction may still land.
- After expiry: explain that the original message can no longer be processed with its old blockhash and that a new transaction requires a new signature.
- For a durable nonce: explain that a failed execution consumed the nonce and that another attempt must use a newly fetched nonce.
Keep “retry” disabled while another worker or tab is already tracking the same operation. If the user intentionally wants a different amount, destination, fee payer, or instruction set, treat that as a new action rather than an automatic retry.
Crashes, No Sound, or Screen Glitches?
Random freezes, missing sound and display glitches usually trace back to one bad driver. Find and replace yours safely.Free scan · under a minutePC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11Operational checklist
- Save the blockhash and
lastValidBlockHeightreturned together. - Save the exact signature returned by submission.
- Query
getSignatureStatusesfor that signature, not for a newly generated replacement. - Use a consistent commitment level for status and expiry decisions.
- Use
getBlockHeightto determine expiry; do not guess from elapsed seconds. - Do not equate an execution error, a timeout, or an empty status with expiry.
- Wait for confirmation or expiry before ordinary recent-blockhash retry.
- After expiry, rebuild the message and obtain every required signature again.
- For durable nonces, refetch the nonce after processing and never reuse a consumed nonce message.
- Keep retry coordination idempotent across browser tabs, workers, webhooks, and process restarts.
The practical answer
A failed Solana transaction can remain valid because failure describes instruction execution while validity describes whether the signed message’s blockhash is still acceptable. The fee and rollback behavior belong to execution; the 150-slot processing-age limit and saved lastValidBlockHeight belong to lifetime.
Track the original signature until the cluster reports a sufficient result or block height proves expiry. Only then decide whether another attempt is needed. Any rebuilt transaction—whether it changes only the blockhash or changes business details as well—is a new message and must be signed by every required signer. Durable nonce transactions follow a different lifetime, but a validated transaction that fails execution still consumes the nonce, so the next attempt must fetch a new one.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
