How to hack bridges with orphan blocks
We got bridge relayers to pay recipients on Robinhood Chain for deposits that later disappeared from Ethereum during naturally occurring reorgs.
We found this while looking into running relayers for our latest MEV project. We tested Across, Relay, and LI.FI Intents.

Why relayers pay before settlement
In the flows we tested, a user deposits assets on one chain and specifies what they want to receive on another. A relayer, sometimes called a solver, sees the deposit event and pays the recipient from its own funds. That payment is the fill. The user chooses the recipient, so they can have the fill sent to a wallet they control. The relayer gets repaid later, through settlement.
For Across, settlement matches the destination fill against the source deposit and checks that their parameters agree. A fill needs a matching deposit to qualify for repayment. Relay and LI.FI Intents have different contracts and repayment rules, but the flows we tested also let a relayer pay before the source block is final.

Figure 1. Simplified Across flow. Repayment depends on a matching deposit in the canonical source-chain history.
When several relayers can fill an order, the first one gets the fee. Some orders give one relayer exclusive rights for a while. For the rest, waiting can mean losing the fee to someone faster. Ethereum finality takes minutes; a relayer completing transfers in seconds has to pay sooner.
What happens if there is a reorg?
A node’s canonical chain is the branch it currently follows under Ethereum’s fork-choice rule. The node can accept a valid block, execute its transactions, and later switch to a different branch. That’s a chain reorganization, or reorg. A block dropped from the canonical chain is commonly called an orphan block. Its state changes and events no longer belong to the history the node follows.
That means a relayer can get a successful receipt and a real deposit event from its RPC, then discover that the block containing them has been orphaned. Asking several RPC providers doesn’t settle this. Their nodes can agree on a block and then all switch to another branch.
An Ethereum logs subscription can report the old event again with removed: true, as Geth documents. An indexer can use that correction to delete a database row. A relayer cannot use it to undo money already sent on another chain.
The fill spends the relayer’s existing funds in a separate destination transaction. Removing the source deposit doesn’t automatically reverse it.
What our experiment showed
We ran successful experiments on Across, Relay, and LI.FI Intents. In each, relayers paid recipients even though Ethereum later removed the source deposits. We’ll use Across as an example below.
A reorg alone isn’t enough. Ethereum may include the original transaction again, recreating the deposit and allowing the relayer to be repaid. We needed to prevent that.
Our Across source transaction created five deposits totaling 1 ETH. The transaction used nonce 15. The orders were filled on Robinhood Chain; one of those fills paid 0.1999085 WETH to the recipient. Ethereum then orphaned the block containing the deposits.
The canonical chain included a different transaction from the same sender, also using nonce 15: a successful 0 ETH transfer back to the sender’s own address, with empty calldata. It made no deposit.
The original transaction had consumed nonce 15 on the discarded branch. On the surviving branch, the self-transfer consumed it instead. The original signed transaction could no longer be included there, so it couldn’t recreate the five deposits.
Figure 2. The deposit disappears, its replacement creates no deposit, and the destination fill survives. Records: deposit, replacement, fill.
Block timestamps don’t tell us exactly when a relayer received the event or detected the reorg.
The source funds were no longer locked by those deposits. The fills on Robinhood Chain remained, but they had no matching deposits to qualify for repayment under Across’s settlement rules.
Other ways a deposit can fail to return
Depending on the deposit contract, a transaction that gets included again can also fail to recreate the order the relayer filled.
One possibility is a deadline checked by the source deposit call. The call succeeds in the original block, but reverts if it’s included after that deadline. It then creates no deposit event. This requires a check on the source call; a deadline for filling the order on the destination chain doesn’t do the same thing.
Another is a deposit ID assigned from a contract’s counter. Suppose a deposit receives ID 42 in the original block. After a reorg, another deposit executes first, and the same call receives ID 43. The relayer’s earlier fill still refers to the old order. Across’s settlement checks the other order parameters too, so another deposit receiving ID 42 doesn’t automatically make that fill valid.
Across has deterministic IDs for some signature-authorized deposits, which avoid IDs changing with execution order. They don’t guarantee that the deposit itself will survive a reorg.
Optimizing the attack: predicting orphan blocks
We kept seeing orphaned blocks at slot 0, the first of the 32 slots in an Ethereum epoch. A 21-month study, covering September 2024 through May 2026, found the same pattern: 1.17% of slot-0 proposals were orphaned, compared with 0.16% across the other positions combined. Slot-0 proposals were about seven times as likely to be orphaned.

Figure 3. Each slice shows one slot’s share of the study’s 8,914 orphaned blocks. The comparison below the ring shows how often proposals were orphaned. Source data.
We also checked Etherscan’s forked-block list. The same fee recipient, 0x7e2a2FA2a064F693f0a55C5639476d913Ff12D05, kept appearing.
Figure 4. Etherscan’s forked-block list. The highlighted fee recipient appears repeatedly.
The study also found large differences between operators. About 31% of the Upbit-labeled cluster’s own slot-0 proposals were orphaned. That cluster accounted for roughly 18% of all slot-0 orphans in the dataset. Many of the orphaned blocks in the study arrived late, often after being built locally by the proposer, leaving less time for validators to see them before voting.
These observations helped us narrow down our attempts. We still needed a relayer to pay before the reorg, and the matching deposit had to stay gone.
Fast confirmation
So what should a relayer check before paying?
Ethereum’s Fast Confirmation Rule (FCR) uses validator votes to confirm blocks before finality. It runs in a consensus client and doesn’t require a hard fork.
FCR assumes that attackers control less than 25% of the stake and that validator votes arrive on time. The specification requires attestations from honest validators to arrive by the end of the slot in which they’re sent. If that assumption breaks, a fast-confirmed block can still be reorged, even without an attacker or slashable behavior. Full finality gives stronger guarantees.

Figure 5. FCR confirms blocks before full finality, under its stake and network assumptions. Times are typical, and the timeline is schematic.
EthPandaOps replayed mainnet data through four FCR implementations and reported zero false confirmations across 5.15 million client-slot evaluations. In the period covered by all four clients, roughly 96% of slots would have confirmed within 12 seconds. The replay used a reconstructed view of attestations, which doesn’t exactly match what an individual node would have received.
Using FCR
Lighthouse v8.3.0 supports FCR, disabled by default. When enabled, it makes the confirmed execution block available through the safe tag. The release notes recommend enabling it only on non-validating beacon nodes. If you use a hosted RPC, check what its provider returns for safe.
Before paying, a relayer should save the block hash from the deposit log and wait until that block is fast-confirmed or is an ancestor of the fast-confirmed block. Compare block hashes, since a different block can replace the deposit’s block at the same height.
Waiting still has a cost. A faster relayer can fill the order before you do. FCR reduces that wait compared with finality, but an operator still has to decide whether its assumptions are acceptable for the transfers it handles.
Conclusion
The relayers in our tests paid for deposits that Ethereum later removed. In the Across case, a same-nonce replacement prevented the original transaction from recreating them.
For relayers handling Ethereum deposits, we recommend checking the deposit block with FCR before filling an order. If FCR’s stake and network assumptions aren’t acceptable, wait for finality.

