Hook
A Bitcoin user lost 1.6 BTC in fees last week. Not a hack. Not a protocol bug. A script error. The transaction had one input, zero outputs, and a fee rate that peaked at roughly 441 sat/vB. The block: 962142, mined by SpiderPool. The cause: an automated RBF (Replace-By-Fee) script that kept raising the fee every second, with no cap. Total loss: ~$103,000 at current prices. This isn't a story about Bitcoin's security. It's a story about the gap between protocol maturity and application-layer carelessness.
Context
RBF (Replace-By-Fee) is a Bitcoin feature standardized in BIP125. It lets a sender replace an unconfirmed transaction with a new one using higher fees, to accelerate confirmation. It's opt-in: the original transaction must set a specific sequence number. Miners then choose the highest-fee version. This is a mature, well-understood mechanism. But the user's script weaponized it. The script generated a new replacement transaction every second, each with a higher fee. No max fee rate was set. No output was created. The entire input value—160,343,885 satoshis—became miner revenue. This is not a protocol flaw. It's a tooling failure.
Core
Let me walk through the technical autopsy. The transaction was single-input, zero-output. This is the first red flag. Any legitimate Bitcoin transaction must have at least one output—either a payment or a change address. A zero-output transaction is a pure fee burn. The script likely confused the change calculation with the fee field, or simply omitted the output construction entirely. Combined with the per-second RBF escalation, the script acted like a runaway loop: every iteration ate more of the UTXO until the pool confirmed the highest-fee version.
From my experience auditing automated trading scripts for institutional clients, this pattern is disturbingly common. The script probably began with a reasonable fee, say 10 sat/vB. Then the RBF loop doubled it every second: 10, 20, 40, 80... 441 sat/vB. The final fee rate was 10-40x the market average at the time (August 12-13, 2024, when typical fees were 10-50 sat/vB). The script ran for hours—the transaction was confirmed on block 962142, which was mined on August 13, but the replacement cycle likely started the previous day. The user probably had no monitoring; they woke up to a 1.6 BTC hole.
This is not a newbie mistake. The user was running a custom script, likely for ordinals inscription, lightning channel management, or a small market-making bot. Standard wallets like Electrum or BlueWallet have built-in fee caps and confirmation prompts. Custom scripts bypass those safeguards. The lesson is mechanical: any automation that manages UTXOs must hardcode a max_fee_rate and a circuit breaker that stops after N consecutive replacements. We didn't learn this from a smart contract hack; we learned it from a simple automation failure.
Contrarian
The mainstream narrative will frame this as 'Bitcoin fees are too high' or 'RBF is dangerous.' That's lazy. The contrarian truth: this event is a microcosm of the mismatch between protocol-level sophistication and user-level tooling. Bitcoin's L1 is a robust, permissionless settlement layer. RBF is a useful tool. The problem is the software layer between the user and the protocol. The 1.6 BTC didn't disappear; it transferred to miners. SpiderPool's block revenue jumped from ~3.125 BTC (subsidy) to ~4.945 BTC—a 58% boost. But that's a one-time windfall, not a systemic risk.
Yields don't care about your script logic; they just follow the fee market. The market impact of this event is zero. Bitcoin's daily trading volume is in the hundreds of billions. One 1.6 BTC fee is a rounding error. The real impact is on user confidence. Stories like this reinforce the perception that self-custody is dangerous, pushing capital toward custodians or L2s. But that's a feature, not a bug. The Bitcoin ecosystem is designed to absorb isolated failures without systemic contagion. The network didn't break; the user's script did.
Takeaway
If you run automated Bitcoin scripts, hardcode a max_fee_rate. Set a replacement limit. Add a kill switch. The cost of sloppy automation is not a protocol exploit—it's a 1.6 BTC tuition fee. We didn't need another hack to learn this. We needed a simple RBF loop to remind us that code doesn't have common sense. The next time you write a script, assume it will fail. Build safety rails before you deploy. Yields don't compensate for bugs.