Jupiter swap trades become irreversible after successful finalization

Quote rejection and the execution record

If you no longer want the quoted route, decline approval before signing to avoid executing the exchange. Review the selected tokens, input amount and acceptable output before signing. After submission, the transaction signature identifies the attempt you need to investigate. Jupiter's execution response can include that signature and actual input and output amounts; preserve those details when the application reports an uncertain result.

Can I stop a swap after signing it?

You can withhold a signed transaction you still control locally, but you can't reliably recall one you've already handed to a service or the network. Signing authorizes the transaction; submission sends that authorization onward.

Many wallet interactions combine approval with immediate submission. Don't assume there's a separate pause between clicking approval and broadcasting. The relevant question is whether the application already received your signed transaction, rather than whether its progress indicator has changed.

A network node can accept a transaction before the wider network confirms it. The submission response therefore proves receipt by that node, not successful execution. The node may continue forwarding the transaction while its blockhash remains valid.

Closing a tab or disconnecting the wallet doesn't send a cancellation instruction for that submitted transaction. Those actions change the application's connection. They don't erase the signed instructions a network participant already holds.

View full-size image

Changing the amount or output token creates different instructions that need fresh authorization. It doesn't amend the first submitted trade. Treat another approval as a potentially additional exchange until the original attempt's outcome is clear.

Pending transactions and blockhash expiration

An unresolved transaction remains a duplicate-execution risk while it can still land, even when the application has stopped waiting for confirmation. A timeout describes the application's wait, not the ledger's outcome.

Ordinary recent-blockhash transactions have a validity boundary. Integrations can compare the network's block height with the transaction's lastValidBlockHeight. For this check, use the confirmed block height and wait until it exceeds that last valid height. Expiration prevents a previously unprocessed transaction from landing later; it doesn't erase an exchange that landed before the boundary. Establish both expiration and the absence of an earlier successful execution before building a replacement. A fixed countdown in seconds is a weaker test because block production varies.

This block-height rule applies to recent-blockhash transactions. Custom transactions using durable nonces have a different validity mechanism, so an integration must identify which transaction type it created.

Status fields that separate success from uncertainty

A useful status check combines execution outcome with confirmation strength, because a transaction can appear in a finalized block and still contain an execution error. Read both fields before treating the swap as complete.

View full-size image

The processed state can belong to a block the network later abandons. Confirmation provides stronger evidence; finalization is the strongest of these states. None gives the trader an intervening cancellation right. For a completed exchange, require a successful execution record as well as the confirmation level you're checking.

Failed execution and charges that remain

A swap transaction that records an execution failure doesn't leave its exchange instructions partly completed, although the fee payer can still incur a network charge. Solana executes a transaction's instructions atomically, so an instruction failure reverts their state changes. This boundary covers the instructions inside that transaction. A separate transaction that already succeeded remains separate.

Network fees pay for processing and can remain payable when execution fails. That differs from rejecting a wallet request before submission, where that unsigned request never reaches execution. Also distinguish a simulation rejection from a failure recorded on the ledger. A displayed error message alone doesn't establish which occurred or whether a fee was charged. The transaction record identifies the fee payer and recorded fee.

Output reconciliation after a reported success

A successful record establishes what the transaction executed, while its balance changes establish which tokens the receiving accounts gained or spent. Match the output mint and account ownership to the intended destination.

Transaction metadata can contain token balances before and after execution, with mint identifiers and decimal information. These fields help distinguish the actual received amount from the earlier quote. Keep native balance movements separate from token movements when accounting for fees or account funding. A wallet's total portfolio valuation isn't an adequate substitute for token-level reconciliation.

A missing transaction lookup also needs interpretation. The record may be unavailable at the requested confirmation level rather than absent from the network altogether. Changing the query or allowing confirmation to progress can resolve that uncertainty. Repeating the exchange doesn't resolve the first transaction's status.

Does swapping back reverse the original trade?

Swapping back creates a new exchange under new execution conditions; it doesn't reverse the original transaction or restore its earlier terms. The original successful trade remains part of the ledger.

View full-size image

A return trade requires an available route for the tokens you now hold. Its output depends on available liquidity, the selected amount and the applicable execution terms. Fees and price movement can change how much of the original token you receive. The earlier quote doesn't reserve a return price, and a successful purchase doesn't establish that an acceptable return route will exist later.

Slippage protection belongs to the execution conditions of each transaction. It doesn't provide a refund after a trade completes within its authorized terms. Likewise, correcting a mistaken token selection requires a separate action involving the token actually received.

Open-order cancellation and completed fills

An open conditional or recurring order has a cancellation process distinct from an immediate swap already submitted for execution. In Jupiter's Trigger V2 flow, initiating cancellation stops further fills and returns an unsigned withdrawal transaction. Sign and submit that withdrawal through the cancellation flow, then verify successful on-chain execution and the returned wallet balance. For recurring orders, cancellation returns the unfilled remainder; it doesn't reverse rounds that already executed. The amount remaining and the cancellation status determine what can still return to the wallet.

Evidence for an unresolved exchange

A support investigation needs enough information to locate the exact attempt and distinguish its recorded result from what the interface displayed. Preserve the transaction signature, wallet address, selected token mints and error text. Include the approximate attempt time and any execution request identifier the application provides.

Those records support diagnosis; they don't create a rollback operation. Jupiter's transaction-recovery explanation identifies an unanswered submission as an ambiguous state because the exchange may already have executed. Creating a different transaction without resolving that state can produce a second swap. If the original record shows successful finalization, investigate any balance discrepancy against that record before approving another trade.