AQ
← All projectsACINQ

Eclair

Scala implementation of a Lightning Network node.

BitcoinLightning NetworkNormal
Repository coverage

231 commits in the local evidence base

Every captured commit receives deterministic security triage and a separate communication-quality score. Security candidates and broader second-pass signals receive full-patch Ollama analysis.

66security candidates48second-pass queue208AI analyses
4commits · 30 days
26commits · 60 days
80commits · 180 days
161commits · 365 days
Backfill bands
Aug 5 → Feb 691 seen11 candidatesComplete
Feb 6 → Jun 660 seen5 candidatesComplete
Jun 6 → Jul 62 seen0 candidatesComplete
Jul 6 → Aug 514 seen0 candidatesComplete
Commit communication

Does the history explain itself?

Message quality measures whether a commit identifies its scope, purpose, rationale, testing, and supporting references. It does not change the security-severity score.

78/100 average clarity
143Strong · 80–100
54Adequate · 60–79
23Thin · 40–59
11Opaque · 0–39
3security candidates with opaque commit messaging
Read the scoring rubric →
Developer activity

Who is changing the project?

Public Git author strings; identities are not independently verified.

DeveloperCommitsCandidatesAnalyzedHigh riskMessage avg.
pm47451633876
Bastien Teinturier13332127581
Fabrice Drouin291424269
Thomas HUET16116075
rorp313069
Nishant Bansal212084
dependabot[bot]111081
ekzyis101058
Rusty Russell101081
Analysis record

Published AI watches

Last scanned 47 minutes ago

Informational 15 AI analysisMessage 36 · Opaque
AQ ACINQEclair BitcoinLightning Network

