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 is a documentation-only edit. It corrects a misleading comment in the code that wrongly claimed all fee estimates returned to LDK are forced to be at least 253 satoshis per 1000 weight units. The new comment clarifies that this minimu…
This change fixes a bug in Lightning Dev Kit's splicing logic. During a splice, one side can broadcast the new funding transaction as soon as it has the other side's signatures. Previously, if that transaction confirmed on-chain before the…
State-machine inconsistency in channel funding lifecycleMissing chain-source watch for in-flight splice funding transactionPotential failure to send splice_locked after splice confirms during signature exchange
This change fixes how Lightning nodes calculate the financial risk from tiny ('dust') HTLCs when the current on-chain fee rate is higher than the node's own local fee estimate. Previously, the code only considered a buffered fee rate when …
Incorrect fee exposure accounting for dust HTLCsPotential to accept HTLCs whose commitment/HTLC-success fees exceed their value under current feerateEconomic griefing / forced-channel-closure cost manipulation
This is a one-line code cleanup in a test file. It replaces a cloned array literal with a slice reference to silence a Rust compiler lint. There is no change to production code, no security fix, and no functional behavior change.
This is a one-line change in a test file to satisfy a Rust linter warning. It replaces a needless clone of a funding transaction with a reference-based slice construction. There is no functional change, no user-facing behavior change, and …
This commit is a test-only fix for a broken continuous integration (CI) build. It updates a test mock to match a new function signature and rewrites an existing test to use three nodes instead of two so the test scenario remains valid unde…
This change fixes a Lightning channel bug where a malicious peer could renegotiate the closing transaction fee while the local node was still waiting for its own signer to produce the final signature. If allowed, the local node might combi…
State-machine guard expansion to prevent fee renegotiation while a closing signature is pendingRisk of combining mismatched signatures across different closing feesRegression test demonstrates malicious peer renegotiation attempt and expected warning rejection
This change fixes a wallet bug in rust-lightning where a UTXO could be selected for a Lightning funding transaction, then rejected because its previous transaction was too large to fit in a Lightning peer message. Previously, that rejectio…
API change to CoinSelectionSource::select_confirmed_utxos adding max_input_prevtx_serialized_lenWalletSync filters UTXOs by prevtx serialized length before selectionFundingBuilder enforces Lightning tx_add_input message-size limit at selection time
This commit hardens LDK's BOLT 12 payment logic so it refuses to pay invoices containing very large unknown record types (4 billion and up). These records are legal under the Lightning spec, but LDK doesn't understand them, so the change t…
Defensive refusal to pay invoices with unknown high-numbered TLV recordsReuses existing UnknownRequiredFeatures failure path instead of adding a new oneAdds explicit checks before payment state insertion and route construction
This commit fixes a backward-compatibility bug in LDK's BOLT 12 invoice parser. A previous change had capped the range of 'experimental' TLV record types at 4 billion, but the Lightning spec imposes no upper bound. As a result, invoices cr…
Backward-compatibility regression in deserialization of persisted channel monitorsDenial-of-service via unreadable monitor blocking all channel monitoringSpec compliance fix: TLV record types have no upper bound
This change fixes a security issue where a signed text message could be crafted so that its prefixed form looks exactly like a Lightning 'node_announcement' gossip message. Because both use the same double-SHA256 hash and the same signing …
Signature replay / message confusion between signed messages and gossip announcementsForged `node_announcement` signatures via chosen-prefix message constructionNew validation rejects prefixed messages that deserialize as `UnsignedNodeAnnouncement`
This change fixes a corner case in how the Lightning node tries to claim multiple pending HTLCs (small Bitcoin payments locked in a channel) when the wallet cannot fund a single large batch transaction. Previously, if the multi-HTLC batch …
Funds-recovery robustness improvement: prevents premature abandonment of a single unbatched HTLCChange in error-handling arithmetic from checked_sub/saturating_sub with max(1)New unit tests covering both failed and successful singleton HTLC funding paths
This change prevents a Lightning node from accidentally overwriting an archived copy of a channel's security monitor with a brand-new one that happens to use the same identifier. In the old code, if a new channel reused the same identifier…
Data-loss prevention: stops archived ChannelMonitor from being overwritten by a later channel with the same keySafety guard added to both sync and async persistence pathsPersistence refusal surfaces as InProgress/UnrecoverableError rather than silent overwrite
This change fixes a place in the Lightning payment routing code where adding up fees could overflow the maximum number a computer can store in a 64-bit integer. Previously, the code assumed this could never happen and would crash (panic) i…
Integer overflow in fee computationPreviously unreachable!() panic path reachableMPP path merge could trigger overflow
This commit fixes a bug where a Lightning node could get stuck after restarting. If the node crashed or restarted while it was still saving the initial channel monitor to disk, and that save later finished in another process, the restarted…
Fixes a state-machine stall on node reload that could leave channels non-functionalRemoves an overstrict assertion that would panic on a legitimate post-reload stateAdds explicit detection of monitor persistence completed in a prior process
This change only updates documentation and code comments in the Lightning Dev Kit library. It clarifies that a particular key-derivation setting is fixed when a channel is first opened and is not changed by splicing. No code behavior was a…
This commit only changes documentation comments in two source files. It corrects the wording of how certain public keys are derived in the Lightning protocol and adds details about which witness script a signer must use when creating justi…
Documentation-only changeClarifies key derivation semantics for Lightning commitment transactionsClarifies justice transaction witness script requirements for signers
This change only adds documentation comments to a Rust struct. It does not modify any executable code, so it cannot by itself introduce or fix a security vulnerability. The new text warns developers that using TokioSpawner incorrectly can …
This commit hardens how Lightning Dev Kit handles custom signing modules. Previously, LDK relied on each custom signer to check that the other party's signatures on a holder commitment transaction were valid. The change adds a ready-made v…
New synchronous signature-verification helper for holder commitment transactionsTrait documentation now mandates verification before Ok(()) because LDK acts immediatelyInMemorySigner now validates that holder funding key belongs to signer before signature checks
This update fixes a corner case in the Lightning Dev Kit where a node could get confused if it received a 'channel_ready' message while still waiting for its own signer to produce the first commitment signature. The patch makes the node re…
State-machine confusion between funding_signed and channel_ready in async signer flowPremature channel_ready could advance counterparty_next_commitment_point before initial commitment is signedPatch closes channel rather than allowing inconsistent commitment state
Remove input value fields from ConstructedTransaction
The local and remote input values are used to determine which node sends tx_signatures first. Instead of persisting these values, compute them only when needed from the input metadata. The spec states that the entire shared input value is to be included for the node sending the corresponding tx_add_input, so it isn't necessary to know the local and remote balances which the metadata does not contain.
73/100 · AdequateMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context
Why it was queued
signing boundary
AI analysis · Low 26/100
This commit refactors how a Lightning node decides which side sends transaction signatures first during an interactive funding transaction. Previously, the node stored separate running totals for local and remote input values inside a data structure called ConstructedTransaction. Now it computes those totals on demand from the input metadata. The change is intended to match the protocol specification, which says the entire shared input value should be counted toward whichever node proposed that input—not split into local and remote portions. There is no direct evidence in the commit that this fixes an active security bug, but it removes a place where stored and computed values could become inconsistent and affect the ordering rule.
Security candidateLimit outbound gossip buffer by size, rather than lengthby Matt Corallo · 4b60d660 · Sep 23, 2025 · 2 filesMessage 85 · StrongLow 28Details
Commit message · Matt Corallo
Limit outbound gossip buffer by size, rather than length
In 686a586c96aae6901d533646fc135379f825eb0d we stopped punishing peers for slowly draining the gossip forwarding buffer, delaying responding to our ping message. While that change was nice on its own, it also now allows us to be a bit more flexible with what enters the `gossip_broadcast_buffer`.
Because we now do not count pending messages in `gossip_broadcast_buffer` against the peer's ping-response timer, there's no reason to continue to limit it based on `messages_sent_since_pong`. Thus, we drop that restriction here.
However, in practice, the reason for the vast majority of gossip forwarding drops on my node is the 24-message total queue limit, rather than the `messages_sent_since_pong` limit. This limit was set to bend over backwards trying to avoid counting message buffer sizes while keeping peer message buffers small.
In practice, there is really no reason to do that - summing the capacity of tens of buffers is negligible cost and allows us to be much more flexible with how many messages we queue.
Here we do so, limiting the total outbound message buffer size before gossip forwards are dropped to 128 KiB per peer, rather than 24 messages. In practice, this appears to almost entirely remove gossip forward drops on my node.
85/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Explains rationale or failure mode
Why it was queued
cryptography-sensitive path
AI analysis · Low 28/100
This commit changes how a Lightning node decides when to stop forwarding gossip messages to a peer. Previously, the node dropped gossip if a peer's outbound message queue reached 24 messages or if too many messages had been sent since the last ping reply. Now it drops gossip only when the total buffered data for that peer exceeds 128 KiB. The change is described by the authors as a performance/flexibility improvement to reduce unnecessary gossip drops, not as a security fix. There is no direct evidence in the commit or supplied references that this resolves an exploitable vulnerability.
Security candidateCheck dust exposure on receiving `commitment_signed`, not `update_fee`by Leo Nash · 2356e052 · Sep 23, 2025 · 4 filesMessage 73 · AdequateModerate 63Details
Commit message · Leo Nash
Check dust exposure on receiving `commitment_signed`, not `update_fee`
We allow a peer to send an `update_fee` message that pushes the dust exposure over our max as long as they send HTLC updates that bring the dust exposure back down under the limit before they send `commitment_signed`.
73/100 · AdequateMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context
Why it was queued
boot or update path
AI analysis · Moderate 63/100
This commit changes when a Lightning node checks whether a proposed fee change would create risky 'dust' exposure. Previously, the check happened immediately when the peer sent an `update_fee` message. Now, the check is deferred until the peer sends `commitment_signed`, which is the moment the new fee would actually take effect. This allows a peer to send a fee update that temporarily looks risky, as long as they add or remove HTLCs before signing the commitment so that the final state is safe. The change also removes some duplicated fee-calculation code and moves an affordability check into the same deferred validation path.
Security candidateAdd a test for the new async `ChainMonitor` operationby Matt Corallo · 462a6479 · Sep 22, 2025 · 1 fileMessage 83 · StrongInformational 15Details
Commit message · Matt Corallo
Add a test for the new async `ChainMonitor` operation
We already have pretty good coverage of the `MonitorUpdatingPersister` itself as well as `ChainMonitor`'s update-completion handling, so here we just focus on an end-to-end test to make sure `ChainMonitor` behaves at all correctly in the new async mode.
83/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Mentions testing or verification
Why it was queued
boot or update path
AI analysis · Informational 15/100
This commit only adds a new automated test for an existing feature. It does not change any production code, so it cannot introduce a security vulnerability or fix one. The test checks that a new asynchronous mode of the ChainMonitor component correctly waits for background writes to finish before reporting them complete.
Correct gossip forwarding criteria while doing background sync
If we're doing gossip backfill to a peer, we first forward all our `channel_announcement`s and `channel_update`s in SCID-order. While doing so, we don't forward any fresh `channel_update` messages for any channels which we haven't yet backfilled (as we'll eventually send the new update anyway, and it might get rejected without the corresponding `channel_announcement`).
Sadly, our comparison for this was the wrong way, so we actually *only* forwarded updates which were for channels we haven't yet backfilled, and dropped updates for channels we already had backfilled.
73/100 · AdequateMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context
Why it was queued
cryptography-sensitive path
AI analysis · Low 36/100
This commit fixes a flipped comparison in Lightning Dev Kit's gossip message forwarding. During a background sync, nodes share old channel announcements in order. To avoid sending updates before their matching announcements, the code was supposed to temporarily hold back fresh updates for channels not yet synced. Instead, the comparison was backwards, so it held back updates for already-synced channels and forwarded only updates for not-yet-synced channels. The fix changes the comparison direction and adds a test to confirm the correct behavior.
Update commitment_signed retransmission for next_funding
The next_funding TLV is included in channel_reestablish when either tx_signatures or commitment_signed is needed for an interactive-tx session. This commit largely includes the spec requirements in the comments, including when to retransmit commitment_signed. But it also adds an additional check that tx_signatures has not yet been received.
73/100 · AdequateMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context
Why it was queued
signing boundary
AI analysis · Low 42/100
This commit tightens the rules for re-sending a 'commitment_signed' message during Lightning channel reconnection when a new interactive funding transaction (such as a splice) is in progress. Previously, the code retransmitted commitment_signed whenever a flag was set; now it also requires that the peer's transaction signatures ('tx_signatures') have not yet been received. This avoids redundant or incorrect retransmissions and better aligns the implementation with the Lightning protocol specification.
No need to construct unused blinded hop data or hardcode session privs/prng seeds.
40/100 · ThinMessage clarity
✓ Descriptive subject✓ Provides an explanatory body! Too few words to establish purpose
Why it was queued
entropy or randomness
AI analysis · Informational 15/100
This commit is a test-only cleanup. It simplifies a single unit test by removing unused setup code and replacing hardcoded cryptographic secrets with deterministic test helpers. There is no change to production code, no security fix, and no vulnerability introduced.
Stop enqueueing error messages for disconnected peers
If a channel is failed while a peer is disconnected, we'll still have a `PeerState` for that peer. Historically, we haven't bothered to check if a peer is actually connected before we push the `error` message onto the `PeerState::pending_msg_events` queue, leaving us sending messages into the void.
This is generally not an issue as `ChannelManager::get_and_clear_pending_msg_events` should be called very regularly, removing these messages and then dropping them as `PeerManager` won't have anything to do with them. Further, when the the message is an `error`, if a peer happens to connect between when we push the message and when `get_and_clear_pending_msg_events` is called the worst that happens is they get the `error` message we'd end up sending them when they try to reestablish the channel anyway.
Still, its awkward to leave the `error`s lying around in a message queue for a disconnected peer, so we remove them here.
73/100 · AdequateMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context
Why it was queued
boot or update path
AI analysis · Informational 18/100
This change stops a Lightning node from queuing 'error' messages for peers that are currently disconnected. Previously, when a channel failed while a peer was offline, the node would still put an error message in that peer's outgoing message queue. The message would normally be discarded harmlessly later, but it was untidy and could briefly sit in the queue. The patch simply checks whether the peer is connected before adding the message. It is described by the authors as a cleanup rather than a security fix, with no practical exploit identified.
If a channel operation occurs while a peer is disconnected, we'll still have a `PeerState` for that peer. Historically, we haven't bothered to check if a peer is actually connected before we push new messages onto the `PeerState::pending_msg_events` field, leaving us sending messages into the void.
This is generally not an issue as `ChannelManager::get_and_clear_pending_msg_events` should be called very regularly, removing these messages and then dropping them as `PeerManager` won't have anything to do with them.
Still, there is a race condition here - if a peer manages to connect between the generation of one such message and when `get_and_clear_pending_msg_events` is called, we may enqueue a message to the peer which makes no sense and could lead to a spurious channel closure (especially in the case of an async `ChannelMonitorUpdate` completion or async signing operation, which often lead to normal channel message generation).
Further, if a peer is slow to send their `channel_reestablish` message after connection this race could be substantially more likely, as such normal channel messages may be nonsense until we've completed the reestablish dance (i.e. the later reestablish dance may lead us to re-send the same messages again immediately).
Here we remove most of the cases where we enqueue messages for disconnected peers.
Note that we differentiate between two different checks for connected-ness - for cases where we're sending an `error` or gossip messages, we allow the messages to be enqueued if the peer is connected at all. For most other cases, we only allow messages to be enqueued if the peer is connected *and* the channel has completed its reestablish dance (if required, i.e. the channel is "connected").
68/100 · AdequateMessage clarity
✓ Descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context
Why it was queued
signing boundary
AI analysis · Moderate 50/100
This commit fixes a race condition in the Lightning Dev Kit where the software could queue up messages for a peer that was temporarily disconnected. If that peer reconnected at just the right moment, it could receive messages that don't make sense for the current channel state, potentially causing a channel to close unexpectedly. The fix adds checks to avoid enqueueing most channel messages unless the peer is connected and the channel re-establishment handshake is complete. Error and gossip messages are still allowed when the peer is simply connected.
Previously, OutboundPayments methods required borrowed logger arguments since Logger lacked a Clone bound. This prevented logging in all desired places, limiting trace statements for debugging. This change initializes OutboundPayments with a cloned Logger, simplifying method signatures and improving logging flexibility.
68/100 · AdequateMessage clarity
✓ Descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context
Why it was queued
signing boundary
AI analysis · Informational 15/100
This commit is a straightforward internal refactoring: it stores a copy of the logging object inside the OutboundPayments helper so individual methods no longer need to be passed a logger every time they are called. There is no change to payment logic, cryptographic handling, network behavior, or user-facing APIs. It only affects how diagnostic messages are produced.
Drop `RevokedOutput::is_counterparty_balance_on_anchors`
When we added anchors support we declined to aggregate claims across different types of outputs for anchor channels, requiring that we track whether a `RevokedOutput` claim came from an anchor channel or not. This was only ever used to decide whether the claim was aggregable or not.
In 0fe90c6f7c3325935b18dbc809be14afd8fe067f we started aggregating by determining whether a claim is pinnable or not, rather than the much-too-coarse aggregable flag, leaving `is_counterparty_balance_on_anchors` unused.
Here we remove it entirely (as it would become ambiguous with zero-commitment-fee anchor channels).
We always write `Some(())`, marking the claim as an anchor claim and resulting in LDK prior to 0.1 refusing to aggregate the claim (which is the more conservative stance). This breaks downgrade to LDK 0.0.115 and earlier.
This commit removes an internal flag used when claiming funds from a revoked Lightning channel. The flag had become unused after a prior change, and removing it simplifies the code. The change intentionally breaks backward compatibility with older versions (before 0.1) to avoid ambiguous behavior with newer anchor channel types. It is a cleanup/refactoring change with a deliberate compatibility trade-off, not a fix for an active exploit.
Generate new `ReleasePaymentComplete` monitor updates
`MonitorEvent`s aren't delivered to the `ChannelManager` in a durable fasion - if the `ChannelManager` fetches the pending `MonitorEvent`s, then the `ChannelMonitor` gets persisted (i.e. due to a block update) then the node crashes, prior to persisting the `ChannelManager` again, the `MonitorEvent` and its effects on the `ChannelManger` will be lost. This isn't likely in a sync persist environment, but in an async one this could be an issue.
Note that this is only an issue for closed channels - `MonitorEvent`s only inform the `ChannelManager` that a channel is closed (which the `ChannelManager` will learn on startup or when it next tries to advance the channel state), that `ChannelMonitorUpdate` writes completed (which the `ChannelManager` will detect on startup), or that HTLCs resolved on-chain post closure. Of the three, only the last is problematic to lose prior to a reload.
In previous commits we ensured that HTLC resolutions which came to `ChannelManager` via a `MonitorEvent` were replayed on startup if the `MonitorEvent` was lost. However, in cases where the `ChannelManager` was so stale that it didn't have the payment state for an HTLC at all, we only re-add it in cases where `ChannelMonitor::get_pending_or_resolved_outbound_htlcs` includes it.
Because constantly re-adding a payment state and then failing it would generate lots of noise for users on startup (not to mention risk of confusing stale payment events for the latest state of a payment when the `PaymentId` has been reused to retry a payment). Thus, `get_pending_or_resolved_outbound_htlcs` does not include state for HTLCs which were resolved on chain with a preimage or HTLCs which were resolved on chain with a timeout after `ANTI_REORG_DELAY` confirmations.
This critera matches the critera for generating a `MonitorEvent`, and works great under the assumption that `MonitorEvent`s are reliably delivered. However, if they are not, and our `ChannelManager` is lost or substantially old (or, in a future where we do not persist `ChannelManager` at all), we will not end up seeing payment resolution events for an HTLC.
Instead, we really want to tell our `ChannelMonitor`s when the resolution of an HTLC is complete. Note that we don't particularly care about non-payment HTLCs, as there is no re-hydration of state to do there - `ChannelManager` load ignores forwarded HTLCs coming back from `get_pending_or_resolved_outbound_htlcs` as there's nothing to do - we always attempt to replay the success/failure and figure out if it mattered based on whether there was still an HTLC to claim/fail.
Here we begin generating the new `ChannelMonitorUpdateStep::ReleasePaymentComplete` updates, updating functional tests for the new `ChannelMonitorUpdate`s where required.
95/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Explains rationale or failure mode✓ Mentions testing or verification
Why it was queued
boot or update path
AI analysis · Moderate 53/100
This commit fixes a reliability bug in the Lightning Dev Kit (LDK) where payment success or failure events could be lost if the node crashes at the wrong moment. The fix adds a new 'ReleasePaymentComplete' monitor update so that once a payment is fully resolved, the ChannelMonitor records it durably. This prevents users from seeing stale or repeated payment events after a restart, especially in setups where persistence happens asynchronously. It is a defensive correctness fix, not an externally exploitable vulnerability.
Remove tx_signatures flags for interactive signing ChannelState
This commit addresses an overlap of state between `InteractiveTxSigningSession` and `ChannelState::FundingNegotiated`. The signing session already tracks whether both holder and counterparty `tx_signatures` have been produced, so tracking the state duplicatively at the `ChannelState` level is unnecessary.
73/100 · AdequateMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context
Why it was queued
signing boundary
AI analysis · Low 27/100
This commit is a code cleanup in a Bitcoin Lightning network library. It removes duplicate state-tracking flags from the channel state and instead relies on an existing 'interactive signing session' object to track the same information. The change simplifies the code and reduces the chance of inconsistent state, but it does not appear to fix an active security bug on its own. Some behavior changes in error handling are visible, but they look like incidental adjustments rather than a disclosed vulnerability fix.
Move interactive signing session into ChannelContext
Since the `InteractiveTxSigningSession` already tracks everything we need, we can remove the duplicate interactive signing state tracking within `ChannelState`.
73/100 · AdequateMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context
Why it was queued
signing boundary
AI analysis · Informational 12/100
This commit is a straightforward internal code cleanup in the Lightning Dev Kit. It moves the interactive transaction signing session from several channel-specific structs into a single shared ChannelContext struct, removing duplicate state tracking. There is no indication this fixes a security bug or changes security-relevant behavior.
Security candidatetest(invoice): add new BOLT11 test vector to test public-key recovery high-S signatureby Erick Cestari · c678a9a2 · Sep 15, 2025 · 1 fileMessage 77 · AdequateInformational 12Details
Commit message · Erick Cestari
test(invoice): add new BOLT11 test vector to test public-key recovery high-S signature
77/100 · AdequateMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Uses a recognizable type or scope✓ Mentions testing or verification✓ Names security-relevant behavior explicitly! No meaningful explanatory body
Why it was queued
signing boundaryfuzzing or regression evidence
AI analysis · Informational 12/100
This commit only adds a new test case to the rust-lightning invoice test suite. It exercises how the library handles a BOLT11 invoice containing a high-S signature during public-key recovery. There is no code change to the actual invoice parsing or signature logic, so by itself this commit does not fix or introduce a security issue. It is a test-only addition.
refactor(invoice): align signature checks with BOLT11 semantics
Simplify `check_signature` logic to follow the BOLT11 rules discussed:
- If an `n` field is present, verify the signature against the included pubkey using `secp256k1_ecdsa_verify`, which enforces normalized low-S form.
- If no `n` field is present, rely on `secp256k1_ecdsa_recover` to extract the pubkey. Recovery accepts both high-S and low-S signatures, matching existing implementations (lnd, c-lightning).
This avoids redundant recovery+verify checks while preserving interoperability.
100/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Uses a recognizable type or scope✓ Provides detailed explanatory context✓ Mentions testing or verification✓ Names security-relevant behavior explicitly
Why it was queued
signing boundary
AI analysis · Low 35/100
This commit changes how Bitcoin Lightning invoices (BOLT11) are validated. Previously, the code always tried to recover the signer's public key from the signature and also verified it, which could reject some signatures that other Lightning implementations accept. Now, if the invoice explicitly includes a public key, it only verifies the signature against that key (and requires a strict low-S signature). If no public key is included, it recovers the public key from the signature, accepting both high-S and low-S signatures like lnd and c-lightning. This is described as an interoperability fix, not a security vulnerability, but it slightly weakens signature strictness in the no-pubkey case.
Once a splice funding transaction has been constructed, the corresponding state must be persisted so that the process can be continued across restarts. This includes exchanging signatures, waiting for enough confirmations, and RBF'ing.
This commit fixes a data-loss bug in the Lightning Dev Kit's new channel-splicing feature. Previously, if a user constructed a splice funding transaction and then restarted their node, the in-progress splice state was not saved to disk, so the splice could not continue or recover correctly. The patch adds serialization (write/read) for the pending splice state so it survives restarts. There is no direct evidence this is exploitable by a remote attacker; the main risk is operational data loss and possible funds stuck in a half-completed splice.
Update OnchainTxHandler channel parameters on renegotiated funding locked
The `ChannelMonitor` now tracks its own set of channel parameters, but in the event they change after a splice, we want to ensure they are updated accordingly at the `OnchainTxHandler` level as well in case the user downgrades after a locked splice has already occurred.
85/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Explains rationale or failure mode
Why it was queued
update trust
AI analysis · Low 41/100
This commit fixes an internal bookkeeping issue in a Bitcoin Lightning Network library. After a channel is resized via 'splicing,' the on-chain emergency transaction handler was not being told about the new channel's size and parameters. If a user later ran older software that relied on that handler, it could operate with stale information, potentially creating invalid or uneconomic rescue transactions. There is no direct evidence this is remotely exploitable by an attacker.
Security candidateSet version 3 on transactions for HTLC signatures in 0FC channelsby Leo Nash · 538c4ccd · Sep 8, 2025 · 1 fileMessage 65 · AdequateLow 42Details
Commit message · Leo Nash
Set version 3 on transactions for HTLC signatures in 0FC channels
Co-authored-by: Matt Corallo <git@bluematt.me>
65/100 · AdequateMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides an explanatory body
Why it was queued
signing boundary
AI analysis · Low 42/100
This commit changes how certain Bitcoin transactions are versioned inside a specific type of Lightning channel (zero-fee-commitment, or 0FC, channels). For those channels, HTLC-related transactions now use transaction version 3 instead of version 2. Transaction version 3 is a newer standard that helps with network-wide fee management (transaction pinning resistance). The change only affects the transaction version number used when building and signing these transactions; it does not by itself move or expose funds.
Security candidateUse `SINGLE|ACP` sighash on signatures from peer in 0FC channelsby Leo Nash · 1cef4c3f · Sep 6, 2025 · 4 filesMessage 65 · AdequateModerate 57Details
Commit message · Leo Nash
Use `SINGLE|ACP` sighash on signatures from peer in 0FC channels
Co-authored-by: Matt Corallo <git@bluematt.me>
65/100 · AdequateMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides an explanatory body
Why it was queued
signing boundarysigning or wallet path
AI analysis · Moderate 57/100
This commit fixes how a Lightning node validates signatures from its channel peer for a newer type of channel (0FC, or 'zero-fee commitments'). Previously, the code expected the older SIGHASH_ALL signature type for these channels, which would cause the node to reject valid peer signatures or fail to build valid transactions. The fix makes the code use SIGHASH_SINGLE|SIGHASH_ANYONECANPAY for 0FC channels, matching the protocol design. A mismatch here could prevent correct operation or, in the worst case, be exploited to make a node accept an invalid transaction state, though the commit itself is small and defensive.
This commit completes a feature that lets a Lightning node ask its peer to resend 'announcement_signatures' messages during channel reestablishment. These signatures are needed to publicly announce a channel on the network. The change simply adds the logic to honor that request, matching a protocol rule. It is a follow-up implementation patch, not a fix for an active vulnerability.
When a splice transaction is promoted (i.e., when splice_locked has been exchanged), announcement_signatures must be sent. However, if we try to send a channel_announcement before they are received, then the signatures will be incorrect. To avoid this, clear the counterparty's announcement_signatures upon promoting a FundingScope.
80/100 · StrongMessage clarity
✓ Descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Explains rationale or failure mode
Why it was queued
signing boundary
AI analysis · Low 45/100
This patch fixes a Lightning channel bug that could produce an invalid channel announcement after a splice is finalized. When a channel is spliced (its on-chain funds are moved to a new transaction), both sides must exchange fresh announcement signatures before re-announcing the channel to the network. The bug caused the old counterparty signature to be kept briefly after the splice was promoted, so if the node tried to build and send a channel_announcement before the new signature arrived, it would use a stale signature and create an invalid message. The fix simply clears the old signature when the splice is promoted, forcing the node to wait for the new one. There is no direct theft-of-funds path, but it could cause gossip inconsistencies or a peer to send invalid protocol messages.
During channel reestablishment, announcement_signatures may need to be retransmitted. The splicing spec allows doing so without retransmitting splice_locked first, which could normally trigger retransmitting announcement_signatures. Instead, my_current_funding_locked lets the sender request retransmitting it.
This commit changes how Lightning nodes request missing announcement signatures after a channel reconnects. It adds a flag to the FundingLocked message so a node can explicitly ask its peer to resend announcement_signatures when needed, rather than relying on the older splice_locked retransmission path. This is a protocol-correctness improvement for splicing; it does not appear to be a direct exploit fix.
Update next_funding_txid logic for channel_reestablish
The splicing spec updates the logic pertaining to next_funding_txid when handling a channel_reestablish message. Specifically:
A receiving node: - if `next_funding_txid` is set: - if `next_funding_txid` matches the latest interactive funding transaction or the current channel funding transaction: - if `next_commitment_number` is equal to the commitment number of the `commitment_signed` message it sent for this funding transaction: - MUST retransmit its `commitment_signed` for that funding transaction. - if it has already received `commitment_signed` and it should sign first, as specified in the [`tx_signatures` requirements](#the-tx_signatures-message): - MUST send its `tx_signatures` for that funding transaction. - if it has already received `tx_signatures` for that funding transaction: - MUST send its `tx_signatures` for that funding transaction. - if it also sets `next_funding_txid` in its own `channel_reestablish`, but the values don't match: - MUST send an `error` and fail the channel. - otherwise: - MUST send `tx_abort` to let the sending node know that they can forget this funding transaction.
Note that the spec is in flux. Instead, next_funding_txid is replaced with next_funding, which contains both a txid and retransmit_flags. The latter is used instead of next_commitment_number to determine whether commitment_signed should be retransmitted.
This commit updates FundedChannel::channel_reestablish accordingly.
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Explains rationale or failure mode
Why it was queued
signing boundary
AI analysis · Low 43/100
This commit updates how the Lightning Dev Kit (LDK) node handles reconnection messages for channels that are in the middle of creating a new funding transaction (a 'splicing' or interactive funding flow). It replaces a simple transaction ID field with a richer structure that also carries flags telling the peer which messages to re-send. The change is a protocol-conformance update for a still-evolving Lightning specification; it does not appear to be a fix for an active security vulnerability, but it prevents possible state mismatches during reconnections.
The ChannelMonitor must be successfully persisted before transmitting any messages.
65/100 · AdequateMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides an explanatory body
Why it was queued
signing boundary
AI analysis · Moderate 60/100
This commit fixes a timing issue in the Lightning Dev Kit where a node could send transaction signatures to its peer before its own local safety record (the ChannelMonitor) had been saved. Sending signatures too early could, in edge cases, leave the node in a vulnerable or inconsistent state if something crashed or went wrong before the save completed. The fix simply waits to send signatures until the monitor update is finished.