LND

This commit is a routine code cleanup: it threads a request-scoped cancellation context through the AddEdgeProof function instead of creating a blank context.TODO() inside the SQL database path. There is no security-relevant behavior change; it simply lets callers pass their own context for timeouts and cancellation.

This commit is a small internal cleanup: it threads a Go request-lifecycle 'context' through the GraphSession database-query helper so callers can cancel or time out graph lookups. The only concrete behavior change is in the SQL backend, where a hard-coded placeholder context.TODO() is replaced by the caller-supplied context. There is no direct security fix, exploit, or vulnerability visible in the diff, but it removes a future foot-gun where graph queries could not respect cancellation/timeouts.

This commit is a routine code-quality refactor: it threads a request-scoped cancellation signal (a 'context') through the IsPublicNode database lookup. Previously the SQL backend used a placeholder TODO context, which meant long-running queries could not be cancelled. The change does not alter what the function returns, only how it handles timeouts and cancellation. It is not a security patch in itself, though better context plumbing can help limit resource exhaustion in future hardening.

This commit is a routine code-quality change: it threads a request-scoped cancellation signal (a 'context') through a database lookup method called HasChannelEdge. Previously some code paths used a blank, never-cancelling context.TODO(), which meant long-running database queries could not be cancelled. The change lets callers cancel or time out the lookup. It is not a security patch in itself and does not fix a known exploitable bug, but it removes a small source of unbounded work that could contribute to denial-of-service conditions.

This change simply threads a request context through a database lookup function so callers can cancel or time out the operation. It does not fix a vulnerability or change behavior in a security-relevant way.

This change is a routine code cleanup: it threads a request-scoped cancellation context through a database lookup function called FetchChannelEdgesByOutpoint. It does not fix a security bug, change behavior, or introduce any new logic. The only effect is that callers can now pass a context, and the SQL backend can use that context instead of a placeholder. The KV backend ignores the context for now.

This commit is a routine code cleanup: it threads a request-scoped cancellation signal (a 'context') into a database lookup function called HasV1ChannelEdge. Previously the SQL database backend used a placeholder context.TODO(), which meant long-running queries could not be cancelled cleanly. The change lets callers cancel or time out the lookup, improving robustness but not directly fixing an exploitable security bug.

This change simply passes a request-scoped cancellation signal (a 'context') through a database lookup function called FetchChannelEdgesByID. It does not fix a concrete bug by itself; it is plumbing work that lets future callers cancel long-running queries or propagate deadlines. There is no direct security vulnerability being patched here.

This change simply passes a request-scoped cancellation signal (a 'context') through the DeleteChannelEdges function and its callers. It does not change what the function does, only how it receives timeout/cancellation information. There is no security vulnerability or fix here.

This change threads a request-scoped cancellation context through a database method that populates the Lightning Network graph cache. It replaces a placeholder TODO context in the SQL backend with a real one, allowing long-running cache population to be cancelled if the caller stops waiting. There is no direct security bug being fixed; it is a robustness and maintainability improvement.

This commit is a routine code cleanup: it passes a request-scoped cancellation signal (a 'context') through a database query method called FilterChannelRange. Previously the SQL backend created a blank context internally, while the caller in the network discovery code ignored any context. Now the context is threaded from the caller down to the database. There is no security bug being fixed here; it is a maintainability and consistency improvement.

This change simply passes an existing request context (a standard cancellation/timeout carrier) into a database query that counts 'zombie' channels. It does not fix a crash, bug, or security flaw by itself; it is a code-cleanup and consistency change that lets callers cancel or time out the query properly. There is no indication this was a security patch.

This change simply passes a request-scoped cancellation signal (a 'context') through the MarkEdgeZombie function and its database backends. It does not alter what the function does, who can call it, or how channel zombie state is decided. There is no security fix or vulnerability here—only a routine code-quality refactor to make the function consistent with the rest of the codebase.

This commit is a routine internal refactoring change. It adds a standard request context parameter to a function called MarkEdgeLive so that database operations can be cancelled or timed out cleanly. There is no security fix or vulnerability here.

This change simply passes a request-scoped cancellation signal (a 'context') through a database query function called NodeUpdatesInHorizon. It does not fix a crash, bug, or security flaw by itself; it is a routine plumbing/refactoring patch that lets callers cancel long-running queries cleanly. There is no indication it addresses a disclosed vulnerability.

This commit is a routine code cleanup: it passes a request-scoped cancellation signal (a 'context') through a database query method called ChanUpdatesInHorizon. The change itself does not fix a crash, bug, or security vulnerability. It simply makes the code more consistent with modern Go practices and allows future callers to cancel long-running queries properly. The SQL implementation now uses the provided context instead of creating a blank one internally, while the older key-value store implementation ignores the new parameter for now.

This change is a routine code cleanup: it threads a request-scoped 'context' parameter through a graph traversal function called ForEachNodeDirectedChannel so that database operations can be cancelled or time out properly. It does not fix a security bug and introduces no user-visible behavior change.

This commit is a routine code cleanup: it threads a standard Go context.Context parameter through the IsZombieEdge function and its callers. The context allows callers to pass cancellation/timeout information into the SQL store implementation, replacing a placeholder TODO context. There is no security-relevant behavior change visible in the diff.

This change simply passes a request-scoped cancellation signal (a 'context') through a database lookup function called DisabledChannelIDs. It does not fix a crash, bug, or security flaw by itself; it is a routine code-quality improvement that makes the function respect caller cancellation and enables future SQL query timeouts. The only concrete effect visible in the diff is that the SQL backend now reuses the caller's context instead of creating a blank one internally.

This commit is a routine code cleanup that threads a request-scoped context.Context parameter through the FetchNodeFeatures function and its callers. It does not change any security logic, fix a bug, or alter behavior. The change simply lets callers pass cancellation/timeout context into database reads instead of the function internally creating a blank context.TODO().

This commit is a minor internal cleanup of a test helper function in lnd's graph database tests. It changes how a comparison helper reports failures but does not alter production code, network behavior, or any security-relevant logic. There is no security issue here.

This commit is a small cleanup of internal test helper code. It changes how a test-only function reports errors so that callers don't have to check an error value themselves. There is no change to the actual LND node software that users run, and no security relevance.

This commit only changes a test helper function in LND's graph test code. It makes the helper report its own errors instead of returning them to callers. There is no change to production code, user-facing behavior, or security-sensitive logic.

This commit is a test-only cleanup in the LND Lightning node project. It replaces old-style manual error checks (which stop the test with t.Fatal) with equivalent helper functions from the testify/require library. No production code, user behavior, or network protocol handling is changed. It cannot affect node security or be exploited.

This commit only changes test files in the LND project. It replaces older-style error-checking code in tests with cleaner helper functions from the testify/require library. No production code is modified, so it cannot affect how the software behaves when users run it, and it introduces no security risk.