Back to dev (#3424)

This commit is a routine post-release housekeeping change. It bumps the software version from 0.14.6 to 0.15.0-SNAPSHOT across several build files, adds a blank release-notes template for the next version, and intentionally adds a startup …

Startup guard added to block accidental execution of development snapshotNo vulnerability fix, cryptographic change, or trust-boundary modification present
c96c3d44by Fabrice Drouin+73−57 files
No security note in commit
High 74 AI analysisMessage 53 · Thin
AQ ACINQEclair BitcoinLightning Network

Eclair v0.14.6 release (#3420)

This commit is the release packaging for Eclair v0.14.6. The release notes explicitly state it contains 'security hardening fixes' that can be exploited by malicious nodes, and thank a researcher for responsible disclosure. The actual code…

Vendor release notes explicitly label the release as containing 'security hardening fixes' exploitable by malicious nodesNew default-on configuration `require-confirmed-inputs-for-splicing` mitigates unconfirmed-input double-spend risk during splicingRelease notes credit @erickcestari for responsible disclosures
50e046efby Fabrice Drouin+28−198 files
Vendor flagged security relevance
High 72 AI analysisMessage 88 · Strong
AQ ACINQEclair BitcoinLightning Network

Splicing robustness improvements (#3417)

This commit hardens Eclair's Lightning channel 'splicing' feature against a malicious peer. Splicing lets users resize a channel by creating a new funding transaction. The patch fixes several ways an attacker could exploit unconfirmed spli…

New default-on configuration `require-confirmed-inputs-for-splicing` to prevent double-spend of unconfirmed splice inputsLimit on remote splice inputs/outputs (10) to bound CPFP costForce-close now selects a commitment whose funding tx is known to bitcoind, re-evaluated per block and splice spend events
c07cc745by pm47+518−6011 files
Vendor flagged security relevance
Moderate 64 AI analysisMessage 81 · Strong
AQ ACINQEclair BitcoinLightning Network

Flag peers that leave liquidity fees unpaid (#3416)

This commit fixes a security gap in Eclair's Lightning node software. A peer could repeatedly get free channel funding ('liquidity') by backing out of payments meant to cover the fees right before the funding transaction was signed. Previo…

Fixes a logic flaw allowing repeated unpaid liquidity feesAdds peer suspicion flagging tied to funding txidExpands state handling for asynchronous LiquidityPurchaseAborted events
c5b9afc0by pm47+192−154 files
Vendor flagged security relevance
Informational 15 AI analysisMessage 36 · Opaque
AQ ACINQEclair BitcoinLightning Network

Back to dev (#3413)

This commit is a routine post-release housekeeping change. It bumps the project version from 0.14.5 to 0.15.0-SNAPSHOT, removes published release checksums, and adds a blank release-notes template. It also adds a startup guard that refuses…

No vulnerability signals presentStartup guard added to block accidental use of development snapshot
06716fceby Fabrice Drouin+73−108 files
No security note in commit
Moderate 67 AI analysisMessage 53 · Thin
AQ ACINQEclair BitcoinLightning Network

Eclair v0.14.5 release (#3412)

This commit is the release packaging for Eclair v0.14.5. The release notes state it is a patch release containing 'security hardening fixes' that can be exploited by malicious nodes, and thank two people for responsible disclosures. The ac…

Release notes explicitly describe 'security hardening fixes' and warn that 'some of these issues can be exploited by malicious nodes'Two independent researchers are credited for responsible disclosuresRemoval of an 'unsafe startup' guard indicates the prior development snapshot was considered unsafe and this release is meant to be safe to run
01384e93by Fabrice Drouin+14−268 files
Vendor flagged security relevance
High 82 AI analysisMessage 81 · Strong
AQ ACINQEclair BitcoinLightning Network

Check remote previous txOut against the blockchain (#3411)

This commit fixes a security bug in Eclair's taproot channel splicing. When two users splice a Lightning channel, one side can describe its bitcoin inputs by sending only a small summary (the txOut) instead of the full previous transaction…

Missing cryptographic/chain validation of peer-supplied transaction dataTaproot signature commits to spent outputs, making a signed-but-unconfirmable splice possiblePotential HTLC theft via old commitment publication after splice timeout
ae0927edby pm47+111−43 files
Vendor flagged security relevance
High 78 AI analysisMessage 86 · Strong
AQ ACINQEclair BitcoinLightning Network

Reject onion per-hop lengths that overflow an `Int` (#3408)

This fix closes a denial-of-service bug in Eclair's Lightning onion routing. A remote sender could craft a malformed per-hop payload length that, when converted from a large number to a normal integer, wrapped around to a negative or tiny …

Integer overflow / truncation from Long to IntNegative length bypasses upper-bound checkException escapes Try block causing DoS
40279a1bby pm47+20−32 files
Vendor flagged security relevance
Informational 15 AI analysisMessage 36 · Opaque
AQ ACINQEclair BitcoinLightning Network

Back to dev (#3405)

This commit is a routine post-release housekeeping change. It bumps the project version from 0.14.4 to 0.15.0-SNAPSHOT, removes the published checksums for the 0.14.4 release, and adds a placeholder release-notes file for the next version.…

No security-relevant code changesAdded explicit unsafe-startup guard to prevent accidental use of development snapshotNo references to CVEs, advisories, or security issues in commit message or diff
c4910b7bby Fabrice Drouin+73−108 files
No security note in commit
High 84 AI analysisMessage 53 · Thin
AQ ACINQEclair BitcoinLightning Network

Eclair v0.14.4 release (#3403)

This commit is the official release marker for Eclair v0.14.4. The release notes included in the commit describe it as a security-hardening patch release with fixes for multiple issues, some of which can be exploited by malicious nodes. Th…

Release notes explicitly label the release as containing 'security hardening fixes' exploitable by malicious nodesHTTP API now rejects Origin-header requests to mitigate browser-based CSRF against basic-authenticated endpointsSeed file length validation added (commit a07fff5)
e1c212c4by Fabrice Drouin+90−8210 files
Vendor flagged security relevance
High 82 AI analysisMessage 93 · Strong
AQ ACINQEclair BitcoinLightning Network

Retry publishing txs evicted by unconfirmed conflicts (#3397)

This commit fixes a security bug in the Eclair Lightning node where a malicious peer could trick the node into permanently giving up on publishing its own commitment or penalty transactions. By publishing and then double-spending a conflic…

The commit message explicitly describes theft risk: "This lets them steal HTLCs by publishing their commitment later"Attack vector involves a malicious peer withholding tx_signatures and double-spending a splice inputFix changes abandonment logic for local commit anchor preconditions
21f1bc8dby pm47+100−254 files
Vendor flagged security relevance
Moderate 66 AI analysisMessage 93 · Strong
AQ ACINQEclair BitcoinLightning Network

Keep unsigned settlements when rejecting commands (#3401)

This commit fixes a bug in Eclair, a Bitcoin Lightning Network node implementation. When the node received a duplicate command to settle a payment (fulfill or fail), it would mistakenly delete the still-pending settlement from its database…

Loss of pending HTLC settlement state on disconnect/reconnectUpstream HTLC timeout risk for relayed fulfilled downstream HTLCsDuplicate/conflicting command handling caused premature DB acknowledgement
7686dfadby pm47+38−32 files
Vendor flagged security relevance
Moderate 66 AI analysisMessage 81 · Strong
AQ ACINQEclair BitcoinLightning Network

Force-close again when a splice RBF sibling confirms (#3400)

This commit fixes a bug in Eclair, a Bitcoin Lightning Network node implementation. When one node force-closed a channel because its peer never finished signing a 'splice' (a way to resize a Lightning channel on-chain), and the peer later …

Funds-locking bug in channel close logicHTLCs not enforced on-chain after confirmed double-spendIncorrect re-force-close trigger condition
9a1ecc99by pm47+59−72 files
Vendor flagged security relevance
Critical 89 AI analysisMessage 78 · Adequate
AQ ACINQEclair BitcoinLightning Network

Reject unpublishable splices (#3396)

This commit fixes a set of vulnerabilities in Eclair's Lightning channel splicing protocol that could let a malicious peer trick the victim into signing a splice transaction that can never be published on the Bitcoin network. Because the v…

Commit title and message explicitly describe preventing a malicious peer from making us sign an unpublishable splice transactionAdds validation of absolute lockTime against current block height to prevent indefinite publication delayAdds rejection of BIP 68 relative lock time on all interactive-tx inputs, including shared splice input
af994180by pm47+235−35 files
Vendor flagged security relevance
High 74 AI analysisMessage 81 · Strong
AQ ACINQEclair BitcoinLightning Network

Reject onion per-hop lengths exceeding packet (#3395)

This commit fixes a bug in how Eclair processes encrypted routing instructions (onion packets) for Lightning payments. A malicious sender could craft a packet that claimed its inner payload was longer than the packet itself. The old code e…

Unchecked length field from attacker-controlled onion packet used for slicingException thrown outside Try block, bypassing expected error handlingRelayer crash could leave HTLC un-failed
d3a146a0by pm47+16−22 files
Vendor flagged security relevance
Moderate 53 AI analysisMessage 98 · Strong
AQ ACINQEclair BitcoinLightning Network

Remove `spendfromchanneladdress` nonce after one sig (#3392)

This commit fixes a cryptographic safety issue in a manual Bitcoin/Lightning recovery tool. When a user runs the `spendfromchanneladdress` operation, the code was re-reading a secret signing nonce from a stored map after using it once. Non…

nonce reuse prevention in Schnorr-like/MuSig2 partial signature flowprivate nonce removed from in-memory store after single usemanual recovery command affected, not hot path
c89af115by pm47+1−11 file
Vendor flagged security relevance
Moderate 66 AI analysisMessage 88 · Strong
AQ ACINQEclair BitcoinLightning Network

Reject seed files with an invalid length (#3389)

This patch fixes a bug in the Eclair Bitcoin Lightning node where, if the node crashed while creating its secret seed file, it could leave an empty file behind. On the next restart, Eclair would silently use that empty seed to generate all…

Use of weak/predictable cryptographic seed for key derivationMissing input validation on security-critical seed fileNon-atomic file write creating corrupt/empty secret material
a07fff56by pm47+31−12 files
Vendor flagged security relevance
Low 25 AI analysisMessage 81 · Strong
AQ ACINQEclair BitcoinLightning Network

Upgrade postgresql client from 42.7.11 to 42.7.12 (#3330)

This commit updates the PostgreSQL database driver used by Eclair from version 42.7.11 to 42.7.12. It is a routine dependency bump by an automated tool. The commit itself does not say what bugs the new driver fixes, but small point-release…

Dependency version bump of a database driverPoint-release upgrade may include upstream security fixes, but none are named in the commitNo application code changes or direct vulnerability evidence in the diff
972dfe99by dependabot[bot]+3−12 files
No security note in commit
Low 31 AI analysisMessage 58 · Thin
AQ ACINQEclair BitcoinLightning Network

Use bitcoin-kmp 0.49 (depends on bitcoin-kmp 0.32.0 and secp256k1-kmp 0.24.0) (#3362)

This commit updates Eclair's Bitcoin library dependency from version 0.48 to 0.49, which internally uses newer versions of bitcoin-kmp and secp256k1-kmp. The code changes only replace old property accesses (like `.txid`) with new method ca…

Dependency version bump for Bitcoin and secp256k1 cryptographic librariesSource changes are API adaptations (.txid -> .getTxid), not logic changesSecurity-critical validation code is touched (PSBT/transaction integrity checks against malicious Bitcoin Core)
6162e2aaby Fabrice Drouin+22−44 files
No security note in commit
Informational 15 AI analysisMessage 86 · Strong
AQ ACINQEclair BitcoinLightning Network

Update build to improve release process (#3381)

This commit is a routine build-system update. It upgrades several Maven plugin versions, removes the git commit ID from one jar manifest field to avoid a build-time circular dependency, and adds an optional build profile for a fuzz-testing…

c3e9f5d6by Fabrice Drouin+834−105 files
No security note in commit
Repository ledger

Explore captured commits

Expand any commit for its author, full message, clarity score, changed files, triage signals, analysis, and source link.

Security candidateEclair v0.14.6 release (#3420)by Fabrice Drouin · 50e046ef · Oct 27, 2026 · 8 filesMessage 53 · ThinHigh 74Details
Commit message · Fabrice Drouin

Eclair v0.14.6 release (#3420)

Eclair v0.14.6 release

53/100 · ThinMessage clarity
✓ Descriptive subject✓ Names a concrete action or component✓ Links an issue, advisory, or supporting reference! No meaningful explanatory body
Why it was queued
cryptography-sensitive path
AI analysis · High 74/100

This commit is the release packaging for Eclair v0.14.6. The release notes explicitly state it contains 'security hardening fixes' that can be exploited by malicious nodes, and thank a researcher for responsible disclosure. The actual code changes in the commit are only version bumps and removal of a startup blocker; the security fixes themselves are not visible in this single commit. A new default setting is added that requires confirmed inputs for splicing to prevent a specific double-spend risk.

Security candidateFlag peers that leave liquidity fees unpaid (#3416)by pm47 · c5b9afc0 · Oct 27, 2026 · 4 filesMessage 81 · StrongModerate 64Details
Commit message · pm47

Flag peers that leave liquidity fees unpaid (#3416)

When a peer buys liquidity using `from_future_htlc`, we take the risk of not being paid, and rely on our suspicious peers mechanism (`max-suspicious-peers`) to bound that risk. But a peer could withdraw the payments that should pay the fees *before* the purchase is signed (with `will_fail_htlc`, by letting the proposal time out, or by disconnecting): we then signed the funding transaction without recording any fee debt, and the peer was never flagged, so it could repeat this indefinitely.


* Flag peers that leave liquidity fees unpaid

When signing a liquidity purchase paid with from_future_htlc, we now
flag our peer as suspicious if some of its fees cannot be collected from
its pending payments, as we already do when funded HTLCs are failed.

* Track underpaid liquidity purchases by funding tx

Underpaid liquidity purchases are now tracked by funding txid instead
of payment hash, and are only cleared by the node operator (using
enableFromFutureHtlc) or when restarting. Failed relays are still keyed
by payment hash. Both count towards max-suspicious-peers, and each is
reported in its own metric.

* Forget underpaid liquidity purchases when aborted

When a liquidity purchase is aborted before its funding transaction is
published, we haven't lost any fees: we now remove the corresponding
underpaid entry, and fail the upstream HTLCs of its funded payments.
We handle this event regardless of our connection state, since it is
sent asynchronously by the channel.


Reported-by: @erickcestari
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

81/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Links an issue, advisory, or supporting reference
Why it was queued
signing boundary
AI analysis · Moderate 64/100

This commit fixes a security gap in Eclair's Lightning node software. A peer could repeatedly get free channel funding ('liquidity') by backing out of payments meant to cover the fees right before the funding transaction was signed. Previously, Eclair didn't flag this behavior, so the peer could do it over and over. The patch now flags such peers as suspicious and temporarily blocks them from using this fee-deferral feature, limiting potential losses.

Security candidateBack to dev (#3413)by Fabrice Drouin · 06716fce · Oct 22, 2026 · 8 filesMessage 36 · OpaqueInformational 15Details
Commit message · Fabrice Drouin

Back to dev (#3413)

After release 0.14.5

36/100 · OpaqueMessage clarity
✓ Subject identifies a change✓ Links an issue, advisory, or supporting reference! No meaningful explanatory body! Opaque security-relevant change
Why it was queued
cryptography-sensitive path
AI analysis · Informational 15/100

This commit is a routine post-release housekeeping change. It bumps the project version from 0.14.5 to 0.15.0-SNAPSHOT, removes published release checksums, and adds a blank release-notes template. It also adds a startup guard that refuses to run the development snapshot unless a special override flag is set, explicitly warning that this version is unsafe to use. There is no security vulnerability here; the change is a deliberate safety measure, not a fix for an exploitable bug.

Security candidateEclair v0.14.5 release (#3412)by Fabrice Drouin · 01384e93 · Oct 20, 2026 · 8 filesMessage 53 · ThinModerate 67Details
Commit message · Fabrice Drouin

Eclair v0.14.5 release (#3412)

Eclair v0.14.5 release

53/100 · ThinMessage clarity
✓ Descriptive subject✓ Names a concrete action or component✓ Links an issue, advisory, or supporting reference! No meaningful explanatory body
Why it was queued
cryptography-sensitive path
AI analysis · Moderate 67/100

This commit is the release packaging for Eclair v0.14.5. The release notes state it is a patch release containing 'security hardening fixes' that can be exploited by malicious nodes, and thank two people for responsible disclosures. The actual code changes in this commit are only version number updates and removal of a startup safety guard that had blocked running the previous snapshot. The security fixes themselves are not visible in this commit; they were presumably made in earlier commits that this release bundles.

Security candidateCheck remote previous txOut against the blockchain (#3411)by pm47 · ae0927ed · Oct 20, 2026 · 3 filesMessage 81 · StrongHigh 82Details
Commit message · pm47

Check remote previous txOut against the blockchain (#3411)

When splicing taproot channels, our peer may only send the `txOut` of its inputs (amount and script) instead of the full previous transaction. Nothing checked that this `txOut` matched the actual output, so our peer could lie about it. Since taproot signatures commit to every spent output, we would sign a splice transaction that can never confirm and keep using it as our latest commitment, while our peer can publish its commitment for the previous funding output after upstream HTLCs have timed out, and steal HTLCs.

This also bypasses the restriction of splices to phoenix peers, which relies on phoenix only adding confirmed swap-in inputs: the swap-in script and confirmation checks used the claimed `txOut`.

We now fetch the previous transaction from our bitcoin node for every remote input that was sent without it, and abort if its output doesn't match.

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

81/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Links an issue, advisory, or supporting reference
Why it was queued
signing boundary
AI analysis · High 82/100

This commit fixes a security bug in Eclair's taproot channel splicing. When two users splice a Lightning channel, one side can describe its bitcoin inputs by sending only a small summary (the txOut) instead of the full previous transaction. Before this fix, Eclair trusted that summary without checking it against the actual blockchain. A dishonest peer could lie about the amount or script of its input, causing the splice transaction to be permanently unconfirmable. Because taproot signatures commit to the spent outputs, the victim would have already signed an invalid splice, while the attacker could later publish the old channel commitment and steal HTLCs (pending Lightning payments) after they time out. The fix fetches the real previous transaction from the user's own bitcoin node and aborts if the summary does not match.

Security candidateReject onion per-hop lengths that overflow an `Int` (#3408)by pm47 · 40279a1b · Oct 20, 2026 · 2 filesMessage 86 · StrongHigh 78Details
Commit message · pm47

Reject onion per-hop lengths that overflow an `Int` (#3408)

The per-hop payload length is decoded as a `Long` (the varint may use up to 9 bytes) but converted to an `Int` without checking that it fits. A sender who knows our node id can compute the shared secret and a valid hmac, so they can choose a length that wraps around when converted:

- fe 80 00 00 05 wraps to a negative value, which passes the upper bound check added in d3a146a08 and then throws when extracting the hmac, outside of the `Try`. Like before that fix, the exception escaped the relayer (which was resumed, so the HTLC was never failed upstream and kept its slot until expiry) and aborted the `PostRestartHtlcCleaner` on the next restart.
- 9-byte varints can wrap to small positive values (one of them even overflows the Long once the varint size is added), which made us silently accept a garbage per-hop payload.

We now require the decoded length to be non-negative and to fit in an Int before converting it, which turns all these cases into an `InvalidOnionVersion` error as for other invalid lengths.

Reported-by: Fire
Co-authored-by: Claude Fable 5.1 <noreply@anthropic.com>

86/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Links an issue, advisory, or supporting reference✓ Names security-relevant behavior explicitly
Why it was queued
memory safetycryptography-sensitive path
AI analysis · High 78/100

This fix closes a denial-of-service bug in Eclair's Lightning onion routing. A remote sender could craft a malformed per-hop payload length that, when converted from a large number to a normal integer, wrapped around to a negative or tiny value. That bypassed safety checks and crashed the relayer or the post-restart cleanup logic, leaving affected HTLCs stuck until they expired. The patch now rejects oversized lengths before converting them.

Security candidateBack to dev (#3405)by Fabrice Drouin · c4910b7b · Oct 16, 2026 · 8 filesMessage 36 · OpaqueInformational 15Details
Commit message · Fabrice Drouin

Back to dev (#3405)

After release 0.14.4

36/100 · OpaqueMessage clarity
✓ Subject identifies a change✓ Links an issue, advisory, or supporting reference! No meaningful explanatory body! Opaque security-relevant change
Why it was queued
cryptography-sensitive path
AI analysis · Informational 15/100

This commit is a routine post-release housekeeping change. It bumps the project version from 0.14.4 to 0.15.0-SNAPSHOT, removes the published checksums for the 0.14.4 release, and adds a placeholder release-notes file for the next version. It also adds a startup guard in Boot.scala that refuses to start the development snapshot unless a special unsafe-startup flag is set, which is a safety measure rather than a vulnerability.

Security candidateEclair v0.14.4 release (#3403)by Fabrice Drouin · e1c212c4 · Oct 15, 2026 · 10 filesMessage 53 · ThinHigh 84Details
Commit message · Fabrice Drouin

Eclair v0.14.4 release (#3403)

Eclair v0.14.4 release

53/100 · ThinMessage clarity
✓ Descriptive subject✓ Names a concrete action or component✓ Links an issue, advisory, or supporting reference! No meaningful explanatory body
Why it was queued
cryptography-sensitive path
AI analysis · High 84/100

This commit is the official release marker for Eclair v0.14.4. The release notes included in the commit describe it as a security-hardening patch release with fixes for multiple issues, some of which can be exploited by malicious nodes. The most clearly described issue is a cross-site request forgery (CSRF) risk on the node's HTTP API: because the API uses HTTP basic authentication and accepts form-encoded parameters, any website visited by the node operator could trick the browser into making authenticated API calls. The release mitigates this by rejecting API requests that carry a browser-style Origin header. Other listed fixes cover seed-file validation, interactive transaction funding, remote closing scripts, channel funding/replacement logic, onion routing packet handling, and transaction publishing. The commit itself only changes version numbers, release notes, CI configuration, and build checksums; the actual code fixes are in the referenced parent commits.

Security candidateRetry publishing txs evicted by unconfirmed conflicts (#3397)by pm47 · 21f1bc8d · Oct 13, 2026 · 4 filesMessage 93 · StrongHigh 82Details
Commit message · pm47

Retry publishing txs evicted by unconfirmed conflicts (#3397)

* Keep retrying local anchor on unconfirmed conflicts

When the funding output was spent and our local commit tx couldn't be found,
we assumed that a remote commit tx was available and permanently gave up on
our local anchor. Since #3376, we may force-close with an older commitment
when our peer withholds tx_signatures for a splice: if our peer publishes
that splice transaction, our commit tx is rejected because it conflicts with
it, and if our peer then double-spends their splice input, we never publish
our commit tx again (until we restart). This lets them steal HTLCs by
publishing their commitment later.

We now only give up on our local anchor if a remote commit tx is actually
available, or if the funding output is spent by a confirmed transaction.
Otherwise we retry at the next block, which publishes our commit tx with our
anchor as soon as the conflicting transaction is evicted.

* Retry final txs after unconfirmed conflicts

When a final (non-replaceable) transaction was rejected because it conflicts
with an unconfirmed mempool transaction, we never retried it. But our peer
can evict that conflicting transaction by double-spending one of its other
inputs, which makes our transaction valid again: our peer could then use
this to make us abandon our commit tx or our penalty transactions.

We now retry at every block until the conflicting transaction confirms, as
we already do for replaceable transactions.

* Retry local anchor with unconfirmed funding tx (#3402)

When the funding output is spent by an unconfirmed transaction and no remote
commit tx is available, we keep retrying our local anchor. But we detected
this by checking the funding output in the UTXO set, which doesn't contain
outputs of unconfirmed transactions: when the funding tx was unconfirmed
(e.g. with 0-conf), we thus still gave up on our commit tx.

If the funding tx is unconfirmed, it can only be spent by an unconfirmed
transaction, so we now retry at the next block in that case as well.

---------

Reported-By: [project-loupe](https://github.com/project-loupe)
Reported-By: @erickcestari

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: Fabrice Drouin <sstone@users.noreply.github.com>

93/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Explains rationale or failure mode✓ Links an issue, advisory, or supporting reference
Why it was queued
signing boundary
AI analysis · High 82/100

This commit fixes a security bug in the Eclair Lightning node where a malicious peer could trick the node into permanently giving up on publishing its own commitment or penalty transactions. By publishing and then double-spending a conflicting transaction, an attacker could prevent the node from claiming funds it was owed, potentially allowing the attacker to steal HTLCs or delay justice transactions. The fix makes the node keep retrying publication each block until the conflicting transaction actually confirms.

Security candidateKeep unsigned settlements when rejecting commands (#3401)by pm47 · 7686dfad · Oct 13, 2026 · 2 filesMessage 93 · StrongModerate 66Details
Commit message · pm47

Keep unsigned settlements when rejecting commands (#3401)

When a settlement command was rejected, we scheduled the deletion of the
pending settlement command stored in our DB for that HTLC. But it may have
been rejected because we had already proposed a settlement for that HTLC,
for example when receiving a duplicate of the same command: if that pending
settlement hadn't been signed yet, it would be lost if we disconnected before
signing it, since we wouldn't replay it on reconnection. For a relayed HTLC
that was fulfilled downstream, this could lead to the upstream HTLC timing
out instead of being fulfilled.

We now keep the pending settlement command in our DB in that case: it is
acknowledged once signed.

Reported-By: [project-loupe](https://github.com/project-loupe)
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

93/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Explains rationale or failure mode✓ Links an issue, advisory, or supporting reference
Why it was queued
signing boundary
AI analysis · Moderate 66/100

This commit fixes a bug in Eclair, a Bitcoin Lightning Network node implementation. When the node received a duplicate command to settle a payment (fulfill or fail), it would mistakenly delete the still-pending settlement from its database. If the node disconnected before that settlement was signed, it would not be replayed on reconnection. For a payment being forwarded through the node, this could mean the downstream side got paid but the upstream side never received the proof it needed, causing the upstream payment to time out and potentially costing the node money. The fix keeps the pending settlement in the database until it has actually been signed.

Security candidateForce-close again when a splice RBF sibling confirms (#3400)by pm47 · 9a1ecc99 · Oct 13, 2026 · 2 filesMessage 81 · StrongModerate 66Details
Commit message · pm47

Force-close again when a splice RBF sibling confirms (#3400)

Since #3376, when our peer withholds their tx_signatures for a splice, we
force-close using a previous commitment, and force-close again if that splice
confirms later. But when the unsigned transaction was an RBF attempt of a
splice, we force-closed using its RBF sibling, which has the same funding tx
index: when the RBF attempt confirmed, we didn't detect that it double-spent
the commit tx we published, and never force-closed again. Our funds stayed
locked until our peer published their commitment, and our HTLCs weren't
enforced on-chain.

We now force-close again whenever the confirmed splice transaction
double-spends the funding transaction of the commit tx we published.

Reported-By: @erickcestari
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

81/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Links an issue, advisory, or supporting reference
Why it was queued
signing boundary
AI analysis · Moderate 66/100

This commit fixes a bug in Eclair, a Bitcoin Lightning Network node implementation. When one node force-closed a channel because its peer never finished signing a 'splice' (a way to resize a Lightning channel on-chain), and the peer later published a different version of that splice (an RBF attempt) which confirmed, Eclair failed to notice that the confirmed transaction had replaced the one used in the force-close. As a result, the node would not re-force-close with the correct commitment, leaving its funds stuck and its payment guarantees unenforced on-chain. The fix makes Eclair re-force-close whenever the confirmed splice transaction spends the same funds as the previously published commitment.

Security candidateReject unpublishable splices (#3396)by pm47 · af994180 · Oct 13, 2026 · 5 filesMessage 78 · AdequateCritical 89Details
Commit message · pm47

Reject unpublishable splices (#3396)

Collection of fixes to prevent a malicious peer to make us sign a splice tx that cannot be published.

* Reject interactive txs with a future lock time

Our peer chooses the lock time of interactive transactions (in open_channel2,
splice_init and tx_init_rbf) and we didn't check it. With a lock time far in
the future, the transaction cannot be published: for a splice, we would then
force-close with a commitment that can never confirm, while our peer can
still publish its commitment for the previous funding output, which lets
them steal HTLCs.

We now reject lock times that are more than a few blocks ahead of our current
block height, to allow for small differences in block height with our peer.

* Reject interactive-tx inputs with relative lock times

Our peer chooses the nSequence of the inputs it adds, including the shared
input when it is the splice initiator. We only rejected values that disable
RBF, so our peer could use a relative lock time (BIP 68) to prevent us from
publishing the transaction for up to 65535 blocks: for a splice, we would
then force-close with a commitment that cannot confirm, while our peer can
still publish its commitment for the previous funding output.

We now reject inputs that enable a relative lock time.

* Check signed splice feerate when we don't contribute

We only checked the feerate of the signed interactive transaction when both
peers contributed to it. When we didn't contribute to a splice, our peer
could provide large witnesses for its inputs and make the feerate of the
signed transaction much lower than the target, potentially below the relay
minimum: we would then force-close with a commitment that cannot confirm,
while our peer can still publish its commitment for the previous funding
output.

A splice transaction funds our latest commitment, so we now check its
feerate even when we don't contribute to it.

* Reject non-standard witnesses in tx_signatures

We only checked that our peer's witnesses were valid, using standard script
flags, but not that they satisfied Bitcoin Core's witness standardness rules
(P2WSH stack and script sizes, taproot annex, tapscript stack items) or that
the signed transaction didn't exceed the standard weight. Our peer could thus
make us store a valid splice transaction that cannot be relayed: we would then
force-close with a commitment that cannot confirm, while our peer can still
publish its commitment for the previous funding output.

We now reject such tx_signatures, as required by BOLT 2.

---------

Closes https://github.com/project-loupe/audit-eclair/issues/62
Closes https://github.com/project-loupe/audit-eclair/issues/91
Closes https://github.com/project-loupe/audit-eclair/issues/400
Closes https://github.com/project-loupe/audit-eclair/issues/265

Reported-By: [project-loupe](https://github.com/project-loupe)
Reported-By: @erickcestari
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

78/100 · AdequateMessage clarity
✓ Descriptive subject✓ Provides detailed explanatory context✓ Explains rationale or failure mode✓ Links an issue, advisory, or supporting reference
Why it was queued
signing boundarysigning or wallet path
AI analysis · Critical 89/100

This commit fixes a set of vulnerabilities in Eclair's Lightning channel splicing protocol that could let a malicious peer trick the victim into signing a splice transaction that can never be published on the Bitcoin network. Because the victim's latest commitment transaction depends on that splice transaction confirming, the victim would be unable to recover their funds through a normal force-close, while the attacker could still broadcast an older commitment and steal HTLCs (pending routed payments). The fixes reject future lock times, relative time locks on inputs, non-standard witnesses, and too-low feerates when the victim does not contribute to the splice.

Security candidateReject onion per-hop lengths exceeding packet (#3395)by pm47 · d3a146a0 · Oct 13, 2026 · 2 filesMessage 81 · StrongHigh 74Details
Commit message · pm47

Reject onion per-hop lengths exceeding packet (#3395)

The sender knows the shared secret, so it can build an onion with a valid
hmac whose per-hop payload length is larger than the packet. We didn't
check that length: we either decoded a garbage next packet, or threw when
extracting the hmac, outside of the Try. This exception escaped the relayer
(which was then resumed, so the HTLC was never failed) and would prevent
PostRestartHtlcCleaner from initializing on the next restart.

We now return InvalidOnionVersion, as we already do for an invalid length.

Closes https://github.com/project-loupe/audit-eclair/issues/104
Closes https://github.com/project-loupe/audit-eclair/issues/215
Closes https://github.com/project-loupe/audit-eclair/issues/140

Reported-By: [project-loupe](https://github.com/project-loupe)
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

81/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Links an issue, advisory, or supporting reference
Why it was queued
cryptography-sensitive path
AI analysis · High 74/100

This commit fixes a bug in how Eclair processes encrypted routing instructions (onion packets) for Lightning payments. A malicious sender could craft a packet that claimed its inner payload was longer than the packet itself. The old code either produced garbage or crashed outside of the expected error-handling path. That crash could escape the payment relayer, meaning the node would not properly fail the affected payment, and it could also break startup recovery code after a restart. The fix adds a length check and returns a standard invalid-onion error instead of crashing.

Security candidateRemove `spendfromchanneladdress` nonce after one sig (#3392)by pm47 · c89af115 · Oct 8, 2026 · 1 fileMessage 98 · StrongModerate 53Details
Commit message · pm47

Remove `spendfromchanneladdress` nonce after one sig (#3392)

Nonces must not be re-used. Although `spendfromchanneladdress` is a
manual recovery operation, there is no reason why we keep the nonce
after the first signature.

Fixes https://github.com/project-loupe/audit-eclair/issues/35.

98/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Explains rationale or failure mode✓ Links an issue, advisory, or supporting reference✓ Names security-relevant behavior explicitly
Why it was queued
signing boundary
AI analysis · Moderate 53/100

This commit fixes a cryptographic safety issue in a manual Bitcoin/Lightning recovery tool. When a user runs the `spendfromchanneladdress` operation, the code was re-reading a secret signing nonce from a stored map after using it once. Nonces must never be reused in this signature scheme, because reuse can leak the private key. The change removes the nonce from the map immediately after it is used, so it cannot be reused accidentally or maliciously in a later signature.

Security candidateReject seed files with an invalid length (#3389)by pm47 · a07fff56 · Oct 5, 2026 · 2 filesMessage 88 · StrongModerate 66Details
Commit message · pm47

Reject seed files with an invalid length (#3389)

Seed files were read without checking their length. Creating a seed file is not atomic: if we crash between creating the file and writing the seed, an empty seed file is left behind. On the next restart we
would then derive our node and channel keys from an empty seed.

We now refuse to start if a seed file doesn't contain exactly 32 bytes. The only exception is legacy seeds (before 31022ceca5), which were serialized compressed private keys: 32 bytes followed by 0x01. We keep accepting them, without dropping the trailing byte, so that our keys don't change.

88/100 · StrongMessage clarity
✓ Descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Explains rationale or failure mode✓ Links an issue, advisory, or supporting reference
Why it was queued
secret or key materialcryptography-sensitive path
AI analysis · Moderate 66/100

This patch fixes a bug in the Eclair Bitcoin Lightning node where, if the node crashed while creating its secret seed file, it could leave an empty file behind. On the next restart, Eclair would silently use that empty seed to generate all the node's private keys, producing predictable keys that could let an attacker steal funds. The fix now refuses to start unless the seed file contains exactly 32 bytes, while still accepting older 33-byte legacy seed files.

Security candidateUpgrade postgresql client from 42.7.11 to 42.7.12 (#3330)by dependabot[bot] · 972dfe99 · Sep 23, 2026 · 2 filesMessage 81 · StrongLow 25Details
Commit message · dependabot[bot]

Upgrade postgresql client from 42.7.11 to 42.7.12 (#3330)

Bumps [org.postgresql:postgresql](https://github.com/pgjdbc/pgjdbc) from 42.7.11 to 42.7.12.
- [Release notes](https://github.com/pgjdbc/pgjdbc/releases)
- [Changelog](https://github.com/pgjdbc/pgjdbc/blob/master/CHANGELOG.md)
- [Commits](https://github.com/pgjdbc/pgjdbc/compare/REL42.7.11...REL42.7.12)

---

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: pm47 <pm.padiou@gmail.com>

81/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Links an issue, advisory, or supporting reference
Why it was queued
cryptography-sensitive pathautomated dependency-update discount
AI analysis · Low 25/100

This commit updates the PostgreSQL database driver used by Eclair from version 42.7.11 to 42.7.12. It is a routine dependency bump by an automated tool. The commit itself does not say what bugs the new driver fixes, but small point-release driver updates often include security fixes. Without a vendor statement linking this specific upgrade to a known vulnerability, we cannot confirm it fixes a security issue, but it is prudent maintenance.

Security candidateUse bitcoin-kmp 0.49 (depends on bitcoin-kmp 0.32.0 and secp256k1-kmp 0.24.0) (#3362)by Fabrice Drouin · 6162e2aa · Sep 22, 2026 · 4 filesMessage 58 · ThinLow 31Details
Commit message · Fabrice Drouin

Use bitcoin-kmp 0.49 (depends on bitcoin-kmp 0.32.0 and secp256k1-kmp 0.24.0) (#3362)

58/100 · ThinMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Links an issue, advisory, or supporting reference! No meaningful explanatory body
Why it was queued
cryptography-sensitive path
AI analysis · Low 31/100

This commit updates Eclair's Bitcoin library dependency from version 0.48 to 0.49, which internally uses newer versions of bitcoin-kmp and secp256k1-kmp. The code changes only replace old property accesses (like `.txid`) with new method calls (like `.getTxid`) to match the updated library's API. There is no explicit security fix described in the commit, and no verified external references are provided. The change could include bug fixes or security improvements in the upstream cryptographic libraries, but the commit itself does not disclose any specific vulnerability.

Security candidateUpdate build to improve release process (#3381)by Fabrice Drouin · c3e9f5d6 · Sep 17, 2026 · 5 filesMessage 86 · StrongInformational 15Details
Commit message · Fabrice Drouin

Update build to improve release process (#3381)

* Update maven plugins

* Don't store commit id in eclair-core jar manifest

It creates a chicken-and-egg problem if you want to commit the checksum of eclair-core.jar to .mvn/checksums/checksums-workspace.sha256.

* Add maven profile for eclair-fuzz

To build eclair-fuzz, use the with-eclair-fuzz profile with -Pwith-eclair-fuzz

86/100 · StrongMessage clarity
✓ Descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Mentions testing or verification✓ Links an issue, advisory, or supporting reference
Why it was queued
fuzzing or regression evidencecryptography-sensitive path
AI analysis · Informational 15/100

This commit is a routine build-system update. It upgrades several Maven plugin versions, removes the git commit ID from one jar manifest field to avoid a build-time circular dependency, and adds an optional build profile for a fuzz-testing module. There are no code changes that affect how the software runs or how users interact with it.

Security candidateReject API access from browsers (#3380)by pm47 · 27438b75 · Sep 15, 2026 · 6 filesMessage 81 · StrongHigh 79Details
Commit message · pm47

Reject API access from browsers (#3380)

Any request carrying an `Origin` header is now rejected with 403 before the inner route runs: browsers set it on every cross-site request and every non-GET/HEAD request, while `curl` and `eclair-cli` never do. Checking presence rather than value also covers `Origin: null` and DNS rebinding.

This is a defence against browser CSRF, not an authentication mechanism — `Origin` is trivially omitted by a non-browser client, and the API should still never be exposed beyond loopback.

Breaking change: the API can no longer be called from a web browser, even same-origin; anyone serving a web front-end against it now needs their own back-end in front.

Fixes project-loupe/audit-eclair#223, and by construction any other CSRF report against an individual endpoint.

81/100 · StrongMessage clarity
✓ Descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Links an issue, advisory, or supporting reference✓ Names security-relevant behavior explicitly
Why it was queued
access control
AI analysis · High 79/100

This commit closes a cross-site request forgery (CSRF) hole in Eclair's admin API. Before the change, a malicious web page visited by a node operator could silently submit authenticated API requests (for example, to send funds or close Lightning channels) because browsers reuse cached HTTP basic-auth credentials. The patch now rejects any API request that carries an Origin header, which browsers set automatically while command-line tools do not. It also removes CORS headers that wrongly advertised cross-origin access. This is a hardening/breaking-change fix, not a full authentication replacement, and the API should still only be reachable on the local machine.

Security candidateImprove the deterministic build (#3378)by pm47 · eb7cb009 · Sep 14, 2026 · 2 filesMessage 76 · AdequateInformational 15Details
Commit message · pm47

Improve the deterministic build (#3378)

Explicitly specify file permissions and line endings so it is easier to end up with the same binaries in various set ups.

76/100 · AdequateMessage clarity
✓ Descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Links an issue, advisory, or supporting reference
Why it was queued
credential or privilege state
AI analysis · Informational 15/100

This commit adjusts build packaging settings to make compiled releases more reproducible across different computers. It sets consistent file permissions and line endings for packaged documentation and runtime files. There is no indication this fixes a security vulnerability or introduces one.

Security candidateMore AI fixes and defense-in-depth (#3376)by pm47 · 4111ad86 · Sep 14, 2026 · 35 filesMessage 91 · StrongCritical 89Details
Commit message · pm47

More AI fixes and defense-in-depth (#3376)

* loupe: add min-to-self-delay check

See: https://github.com/project-loupe/audit-eclair/issues/205

* loupe: use distinct nonces for initial commitments

See https://github.com/project-loupe/audit-eclair/issues/83

* loupe: check signed psbt

See https://github.com/project-loupe/audit-eclair/issues/44

* loupe: prevent overflow on relay-fee calculation

See https://github.com/project-loupe/audit-eclair/issues/31

* Validate relay parameters before on-the-fly funding

When relaying a blinded payment to a wallet node we don't have a channel
with, we cannot validate the relay parameters against a channel_update,
so we skipped that validation entirely before attempting on-the-fly
funding. A malicious wallet node could thus create a blinded path with
a null cltv_expiry_delta for our node, and we would fund a channel and
relay an HTLC that expires at the same block as the upstream HTLC. That
HTLC could then be fulfilled on-chain by the wallet node while the
upstream HTLC times out, making us lose the HTLC amount.

We now validate the relay parameters against the ones the channel we
would create would use (our expiry delta, htlc minimum and our default
relay fees) and fail early instead of funding a
channel for a payment we would have rejected anyway.

See: https://github.com/project-loupe/audit-eclair/issues/162

* Force-close with a publishable commitment

When we sign a splice transaction first (which always happens when we
don't contribute any input) and our peer withholds their tx_signatures,
we cannot publish that splice transaction. Our latest commitment builds
on it, so its commit tx cannot confirm unless our peer publishes the
splice transaction. We still force-closed with that commitment, and the
publisher then retried forever waiting for the parent.

A malicious peer could exploit this to lock our funds indefinitely, or
worse, to steal pending HTLCs: they wait for the upstream HTLC to time
out, then publish the previous commitment and claim the HTLC with its
preimage, since we were unable to time it out on-chain.

When force-closing, we now skip commitments whose funding transaction
hasn't been fully signed and use the latest one that can confirm. The
commitments themselves are left untouched: the closing state now
resolves the commitment matching each published commit txid (ours or
our peer's) wherever it needs commitment-specific data (HTLC signatures,
keys, format), including when restoring after a restart and when
reporting the closed channel. Revoked and future commit txs cannot be
matched and keep using the latest commitment, as before. If our peer
later publishes that splice transaction and it confirms, our commit tx
is double-spent and we force-close again with the latest commitment.

* Bound closing fees proposed by our peer

When we pay the closing fees and our peer sends a closing_signed with a
fee outside of our fee range, we try to converge towards their fee, for
compatibility with implementations that ignore fee ranges. But nothing
bounded that fee: a malicious peer could propose a fee larger than our
balance, we would drop our output and sign a closing transaction that
sends our whole balance to miners, in a single round-trip.

We now refuse fees that exceed what our maximum closing feerate allows
when we pay the fees, and reply with a warning: our peer must propose a
reasonable fee, or we can force-close.

See: https://github.com/project-loupe/audit-eclair/issues/63

* Extract preimage from taproot HTLC-success with annex

When our peer publishes their commit tx and claims an HTLC with an
HTLC-success transaction, we extract the preimage from its witness to
relay it upstream. For taproot channels, we only handled the witness
without an annex, whereas we already handled both cases for
Claim-HTLC-success transactions. If an HTLC-success transaction with an
annex was confirmed, we would fail to extract the preimage and treat
the HTLC as timed out, failing it upstream even though it was fulfilled
downstream.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

* Use pending signed commitment in canSendFee

When checking that we can afford a new feerate, we were using the spec
of the remote commitment we last received a revocation for, ignoring
the changes we had already signed in a pending commit_sig. Every other
balance check uses the pending commitment when there is one. We could
thus send an update_fee that our peer cannot accept, since they check
it against the commitment we signed, which would make them force-close.

* Bound hidden blinded path fees per payment part

When we hide part of the blinded path fees from the payer, we accept
HTLCs whose amount is smaller than the onion amount by at most those
fees. That bound was computed on the whole invoice amount for every
HTLC, so a payer splitting the payment in several parts could underpay
us by the proportional fee on each part.

The hidden fees are paid on each part, so we now compute the bound on
the part's onion amount. We add a small tolerance since LDK doesn't use
the BOLT 4 formula to compute amt_to_forward inside blinded paths and
rounds down the fee it pays as a sender, which can leave parts short by
a few msat.

* Only accept derivation paths tracked by our wallet

When using the eclair signer, Bitcoin Core only holds a watch-only
wallet built from our BIP84 and BIP86 account xpubs. We verified that
addresses and change outputs it provides belong to us by re-deriving
the public key along the derivation path it gives us, but we accepted
any path. Since Bitcoin Core knows our account xpubs, a malicious node
could provide addresses for deeper or non-standard branches: we would
consider them ours and use them for channel closing scripts, splice
outputs and change, but our wallet would never track them and we would
be unable to find those funds.

We now only accept paths of the form purpose'/coin_type'/account'/{0,1}/i
matching the descriptors we import, with the purpose matching the
address type.

* Check mining fees of wallet-funded interactive txs

When funding an interactive transaction (dual funding or splice), we
let bitcoind select wallet inputs and add a change output. We verified
that the funding output and our outputs were preserved, but never that
the resulting mining fee was sane: interactive-tx validation only
enforces a lower bound on the feerate, and splices don't provide a fee
budget. A malicious bitcoind could thus select inputs worth much more
than needed and skip the change output: all checks would pass and the
difference would be paid to miners once we sign.

We now verify that the mining fee we pay stays close to the target
feerate before announcing our inputs to our peer, like we already do
for single-funded channels.

* Add max-funding-feerate configuration parameter

The feerate we use for funding and splice transactions comes from our
fee estimator, which relies on external data. Nothing bounded that
feerate, so inaccurate or malicious data could make us pay arbitrarily
high mining fees on every channel open or splice. Closing transactions
were already protected by max-closing-feerate.

We add a max-funding-feerate parameter (50 sat/byte by default) that
caps the feerate we use for funding and splice transactions. Operators
can RBF their transactions or increase this value and restart their
node if their transactions don't confirm when the mempool is congested.

---------

Co-authored-by: Claude Fable 5.1 <noreply@anthropic.com>

91/100 · StrongMessage clarity
✓ Descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Mentions testing or verification✓ Links an issue, advisory, or supporting reference✓ Names security-relevant behavior explicitly
Why it was queued
explicit security languagesigning boundarymemory safetydefensive validationcryptography-sensitive pathsigning or wallet path
AI analysis · Critical 89/100

This is a large security patch for the Eclair Lightning node that fixes multiple ways an attacker could steal funds, burn money to miners, or lock funds forever. The fixes include: preventing force-closes with un-publishable splice transactions; capping funding/closing miner fees; validating relay fees before opening channels on-the-fly; stopping overflow in fee math; rejecting fake Bitcoin Core change addresses; checking signed PSBTs haven't been altered; extracting payment secrets from newer taproot transactions; and ensuring distinct cryptographic nonces are used when signing commitments.

Security candidateMore robust splicing edge cases (#3366)by Bastien Teinturier · 59772fe1 · Aug 26, 2026 · 11 filesMessage 81 · StrongHigh 70Details
Commit message · Bastien Teinturier

More robust splicing edge cases (#3366)

We apply some defense-in-depth to better handle edge cases during
splicing where a remote peer doesn't follow the BOLTs. This also
includes more thorough pattern-matching, which protects against
future refactoring or new features from inadvertently introducing
a vulnerability related to splicing.

Co-authored-by: Fabrice Drouin <sstone@users.noreply.github.com>

81/100 · StrongMessage clarity
✓ Descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Links an issue, advisory, or supporting reference✓ Names security-relevant behavior explicitly
Why it was queued
explicit security language
AI analysis · High 70/100

This commit hardens Eclair's handling of the Lightning 'splicing' feature when a peer misbehaves. Splicing lets two nodes resize an open payment channel without closing it on-chain. The patch adds extra checks so that if a peer sends unexpected messages during the splice—especially messages that would shift the channel's commitment index—it disconnects or force-closes instead of applying them. Applying such messages could let a malicious peer trick the node into revoking a commitment number that a new splice commitment is still using, potentially putting funds at risk. The commit also fixes a batching bug so that a single commit_sig is delivered as a single message, not as a one-message batch that could trigger an unnecessary force-close.

Security candidateAdd optional rate-limit on incoming pre-auth connections (#3356)by Bastien Teinturier · a2fe6c74 · Aug 26, 2026 · 11 filesMessage 86 · StrongModerate 54Details
Commit message · Bastien Teinturier

Add optional rate-limit on incoming pre-auth connections (#3356)

Peers that open a connection but never complete the BOLT 8 handshake
consume resources on our node (memory, file descriptors and CPU).

We now bound how many of those we're willing to keep around, with an
eviction mechanism that lets honest peers eventually get connected.

Note that this only affects incoming connections: outgoing connections
are not rate-limited, which means that peers with whom we have channels
cannot be negatively affected by this mechanism since we'll actively
reconnect to them.

This isn't a foolproof DDoS protection at all however: attackers that
spam connection attempts can still severely delay or prevent honest
new peers from connecting. It should be coupled with a DDoS protection
layer at the cloud provider layer, where it is easier to do correctly
and more efficient.

86/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Links an issue, advisory, or supporting reference✓ Names security-relevant behavior explicitly
Why it was queued
explicit security language
AI analysis · Moderate 54/100

This commit adds a safety net to the Eclair Lightning node to limit how many incoming peer connections can sit unfinished before completing the cryptographic handshake. Previously, an attacker could open many TCP connections and leave them hanging, consuming memory, file descriptors, and CPU. The change caps those pending connections, evicts the oldest ones after a short grace period, and briefly pauses accepting new connections when the cap is hit. It also fixes a related bug where authenticated-but-never-initialized connections could stay open forever.

Security candidateFix a batch of Tor-related issues (#3354)by Bastien Teinturier · 3d092da8 · Aug 26, 2026 · 7 filesMessage 98 · StrongModerate 67Details
Commit message · Bastien Teinturier

Fix a batch of Tor-related issues (#3354)

* Verify that Tor cookie is 32-bytes

In order to be valid, a Tor cookie must be exactly 32 bytes.
We verify that and fail otherwise.

* Use Tor safe-cookie mode by default

And fail if password mode is used but the host is remote.

* Fix race condition in file permissions

There was a race condition in file permissions that allowed attackers
on the machine to read secrets, because we started by creating the
secret and only after that we set the file permissions.

We now reverse that flow: we create an empty file with the right
permissions and then write the secret to it.

This applies to our seed files and to tor private keys.

98/100 · StrongMessage clarity
✓ Descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Explains rationale or failure mode✓ Mentions testing or verification✓ Links an issue, advisory, or supporting reference
Why it was queued
explicit security languagesecret or key materialcredential or privilege stateparser or protocol path
AI analysis · Moderate 67/100

This commit fixes three security issues in how Eclair connects to the Tor network and stores sensitive files. First, it changes the default Tor authentication from password to safecookie, and blocks password mode when the Tor control port is on a remote machine, because password mode sends secrets in cleartext and cannot prove the server is really Tor. Second, it checks that Tor's authentication cookie is exactly 32 bytes. Third, it fixes a race condition where secret files (seed files and Tor private keys) were created with loose permissions before being locked down, which could let other users on the same machine read them; now the file is created with strict permissions first, then the secret is written.

Security candidateReject messages that include the wrong type of signatures (#3368)by Fabrice Drouin · 1fc3dd7c · Aug 26, 2026 · 16 filesMessage 86 · StrongModerate 60Details
Commit message · Fabrice Drouin

Reject messages that include the wrong type of signatures (#3368)

Signatures can either be standard signatures, for non-taproot channels, or partial signatures for taproot channels.
Here we reject messages that include signatures that don't match the channel commitment format.
This will fix an error where, for non-taproot channels, when our peer sends a message that contains a valid "single"
signature and an invalid "partial" signature, we would check the correct "single" signature, but store the invalid "partial" signature.

86/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Links an issue, advisory, or supporting reference✓ Names security-relevant behavior explicitly
Why it was queued
signing boundarysigning or wallet pathparser or protocol path
AI analysis · Moderate 60/100

This commit fixes a bug in the Eclair Lightning node where a peer could send a message containing both a correct standard signature and an incorrect partial signature. The old code would verify the correct signature but then store the invalid partial signature for later use. The fix makes Eclair reject messages that include the wrong kind of signature for the channel type, so non-taproot channels ignore partial signatures and taproot channels require partial signatures.