rust-lightning

This commit is a minor logging and API cleanup change. It changes the LiquidityManager persistence methods to return a boolean indicating whether any data was actually written, and only logs a 'Persisted' message when something was actually saved. Previously, the background processor logged 'Persisting LiquidityManager...' on every wakeup even when there was nothing to save, which could produce excessive log output. There is no security issue here.

This commit is purely a code formatting cleanup. It removes manual rustfmt skip annotations and lets rustfmt reformat several match statements and function signatures in the Lightning channel code. There are no logic changes, no security fixes, and no behavior differences.

This commit is a straightforward internal code cleanup: it changes a Rust enum variant from storing two unnamed fields to storing two named fields. It does not alter what data is stored, how payments are validated, or any network-visible behavior. There is no security fix or vulnerability here.

This commit is a straightforward internal code cleanup in the Lightning Dev Kit's channel handling code. It changes how data is packaged inside an internal enum (InboundHTLCRemovalReason) from unnamed tuples to named struct fields, so that future serialization code can handle it more easily. There is no change to security logic, no bug fix, and no externally visible behavior change.

This commit adds safety checks in the Lightning Dev Kit (LDK) to ensure that the inner 'trampoline' payment instructions match the outer onion packet's amounts and deadlines. Without these checks, a malicious or buggy sender could craft a trampoline payment where the outer layer promises one amount or deadline while the inner layer demands a higher one, potentially allowing a node to be tricked into accepting or relaying an inconsistent payment. The patch enforces that the outer onion's amount and CLTV expiry are at least as large as the trampoline onion's, and adds tests for underpayment and deadline mismatch cases.

This commit only adds new test cases to the project's test suite. It does not change any production code. The tests verify that the software correctly handles tiny fractions of Bitcoin (millisatoshis) when building special zero-fee Lightning commitment transactions, including cases where dust amounts add up. There is no indication of a security fix or vulnerability being patched here.

This commit adds the funding redeem script (the cryptographic lock script for a Lightning channel's funding output) to the SplicePending event that LDK emits when a splice is being negotiated. It is an API/data-visibility change, not a logic fix. There is no direct evidence in the commit that this resolves a security vulnerability; it appears to give downstream wallet software the information it needs to recognize and spend the new funding output after a splice.

This commit adds a new piece of public information—the funding redeem script—to two existing data structures that describe Lightning channels. It does not change how funds are secured, how transactions are signed, or how peers communicate. It simply lets downstream wallet software reconstruct the channel's funding transaction output so it can calculate fees more accurately when splicing funds into a channel. There is no indication this fixes a vulnerability or introduces a new attack path.

This commit adds three new error-code labels used when a Lightning payment fails while being forwarded through a special routing feature called Trampoline payments. It is essentially a standards-compliance update that maps new internal reasons to the correct numeric failure codes and serialization IDs. There is no direct evidence this fixes an active security bug or vulnerability.

This commit is purely a code cleanup: it tidies up formatting in a test function and extracts a small helper to reduce repetition. There is no change to production behavior, no bug fix, and no security relevance.

This commit is purely a code-formatting cleanup in a test file. It removes a directive that told the Rust formatter to ignore a particular test function, then re-wraps long lines so the code follows normal style rules. No program behavior, logic, or security-sensitive code is changed.

This commit is a code-style cleanup in a test file. It removes a file-wide directive that told the Rust formatter to ignore the file, and instead marks individual helper functions to skip formatting. The actual test logic and program behavior are unchanged.

This commit improves how the Lightning node handles reconnections after a network interruption. Previously, when re-establishing a channel, the node sometimes had to ask an external signer for a cryptographic proof point and could not proceed until the signer responded. The change keeps the two most recent revoked proof points cached locally so the common case no longer needs to wait for the signer. It only defers to the signer asynchronously in the rare 'stale state' case, where the peer claims our node is behind. That stale case either proves data loss (causing a protective panic) or proves the peer is lying (causing a force-close). The commit is a defensive hardening/feature change, not a fix for an active exploit.

This commit is purely a code-formatting cleanup. It removes `#[rustfmt::skip]` annotations from a few functions in the Lightning channel manager and lets rustfmt reformat the code. No logic, behavior, or security properties of the program change.

This commit is a code cleanup change. It removes repeated node IDs and payment hashes from individual log messages because the logging framework now automatically includes those details as structured fields. No security vulnerability is fixed or introduced; it only makes log output less cluttered.

This commit only adds a new unit test to the Lightning Dev Kit codebase. It does not change any production code, fix a bug, or alter behavior. The test exercises a specific scenario involving small ('dust') HTLCs in a v3 commitment transaction. There is no security-relevant change in the diff itself.

This commit adds support for Bitcoin's new Testnet4 network in the rust-lightning library. It mainly bumps a dependency version and maps Testnet4 invoices to use the existing Testnet currency type. The change is a routine compatibility update, not a security fix, though it removes a fallback that previously treated unknown networks as regtest.

This is a trivial code cleanup: a developer removed a temporary variable that held an error message and instead put the message text directly into the logging call. The program's behavior, error messages, and security posture are unchanged.

This commit is a pure code reorganization: it moves several large blocks of macro definitions lower in the same file so that a later commit can reuse them more easily. No behavior, logic, or security properties of the code change.

This commit is a pure code cleanup: it extracts the handling of unfunded channels from a large macro into a small internal function. There is no change to user-visible behavior, no bug fix, and no security relevance.

This commit is a code cleanup that moves some repeated logic into a new helper function. It does not change what the program does; it only reorganizes how the code is structured to make builds slightly faster. There is no indication of a security fix.

This commit is purely a code formatting and minor refactoring change. It splits a few long single-line expressions into multiple shorter lines and introduces temporary variables for readability. There is no functional change, no bug fix, and no security relevance.

This commit is a straightforward code cleanup: it removes a small internal macro and copies its contents directly into the two functions that used it. There is no change in behavior, no bug fix, and no security-relevant change. It is purely a refactoring to make the code easier to read and maintain.

This commit is purely a code-formatting cleanup of a macro and a few nearby functions in the Lightning channel manager. It renames local variables for brevity, wraps long argument lists, and shortens a couple of log/debug strings. There is no functional change and no security relevance.

This commit is a straightforward code cleanup: it takes a large block of code that was duplicated inside a macro and moves it into a regular function. The behavior is unchanged; the change only reduces compile time and memory usage slightly. There is no security fix or vulnerability here.