One Integer Blocks Everything Behind It: Reading Ethereum’s Account Nonce

The account nonce is not a security feature; it is a position. One underpriced transaction parks every well-paid transaction behind it, and the only repair is to occupy the slot yourself.

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 nonceWhat the node doesThe error you see
Lower than the countdiscards it, the slot is already spentnonce too low
Equal to the countaccepts it, eligible for the next blocknothing, it just works
Higher than the countholds it, marked queued, waits for the gap to fillnothing, 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.”

One Integer Blocks Everything Behind It: Reading Ethereum's Account Nonce
Oljylautta, Public domain, via Wikimedia Commons

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 revert

Cancelling 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.

One Integer Blocks Everything Behind It: Reading Ethereum's Account Nonce
Unknown author, Public domain, via Wikimedia Commons

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.

  1. Frontier Account model ships with a single scalar nonce per address and strict ordering.

  2. EIP-155 Chain ID enters the signed payload. Cross-chain replay dies; the nonce stays a counter.

  3. EIP-1559 Two fee fields replace gas price. Replacement now has to beat both by the bump.

  4. 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.

One Integer Blocks Everything Behind It: Reading Ethereum's Account Nonce
Carlos ZGZ from Paris, France, CC BY 2.0, via Wikimedia Commons

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)

Ethereum

The Approval You Never Sent: Reading an EIP-712 Signature Field by Field

2026-10-30 1:02:28

Analysis

FinCEN Withdraws the $3,000 Crypto Wallet Rule: What Actually Changed

2026-10-8 0:11:20

❯
Profile
Cart
Coupons
Search