rust-lightning

This commit is a straightforward internal code reorganization in the Lightning Dev Kit's channel manager. It converts two standalone helper functions into methods on the ChannelManager struct and moves them to a different location in the same file. The only functional change is that a logging context object is now created inside the method when needed, rather than being passed in by callers. There is no user-visible behavior change and no security fix or vulnerability introduced.

This is a documentation-only change that updates an internal code comment to match renamed variable names. No code behavior was altered, and there is no security impact.

This commit changes how the Lightning Dev Kit (LDK) node restores its record of in-flight payment forwards after a restart. Previously, the code preferred newly reconstructed forward maps built from channel monitor data, which required complex de-duplication logic to avoid processing the same HTLC twice. The commit switches production code to always use the older, persisted forward maps instead, while keeping the new reconstruction path active only in tests (randomly or via an environment variable). It also adds a small guard to avoid pushing duplicate intercept events if a restart re-processes an already-handled intercept forward.

This commit is a straightforward performance optimization in the Lightning Dev Kit's channel manager. It changes how pending payment packets (HTLCs) are looked up and removed from a tracking map, replacing a full scan of all entries with a direct lookup by channel identifier. There is no security-relevant change visible in the diff.

This commit fixes a bug in the Lightning Dev Kit where, after restarting a forwarding node, an already-forwarded payment could be forwarded a second time. The bug only affected the node that restarts, and could lead to duplicate HTLCs being sent downstream, potentially causing funds to be locked or payment failures. The fix prunes already-forwarded HTLCs from a rebuilt in-memory map during startup.

This commit is a pure code restructure: it moves an existing `if is_channel_closed` check inside the loops that process HTLCs, rather than wrapping the loops from the outside. The commit message explicitly says it is 'necessary for the next commit and makes it easier to read.' No behavior changes are visible in the diff, and there is no security fix here.

This commit only adds documentation comments to a Rust function. It clarifies which feature flags and conditions are needed to use the splicing feature. No code behavior was changed, so there is no security issue.

This commit only adds new test code to verify how an existing 'accountable' flag is forwarded between Lightning nodes. It does not change production logic, so it cannot introduce a new security vulnerability by itself. The tests check that the flag is correctly propagated (or not propagated) across a three-node payment path.

This is a small code cleanup that removes an unnecessary clone (duplicate copy) of update_add data when serializing a Lightning channel to bytes. It changes the vector to hold references instead of owned copies, with no functional change to behavior or security.

This commit adds a new boolean flag called 'accountable' to outbound payment records (HTLCs) in a Lightning Network implementation. It ensures the flag is saved to disk and restored correctly when the node restarts. The change appears to be a data-model fix to support tracking which payments should be held financially accountable, likely as part of a larger feature. There is no direct evidence in the commit that this fixes an active security vulnerability, but incomplete state serialization can lead to incorrect behavior after a restart.

This commit adds a new 'accountable' flag to forwarded Lightning payments that is preserved when an HTLC is queued in a channel's holding cell. The flag appears intended to track whether a downstream node can be held financially responsible if a forwarded payment fails after the upstream side has already been settled. The change itself is a data plumbing patch; it does not contain an obvious active vulnerability, but it is part of a larger accountability mechanism whose security implications depend on how the flag is consumed elsewhere.

This commit adds a new boolean flag called incoming_accountable to an internal data structure (PendingHTLCInfo) used when routing Lightning payments. The flag records whether the node is expected to be 'accountable' for resolving an incoming payment on time. It is read from an optional TLV field in the incoming message and defaults to false when not present. The change is a straightforward plumbing/data-model update; it does not by itself fix or introduce a security flaw, but it is part of work that could affect how reputation and payment-timeout penalties are tracked in the future.

This commit adds a new experimental flag called 'accountable' to the Lightning update_add_htlc message. The flag is purely informational right now: it is sent and received, but the code does not use it to make any forwarding or security decisions. It is marked experimental and is not treated as authoritative. There is no obvious security vulnerability in the change itself.

This commit adds a missing macro rule in a Rust serialization helper so that optional fields can use a custom byte encoding. It is a feature addition with a regression test; there is no indication it fixes a security vulnerability.

This commit adds a new optional method that lets a Lightning node read its saved channel monitors in parallel, including the CPU-heavy step of turning stored data back into usable objects. It is a performance improvement, not a security fix. The existing single-threaded method remains available and unchanged in behavior.

This commit is a performance optimization, not a security fix. It changes how Lightning node data is loaded from storage when the program starts up. Previously, certain update records were read one at a time; now they are read in parallel. The commit message and code changes only describe speed improvements and reducing network round trips. There is no indication of a vulnerability being fixed.

This commit is a performance and robustness improvement, not a fix for an active security bug. It changes how Lightning channel monitor data is loaded on startup so that the code lists available update files first, rather than repeatedly trying to read update files until it gets a 'not found' error. This removes one round-trip to storage for users with no pending updates and makes the loader no longer depend on storage backends correctly returning a specific 'not found' error. The old behavior could, in theory, cause a node to fail to start or misload state if a storage backend returned the wrong error kind, but the commit itself does not describe any such failure being exploited.

This commit is a routine internal API change. It updates the FutureSpawner trait so that spawning a background future can return the future's result, similar to tokio::spawn. It does not fix a security bug and does not introduce obvious security flaws; it is preparation for a later feature.

This commit is a performance improvement, not a security fix. It changes how Lightning Dev Kit loads saved channel data on startup so that multiple pieces can be read at the same time rather than one after another. The change introduces a small amount of `unsafe` Rust code, but the included safety comment explains why the authors believe it is correct. There is no indication in the commit that this fixes a vulnerability or that it creates one.

This commit adds a test-only option to make hash map iteration order deterministic. It does not change production code and has no security relevance. It is purely a testing convenience for comparing test logs across runs.

This change only affects internal test code. It adds an environment variable so developers can choose a fixed block-connect style during testing instead of having one picked at random. There is no production code change and no security impact.

This commit is purely a code-formatting cleanup. It removes `#[rustfmt::skip]` annotations from three methods in the Lightning channel code and lets rustfmt reformat the function signatures, calls, and log statements across multiple lines. No logic, behavior, or security checks were changed.

This commit is a pure code cleanup: it extracts long error message strings into local variables before building the same error return values. There is no functional change, no security fix, and no change to what the program does.

This is a minor internal code cleanup in the Lightning Dev Kit's channel handling. It changes how a function accepts several lists of pending actions, switching from mutable references that append into internal storage to a style that consumes the vectors directly. There is no user-visible behavior change and no security relevance.

This commit only adds a logging parameter to an internal helper function and its callers. It does not change program logic, state handling, or security behavior. The change is purely for better observability when channel monitor updates are paused.