Jupiter swap
Jupiter swap status checks distinguish completed trades from unresolved attempts
Jupiter swap transactions need an on-chain status check before you approve a replacement trade. A timeout means the application stopped waiting; the original transaction may still execute. Find its transaction signature, inspect its confirmation status and check for an execution error. A successful result calls for output reconciliation, while an unresolved attempt needs further investigation before another approval.
Updated onThe signature connects the submitted exchange to its network record. Keep it alongside the selected tokens and quoted amount. An unchanged balance or a stalled progress message alone doesn't establish whether the exchange completed, failed or remains eligible to execute.
In short: A pending message doesn't establish failure; check the original transaction before authorizing another exchange of the same tokens.
The quoted exchange and its execution record
The quote identifies the intended input and expected output. Before signing, review the selected tokens, amount and acceptable output. You can decline to sign or request a different quote without executing that proposed exchange. Signing authorizes the transaction, while submission hands it to the execution service or network. The resulting record identifies what actually happened. Jupiter's managed execution response can include a signature, status, error information and actual input and output amounts. Preserve the response when a connection problem interrupts the application.
Match the signature to the attempt you're investigating before interpreting its status. Several approvals can produce separate transactions with similar amounts. A request identifier used by an application isn't interchangeable with the transaction signature used for an on-chain lookup. For direct Solana submission, receiving a signature confirms the node accepted the request; it doesn't establish successful execution.
Confirmation status and execution outcome
A transaction record answers separate questions: whether the network has accepted the block containing it and whether its instructions succeeded. Read the confirmation status together with the execution error field.
Processed
A processed status means the queried node has processed the transaction's block. That block can still leave the accepted chain. Treat this as an intermediate observation when deciding whether a replacement would duplicate an exchange. An early successful execution result doesn't carry the same finality as a finalized record.
Confirmed and finalized
A confirmed block has received votes from a supermajority of stake. Finalized is the strongest confirmation state the network exposes. These labels describe block commitment, so a finalized transaction can still contain an execution error. To establish that a finalized swap succeeded, check both its finalized status and the absence of an execution error.
Execution errors
The
err
field reports an execution error when one occurred. Within an existing status record,
err: null
indicates no reported execution error. A missing status record is different: it supplies no execution outcome. Don't interpret every appearance of
null
as either success or failure.
Why does my transaction lookup return no result?
A missing result means the queried service hasn't returned a matching record within that lookup's scope. It doesn't establish that the transaction failed. The status method
getSignatureStatuses
searches a recent cache unless
searchTransactionHistory
requests a broader search. An older transaction may therefore need a history lookup.
The method
getTransaction
also returns no transaction when it can't find one at the requested commitment. A finalized lookup can lag behind an earlier confirmation. Check the signature, network and requested commitment before drawing a conclusion. When services disagree, retain the uncertainty until their records establish the outcome; repeatedly refreshing the same incomplete response doesn't strengthen it.
Expiration before replacement approval
Expiration establishes whether an unprocessed transaction can still land. It doesn't erase an exchange that already completed. The applicable expiration rule depends on how the original transaction was constructed.
Recent-blockhash transactions
A transaction using a recent blockhash has a limited validity window. An integration should retain the
lastValidBlockHeight
associated with that exact blockhash and compare it with the block height returned by getBlockHeight at confirmed commitment.
For a recent-blockhash transaction, a confirmed block height beyond its associated last valid block height establishes expiration.
The threshold belongs to the original transaction; fetching a new blockhash doesn't reveal the old one's deadline.
Nonce-based transactions
A durable nonce transaction uses a stored nonce value instead of ordinary recent-blockhash expiration. Its validity requires checking the relevant nonce state. Don't apply a fixed waiting period or an unrelated block-height threshold to it. A transaction's construction determines the applicable rule, even when the application presents the same pending message.
A pending exchange checked before another approval
Consider a hypothetical attempt where the application times out after submission. Assume the saved signature belongs to a recent-blockhash transaction, its associated expiry threshold is available and the first lookup returns no status. The wallet user wants to complete the exchange without submitting an additional trade while the original remains unresolved.
The available choices are to continue read-only status checks or approve a newly quoted replacement. Both depend on the same question: has the first attempt completed, or can it still execute? A recent-blockhash transaction can't execute after its validity window ends. The block-height threshold and current network height are values specific to this attempt.
In this hypothetical case, the checked block height remains below the saved threshold. The wallet user continues checking the original signature without approving another trade. A later lookup returns a finalized record with no execution error. The transaction's token changes match the selected input and output, so the exchange is complete and no replacement is necessary.
A finalized record containing an execution error would instead establish that this attempt failed to complete the exchange. Expiration without a successful execution record would require establishing that it didn't land before considering a replacement. A missing or incomplete history response would leave that question unresolved. The expired transaction itself cannot execute later.
Recorded failures and a fresh approval
A failed on-chain transaction doesn't partially complete its swap instructions. Solana processes the swap instructions atomically: an instruction failure rolls back the swap's state changes. Transaction fees can still remain. This distinction explains why a recorded failure may leave no received tokens while the fee payer's balance has decreased.
A replacement needs a fresh review of the selected input, available balance and acceptable output. Address the reported failure first. A slippage error concerns the transaction's permitted output terms; raising tolerance doesn't resolve an unknown transaction status. A newly signed exchange also doesn't cancel an earlier successful trade or restore its original terms.
Which record confirms the tokens actually arrived?
The successful transaction's account changes establish which tokens moved and where they went. For an output held in a token account, match the output mint and receiving account to the intended exchange, then inspect the recorded token amounts. A wallet's current total can include other transfers, so it may not isolate this particular swap.
Transaction metadata can contain token balances before and after execution, account identifiers and the fee charged. Keep these together with the signature when an application display disagrees with the record. Missing metadata needs further investigation rather than another approval. A successful finalized swap remains completed even when its display needs correction; compare the receiving token account's preTokenBalances with
postTokenBalances. If the output is unwrapped SOL, inspect native SOL balance changes and account for transaction fees and any account creation or closure.
Jupiter swap: what people ask
Does a successful simulation mean my pending Jupiter swap completed?
A successful simulation doesn't establish that the swap executed on-chain. Simulation evaluates a transaction against a particular state before submission. The exchange still needs to land and produce a successful execution record. Keep the simulation result separate from the status associated with the submitted transaction signature.
Can a rate-limit error justify submitting the swap again?
A rate-limit error doesn't establish anything about the original swap's execution. It means the service rejected that lookup request. Allow the lookup service to recover or check through another functioning service on the same network. Preserve the original signature while resolving the missing status instead of treating the lookup error as a failed trade.
How can I investigate a swap if I lost its transaction signature?
The wallet's transaction history may help recover the matching signature. An integration can also query confirmed transactions referencing the wallet address with getSignaturesForAddress. Match the candidate transaction's token movements and account details to the intended exchange. Absence from that history doesn't establish that an unresolved submission never occurred.
Why does my integration report an unsupported transaction version during a status investigation?
An unsupported-version error concerns the client's ability to retrieve or interpret the transaction. It doesn't report a failed swap. The getTransaction request supports maxSupportedTransactionVersion, which must reflect the transaction versions the client can handle. Correct the retrieval configuration before deciding what happened to the exchange.
Is wallet signing required just to look up a pending transaction?
Looking up a transaction by its public signature doesn't require wallet signing or a recovery phrase. Signing authorizes a transaction; a status query reads an existing record. If a supposed status check requests approval for another swap, inspect that request as a separate authorization rather than treating it as part of the lookup.