Your channel balance is gone. Not stolen — burned.
On September 14, ACINQ shipped Eclair 0.14.3. A patch note. A wallet upgrade recommendation. Bitcoin Optech confirming the fix. Most people scrolled past it. Most people were wrong to. Because buried inside that release are three vulnerabilities that don't behave like the attacks you're used to. There is no attacker wallet to trace. No drain address to blacklist. No exploit contract waiting in a mempool. The money leaves your channel and lands in a miner's coinbase. That's the part nobody is talking about.
I've traded through three cycles and lost real money learning the difference between a hack and a config error wearing a hack's clothes. This is the second kind. And if you run a Lightning node — especially a routing node — this is the most important thing you'll read this week.
Context: Who Is Eclair, And Why Should You Care
Eclair is a Lightning Network node implementation built by ACINQ. It's the minority implementation. LND from Lightning Labs is the default base layer for most of the ecosystem — BTCPay Server runs on it, the majority of enterprise nodes run on it. Core Lightning sits somewhere in the middle. Eclair is the aggressive one.
Aggressive means it ships features fastest. Splicing — the ability to resize a channel's on-chain funding without closing it. On-the-fly funding, also called JIT channels — opening a channel at the exact moment you forward a payment through it. These are Eclair's differentiators. They're also, as of last week, the exact places where the attacks landed.
Here's the summary. Three vulnerabilities. One: cooperative close fee manipulation. A malicious peer proposes a closing fee that exceeds the victim's local balance. Eclair's fallback negotiation logic — designed to keep a deal alive when the first proposal fails — accepts it. The victim's output is erased. Their balance burns as a fee to the miner. Two: incomplete splice fund lockup. Eclair signs first, the peer withholds their signature, and the latest channel state now depends on a transaction the victim cannot broadcast. Three: JIT expiry manipulation. A malicious wallet games payment expiry, collects the outbound on-chain payment, lets the inbound payment expire, and dumps the loss on the routing node.
None of them involve private key theft. All three require the attacker to be your direct channel counterparty. All three were patched. And all three tell you something about where Lightning is actually fragile.
The competitive picture matters here. When I look at the Lightning implementation layer, I see a market that has quietly reordered its priorities. For years the fight was about features — fees, routing, liquidity. Now the fight is about safety. LND and Eclair came under pressure in the same window. That's not coincidence. That's a maturity phase, and the operators who read it wrong will pay for it.
Core: Decoding the Three Bugs
Let me take these apart one at a time. Because the mechanics matter more than the headlines.
The Fee-Burn Paradox
Start with the cooperative close attack. In a cooperative close, both parties agree to shut the channel and split the funds. Someone has to pay the on-chain fee. Eclair, as the initiator in certain flows, handles the fee proposal. A malicious peer proposes a fee higher than what the victim holds in the channel. Eclair's fallback logic accepted a proposal that wiped the victim out.
Read that again. The victim's local balance didn't get redirected to the attacker. It got redirected to the miner. The victim's satoshis became the fee. That's a fee-burn, not a theft.
This is where most people's threat model breaks. We're trained to look for the attacker's profit. Money in, money out, follow the trail. Here there's no trail to follow because the attacker walks away empty-handed. The value is destroyed from the channel and recreated as miner revenue on Layer 1.
Which raises the obvious question. Why would anyone do this? Three possibilities. One: the attacker is a miner, or colludes with one. The burned fee comes right back as block reward. Two: pure griefing — the attacker's goal is destruction, not profit. Three: the attacker targets a third party downstream. If your channel counterparty is an exchange running the victim node, wiping the channel hurts the exchange's withdrawal rails. That's a second-order attack.
The economic rationality of this attack only exists if the attacker captures the burned value indirectly — through mining, through competitive sabotage, or through a downstream target.
That's the single most important sentence in this whole report. Because it tells you this is not a hobbyist attack. This requires resources, coordination, or a grudge. And it tells you the patch is a hardening, not a solution to a solved problem.
There's a deeper coupling here that almost nobody is discussing. When a fee-burn attack executes, the burned satoshis show up as an abnormally high-fee transaction. That distorts the fee estimator. The same estimator that nodes rely on to set their closing fees. So the attack doesn't just destroy value — it can poison the signal that other nodes use to price their own closes. That's an oracle-style dependency risk hiding inside a funding path. I've been screaming about feed latency and estimator trust in DeFi oracles for years, and here it is again, wearing a Bitcoin hat.
I learned this lesson in 2018, after the ICO bubble popped and I liquidated my portfolio to study Uniswap. I ran fifty-plus swaps on the Ethereum testnet by hand, logging every failed transaction in a Notion database. What I learned wasn't about slippage math. It was that the value in any trade goes to whoever controls the rails — and the rails here are the miner fee market. When the fee-burn attacker strikes, the miner is the house. The house always gets paid.
The Splice Lockup
Vulnerability two is subtler. Splicing lets you resize a channel without closing it — you swap the funding transaction for a new one. The catch is that splicing is a multi-step, two-party signing dance. Eclair signed its half. The malicious peer withheld theirs. Now the latest channel state is anchored to a transaction the victim cannot broadcast. The funds are frozen. Not stolen. Trapped.
Pain is just data you haven't decoded yet. And the data here says something specific: this attack pattern — withhold a signature, broadcast an old state, use the payment preimage to collect the outbound leg — is the signature of the replacement cycling family.
That name matters. Antoine Riard disclosed a class of Lightning attacks built around repeatedly replacing transactions so the counterparty can't respond in time. He later stepped back from Lightning development over the risk. I won't claim Eclair's splice bug is a confirmed member of that family — the source material doesn't name it. But the fingerprint is there. Withhold. Broadcast stale. Harvest.
Splicing is new. Replacement cycling is a known theoretical threat. When you ship a new feature on top of a known threat class without hardening the interaction, you don't get a new bug. You get an old bug with a new front door.
You need an independent audit to tell you a new feature is safe. But what I've seen in this ecosystem is that audits lag behind feature delivery — sometimes by months. The audit came too late for anyone running Eclair's splicing in production. If you ship the feature before you ship the security proof, you're running an unverified experiment with real money.
The JIT Expiry Machine
Vulnerability three targets routing nodes specifically. On-the-fly funding opens a channel at the moment a payment needs forwarding — a liquidity bootstrap. The malicious wallet manipulates payment expiry. The inbound payment expires. The outbound on-chain payment gets collected. The routing node providing the liquidity eats the difference.
This is counterparty risk dressed as a feature. The routing node's whole business model is providing liquidity and earning fees for it. JIT funding is the ultimate expression of that — you provide capital the instant it's needed. The bug turns that instant-provision instinct into a liability. The fix — requiring inspection of routing fees and expiry buffers before committing funds — is a trust boundary tightening. It says: don't trust the counterparty's timing. Verify it.
Market noise is just fear wearing a suit. And JIT is a feature that turns a node's confidence into exposure. That's the whole game. Confidence is the thing that gets you killed in a market full of adversarial peers.
The Operational Attack Surface
Now zoom out. Because Eclair isn't the whole story. The same week, BTCPay Server — the open-source Bitcoin payment processor — went public with its own incident. Attackers were targeting exposed LND nodes. The vector wasn't a cryptographic break. It was operational.
An exposed LND API plus a manually reopened external connection equals a takeoverable node. The macaroon — LND's API credential — grants fine-grained control. Expose it and someone else holds your keys. BTCPay's mitigations were telling: unique passwords, edge-level blocking of unauthenticated routes, and a warning not to expose the API. That's operational hardening, not a software fix.
That distinction is everything. If the mitigation is a config change, the root cause is a design choice. BTCPay hardened its perimeter because the vulnerability lived in how nodes get exposed, not in how the code gets compiled. And here's the part that should scare you: there are bots probing for these exposures. Repeatedly. Automatically. This isn't a targeted campaign waiting for a victim. This is mass scanning. Which means any exposed node — yours, mine, the exchange down the street — is a candidate.
I deployed an AI trading agent in 2026. It ran a 25% monthly return for six months after I manually capped its risk parameters. The lesson there applies here. Overfitting kills. Automation amplifies whatever bias you feed it. A bot scanning for exposed LND endpoints isn't clever. It's tireless. And tirelessness beats cleverness when the target set is large enough.
The human element is the real bug. BTCPay's incident didn't happen because someone broke cryptography. It happened because someone manually reopened external access, creating a brief unlock window that a bot swept up. That's not a hack. That's an operator deciding that five minutes of downtime was more painful than five minutes of exposure.
I know that decision. In 2021, during the NFT floor-price frenzy, I did 200 BAYC trades in three months and netted $15,000. Then I missed a gas fee optimization window during peak congestion and gave a chunk of it back. I wasn't hacked. I was exhausted. And when you're exhausted, you make config decisions that a bot punishes within seconds. The Eclair fee-burn, the BTCPay exposure — they exploit the same human weakness. Fatigue.
Contrarian: The Real Risk Isn't the Bug
Here's what the headlines get wrong.
"Entire balance straight to miners." That phrase is doing a lot of emotional work. It sounds like a heist. It isn't. The vulnerabilities were found, patched, and disclosed responsibly. ACINQ shipped 0.14.3. Bitcoin Optech verified it. The Eclair code paths were hardened. Anyone who upgrades is safe. The bug is dead.
The surviving risk is not the bug. It's the response time.
The candlestick doesn't lie, but your bias might. And your bias — the trader's bias — is to believe a known vulnerability is a contained one. It isn't. A known vulnerability plus an unupgraded node is an open wound. The patch exists. The question is whether the operator applied it.
Look at the failure mode. The Eclair bugs require a malicious channel counterparty. The LND attacks require an exposed API. Both are eliminated by action, not by waiting. And the three Eclair bugs cluster in new features — splicing, JIT — which tells you the pattern: feature velocity is outrunning security validation, and that gap is where the money dies.
That's the ecosystem-level signal. Two implementations under pressure in the same window. Not a coincidence. A maturity phase. And here's the contrarian kicker. The attacker in the fee-burn attack gains nothing directly. So either it's griefing, miner collusion, or a downstream third party. All three are worse than a simple theft. A thief stops when the money runs out. A griefer doesn't.
Takeaway: What You Actually Do
Actionable, in order.
Check your node version. If you're on Eclair, be on 0.14.3. No exceptions. Set the automatic fee ceiling to a conservative value — the new 50 sat/vB default is a floor of safety, not a suggestion.
If you run anything touching LND, especially behind BTCPay, audit your exposure right now. No API on the open internet. Unique passwords. Edge-level blocking. Assume a bot is already knocking.
If you run a routing node, treat every new counterparty as a potential attacker. Upgrade, then audit your forwarding config, then start a blacklist. Splicing and JIT attacks hunt routing nodes because that's where the liquidity pools.
And then watch. The question isn't whether Eclair got patched — it did. The question is whether the next feature ships before the next bug. Because the loop is: new feature, new attack surface, new patch, and the operators who move first survive while the ones who read the patch notes three weeks late become miner revenue.
Which side of that trade are you on?
