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.
Message quality measures whether a commit identifies its scope, purpose, rationale, testing, and supporting references. It does not change the security-severity score.
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
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
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
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
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
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
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
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
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
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)
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
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
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
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
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
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
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
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
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)
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…
Expand any commit for its author, full message, clarity score, changed files, triage signals, analysis, and source link.
AI review queuedBack to dev (#3424)by Fabrice Drouin · c96c3d44 · Oct 28, 2026 · 7 filesMessage 36 · OpaqueInformational 15Details
Commit message · Fabrice Drouin
Back to dev (#3424)
After release 0.14.6
36/100 · OpaqueMessage clarity
✓ Subject identifies a change✓ Links an issue, advisory, or supporting reference! No meaningful explanatory body
Why it was queued
second-pass: opaque commit message
AI analysis · Informational 15/100
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 guard that refuses to run the development snapshot unless a special override flag is set. There is no security vulnerability being fixed here; the change is meant to prevent users from accidentally running unfinished development code.
✓ 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.
AI review queuedSplicing robustness improvements (#3417)by pm47 · c07cc745 · Oct 27, 2026 · 11 filesMessage 88 · StrongHigh 72Details
Commit message · pm47
Splicing robustness improvements (#3417)
Make splicing more robust when splice transactions don't confirm:
- add `require-confirmed-inputs-for-splicing` (enabled by default): splices only spend confirmed transactions, and we limit the number of inputs and outputs our peer can add - when force-closing, use a commitment whose funding transaction is known by our bitcoind, and re-evaluate it when blocks are found or splice transactions are published - when CPFP-ing our commit tx, take its unconfirmed funding transaction into account - claim the outputs of a previous remote commitment as soon as it confirms - warn against using `zero_fee_commitments` when splicing with untrusted peers
Note that `require-confirmed-inputs-for-dual-funding` doesn't apply to splices anymore.
* Add tests for splices with unconfirmed parents
We add a `require-confirmed-inputs-for-splicing` setting (not used yet) and tests showing that we should: - require our peer's splice inputs to be confirmed - not splice on top of an unconfirmed splice transaction - limit the number of inputs and outputs our peer adds to a splice
* Only splice with confirmed parents
When `require-confirmed-inputs-for-splicing` is set (the default), we now require our peer to only use confirmed inputs in splices, and we don't initiate a splice on top of an unconfirmed splice transaction (our peer already cannot). We also limit the number of inputs and outputs our peer can add to a splice transaction to 10.
Note that `require-confirmed-inputs-for-dual-funding` doesn't apply to splices anymore, only to channel creation.
* Require confirmed splice inputs in tests
We use the default value of `require-confirmed-inputs-for-splicing` in tests. Our test wallet now considers the inputs it uses to fund transactions confirmed (this can be disabled to test unconfirmed inputs), and shares them with other test wallets so that our peer can verify them.
Tests that splice on top of unconfirmed splices now explicitly disable it: those scenarios can still happen with zero-conf, so we keep testing them.
* Add tests for force-close with unconfirmed splices
We add tests for the commitment we use when force-closing while splice transactions are unconfirmed. Our test wallet now considers the transactions it has published to be in its mempool.
* Force-close with a commitment whose funding tx can confirm
When force-closing while splice transactions are unconfirmed (without zero-conf), we now use the most recent commitment whose funding tx is known by our bitcoind (in its mempool or confirmed), or the most recent confirmed commitment otherwise. We re-evaluate it at every block and when a splice transaction spends a funding output, and force-close again using a different commitment if needed.
* Add test for anchor CPFP with an unconfirmed funding tx
When our commit tx spends an unconfirmed funding transaction, our anchor tx should also pay for that funding transaction to reach our target feerate.
* Pay for unconfirmed funding tx when CPFP-ing commit tx
Miners evaluate our anchor tx with all of its unconfirmed ancestors. When our commit tx spends an unconfirmed funding transaction (with zero-conf or splices), we now include the fees and weight of its unconfirmed ancestors when computing the fees our anchor tx must pay.
* Warn against zero_fee_commitments with splicing
With zero_fee_commitments, our commit tx is a v3 transaction, which cannot spend an unconfirmed v2 transaction such as a splice transaction (TRUC rules), so we cannot CPFP it. We document that this feature should not be used when splicing with untrusted peers.
* Add test for claiming htlcs of a previous remote commit
When our peer publishes its commit tx for a previous commitment, we should claim its outputs as soon as it confirms.
Existing tests that confirm a previous commit tx now use a height that is deep enough to directly test the min-depth handling.
* Claim previous remote commit outputs as soon as it confirms
When our peer publishes its commit tx for a previous commitment, we waited for min-depth before claiming its outputs. We now claim them as soon as it confirms, without forgetting our other commitments, which we only reset once it is deeply confirmed. We don't do it for revoked commit txs, whose outputs are delayed.
* Add test for published stale local commit tx
When we switch to a different commitment while force-closing (because the funding tx of our commit tx left our mempool), the commit tx we previously published may still confirm, since miners may still have it along with its parent splice transaction. We must then claim its outputs instead of treating it as a remote commit tx.
* Handle our stale local commit tx in CLOSING
When force-closing, we may switch to a different commitment if the funding tx of our commit tx isn't known by our bitcoind anymore. The commit tx we previously published may still confirm though: we now recognize it as one of our local commit txs and force-close again with its commitment, instead of handling it as a remote commit tx, which would lead to ERR_INFORMATION_LEAK or to a bogus revoked commit.
✓ Descriptive subject✓ Provides detailed explanatory context✓ Explains rationale or failure mode✓ Mentions testing or verification✓ Links an issue, advisory, or supporting reference
Why it was queued
signing or wallet pathsecond-pass: security-sensitive path
AI analysis · High 72/100
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 splice transactions: by double-spending inputs to make the splice invalid, by adding so many inputs/outputs that the honest node can't afford to speed it up (CPFP), or by publishing an old commitment while a splice is stuck. The changes add a new default-on setting that requires splice inputs to be confirmed, limit how many inputs/outputs a peer can add, make force-closing pick a commitment whose funding transaction is actually known to the node's own Bitcoin Core, include unconfirmed ancestors when paying to speed up a commitment, and claim outputs from an old remote commitment as soon as it confirms. The commit message explicitly warns that using zero-fee commitments with splicing and untrusted peers can lead to loss of funds.
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.
✓ 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.
Lower-priorityMake Dockerfile work for release versions (#3406)by Fabrice Drouin · c621fbe8 · Oct 20, 2026 · 1 fileMessage 86 · StrongTriage 8Details
Commit message · Fabrice Drouin
Make Dockerfile work for release versions (#3406)
Our docker file first builds eclair without sources to download and cache all its dependencies, and then builds with the actual source files. This is standard for many maven projects but does not work for release builds which include a checksum verification for eclair-core.jar (which requires that we build the exact same source files). => Here we skip check verification during the first step. They will all be verified during the second build.
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
Never relay HTLCs expiring after upstream HTLCs (#3409)
When relaying a trampoline payment, we set the route's maximum CLTV to ensure that our outgoing HTLCs expire before the incoming ones. But when no route was found, the path-finding retry relaxed the maximum CLTV to 2016 blocks, which could let the payer use routing hints or blinded paths with large CLTV deltas to make us send HTLCs expiring long after the incoming HTLCs. The payer could then get their incoming HTLCs refunded on-chain while the recipient claims our outgoing HTLCs.
We now only relax the route length in that retry.
Reported-by: @Nuhiat-Arefin 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
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.
✓ 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.
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.
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.
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.
Settle relayed on-the-fly upstreams on hash reuse (#3399)
When an on-the-fly HTLC was settled, we fulfilled the upstream HTLCs of the payment we were tracking for that payment_hash. But we stop tracking funded payments when their HTLCs reach their expiry, while those HTLCs can still be claimed on-chain, and a new payment may then reuse the same payment_hash: we would fulfill the upstream HTLCs of that new payment instead of the ones of the payment that was relayed. A colluding payer and recipient could thus claim the original HTLC downstream while the original upstream HTLCs time out back to the payer.
We now only consider the tracked payment relayed if it matches the payment that was settled, and otherwise fulfill the upstream HTLCs of the settled payment while we keep tracking the new one.
Reported-by: 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
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.
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.
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.
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.
Only relay on-the-fly payment on funded channel (#3394)
We previously relayed funded on-the-fly payments on any channel with our peer whose funding index was high enough. At expiry we only inspect the funded channel, so we could fail upstream while the HTLC was still claimable on another channel.
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
Lower-priorityUse published commitment in PostRestartHtlcCleaner (#3393)by pm47 · 248893a3 · Oct 8, 2026 · 2 filesMessage 81 · StrongTriage 0Details
Commit message · pm47
Use published commitment in PostRestartHtlcCleaner (#3393)
Since #3376 we may force-close with an older commitment, so HTLC outputs must be matched against the commitment of the published commit tx, as the live CLOSING handler already does.
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
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.
✓ 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.
We only validated our peer's closing script in their first shutdown. Subsequent shutdown messages (in `SHUTDOWN`, `NEGOTIATING` and `NEGOTIATING_SIMPLE`) and closing_complete could replace it with an arbitrary script and bypasses option_upfront_shutdown_script.
We now ignore those messages and send a warning when the script is invalid, as required by BOLT 2.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
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
defensive validation
Lower-priorityHarden interactive-tx funding against a malicious bitcoind (#3390)by pm47 · e43fbf69 · Oct 5, 2026 · 4 filesMessage 81 · StrongTriage 8Details
Commit message · pm47
Harden interactive-tx funding against a malicious bitcoind (#3390)
With the "Eclair signer" mode, bitcoind selects coins and builds transactions, but Eclair holds the keys and signs. A compromised bitcoind therefore can't steal wallet funds directly. But it could still make us pay excessive mining fees during dual-funding and splicing by under-reporting the fee or by tampering with the outputs we rebuild our contributions from.
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Links an issue, advisory, or supporting reference
Why it was queued
defensive validation
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.