rust-lightning

This commit adds a Rust compiler lint configuration to the lightning-tests package. It tells the compiler to treat 'taproot' as an expected configuration flag and to forbid unexpected ones. This is a code-quality/build-hardening change, not a security fix for a vulnerability.

This commit raises the Minimum Supported Rust Version (MSRV) from 1.63.0 to 1.75.0 for the rust-lightning project. It updates CI configuration, documentation, linting rules, and dependency pinning scripts. It also replaces older Rust idioms with newer, cleaner equivalents (such as using div_ceil and is_some_and methods) that require the newer compiler version. There is no security fix or vulnerability being patched here.

This change fixes a bookkeeping error in Lightning Dev Kit's channel monitor after a splice (a way to resize a Lightning channel's on-chain funding). If a channel had HTLCs (pending payments) in an older commitment state but no new commitment was negotiated during the splice, the monitor could keep stale HTLC data for a commitment transaction that never existed for the new funding transaction. The patch clears that stale data once the splice is locked. The main risk is that stale data might cause incorrect behavior when claiming or revoking funds if an old commitment were somehow broadcast, but the commit message frames this as a correctness fix rather than an active exploit.

This commit simply removes one test command from the project's continuous integration script. It is a cleanup change with no security relevance: it stops running tests under an 'async_payments' configuration flag that had already been removed from the code. There is no vulnerability, no bug fix, and no user-facing behavior change.

This commit only adds contributor statistics and author names to the project's CHANGELOG.md for the 0.1 release. It contains no code changes, no bug fixes, and no security-related modifications.

This commit only changes test code. It updates a test helper macro and related reconnection tests to capture and optionally handle 'stfu' messages sent when Lightning channels reconnect. There is no change to production code, so it does not introduce or fix a security vulnerability on its own.

This commit only adds a new test case and a small test helper. It does not change production code, so it cannot introduce a runtime security vulnerability. The test exercises a specific Lightning protocol scenario: proposing a channel splice while the peer is temporarily disconnected, including node reload and zero-conf channel variants.

This patch fixes a logic gap in the Lightning Dev Kit where two sides tried to splice the same channel at the same time. If the counterparty won the tie-breaker, the local node's queued splice could be forgotten and never attempted. The fix re-queues the local splice once the counterparty's splice becomes locked, so the channel eventually reaches the intended upgraded state.

This change lets a user queue a Bitcoin Lightning 'splice' request even when the other party is offline, so it can proceed once they reconnect. Previously the software rejected splice requests while disconnected. The patch also adds clearer logging when the protocol waits for reconnection. It is a feature change, not a fix for an active exploit.

This commit fixes a protocol-handling gap for zero-confirmation channel splices in the Lightning Dev Kit. When two peers agree to a splice that does not require waiting for blockchain confirmations, the node now immediately sends a 'splice_locked' message right after exchanging transaction signatures. Previously, this message was only sent after blocks were mined, which could leave a 0-conf splice stuck and unusable. The change is a correctness fix in the Lightning state machine rather than a patch for a remote exploit.

This commit only adds a log message when an interactive funding transaction is broadcast, and refactors three call sites to use a shared helper function. It does not change any security-critical behavior, transaction validation, or network logic. There is no indication of a vulnerability being fixed.

This change fixes a logic bug in the LSPS2 liquidity service of rust-lightning. Previously, when an intercepted HTLC carried a short channel ID (SCID) that the LSPS2 service did not recognize, the handler silently did nothing. Now it returns a clear error so the caller can route the HTLC to another handler or fail it back. The fix prevents HTLCs from getting stuck or being silently dropped when multiple interceptors are active or when old SCIDs overlap with the fake SCID namespace.

This commit only adds a new automated documentation-build check to the project's continuous integration (CI) pipeline. It does not change any production code, cryptographic logic, network handling, or user-facing behavior. There is no security vulnerability here.

This commit is a routine documentation build fix. It swaps one Rust compiler feature flag used only when building documentation on docs.rs (`doc_auto_cfg`) for another (`doc_cfg`) because the old one was removed/merged in the Rust toolchain. It does not change any runtime code, network behavior, or security logic.

This commit changes the numeric identifier (TLV type) used for an optional extra field in a Lightning protocol message called CommitmentSigned. Previously a temporary placeholder number (1001) was used; now it is changed to the final spec-mandated number (1). This is a protocol-correctness update, not a fix for an active security vulnerability. However, because it alters wire serialization, mismatched versions of the software could fail to understand each other's messages, which could in turn affect channel state consistency.

This commit only updates the documentation comments for a function called splice_channel. It does not change any actual code logic. The new docs explain how splicing works, what events are emitted, and how fees are handled. There is no security issue here.

This is a small bug fix in a Bitcoin Lightning Network library. After a successful 'splice' operation (a way to resize a payment channel), the software now correctly saves the updated channel state to disk. Before, it skipped saving. The risk is that if the program crashed or restarted right after a splice, it could lose track of the new channel state and potentially behave incorrectly or lose funds.

This change fixes a bookkeeping bug in the Lightning Dev Kit's splicing feature. When a peer disconnects while a splice is being negotiated (but before signatures are exchanged), the software now emits a SpliceFailed event so the user's wallet knows the splice attempt is dead and can unlock any reserved funds. Previously, the internal splice state was reset on disconnect but no event was emitted, which could leave a wallet waiting indefinitely for a splice that would never complete.

This commit fixes a bug in the Lightning Dev Kit where a wallet reload could silently drop an in-progress channel splice. Previously, if the program restarted while a splice was in an early negotiation state, the user would never receive a 'SpliceFailed' event, so their funds could appear stuck or the failure could go unnoticed. The fix temporarily saves a failure event during persistence so it can be emitted after the reload, then removes it from storage. It is a reliability/notification fix, not a direct theft or remote-exploitation vulnerability.

This commit is a routine internal code cleanup in the Lightning Dev Kit's Rust implementation. It splits one large Rust macro into two smaller ones, with no change to what the code actually does. There is no security issue visible in the change.

This commit is a code cleanup: it pulls out an existing code pattern into a new macro with a clearer name and adds documentation. It does not change behavior or fix a security issue.

This commit is a pure code cleanup: it pulls one specialized branch of a large Rust macro out into its own named macro and updates the three call sites to use the new name. No behavior, logic, or security properties change.

This commit is a small internal code cleanup in the Lightning Dev Kit's Rust implementation. It pulls out a repeated block of code into a new macro named handle_initial_monitor and updates the existing macro accordingly. There is no change to what the code actually does, no bug fix, and no security-relevant behavior change.

This commit is a straightforward internal code cleanup in the Lightning Dev Kit's Rust implementation. It takes a chunk of logic that was duplicated inside a macro and moves it into a normal Rust function. The behavior is intended to be identical; there is no user-facing change or security fix.

This commit changes which experimental 'feature bit' the Lightning Dev Kit software advertises to peers for an unfinished channel-splicing capability. It stops advertising the older production-like bit and starts advertising a prototype bit that was agreed upon with other Lightning implementations. This is a protocol-compatibility and testing change, not a security fix or vulnerability.