account 0x7c41… next executable nonce
0x06confirmed
0x07missing
0x08queued
Five of your transactions are stuck. Only the first one is underpriced. The other four are perfectly well paid and completely unable to move, because Ethereum will not execute them until the one in front of them clears.
Every “transaction stuck” thread on every forum eventually fills with advice about gas. Raise the tip, raise the cap, wait for the base fee to drop. All of it assumes the problem is price. Half the time the problem is position, and no amount of gas fixes a position.
The thing that produces the position is a single integer per account, and it is the most misunderstood field in an Ethereum transaction. It is also the field I would make every user read once, because understanding it turns a panic into a fifteen-minute repair.
A nonce is a position, not a password
Every externally owned account — every address controlled by a private key rather than contract code — carries a counter. It starts at zero. The first transaction you send uses nonce 0, the next 1, and so on, forever.
A node will only execute a transaction whose nonce equals the account’s current on-chain count. Not lower, not higher. That single rule produces three outcomes:
| Your nonce | What the node does | The error you see |
|---|---|---|
| Lower than the count | discards it, the slot is already spent | nonce too low |
| Equal to the count | accepts it, eligible for the next block | nothing, it just works |
| Higher than the count | holds it, marked queued, waits for the gap to fill | nothing, it silently sits |
That third row is the one that ruins people’s mornings. There is no error. The wallet shows the transaction as pending, the explorer shows it as pending, and it will stay pending until the missing nonce arrives — possibly forever. A transaction sitting in a mempool is not evidence that it can execute independently. It is evidence that a node has it.
This is where the vocabulary matters. Pending means executable now: the nonce is exactly right. Queued means the nonce is ahead of the gap and the transaction is being held. The difference between them is the difference between “waiting for a block” and “waiting for you to fix something.”

If you want to know how many of your own transactions are in the air, subtract two numbers:
// latest = transactions already mined
// pending = mined + everything the node is holding for you
const latest = await provider.getTransactionCount(address, "latest");
const pending = await provider.getTransactionCount(address, "pending");
// pending - latest = how many nonces you have in flight
One caveat that matters more than it looks: pending describes the node you asked, not the network. Load-balanced RPC endpoints can give two different answers seconds apart, because there is no global transaction pool. If your count looks wrong, the first thing to check is which node answered.
The counter moves even when the transaction fails
Here is the detail that separates people who have actually debugged this from people who have read about it: the nonce increments when a transaction is included and executed, regardless of whether the execution succeeded.
A transaction that reverts still consumes its nonce and still pays gas. From the account’s point of view, the slot is spent. This is not a bug; it is the only sane design. If failed transactions left their slots open, an attacker could replay a failing transaction forever at no cost to its position, and the ordering guarantee would collapse.
The practical consequence: you cannot “undo” a bad transaction by making it fail. If it lands and reverts, you have paid for the attempt and moved forward one position. The only real undo is to get a different transaction confirmed at that same nonce before the bad one does.
Why a block cannot reorder you
It is worth asking why this constraint exists at all, because it is stricter than it needs to be for most purposes.
Within a block, transactions from the same sender must appear in ascending nonce order, and they execute sequentially against the state each previous one left behind. A builder cannot decide to include your nonce 8 and skip 7, even if 8 pays more. Two transactions from the same account can therefore never execute in parallel, and one cannot observe the other’s effects before it happens.
That is the cost of the account model: balances are a single mutable cell, and the only way to keep updates to that cell deterministic is to serialise them. Bitcoin does not have this problem because it does not have accounts — every input is an independent object, so two transactions spending different coins are naturally parallel. This is the deep trade at the centre of the UTXO-versus-account comparison: accounts give you simpler state and cheaper writes, and charge you in ordering.
Replacing and cancelling are the same operation
Because only one transaction can occupy a given nonce, a second transaction at the same nonce is by definition a replacement. There is no separate cancel opcode and no way to withdraw a signed transaction from the network.
A replacement is accepted only if it pays meaningfully more. Geth, which most of the network runs, defaults to a 10 percent price bump, and for EIP-1559 transactions that applies to both maxFeePerGas and maxPriorityFeePerGas. Bump one and not the other and you get replacement transaction underpriced, which is the node telling you that you tried to buy the slot at a discount.
nonce(n+1) = nonce(n) + 1the counter moves once per included transaction, success or revertCancelling is the same mechanism aimed at a different target. You send a transaction with the stuck nonce, zero value, to your own address, at a high fee. If it confirms, the slot is consumed, and the original transaction becomes permanently invalid — not deleted, just impossible. The cost of cancelling is the fee on a transfer of nothing to yourself.

The one hard limit: all of this works only while the transaction is pending. Once it is mined there is nothing left to replace. Which means the worst outcome is not “stuck” but “landed late” — the payment you gave up on arrives three days later, after you already sent it again.
What the nonce does not do
Now the cut that most explanations get wrong. Ask what stops someone from taking your signed transaction and rebroadcasting it, and you will hear “the nonce.” That is only half true, and the half it gets wrong causes real confusion.
The nonce prevents replay on the same chain: a transaction at nonce 7 cannot execute twice, because after the first execution the account count is 8. But a signature is just maths, and the same signed transaction is equally valid on any chain that shares the same account state. If Ethereum and a fork of Ethereum both start from the same state, a transaction signed for one is valid on the other.
EIP-155, activated in 2016 at block 2,675,000, fixed that by folding the chain ID into the signed payload. A transaction signed for chain 1 produces a different signature than the same transaction signed for chain 56, and neither will verify on the other. Cross-chain replay is a signature problem, solved in the signature. Same-chain replay is a state problem, solved by the counter.
Two mechanisms, two different jobs, constantly conflated. If you take one thing from this article, take that distinction.
Frontier Account model ships with a single scalar nonce per address and strict ordering.
EIP-155 Chain ID enters the signed payload. Cross-chain replay dies; the nonce stays a counter.
EIP-1559 Two fee fields replace gas price. Replacement now has to beat both by the bump.
EIP-4337 Smart accounts get 2D nonces: a key plus a sequence, so streams can run in parallel.
Where this is heading
Account abstraction exists largely because of the constraint in this article. A smart account under EIP-4337 uses a two-dimensional nonce — one part identifying a parallel stream, one part ordering within it — so a swap and an airdrop claim no longer block each other. That is not a fix to the protocol; it is a fix built on top of it, by people who got tired of explaining that a well-paid transaction can be stuck behind a badly paid one.

For now, three things are worth doing:
- If a transaction is stuck, check the fee and the nonce. A gap is not a price problem.
- Never cancel a nonce out of order. Clear from the oldest pending nonce forward, one at a time.
- When sending from two devices with the same key, expect drift. Both track their own idea of the next nonce and only one can be right.
A nonce is four bytes of ordering discipline. It is boring, it is load-bearing, and it is the reason your five transactions are not slow — they are in line, and the line starts at a number you can see.
(The End)


