Every captured commit receives deterministic security triage and a separate communication-quality score. Security candidates and broader second-pass signals receive full-patch Ollama analysis.
Message quality measures whether a commit identifies its scope, purpose, rationale, testing, and supporting references. It does not change the security-severity score.
This change fixes a wallet synchronization check in LND. Previously, the wallet only compared block heights to decide if it was fully caught up with the Bitcoin chain. During a chain reorganization (a temporary fork where one block is repl…
State synchronization check previously used height only, which is insufficient across reorgsFix adds block hash comparison to prevent false-positive sync statusCould cause LND to proceed while wallet state reflects an invalidated or not-yet-updated chain tip
This commit fixes a missing permission check on a new Lightning routing RPC called XFindBaseLocalChanAlias. Without the entry, any valid macaroon could call that RPC, bypassing the normal access-control list. The patch adds the required pe…
Missing macaroon authorization entry for an RPC endpointPotential privilege escalation: any valid macaroon could invoke an unprotected RPCRegression test added to enforce macPermissions coverage
This large LND patch changes when an ordinary invoice is considered 'paid'. Previously, releasing the preimage (the secret that lets the payer claim the funds) immediately marked the invoice as settled. Now the invoice enters a new interme…
New intermediate invoice/HTLC state prevents premature settlement reportingOn-chain HTLC outcomes persisted without opt-in to support restart recoveryForwarding package marker persisted before preimage release to avoid replay rejection on restart
This commit only adds documentation to the release notes. It describes a previously merged code change (PR 11555) about how LND handles invoice finality, but the commit itself contains no code, bug fixes, or behavior changes. There is noth…
This change fixes a bug in LND's invoice handling for multi-part payments (MPP and AMP). When a payment is split into several pieces (HTLCs), each piece is accepted individually. Previously, an old accepted piece could become too close to …
Fixes missing revalidation of accepted HTLC CLTV expiries at MPP/AMP set completionPrevents settlement of shards whose on-chain claim window has become unsafe while heldAdds new fail resolution ResultHtlcSetExpiryTooSoon and cancels the entire affected set
This commit changes how LND's wallet locks (leases) unspent coins through its RPC interface. It removes a recently added 'release after N confirmations' option and replaces it with an explicit 'no expiry' flag. Old clients that still send …
Breaking API change that reserves removed protobuf fields to prevent accidental reintroductionExplicit rejection of legacy `release_after_spend_confs` parameters from old clients instead of silent fallbackValidation prevents conflicting no-expiry + duration lease settings before wallet state is touched
This commit refactors how the Lightning Network Daemon (LND) stores and queries channel graph data so that the same channel or node can exist under both old (v1) and new (v2) gossip protocols without the database returning stale, missing, …
Cross-version data consistency: prevents a v2 channel shell from shadowing a usable v1 channel, which could affect routing decisions and RPC output.Cache consistency: ensures the in-memory pathfinding cache and the SQL-backed RPC reads agree on which channel version and policies are active.Bug fix: zombie edge info now carries the correct channel ID instead of 0, which could have caused incorrect channel identification during resurrection.
This is a large bug-fix patch for LND (a Bitcoin Lightning Network node) that tightens correctness rules across many subsystems. It prevents several ways a node could mis-handle channel data, accept bad network gossip, commit corrupted dat…
Database transaction commit now aborts on read errors (etcd) - prevents silent data corruption / inconsistent stateGossip zombie marking removed for invalid funding script - prevents denial-of-service / channel graph poisoningWire message length bounding added to watchtower protocol - prevents memory exhaustion / malformed message parsing
This commit changes how LND handles multi-part Lightning payments when one part fails after the preimage was already released. Previously, the invoice could be marked as fully paid even if one shard was later reclaimed by the payer on-chai…
Changes invoice settlement semantics for released-but-failed HTLCsAdds new persisted HTLC state `HtlcStateFailed`Prevents invoice from reaching `ContractSettled` when any released shard fails
This change tightens the rules for opening Lightning payment channels by refusing a setting called the CSV delay when it is set to zero. The CSV delay is the waiting period a user must endure before reclaiming their own funds from a channe…
Rejects a zero CSV delay that would eliminate the breach-remedy windowCentralizes the check in VerifyConstraints so all channel types and directions are coveredAdds explicit error type and unit test for the new constraint
This commit fixes two bugs in how Lightning Network channel data is saved to disk. First, it stops extra 'aux' signatures meant only for advanced taproot channels from being saved on ordinary channels, where they don't belong. Second, it p…
Persisted state could become unreadable due to writer/reader size mismatchAuxiliary signatures for taproot overlay channels were persisted on plain channel HTLCsFix adds explicit serialization bound to prevent unreadable channel records
This commit adds the first end-to-end BOLT 12 'Offers' flow to LND: a new dev-only RPC and CLI command to create offers, plus a dispatcher that listens for incoming onion-message invoice requests and replies with signed BOLT 12 invoices. I…
New network-facing dispatcher answers invoice requests from any peer; rate and concurrency limits are appliedBlinded-path PathID check prevents reply linking to self-created paths, but TODO notes the check should move once offers can have offer_pathsCreateOffer RPC is restricted to dev builds and requires offchain:write macaroon permission
This change fixes a bug in LND's invoice handling for AMP (Atomic Multi-Path) payments. Previously, if someone tried to pay a fresh shard for an AMP set that was already fully paid, the invoice updater could return an internal error that w…
Denial-of-service vector: an internal updater error could force-fail a shared channel link, disrupting unrelated sibling HTLCsAMP invoice state machine edge case: reusable invoice stays open for other sets but must reject new shards for already-settled setsClean failure path introduced: ResultInvoiceNotOpen instead of error-driven link failure
This is a large feature merge for LND that adds a new optional RPC subsystem called switchrpc. It lets an external program hand a pre-built onion packet to LND for direct dispatch over a Lightning channel, instead of LND doing its own path…
New optional RPC surface (switchrpc) that accepts externally crafted onion packets and directly dispatches HTLCsIdempotency/deduplication added via InitAttempt durable write-ahead log and ErrPaymentIDAlreadyExistsStartup orphan cleanup fails half-open or pre-commit attempts to avoid hangs
This commit fixes a bug in LND's transaction sweeping logic. Previously, if the Bitcoin backend rejected a sweep transaction for a temporary or unknown reason (for example, the mempool was full, a network error occurred, or the rejection r…
Funds-availability / liveness fix: temporary or unknown mempool rejections could leave sweep inputs unspent.Error-handling reclassification: previously fatal errors now retryable.Retry metadata preservation: next fee rate and fee cap kept across attempts.
This change is a hardening fix for LND's remote-signing feature. Previously, if a node was configured to act as an outbound remote signer but was compiled without the required 'signrpc' and 'walletrpc' sub-servers, it would silently fall b…
silent-degradation-to-no-op preventedconfiguration-misconfiguration now surfaces as fatal errorbuild-tag-dependency explicitly validated at runtime
This commit only fixes blank-line spacing in a single test file to satisfy lint checks. It adds one blank line after a function signature and removes one trailing blank line. There are no code behavior changes, no bug fixes, and no securit…
This change updates two GitHub Actions used in the project's automated lint workflow so they are locked to specific commit hashes instead of floating version tags. A floating tag could be silently repointed to a different, possibly malicio…
CI/CD supply-chain hardeningthird-party action pinning by commit hashprevention of tag-movement attacks
This commit fixes the GitHub Actions CI setup for running a custom code linter. It makes sure Docker can read and write build caches correctly and that the built linter image is available for later steps. There is no user-facing security f…
This patch fixes a database bug in the Lightning Network Daemon (LND) where very long lists of unsigned, acknowledged channel updates could be silently truncated when saved to disk. Because the storage format used a 16-bit counter, lists l…
Integer truncation / wrap-around in serialization format (uint16 count)Silent data loss on restart due to undersized length fieldDefensive deserialization with count-modulo validation
lntest: pin pre-v30 mempool policy defaults in itest bitcoind
Bitcoind v30 lowered the default minrelaytxfee and incrementalrelayfee from 1000 sat/kvB (1 sat/vB) to 100 sat/kvB. The itest suite was written against the old defaults and the lower values cascade into:
- integer sat/vByte assertions losing precision below 1 sat/vB, and - RBF bump thresholds that alter sweeper/bumpfee replacement timing.
Pin the old defaults in the itest bitcoind backend so the existing tests keep passing without per-test adaptation. Running against the new defaults is still worth doing, but that is a separate exercise that should not be bundled with the v30 version bump.
83/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Mentions testing or verification
Why it was queued
access control
AI analysis · Informational 14/100
This change only adjusts the settings used for internal testing of LND with a Bitcoin Core backend. It pins older Bitcoin Core fee defaults so that existing automated tests continue to produce the same results after Bitcoin Core v30 changed its defaults. It does not change production LND code, user-facing behavior, or network consensus rules, and it does not fix a security vulnerability.
Security candidatepeer: gate onion message ingress on having an open channelby Olaoluwa Osuntokun · c0827e8e · Apr 15, 2026 · 9 filesMessage 95 · StrongHigh 76Details
Commit message · Olaoluwa Osuntokun
peer: gate onion message ingress on having an open channel
Onion message forwarding is an unpaid side channel. Without any peer qualification the byte-bucket limiters added in the previous commits are our only defense against a Sybil attacker: an attacker that can cheaply spin up N identities and burn a full per-peer byte budget on each one saturates the global bucket and converts the aggregate cap into a service-denial primitive against legitimate channel peers. This was raised on PR review — the per-peer cap is good, but the global cap on its own is a Sybil multiplier if peer identity is free. The proper fix is to make new identities cost real capital, which is what requiring a funded channel does.
This commit adds a channel-presence gate as the first check in allowOnionMessage, ahead of both the per-peer and the global rate limiters. Messages from peers that do not have at least one fully open channel with us are dropped with a new dropReasonNoChannel sentinel and never allocate any rate limiter state — the gate runs before either limiter is consulted, so no-channel peers cannot burn tokens on any bucket. Pending channels are deliberately excluded from the check: they are represented as nil values in the activeChannels map, are cheap to open and prone to getting stuck, and so do not provide the capital-cost guarantee the Sybil defense depends on. Existing Brontide cleanup paths (StopOnionActorIfExists, OnionPeerLimiter.Forget) already handle teardown on peer disconnect; nothing new is needed there because the gate keeps no-channel peers from ever allocating per-peer state in the first place.
For the hot path we cannot afford to iterate the activeChannels registry on every incoming onion message, so Brontide now carries a numActiveChans atomic.Int32 that shadows the count of non-pending entries in activeChannels. hasActiveChannels is a single atomic Load and is therefore O(1). The counter is maintained in lockstep with activeChannels at every mutation site: loadActiveChannels increments it as it populates the registry during Start(); addActiveChannel uses a new lnutils.SyncMap.Swap method (a thin typed wrapper around sync.Map.Swap) to atomically replace any prior entry so that both brand-new channels and pending-to-active promotions bump the counter by exactly one; WipeChannel and handleRemovePendingChannel both use LoadAndDelete so they can inspect the prior value and only decrement when the removed entry was non-nil. Under race, this keeps the counter and the map consistent even when RPC WipeChannel races with the channelManager goroutine.
The accompanying unit tests cover: the no-channel drop path at the allowOnionMessage level, asserting that neither the global stub counter nor the per-peer limiter's dropped counter move when the gate fires; the subsequent channel-gained path on the same peer, asserting the same message is accepted once hasChannel flips; and a focused Brontide-level test that walks the counter through initial emptiness, a pending-only state (counter must stay at zero), a pending-to-active promotion via direct Store + Add, the pending delete path through handleRemovePendingChannel (must not underflow), and the active delete path through LoadAndDelete + Add(-1) that WipeChannel uses internally. Running with -race confirms the Swap/LoadAndDelete patterns keep the counter and the map in sync under concurrent access.
95/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Explains rationale or failure mode✓ Mentions testing or verification
This change closes a denial-of-service weakness in LND's onion-message forwarding. Previously, an attacker could create unlimited free peer identities and burn through the global byte-budget reserved for onion messages, starving real peers. The patch now requires a peer to share at least one funded, fully open Lightning channel before any onion message is accepted, so each attacker identity must lock up real bitcoin. It also adds a fast O(1) atomic counter so this check does not slow down every incoming message.
The existing per-peer actor mailbox (capacity 50, RED from depth 40) only bounds in-flight queue depth. It does not cap throughput: a peer that drains its actor quickly can saturate our Sphinx unwrap CPU, replay-DB writes, and outbound forwarding bandwidth without ever tripping RED. At spec-max onion message sizes (~32 KiB per sphinx packet) a single well-behaved-draining peer is enough to push multiple Mbps of unpaid forwarded traffic through us, and aggregate fan-in from many peers multiplies that into tens of Mbps — an amount of bandwidth that is very much out of proportion for a side channel on a payment routing node.
This commit adds the building blocks for two token-bucket limiters that will be wired into the onion message ingress path in a follow-up commit: a process-wide global limiter and a per-peer registry. Both drop (rather than wait) on over-limit so that a hostile peer cannot grow our goroutine or memory footprint simply by sustaining above-threshold traffic. The per-peer registry keys buckets on the peer's compressed pubkey, creates them lazily, and retains them for the lifetime of the process so a peer cannot reset its burst by cycling the connection; cardinality is bounded by the live channel-peer count (the ingress call site gates on having a channel before allocating per-peer state), so no time-based GC is needed.
A minimal RateLimiter interface is introduced so that callers and tests can substitute noop or alternate implementations without reaching into x/time/rate directly, and a small countingLimiter wrapper keeps an atomic drop counter plus a one-shot first-drop flag for observability. A rate of zero (or a non-positive burst) yields a noop limiter, providing a clean "disabled" mode without branching at the call site.
On top of those, a single IngressLimiter interface composes the per-peer and global buckets behind one surface so that callers — notably the peer readHandler — only thread one object through Config and call one method per incoming onion message. Drop reasons are surfaced as sentinel errors (ErrPeerRateLimit, ErrGlobalRateLimit) wrapped in fn.Result[fn.Unit] so callers match on them with errors.Is rather than comparing free-form strings. The stock implementation encodes the load-bearing ordering — per-peer first, then global — inside AllowN so that a hostile peer whose own bucket is already empty cannot burn global tokens on every rejected attempt and starve legitimate peers.
Default constants targeting roughly ~5 Mbps worst-case ingress at spec-max message sizes are added alongside the existing mailbox defaults.
95/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Explains rationale or failure mode✓ Mentions testing or verification
Why it was queued
secure hardware boundary
AI analysis · Moderate 61/100
This commit adds new rate-limiting building blocks for LND's onion message handling. It does not yet wire them into live message processing, so by itself it cannot stop an attack. The code is clearly preparing to fix a denial-of-service risk: a single peer (or many peers together) could currently flood a routing node with large, unpaid onion messages and consume CPU, database writes, and outbound bandwidth. The new primitives cap per-peer and total incoming onion-message bytes using token buckets, and they drop excess traffic immediately rather than queuing it.
Security candidatelnwallet: emit actual MuSig2 partial sigs and nonces in test vectorsby Olaoluwa Osuntokun · fa97946f · Apr 13, 2026 · 1 fileMessage 88 · StrongInformational 18Details
Commit message · Olaoluwa Osuntokun
lnwallet: emit actual MuSig2 partial sigs and nonces in test vectors
In this commit, we fix the taproot test vector generator to capture and emit the real MuSig2 partial signatures and public nonces rather than the dummy `CommitSig` value which is zeroed out for taproot channels.
Previously, the generator was reading from `CommitSig.ToSignatureBytes()` which yielded a minimal DER encoding of `(0, 0)` (the 8-byte string `3006020100020100`). For taproot channels the actual signature lives in the `PartialSig` field of the `CommitSigs` struct, which carries both the 32-byte partial sig scalar and the 66-byte compressed public nonce needed by the verifier to reconstruct the combined signature.
We now unwrap the `PartialSig` from both the local and remote commitment signatures, extract the nonce and sig bytes, and include `local_nonce` and `remote_nonce` fields alongside `remote_partial_sig` in the emitted JSON. This gives other implementations (eclair, CLN, etc.) all the material they need to independently verify commitment transaction signatures using their own MuSig2 libraries.
88/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Mentions testing or verification✓ Names security-relevant behavior explicitly
Why it was queued
signing boundaryfuzzing or regression evidencesigning or wallet path
AI analysis · Informational 18/100
This commit fixes a test-data generator used by the LND Lightning node. Previously, the generator wrote a placeholder zero-value signature into its JSON test vectors for Taproot channels. Now it writes the real partial signature and public nonce values that other Lightning implementations need to independently check those test vectors. This is a test tooling fix, not a live security bug in production code.
multi: add custom nonce rand support to MuSig2 sessions
In this commit, we add the ability to inject a custom random source for generating JIT (Just-In-Time) signing nonces in MuSig2 sessions. By default, MuSig2 signing nonces are generated using crypto/rand, which makes signatures non-deterministic across runs. For test vector generation, we need fully reproducible signatures from a fixed seed.
A new `customNonceRand` field is threaded through `MusigSession`, `MusigSessionCfg`, `MusigPairSession`, and exposed via the `WithCustomSigningRand` channel option. When set, the custom reader is passed to `musig2.WithCustomRand()` during JIT nonce generation in `SignCommit`. All existing callers pass `fn.None[io.Reader]()` to preserve the current behavior of using the system CSPRNG.
88/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Mentions testing or verification✓ Names security-relevant behavior explicitly
Why it was queued
entropy or randomnesssigning boundaryfuzzing or regression evidencesigning or wallet path
AI analysis · Informational 19/100
This change adds a hidden switch that lets developers plug in a custom random source when creating MuSig2 signing nonces, mainly so tests can produce exactly the same signatures every time. In normal operation the switch is left empty, so the code still uses the operating system's cryptographic random generator. The patch itself is a test-infrastructure feature, not a fix for an active security bug, but any future misuse of the switch could weaken signature security.
lnwallet: add taproot channel test vector generator
In this commit, we add a test vector generator and verifier for taproot channel constructions. All vectors are derived deterministically from a single 32-byte seed using SHA256(seed || label) for key derivation, ensuring any implementation can reproduce them independently.
The generator covers two areas:
Script vectors decompose the full tapscript trees for every output type: funding (MuSig2 aggregated key), to_local (delay + revocation leaves), to_remote (1-block CSV leaf), anchors (OP_16 OP_CSV), offered/accepted HTLCs on both local and remote commits, and second-level HTLC transactions. Each entry captures the raw leaf scripts, leaf hashes, tapscript root, internal key, output key, and pkScript.
Transaction vectors produce full serialized commitment transactions and HTLC resolution transactions for three scenarios: a simple commitment with no HTLCs, a commitment with five untrimmed HTLCs, and the same HTLCs at a higher fee rate causing some to be trimmed.
To generate: go test -run TestTaprootVectors ./lnwallet/ -args -generate-taproot-vectors To verify: go test -run TestTaprootVectors ./lnwallet/
83/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Mentions testing or verification
Why it was queued
secret or key materialfuzzing or regression evidencesigning or wallet path
AI analysis · Informational 15/100
This commit only adds new test code and a JSON file of expected test outputs for Taproot Lightning channels. It does not change any production logic, network behavior, or wallet handling. There is no security issue in the commit itself.
lnwallet: add 3rd-party signature verification for taproot test vectors
In this commit, we add a `signature_verification` sub-test to the taproot test vector verifier that performs full script execution against both the commitment transaction and all HTLC resolution transactions.
This uses `txscript.NewEngine` to execute the taproot witness programs exactly as a Bitcoin node would, providing an independent check that all signatures in the test vectors are cryptographically valid. For the commitment transaction, we verify its witness against the funding output pkScript. For each HTLC resolution transaction, we verify its witness against the corresponding commitment output it spends.
This catches issues that the structural comparison tests (hex matching) cannot: for instance, a transaction can have the correct structure but carry an invalid signature if the sighash was computed over the wrong prevout or if the wrong key was used for signing. Running the full script engine also validates the control block, the tap leaf hash, and the overall taproot spend path.
88/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Mentions testing or verification✓ Names security-relevant behavior explicitly
Why it was queued
signing boundarydefensive validationfuzzing or regression evidencesigning or wallet path
AI analysis · Informational 12/100
This commit only adds a new test to the project's test suite. It does not change any production code, user-facing behavior, or network protocol. The new test cryptographically checks that example transactions in the project's test data carry valid Bitcoin signatures. It is a defensive quality improvement, not a fix for a known bug or vulnerability.
lnwallet: regenerate test vectors with BIP-340 HTLC signatures
Regenerate the test vector JSON with HTLC second-level transaction signatures that use BIP-340 standard nonce derivation (zero auxrand) instead of RFC6979. This makes the HTLC signatures reproducible across different Schnorr implementations. The commitment transaction MuSig2 signatures are unchanged.
83/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Mentions testing or verification
Why it was queued
signing boundaryfuzzing or regression evidencesigning or wallet path
AI analysis · Informational 15/100
This commit only updates test data in a single JSON file. It changes the example signatures used in automated tests so they are generated with a standard BIP-340 nonce method instead of an older RFC6979 method. No production wallet code, protocol logic, or user-facing behavior is changed. There is no security vulnerability here.
Security candidatelnwallet: add MuSig2 secret nonces and partial sig replay to test vectorsby Olaoluwa Osuntokun · 4c225ddf · Apr 13, 2026 · 1 fileMessage 88 · StrongInformational 12Details
Commit message · Olaoluwa Osuntokun
lnwallet: add MuSig2 secret nonces and partial sig replay to test vectors
In this commit, we extend the taproot test vector generator and verifier to include MuSig2 secret nonces and a full partial signature replay test.
For the generator, we now capture the correct nonces for each commitment transaction: local's verification nonce (from LocalSession) for local's own commitment, and remote's JIT signing nonce (from RemoteSession) for the same commitment. Previously, the local nonce was incorrectly captured from the RemoteSession, which corresponds to a different commitment transaction.
The new musig2_partial_sig_replay test sub-suite verifies three properties for each test case:
1. The remote partial sig can be independently reproduced from the secret nonce and private key using musig2.Sign().
2. The local partial sig can be independently produced and verified using the local secret nonce.
3. Both partial sigs combine (via the Session API) into the exact Schnorr signature present in the commitment transaction witness.
This enables interop implementations to validate their MuSig2 signing logic against the test vectors without needing to match nonce derivation algorithms across different secp256k1 libraries.
88/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Mentions testing or verification✓ Names security-relevant behavior explicitly
Why it was queued
secret or key materialsigning boundarydefensive validationfuzzing or regression evidencenonce handlingsigning or wallet path
AI analysis · Informational 12/100
This commit only changes test code. It improves the test-vector generator for taproot channels so it records the correct MuSig2 secret nonces, and adds a new test that replays the signing process to confirm the produced signatures match the ones stored in the test vectors. There is no change to production wallet or signing logic, so it does not introduce or fix a live security vulnerability.
Security candidatelnwallet: use BIP-340 nonce derivation for HTLC sigs in test vectorsby Olaoluwa Osuntokun · 63450b85 · Apr 13, 2026 · 1 fileMessage 88 · StrongInformational 19Details
Commit message · Olaoluwa Osuntokun
lnwallet: use BIP-340 nonce derivation for HTLC sigs in test vectors
btcd's schnorr.Sign defaults to RFC6979 nonce derivation, while libsecp256k1 (used by eclair, CLN, etc) uses BIP-340's standard nonce derivation with zero auxrand. Both are deterministic but produce different signatures for the same key and message, causing HTLC signature mismatches in interop test vectors.
This commit introduces a bip340Signer wrapper that overrides SignOutputRaw for taproot script path spends to use schnorr.CustomNonce([32]byte{}) — matching BIP-340 deterministic signing behavior. The wrapper is only used in the test vector generator; production signing paths are unchanged.
Note that MuSig2 commitment signatures were already using BIP-340 nonces internally (via the musig2.Sign path), so only the HTLC second-level transaction signatures were affected.
88/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Mentions testing or verification✓ Names security-relevant behavior explicitly
Why it was queued
signing boundaryfuzzing or regression evidencesigning or wallet path
AI analysis · Informational 19/100
This commit changes only a test file in LND. It makes the test-vector generator produce HTLC signatures using the same nonce math as other Lightning implementations (Eclair, Core Lightning), so cross-implementation test vectors match. Production signing code is not touched, so real user funds or network behavior are unaffected. There is no security vulnerability being fixed here; it is a test-infrastructure consistency change.
lnwallet: fix HTLC sig-to-transaction mapping in test vector generator
In this commit, we fix two interrelated bugs in the way HTLC signatures are associated with their corresponding second-level transactions in the taproot test vector generator.
The first issue was that HtlcSigs are sorted by BIP 69 output index (matching the commitment transaction's output ordering), but the old code was assigning signatures using the iteration order of incoming HTLCs followed by outgoing HTLCs. This meant timeout transaction signatures were getting paired with success transactions and vice versa whenever the output ordering didn't happen to match the incoming-first iteration order. This is the root cause of the invalid HTLC-timeout signatures that eclair reported when cross-validating.
We now collect all HTLC entries (both incoming and outgoing) into a single slice, sort them by their commitment output index, then zip them against the HtlcSigs array so each signature lines up with the correct second-level transaction.
The second issue was in the HTLC-success preimage extraction path. The old code read the witness script from index [4] (the control block) and used a hardcoded byte offset of 69 to locate the payment hash, then wrote the preimage into index [3] (overwriting the script). The correct taproot witness layout is [remoteSig, localSig, preimage, script, controlBlock], so the script lives at [3] and the preimage slot is [2]. We now use `txscript.ScriptTokenizer` to walk the script opcodes and find OP_HASH160 followed by the 20-byte push data, which is far more robust than relying on fragile byte offsets that break if the script template ever changes.
100/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Explains rationale or failure mode✓ Mentions testing or verification✓ Names security-relevant behavior explicitly
Why it was queued
signing boundaryfuzzing or regression evidencesigning or wallet path
AI analysis · Informational 24/100
This commit fixes bugs in a test-data generator used by LND, not in the live Lightning node software itself. The generator produces sample HTLC (multi-hop payment) resolution transactions and signatures that other implementations use to cross-check compatibility. The old code paired signatures with the wrong transactions when HTLC outputs were not ordered 'incoming first,' and it also read preimages from the wrong witness slot using a hardcoded byte offset. These bugs caused invalid test vectors, which another implementation (Eclair) noticed during cross-validation. The fix only changes test code, so it does not create or close a real attack path against running LND nodes.
Regenerate `test_vectors_taproot.json` to reflect the corrected test vector generator. Changes include actual 32-byte MuSig2 partial signatures (replacing the dummy 8-byte DER stubs), 66-byte public nonces for both local and remote parties, corrected HTLC sig-to- transaction mapping sorted by BIP 69 output index, proper HTLC-success witness layout with preimage in the correct witness slot, and the updated trimming test case which now trims 3 of the 5 test HTLCs below the 2500 sat dust limit (down from 5 HTLC outputs to 2).
78/100 · AdequateMessage clarity
✓ Descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Mentions testing or verification
Why it was queued
signing boundaryfuzzing or regression evidencesigning or wallet path
AI analysis · Informational 18/100
This commit only updates a single JSON file of test vectors for taproot Lightning channels. It replaces placeholder signature data with realistic values, fixes the order of test transactions, and adjusts a dust-limit test case. There is no change to production wallet or node code, so it does not directly affect live funds or network security. It is essentially a correction to the project's test fixtures.
lnwallet: regenerate taproot test vectors with secret nonces
Regenerate the test vectors JSON to include local_sec_nonce and remote_sec_nonce fields alongside the existing public nonces. The local nonce fields now correctly correspond to local's verification nonce for their own commitment transaction, matching the commitment tx stored in the test vector.
83/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Mentions testing or verification
Why it was queued
defensive validationfuzzing or regression evidencenonce handlingsigning or wallet path
AI analysis · Informational 12/100
This commit only updates test data in a JSON file used for automated tests of Lightning's new taproot channel features. It adds secret nonce values and corrects public nonce values so the test vectors match the expected commitment transactions. There is no change to production wallet or network code, so it does not introduce a security vulnerability or fix one in running software.
Security candidatelnwallet: add secret nonce stashing to MusigSession for test vectorsby Olaoluwa Osuntokun · 2148445c · Apr 13, 2026 · 1 fileMessage 83 · StrongInformational 18Details
Commit message · Olaoluwa Osuntokun
lnwallet: add secret nonce stashing to MusigSession for test vectors
In this commit, we add the ability for MusigSession to capture and expose the raw 97-byte MuSig2 secret nonce generated during JIT signing nonce creation. This is gated behind the customNonceRand option, so it only activates in test vector generation mode.
The stashed secret nonce is consumed on read (cleared after access) to prevent accidental nonce reuse. This enables interop test vectors to include the raw secret nonces, allowing other implementations to replay the MuSig2 signing process without needing to match the exact nonce derivation algorithm used by btcd's musig2 library.
83/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Mentions testing or verification
Why it was queued
signing boundaryfuzzing or regression evidencenonce handlingsigning or wallet path
AI analysis · Informational 18/100
This commit adds a test-only feature that lets LND temporarily save the secret random number (nonce) used in MuSig2 signing when running in a special test-vector generation mode. The saved value is automatically erased after one read to prevent accidental reuse. There is no indication this feature is active in normal production code, and the change is explicitly described as being for interoperability test vectors only.
input: add production taproot HTLC succeed input constructor
This commit adds MakeTaprootHtlcSucceedInputFinal, a new input constructor specifically for creating HTLC success inputs that use production taproot witness types. This function parallels the existing MakeTaprootHtlcSucceedInput but creates inputs with the TaprootHtlcAcceptedRemoteSuccessFinal witness type instead of the staging variant.
The new constructor follows the same pattern and signature as its staging counterpart, ensuring consistency in the input creation API. This allows contract resolvers to create the appropriate input type based on whether they are handling a staging or production taproot channel, ensuring that the correct witness generation logic is applied during transaction creation.
This addition provides the necessary infrastructure for production taproot channels to properly construct inputs for sweeping HTLC outputs on remote commitment transactions with the optimized script structure.
78/100 · AdequateMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Names security-relevant behavior explicitly
Why it was queued
signing boundary
AI analysis · Informational 17/100
This commit adds a new helper function in LND for creating a specific kind of Bitcoin transaction input used when claiming a Lightning HTLC (a payment locked by a hash/time condition) on a production taproot channel. It mirrors an existing staging-channel helper but uses the final/production witness type. There is no direct evidence in the commit of a security vulnerability; it appears to be infrastructure for an upcoming or recently enabled feature.
actor: add CompleteWith and AwaitFuture generic package-level helpers
In this commit, we add two package-level generic helpers to the actor module as part of the broader chan error -> Future[error] migration in the discovery package.
CompleteWith[T](p Promise[T], val T) is a one-liner convenience wrapper over p.Complete(fn.Ok(val)). It lets callers complete a promise with a plain value without constructing an fn.Result inline, which cuts noise at every completion site.
AwaitFuture[T](ctx, f Future[T]) (T, error) provides the symmetric receive side: it blocks until the future resolves or the context is cancelled and returns the value and any context error unpacked from the fn.Result, matching the (val, err) convention callers expect.
Both functions are deliberately thin (no policy, no timeout, no new state) so they compose freely with higher-level helpers built on top, e.g. discovery.AwaitGossipResult.
go.mod is updated to pin the actor module via a local replace directive so the rest of the lnd module picks up these additions without waiting for a tagged release.
73/100 · AdequateMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context
Why it was queued
access control
AI analysis · Informational 15/100
This commit adds two small helper functions to an internal actor package and updates the Go module file to use the local copy of that package. There is no security-relevant change; it is purely a code cleanup and convenience addition for future development work.
Security candidategraph/db: add gossip version parameter to FilterKnownChanIDsby Elle Mouton · 12f8e509 · Apr 9, 2026 · 5 filesMessage 78 · AdequateLow 27Details
Commit message · Elle Mouton
graph/db: add gossip version parameter to FilterKnownChanIDs
Add an explicit lnwire.GossipVersion parameter to FilterKnownChanIDs on the Store interface, SQLStore, KVStore, and ChannelGraph. Since FilterKnownChanIDs is always called from a version-scoped ChanSeries context, a single version parameter is cleaner than per-item version reads. A convenience wrapper on VersionedGraph preserves the existing ChanSeries call-site signature by threading c.v automatically.
78/100 · AdequateMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Names security-relevant behavior explicitly
Why it was queued
signing boundary
AI analysis · Low 27/100
This commit refactors how a Lightning Network routing database method, FilterKnownChanIDs, receives the gossip protocol version. Previously the version was read from each individual channel record; now it is passed explicitly from the version-scoped wrapper. The change also adds a sanity check that zombie channels returned by the database match the expected gossip version, and updates tests to cover both v1 and v2 gossip. It is a defensive correctness improvement rather than a clear-cut fix for an active vulnerability.
Security candidateci: use GITHUB_TOKEN instead of PAT for PR severity workflowby ziggie · 77c566f2 · Apr 8, 2026 · 1 fileMessage 97 · StrongLow 32Details
Commit message · ziggie
ci: use GITHUB_TOKEN instead of PAT for PR severity workflow
The PR severity classifier only needs to run `gh pr view`, `gh pr edit` (labels), and `gh pr comment`. All three operations are fully covered by the built-in GITHUB_TOKEN given the existing permissions block:
The workflow uses `pull_request_target`, which runs in the base repo context, so GITHUB_TOKEN has write access even for fork PRs.
Inspection of the claude-code-action@v1 source confirmed that the only internal call that would require `contents: write` is branch deletion, which is never exercised here because Claude's tools are locked down to `gh pr view/edit/comment` via --allowedTools.
This removes the dependency on the PR_SEVERITY_BOT_TOKEN PAT secret.
97/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Uses a recognizable type or scope✓ Provides detailed explanatory context✓ Explains rationale or failure mode
Why it was queued
credential or privilege statedocumentation-only discount
AI analysis · Low 32/100
This commit changes a GitHub Actions workflow so it uses the automatically provided GITHUB_TOKEN instead of a long-lived personal access token (PAT) named PR_SEVERITY_BOT_TOKEN. The workflow labels and comments on pull requests. The change reduces the risk that a leaked or overly powerful PAT could be misused, and it is a security-hardening improvement rather than a fix for an active vulnerability.
graph/db: convert TestLightningNodeSigVerification to versioned test
Rename to testLightningNodeSigVerification and add it to the versionedTests table so it runs against both v1 and v2. The signing step is version-specific (ECDSA for v1, Schnorr for v2) while the verification path is shared.
83/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Mentions testing or verification
Why it was queued
signing boundarydefensive validation
AI analysis · Informational 15/100
This commit only changes a test file. It renames an existing test and makes it run against two versions of the software's gossip protocol, adding Schnorr signature coverage for the newer version. There is no change to production code, so it does not introduce or fix a security vulnerability in the running software.
lnwire: validate MuSig2 nonces in LocalNoncesData decode
Validate each nonce in decodeLocalNoncesData with ValidateMusig2Nonce to reject malformed entries.
65/100 · AdequateMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides an explanatory body
Why it was queued
defensive validationnonce handling
AI analysis · Moderate 59/100
This change adds a safety check when LND reads stored MuSig2 cryptographic nonces from disk or network data. Previously, a malformed or all-zero nonce could be loaded silently; now the decoder rejects it. MuSig2 nonces are used in multi-signature Bitcoin transactions for the Lightning Network, so bad nonces could in theory lead to failed channel operations or, in worst-case cryptographic scenarios, weaken security guarantees.
Security candidategraph/db: add v2 block-height path for NodeUpdatesInHorizonby Elle Mouton · c14a79c0 · Mar 31, 2026 · 5 filesMessage 78 · AdequateInformational 15Details
Commit message · Elle Mouton
graph/db: add v2 block-height path for NodeUpdatesInHorizon
Add GetNodesByBlockHeightRange SQL query and wire it into SQLStore.nodeUpdatesInHorizonV2. This mirrors the existing v1 time-based query but filters on (version, block_height) instead of last_update, using the same [start, end) exclusive-end semantics and (block_height, pub_key) compound cursor pagination.
The public-node filter for v2 checks for channels with a non-empty channel announcement signature (c.signature), matching the v2 protocol's public channel indicator.
78/100 · AdequateMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Names security-relevant behavior explicitly
Why it was queued
signing boundary
AI analysis · Informational 15/100
This commit adds a new database query path for a planned v2 gossip protocol feature in LND. It is purely functional code that lets the node list other nodes by block-height range, similar to an existing time-based query. There is no indication this fixes a security bug or introduces a vulnerability; it appears to be a normal feature implementation.
Security candidateonionmessage: use BackpressureMailbox for onion peer actorsby Gijs van Dam · e87f4bfb · Mar 28, 2026 · 3 filesMessage 78 · AdequateLow 40Details
Commit message · Gijs van Dam
onionmessage: use BackpressureMailbox for onion peer actors
This commit adds per-peer backpressure control to the onion message actor system by introducing a BackpressureMailbox that uses Random Early Detection (RED) to probabilistically drop messages when the per-peer queue depth exceeds a configurable threshold.
The OnionActorFactory type now accepts variadic ActorOptions, allowing the spawn call site (brontide) to provide per-peer mailbox configuration. A DefaultOnionActorOpts helper provides the standard RED thresholds so callers don't need to wire up the BackpressureMailbox manually.
Key changes: - OnionActorFactory signature extended with ...ActorOption[*Request, *Response] so backpressure policy is no longer baked into the factory. - NewOnionActorFactory drops its shouldDrop parameter; it forwards opts through to serviceKey.Spawn. - DefaultOnionActorOpts(shouldDrop) returns the default backpressure options (BackpressureMailbox + DefaultOnionMailboxSize). - peer.Config gains OnionActorOpts callback for per-peer customization. - server.go creates default opts once and returns them for every peer.
78/100 · AdequateMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Names security-relevant behavior explicitly
Why it was queued
signing boundary
AI analysis · Low 40/100
This commit adds a safety valve to how LND handles 'onion messages'—a type of private Lightning Network message. Before this change, a flood of onion messages from a peer could fill up an internal queue and stall the connection handler. Now, when a per-peer queue gets too full, messages are probabilistically dropped using a technique called Random Early Detection (RED), and the handler uses a timeout so it cannot block forever. The change is defensive hardening rather than a fix for a known active attack.
lnwallet/chancloser: address lint and PR review feedback
Fix all lint issues across the taproot RBF coop close changes:
- Fix line length violations (ll) by wrapping long lines and adding nolint:ll where wrapping would hurt readability. - Fix nlreturn: add blank lines before return statements. - Fix misspell: correct "siganture" typos. - Fix forcetypeassert: add checked type assertions. - Fix nonamedreturns: remove named returns from function signatures. - Fix usetesting: replace context.Background() with t.Context(). - Fix unused: remove unused remoteSchnorrSig variable. - Fix whitespace: add newlines after multi-line func signatures. - Fix gocritic appendAssign warning. - Fix gci: correct import ordering.
Also address PR review comments from @erickcestari:
- Remove nonce cache in ClosingNonce() to prevent future footguns. - Rename extractSigAndNonce to extractSigAndNonceFromClosingSig. - Rename extractSigAndNonceFromComplete to extractSigAndNonceFromClosingComplete with channel type validation. - Replace env.RemoteMusigSession \!= nil with env.IsTaproot(). - Swap manual mocks to mock.Mock in musig_nonce_order_test.go.
85/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Explains rationale or failure mode
Why it was queued
signing boundarysigning or wallet path
AI analysis · Informational 17/100
This commit is a follow-up cleanup patch for a larger feature adding RBF (Replace-By-Fee) cooperative channel closes for Taproot channels in LND. It contains no direct security fixes. The changes are almost entirely code-style fixes (line length, blank lines, spelling, import ordering), test-only refactors, and minor defensive tweaks such as adding checked type assertions and removing a nonce cache that could be a 'footgun' in the future. The one substantive behavior change—removing the nonce cache—is described by the author as preventing future mistakes rather than fixing an active vulnerability.
Security candidatemulti: wire taproot RBF support throughout the stackby Olaoluwa Osuntokun · 85adad75 · Mar 27, 2026 · 2 filesMessage 73 · AdequateLow 34Details
Commit message · Olaoluwa Osuntokun
multi: wire taproot RBF support throughout the stack
In this commit we, integrate the taproot RBF cooperative close functionality throughout the LND stack. This includes updating protocol configuration and peer connection handling to support the new taproot closing flow.
The changes wire through the taproot channel detection, nonce exchange during shutdown, and proper handling of the enhanced wire protocol messages in the peer layer. This completes the integration of taproot RBF cooperative close functionality, providing a complete alternate closing path for taproot channels that leverages MuSig2 signatures and implements proper nonce rotation for secure RBF scenarios.
73/100 · AdequateMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context
Why it was queued
signing boundaryparser or protocol path
AI analysis · Low 34/100
This commit enables a new, more flexible way for taproot Lightning channels to close cooperatively. Previously, taproot channels had to fall back to an older close path even when the new RBF-based cooperative close feature was enabled. The change removes that restriction and adds the necessary nonce-exchange logic so taproot channels can use the modern close flow. It is a feature-completion patch rather than a clear-cut security fix, but because it touches cryptographic state setup for channel closing, it could affect safety if the new path has latent bugs.
Security candidatechancloser: update RBF close documentation for taproot supportby Olaoluwa Osuntokun · 57def3bc · Mar 27, 2026 · 1 fileMessage 78 · AdequateInformational 15Details
Commit message · Olaoluwa Osuntokun
chancloser: update RBF close documentation for taproot support
In this commit we, update the RBF cooperative close documentation to comprehensively cover the taproot channel closing flow. The documentation now explains the JIT nonce pattern, asymmetric signature roles, and the complete nonce exchange protocol for taproot channels.
Key additions include detailed explanations of how nonces flow through the RBF process, the distinction between closer and closee roles, and the specific wire message extensions for PartialSigWithNonce and NextCloseeNonce fields. The documentation also covers validation requirements and implementation notes specific to taproot channels.
This documentation provides a complete reference for understanding and implementing the enhanced taproot RBF cooperative close protocol.
78/100 · AdequateMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Names security-relevant behavior explicitly
Why it was queued
signing boundarysigning or wallet pathdocumentation-only discount
AI analysis · Informational 15/100
This commit only adds documentation to a markdown file describing how taproot channel cooperative closes work in LND. It changes no source code, no configuration, and no executable behavior. There is no security issue in the commit itself.