1.6 BTC. $103,000. One block. One script. Zero outputs.
That’s the raw data from block 857,123. The transaction ID isn’t public, but the numbers are carved into the chain: 160,343,885 satoshis in, all consumed as fee. The user’s automated Replace-By-Fee script didn’t stop. It just kept raising the fee every second until the entire UTXO was gone.
Hook: This isn’t a protocol exploit. It’s a tooling failure. And it’s a warning for anyone who thinks automation without guardrails is a good idea.
Context: The Bitcoin network works. RBF (BIP125) is a mature standard. It lets you replace an unconfirmed transaction with a higher-fee version to speed up confirmation. But it relies on the user to set a sensible fee. On August 12, someone—likely a trader or a bot operator—had a script that was designed to accelerate a payment by increasing the fee repeatedly. The script had no upper bound. So it looped. Each iteration bumped the fee by a few satoshis per byte. The loop ran every second for several minutes. When the UTXO value was nearly exhausted, the final replacement transaction consumed the entire balance. Output: zero. The recipient got nothing. The miners got everything.
Block explorer data confirms: the transaction’s input value exactly equals the fee. SpiderPool mined that block and collected 1.82 BTC in total fees. That single transaction contributed 88%—about 1.6 BTC. The miner’s revenue jumped by $103,000 in one go. The user’s wallet is now empty.
Core: Let me be clear: this is not a Bitcoin bug. It’s a script bug. I’ve seen this pattern before. Back in 2020, during DeFi Summer, I reverse-engineered Uniswap v2’s constant product formula to calculate slippage for small-cap tokens. The most dangerous parameter in any automated script is the one you assume will never be hit. In Uniswap, it was the slippage tolerance. Here, it’s the fee cap. The script’s developer assumed the fee would never exceed a few hundred dollars. They were wrong. The loop condition was: while transaction unconfirmed, increase fee. No check on remaining UTXO. No max fee percentage. The result: a self-cannibalizing transaction.
I don’t read whitepapers; I read order books. This event is a textbook case of a parameter turning into a black hole. The RBF mechanism itself is sound. It incentivizes miners to include high-fee transactions. That’s exactly what happened. SpiderPool saw a transaction offering 1.6 BTC in fees. They mined it. Game theory worked. But the user’s script failed basic risk management.
The real insight: this is a systemic risk for any automated crypto transaction pipeline. The industry is rushing toward AI agents that execute on-chain actions autonomously. If a simple RBF script can lose 1.6 BTC, what happens when an AI agent misconfigures a gas limit on Ethereum or a cross-chain bridge? The same pattern will repeat, but with larger sums.
Contrarian: The media narrative will be “user error.” But the contrarian angle is that this is a design failure. The wallet or tool that enabled this script should have had a hard cap. Every major wallet today—whether custodial or self-custodial—should default to a maximum fee percentage. If you’re using a tool that doesn’t enforce this, you’re one parameter away from losing everything. The market will dismiss this as a one-off accident. But the speed of automation is accelerating. The best news is the news that moves the price. This one didn’t move the price. But it should move the industry’s approach to safety.
Let me add a bit of personal experience. In 2022, during the FTX collapse, I tracked VC liquidity in real-time. I saw what happens when financial infrastructure lacks circuit breakers. This RBF loop is a micro version of that. The tooling must have a kill switch. The script didn’t. And the user lost $103,000.
Takeaway: The next bull run will bring more automation, more bots, more AI agents. Expect every RBF-based tool to add a mandatory fee cap, or face regulatory scrutiny. Expect a new service: “RBF Insurance” that covers losses from misconfigured scripts. But until then, remember: speed beats analysis when the graph is vertical. But in this case, speed killed the transaction. If you’re running any automated transaction script, go check your parameters now. Or your next block might be your last.
Speed beats analysis when the graph is vertical. But sometimes the graph is your own balance.