LND

This commit only adds a single line to the release notes document, linking to a prior code change about finalizing a SQL database implementation for payment records. There is no actual code change, no bug fix, and no security content in the diff itself.

This commit simply renames a database migration file from version 9 to version 10 to avoid a numbering conflict with another migration that was merged first. The actual SQL content of the migration is unchanged. There is no security issue here.

This commit only adds a code comment (a TODO note) suggesting a future cleanup for payments that were started but never had an actual payment attempt registered. It makes no code changes that fix or alter behavior, so it does not by itself address any active security issue.

This commit only reorganizes and rewrites test code for the payments database. It splits one KV-backend-specific test into a focused duplicate-payment test, and moves the general 'delete non-in-flight payments' test into a database-agnostic test file. No production code is changed, so it cannot affect live node behavior or security.

This commit is a code cleanup: it moves a setting that controls whether failed Lightning payment attempts are kept in the database out of the database layer and into the routing subsystem. The user-visible behavior (keeping or deleting failed attempts based on configuration) is preserved. There is no security vulnerability introduced or fixed here.

This commit only adds and updates unit tests for the payments database code in the LND lightning node. It does not change any production code, so it cannot introduce a security vulnerability or fix one. The tests verify that payment attempts with AMP data, blinded routes, and various failure scenarios are stored and retrieved correctly.

This commit only adds a new unit test to verify that payment route data—specifically the first hop amount and custom records—is correctly saved and retrieved from the database. There are no code behavior changes, no bug fixes, and no security-related modifications.

This commit only refactors test helper functions in the payments database test code. It changes helper functions to use internal assertion helpers instead of returning errors, and updates callers accordingly. There is no change to production code, no security fix, and no behavior change in the actual Lightning node software.

This change is a routine code cleanup: it replaces a placeholder 'context.TODO()' with a proper context that is passed down through several related functions. Contexts help control timeouts and cancellation in Go programs. The patch itself does not fix a known security vulnerability or change any security-critical behavior; it mainly improves code quality and makes cancellation/timeouts more consistent.

This commit only adds a single line to the release notes document, listing another internal code-cleanup pull request. It does not change any program code, configuration, or behavior of the LND software. There is no security relevance.

This commit replaces a placeholder 'context.TODO()' with a proper cancellation context in one internal payment-tracking method. It is a code-quality and graceful-shutdown improvement, not a fix for an active security vulnerability. There is no evidence of exploitability from the diff alone.

This change updates the SendPayment function so it accepts a caller-provided context instead of always creating a fresh background context. In plain terms, it lets the payment-sending code respect cancellation or timeout signals from the caller (for example, if an RPC client disconnects). There is no direct security bug being fixed here; it is a code-quality and resource-cleanup improvement.

This is a small internal code cleanup in LND's payment routing logic. It changes a helper function so callers pass in an existing request context, instead of the helper creating a blank placeholder context. There is no direct security fix here, but it removes a minor anti-pattern that could theoretically hide cancellation or timeout problems in future changes.

This commit is a small code-quality cleanup. It changes one internal function so it accepts a context parameter from its caller instead of creating a blank placeholder context internally. There is no security fix here and no behavior change visible to users.

This commit threads request context objects through LND's payment lifecycle code so that database operations can continue even when the caller's request is cancelled. It is a defensive refactor that reduces the risk of payment state corruption or stuck payments if an RPC client disconnects mid-payment. It does not appear to fix an active exploit, and the commit message does not describe it as a security fix.

This change is a straightforward code cleanup: it threads a context.Context parameter through the SettleAttempt function so callers pass in a request-scoped context instead of the function internally using a placeholder context.TODO(). It does not change payment logic, access controls, or cryptographic handling. The only functional difference is that database operations during settle can now be cancelled or timed out by the caller's context, which is generally an improvement but not a security fix on its own.

This change threads a context.Context through the payment-failure code paths in LND. The most user-visible effect is that when a payment's own context is cancelled, the code now uses a fresh context (context.WithoutCancel) so the database can still record the payment as failed instead of leaving it stuck in-flight. It also removes several context.TODO() placeholders in the SQL store and routing lifecycle. This is a robustness/cleanup change rather than a security fix; there is no exploit or attacker-controlled path visible in the diff.

This change replaces a placeholder 'context.TODO()' with a proper cancellation context in a routing function used when sending Lightning payments. It is a code-quality and robustness improvement that lets long-running route-finding operations be cancelled cleanly. There is no direct evidence this fixes an exploitable security vulnerability.

This change is a routine code cleanup: it threads a context.Context argument through the FailAttempt function and its callers. Contexts let operations respect cancellation and timeouts. The patch does not fix a known vulnerability; it removes two temporary context.TODO() placeholders and makes the function signature consistent with related functions like SettleAttempt. There is no security-relevant behavior change visible in the diff.

This change threads a context parameter through the DeleteFailedAttempts function so that database cleanup operations can continue even if the original request context is cancelled. It is a robustness improvement, not a fix for an actively exploitable security vulnerability. The commit message and diff do not describe any security issue.

This change is a straightforward internal code cleanup: it threads a context.Context argument through the RegisterAttempt method so callers can pass cancellation/timeout information instead of the database layer creating a blank context.TODO(). It does not change payment logic, validation rules, or security boundaries. The only functional difference is that the SQL store now uses whatever context the caller provides rather than a placeholder context. There is no indication this fixes a vulnerability or introduces a new attack path.

This commit only adds a single line to the release notes document, referencing a prior code change about threading context through payment database functions. It contains no code changes, no bug fixes, and no security-related content.

This change is a routine code cleanup: it threads a context.Context argument through the InitPayment function across several files. A context lets callers cancel or time out long-running operations. The patch removes placeholder context.TODO() calls in the SQL store and control tower, but it still introduces a new context.TODO() in the router's PreparePayment path. There is no direct security fix here, but it improves the ability to cancel database transactions properly in the future.

This change threads a context parameter through the FetchInFlightPayments function across multiple components. It replaces a hardcoded context.TODO() in the SQL store with a caller-provided context, allowing better cancellation and timeout control. There is no direct security vulnerability being fixed here; it is a code-quality and operational improvement.

This commit only adds a single line to the release notes document, describing a completed code change (finalizing SQL payments implementation and enabling tests). It does not modify any program code, configuration, or security mechanism.