LDK
← All projectsLightning Dev Kit

rust-lightning

Composable Rust libraries for building Lightning wallets, nodes, and services.

BitcoinCryptographic librariesLightning NetworkNormal
Repository coverage

1924 commits in the local evidence base

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.

300security candidates261second-pass queue1606AI analyses
175commits · 30 days
261commits · 60 days
636commits · 180 days
1314commits · 365 days
Backfill bands
Aug 5 → Feb 6819 seen18 candidatesComplete
Feb 6 → Jun 6468 seen16 candidatesComplete
Jun 6 → Jul 6128 seen8 candidatesComplete
Jul 6 → Aug 561 seen3 candidatesComplete
Commit communication

Does the history explain itself?

Message quality measures whether a commit identifies its scope, purpose, rationale, testing, and supporting references. It does not change the security-severity score.

71/100 average clarity
704Strong · 80–100
856Adequate · 60–79
302Thin · 40–59
62Opaque · 0–39
3security candidates with opaque commit messaging
Read the scoring rubric →
Developer activity

Who is changing the project?

Public Git author strings; identities are not independently verified.

DeveloperCommitsCandidatesAnalyzedHigh riskMessage avg.
Matt Corallo58679418876
Elias Rohrer15415153667
auto-pr-bot571823287
Jeffrey Czyz19645182169
Wilmer Paulino15945155169
Valentine Wallace15715145169
Leo Nash11613116162
Vincenzo Palazzo11311183
Joost Jager16324162069
elnosh401434059
shaavan22622069
wpaulino2059082
Analysis record

Published AI watches

Last scanned 2 minutes ago

Informational 15 AI analysisMessage 81 · Strong
LDK Lightning Dev Kitrust-lightning BitcoinCryptographic librariesLightning Network

Correct FeeEstimator docs on the 253 sat/kW lower bound

This is a documentation-only edit. It corrects a misleading comment in the code that wrongly claimed all fee estimates returned to LDK are forced to be at least 253 satoshis per 1000 weight units. The new comment clarifies that this minimu…

ea2051feby auto-pr-bot+9−31 file
No security note in commit
Moderate 54 AI analysisMessage 81 · Strong
LDK Lightning Dev Kitrust-lightning BitcoinCryptographic librariesLightning Network

Merge PR 'Track splice confirmation while awaiting tx_signatures' (#5570)

This change fixes a bug in Lightning Dev Kit's splicing logic. During a splice, one side can broadcast the new funding transaction as soon as it has the other side's signatures. Previously, if that transaction confirmed on-chain before the…

State-machine inconsistency in channel funding lifecycleMissing chain-source watch for in-flight splice funding transactionPotential failure to send splice_locked after splice confirms during signature exchange
ca778e61by Matt Corallo+245−32 files
No security note in commit
Moderate 63 AI analysisMessage 81 · Strong
LDK Lightning Dev Kitrust-lightning BitcoinCryptographic librariesLightning Network

Merge PR 'Account for current HTLC fees in dust exposure' (#5690)

This change fixes how Lightning nodes calculate the financial risk from tiny ('dust') HTLCs when the current on-chain fee rate is higher than the node's own local fee estimate. Previously, the code only considered a buffered fee rate when …

Incorrect fee exposure accounting for dust HTLCsPotential to accept HTLCs whose commitment/HTLC-success fees exceed their value under current feerateEconomic griefing / forced-channel-closure cost manipulation
cc798f60by Matt Corallo+108−382 files
No security note in commit
Informational 15 AI analysisMessage 91 · Strong
LDK Lightning Dev Kitrust-lightning BitcoinCryptographic librariesLightning Network

Merge PR 'Replace cloned array literal with slice::from_ref in reload test' (#5689)

This is a one-line code cleanup in a test file. It replaces a cloned array literal with a slice reference to silence a Rust compiler lint. There is no change to production code, no security fix, and no functional behavior change.

03ca832fby Matt Corallo+1−11 file
No security note in commit
Informational 15 AI analysisMessage 91 · Strong
LDK Lightning Dev Kitrust-lightning BitcoinCryptographic librariesLightning Network

Replace cloned array literal with slice::from_ref in reload test

This is a one-line change in a test file to satisfy a Rust linter warning. It replaces a needless clone of a funding transaction with a reference-based slice construction. There is no functional change, no user-facing behavior change, and …

93e0129cby auto-pr-bot+1−11 file
No security note in commit
Informational 12 AI analysisMessage 91 · Strong
LDK Lightning Dev Kitrust-lightning BitcoinCryptographic librariesLightning Network

Merge PR 'Fix CI: rebuild test coin-selection impl and rework reused-ID balance test' (#5684)

This commit is a test-only fix for a broken continuous integration (CI) build. It updates a test mock to match a new function signature and rewrites an existing test to use three nodes instead of two so the test scenario remains valid unde…

17bac68aby Matt Corallo+26−202 files
No security note in commit
Moderate 68 AI analysisMessage 81 · Strong
LDK Lightning Dev Kitrust-lightning BitcoinCryptographic librariesLightning Network

Merge PR 'Guard pending closing signatures before channel_ready' (#5681)

This change fixes a Lightning channel bug where a malicious peer could renegotiate the closing transaction fee while the local node was still waiting for its own signer to produce the final signature. If allowed, the local node might combi…

State-machine guard expansion to prevent fee renegotiation while a closing signature is pendingRisk of combining mismatched signatures across different closing feesRegression test demonstrates malicious peer renegotiation attempt and expected warning rejection
a01273a2by Matt Corallo+169−21 file
No security note in commit
Low 48 AI analysisMessage 81 · Strong
LDK Lightning Dev Kitrust-lightning BitcoinCryptographic librariesLightning Network

Merge PR 'Release wallet UTXOs when FundingBuilder rejects a coin selection' (#5634)

This change fixes a wallet bug in rust-lightning where a UTXO could be selected for a Lightning funding transaction, then rejected because its previous transaction was too large to fit in a Lightning peer message. Previously, that rejectio…

API change to CoinSelectionSource::select_confirmed_utxos adding max_input_prevtx_serialized_lenWalletSync filters UTXOs by prevtx serialized length before selectionFundingBuilder enforces Lightning tx_add_input message-size limit at selection time
56054190by Matt Corallo+148−155 files
No security note in commit
Low 48 AI analysisMessage 81 · Strong
LDK Lightning Dev Kitrust-lightning BitcoinCryptographic librariesLightning Network

Refuse to pay BOLT 12 invoices with records above experimental range

This commit hardens LDK's BOLT 12 payment logic so it refuses to pay invoices containing very large unknown record types (4 billion and up). These records are legal under the Lightning spec, but LDK doesn't understand them, so the change t…

Defensive refusal to pay invoices with unknown high-numbered TLV recordsReuses existing UnknownRequiredFeatures failure path instead of adding a new oneAdds explicit checks before payment state insertion and route construction
2970372fby auto-pr-bot+106−177 files
No security note in commit
Moderate 64 AI analysisMessage 81 · Strong
LDK Lightning Dev Kitrust-lightning BitcoinCryptographic librariesLightning Network

Read invoice TLV records above the experimental range

This commit fixes a backward-compatibility bug in LDK's BOLT 12 invoice parser. A previous change had capped the range of 'experimental' TLV record types at 4 billion, but the Lightning spec imposes no upper bound. As a result, invoices cr…

Backward-compatibility regression in deserialization of persisted channel monitorsDenial-of-service via unreadable monitor blocking all channel monitoringSpec compliance fix: TLV record types have no upper bound
9e28db58by auto-pr-bot+133−84 files
No security note in commit
High 74 AI analysisMessage 81 · Strong
LDK Lightning Dev Kitrust-lightning BitcoinCryptographic librariesLightning Network

Merge PR 'Refuse to sign messages that collide with gossip serializations' (#5677)

This change fixes a security issue where a signed text message could be crafted so that its prefixed form looks exactly like a Lightning 'node_announcement' gossip message. Because both use the same double-SHA256 hash and the same signing …

Signature replay / message confusion between signed messages and gossip announcementsForged `node_announcement` signatures via chosen-prefix message constructionNew validation rejects prefixed messages that deserialize as `UnsignedNodeAnnouncement`
ec40e097by Matt Corallo+74−148 files
Vendor flagged security relevance
Low 37 AI analysisMessage 81 · Strong
LDK Lightning Dev Kitrust-lightning BitcoinCryptographic librariesLightning Network

Merge PR 'Retry a single HTLC before abandoning an unfundable batch' (#5406)

This change fixes a corner case in how the Lightning node tries to claim multiple pending HTLCs (small Bitcoin payments locked in a channel) when the wallet cannot fund a single large batch transaction. Previously, if the multi-HTLC batch …

Funds-recovery robustness improvement: prevents premature abandonment of a single unbatched HTLCChange in error-handling arithmetic from checked_sub/saturating_sub with max(1)New unit tests covering both failed and successful singleton HTLC funding paths
643e8684by wpaulino+119−21 file
No security note in commit
Moderate 54 AI analysisMessage 81 · Strong
LDK Lightning Dev Kitrust-lightning BitcoinCryptographic librariesLightning Network

Merge PR 'Refuse to persist fresh monitors that alias archived monitors' (#5645)

This change prevents a Lightning node from accidentally overwriting an archived copy of a channel's security monitor with a brand-new one that happens to use the same identifier. In the old code, if a new channel reused the same identifier…

Data-loss prevention: stops archived ChannelMonitor from being overwritten by a later channel with the same keySafety guard added to both sync and async persistence pathsPersistence refusal surfaces as InProgress/UnrecoverableError rather than silent overwrite
3c606c11by Matt Corallo+298−332 files
No security note in commit
Moderate 52 AI analysisMessage 86 · Strong
LDK Lightning Dev Kitrust-lightning BitcoinCryptographic librariesLightning Network

Merge PR 'Handle fee multiplication overflow when merging MPP paths' (#5288)

This change fixes a place in the Lightning payment routing code where adding up fees could overflow the maximum number a computer can store in a 64-bit integer. Previously, the code assumed this could never happen and would crash (panic) i…

Integer overflow in fee computationPreviously unreachable!() panic path reachableMPP path merge could trigger overflow
25f8a740by Matt Corallo+42−171 file
No security note in commit
Low 43 AI analysisMessage 81 · Strong
LDK Lightning Dev Kitrust-lightning BitcoinCryptographic librariesLightning Network

Merge PR 'Resume channels stuck awaiting a completed monitor persistence on reload' (#5610)

This commit fixes a bug where a Lightning node could get stuck after restarting. If the node crashed or restarted while it was still saving the initial channel monitor to disk, and that save later finished in another process, the restarted…

Fixes a state-machine stall on node reload that could leave channels non-functionalRemoves an overstrict assertion that would panic on a legitimate post-reload stateAdds explicit detection of monitor persistence completed in a prior process
11815ed1by Matt Corallo+334−74 files
No security note in commit
Informational 15 AI analysisMessage 81 · Strong
LDK Lightning Dev Kitrust-lightning BitcoinCryptographic librariesLightning Network

Merge PR 'Correct KeysManager docs on spliced channels' remote_key derivation' (#5609)

This change only updates documentation and code comments in the Lightning Dev Kit library. It clarifies that a particular key-derivation setting is fixed when a channel is first opened and is not changed by splicing. No code behavior was a…

83a4d243by Matt Corallo+17−91 file
No security note in commit
Informational 15 AI analysisMessage 81 · Strong
LDK Lightning Dev Kitrust-lightning BitcoinCryptographic librariesLightning Network

Merge PR 'Fix DelayedPaymentKey/HtlcKey from_basepoint docs and document justice tx witness script' (#5596)

This commit only changes documentation comments in two source files. It corrects the wording of how certain public keys are derived in the Lightning protocol and adds details about which witness script a signer must use when creating justi…

Documentation-only changeClarifies key derivation semantics for Lightning commitment transactionsClarifies justice transaction witness script requirements for signers
2f832195by Matt Corallo+44−62 files
No security note in commit
Informational 19 AI analysisMessage 81 · Strong
LDK Lightning Dev Kitrust-lightning BitcoinCryptographic librariesLightning Network

Merge PR 'Document that TokioSpawner requires all of LDK in a tokio context' (#5621)

This change only adds documentation comments to a Rust struct. It does not modify any executable code, so it cannot by itself introduce or fix a security vulnerability. The new text warns developers that using TokioSpawner incorrectly can …

Documentation-only changeNo code logic modifiedNo unsafe blocks added
6e555fa2by Matt Corallo+11−01 file
No security note in commit
High 70 AI analysisMessage 91 · Strong
LDK Lightning Dev Kitrust-lightning BitcoinCryptographic librariesLightning Network

Merge PR 'Make custom signers verify holder commitment sigs synchronously' (#5616)

This commit hardens how Lightning Dev Kit handles custom signing modules. Previously, LDK relied on each custom signer to check that the other party's signatures on a holder commitment transaction were valid. The change adds a ready-made v…

New synchronous signature-verification helper for holder commitment transactionsTrait documentation now mandates verification before Ok(()) because LDK acts immediatelyInMemorySigner now validates that holder funding key belongs to signer before signature checks
0e3b6d33by Matt Corallo+324−954 files
Vendor flagged security relevance
Moderate 64 AI analysisMessage 81 · Strong
LDK Lightning Dev Kitrust-lightning BitcoinCryptographic librariesLightning Network

Merge PR 'Refuse channel_ready while the initial funding_signed is pending' (#5612)

This update fixes a corner case in the Lightning Dev Kit where a node could get confused if it received a 'channel_ready' message while still waiting for its own signer to produce the first commitment signature. The patch makes the node re…

State-machine confusion between funding_signed and channel_ready in async signer flowPremature channel_ready could advance counterparty_next_commitment_point before initial commitment is signedPatch closes channel rather than allowing inconsistent commitment state
d68d2235by Matt Corallo+101−12 files
No security note in commit
Repository ledger

Explore captured commits

Expand any commit for its author, full message, clarity score, changed files, triage signals, analysis, and source link.

Security candidateoffers: rename matches_invoice_signing_pubkey to key_can_sign_invoiceby Vincenzo Palazzo · 388187ca · Aug 31, 2026 · 3 filesMessage 73 · AdequateInformational 15Details
Commit message · Vincenzo Palazzo

offers: rename matches_invoice_signing_pubkey to key_can_sign_invoice

Follow-up to #4884 addressing Matt's naming nit.

Co-authored-by: Cursor <cursoragent@cursor.com>

73/100 · AdequateMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides an explanatory body✓ Links an issue, advisory, or supporting reference
Why it was queued
signing boundarysigning or wallet path
AI analysis · Informational 15/100

This commit is a simple rename of a function and its documentation from matches_invoice_signing_pubkey to key_can_sign_invoice. No logic, behavior, or security properties changed. It is a follow-up code-review naming cleanup.

AI review queuedMerge PR 'offers: add Offer::permits_invoice_signed_by' (#4884)by Matt Corallo · 016af8f9 · Aug 31, 2026 · 5 filesMessage 81 · StrongInformational 18Details
Commit message · Matt Corallo

Merge PR 'offers: add Offer::permits_invoice_signed_by' (#4884)

from lightning-payer-proof-offer-api into main

Reviewed-on: https://git.rust-bitcoin.org/lightningdevkit/rust-lightning/pulls/4884
Reviewed-by: Matt Corallo <matt@noreply.git.rust-bitcoin.org>

81/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Links an issue, advisory, or supporting reference
Why it was queued
signing or wallet pathmerge-commit duplicate discountsecond-pass: security-sensitive path
AI analysis · Informational 18/100

This commit adds a new public helper method, Offer::matches_invoice_signed_by (later renamed matches_invoice_signing_pubkey), that lets callers check whether an invoice signing key belongs to the recipient named by a BOLT 12 offer. It also refactors an existing internal validation function to reuse the same logic. There is no direct bug fix or security patch in the diff; it is an API addition with tests and a changelog entry.

AI review queuedSupport retired TLV fields in object-constructing macrosby Jeffrey Czyz · 6d7c2bda · Aug 26, 2026 · 2 filesMessage 85 · StrongLow 29Details
Commit message · Jeffrey Czyz

Support retired TLV fields in object-constructing macros

The retired field type was initially limited to manual
`write_tlv_fields!`/`read_tlv_fields!`-style implementations because the
macros which construct the deserialized object (`impl_ser_tlv_based!`,
the enum macros, and `impl_writeable_msg!`) emit a struct literal or
match pattern naming every field, and a retired field has no backing
struct field to name.

Extend the `lightning-macros` filters that already drop `legacy` fields
from those positions to also drop `retired` fields, and route
`impl_writeable_msg!`'s constructed literal through the same filter,
which it previously bypassed. This lets any TLV field list mark a
retired type number rather than falling back to a manual implementation
just to reserve one.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

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
second-pass: broader security terminology
AI analysis · Low 29/100

This commit is a feature enhancement for LDK's internal serialization macros. It allows developers to mark old protocol fields as 'retired' (reserved but no longer used) in more places, so those type numbers cannot be accidentally reused. The change itself is not a security bug fix; it is infrastructure that makes it easier to safely reserve obsolete TLV type numbers. There is no direct exploit here, but it helps prevent future protocol-versioning mistakes.

Security candidateReplace splice failure wire tests with a 0.2 downgrade testby auto-pr-bot · 80f2b44f · Aug 26, 2026 · 3 filesMessage 91 · StrongInformational 17Details
Commit message · auto-pr-bot

Replace splice failure wire tests with a 0.2 downgrade test

@matt said:

> Feel free to squash.

@jkczyz said:

> Squashed

@matt asked:

> This is at least straightforward now. There's a lot of tests checking
> low-level serialization which I don't really buy as a way to test the
> 0.2 deserialization logic - if we want to test the 0.2 deserialization
> logic we need to actually use the 0.2 deserialization logic, not a copy
> of it using 0.3 types. Gonna go ahead and land this since the code is
> right and we need to get it over the line, but @auto-pr-bot can you
> replace the tests in events/mod.rs with tests in `lightning-tests` that
> use the 0.2 code to check the events? There's already some tests that do
> this in the PR so check that you're not duplicating coverage first.

@matt asked on the diff:

> I don't see the point of any of these tests. They feel like tests for
> tests sake rather than actually testing something meaningful.
> @auto-pr-bot

@matt asked on the diff:

> Same here. If we want to test upgrade/downgrade semantics the correct
> way is a `lightning-tests` multi-version test, not a test that checks
> the "wire" encoding of an `Event`.
>
> @auto-pr-bot

@matt asked on the diff:

> Yes, this is implied by the lack of implementation lol there's no need
> to document this @auto-pr-bot.

The `events` tests removed here built an `Event` by hand, wrote it, and
asserted on the bytes, or read bytes assembled to look like something
0.2 would have written. Either way they only ever exercised current
code's reader and writer, so they could not have caught a mismatch with
what 0.2 actually does -- the thing the encoding changes were about.
Checking that requires running 0.2's serialization, which is what
`lightning-tests` is for.

The reloads there already cover a splice failure releasing its whole
contribution, both for a negotiation aborted in flight and for one still
queued on quiescence, along with the `DiscardFunding` event type 0.2 has
to skip. What none of them cover is a contribution which reuses inputs
or outputs already committed to a pending splice: that is refused with
only the parts unique to it released, and those are what a downgraded
0.2 node has to learn about via `SpliceFailed`, since the
`DiscardFunding` carrying them is written under an event type it
ignores. Add a reload of a manager written with such a partial failure
pending, asserting 0.2 surfaces exactly the released output.

`FundingContribution::new_for_test` existed only to build contributions
for the removed tests, so it goes with them, as does the
`FailedSpliceContribution` note about having no serialization of its
own -- that is implied by the lack of any `Writeable`/`Readable`
implementation, so it tells callers nothing they need.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Requested-by: @matt
Link: https://git.rust-bitcoin.org/lightningdevkit/rust-lightning/pulls/4920#issuecomment-442672
Link: https://git.rust-bitcoin.org/lightningdevkit/rust-lightning/pulls/4920#issuecomment-442657
Link: https://git.rust-bitcoin.org/lightningdevkit/rust-lightning/pulls/4920#issuecomment-442658
Link: https://git.rust-bitcoin.org/lightningdevkit/rust-lightning/pulls/4920#issuecomment-442669

91/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Mentions testing or verification✓ Links an issue, advisory, or supporting reference
Why it was queued
update trust
AI analysis · Informational 17/100

This commit is a test-only cleanup in the Lightning Dev Kit (LDK) Rust codebase. It removes low-level byte-level tests for splice failure events and replaces them with a single cross-version test that actually loads a 0.2 node with serialized state from current code. There is no change to production logic, no fix for an active vulnerability, and no new attack surface. The work is defensive testing to ensure future serialization changes stay compatible with older LDK versions.

Security candidateDocument duplicate HTLC handling on revoked commitmentsby auto-pr-bot · c5bd8b11 · Aug 25, 2026 · 1 fileMessage 98 · StrongLow 28Details
Commit message · auto-pr-bot

Document duplicate HTLC handling on revoked commitments

@matt said:

> Bitcoin red team flagged that if there's two HTLCs with identical
> `(payment_hash, amount)`s on a channel and the counterparty broadcasts a
> revoked commitment tx and then claims both we will only propagate the
> claim backwards on one of the two. This is, of course, not a
> "vulnerability" because we'll still get our money by taking our
> counterparty's funds via the revocation path, but it might be nice to
> claim both HTLCs cause, why not, free money.
>
> @auto-pr-bot can you do this? try to keep the code change small and
> contained, if its too big I'll respond in review and we'll switch to
> just leaving a comment instead.

@matt said:

> @auto-pr-bot try again.

@matt asked:

> Turned out to be way too much code. @auto-pr-bot can you instead just
> add a comment?

HTLC outputs on a revoked counterparty commitment transaction don't come
with an `HTLCSource`, so when one is spent we search the counterparty's
non-revoked commitment transactions for an HTLC with a matching
direction, payment hash and value. If a channel had two HTLCs which
share both a payment hash and a value, spends of either output match the
same first source.

Thus, if the counterparty claims both outputs with the preimage, we
propagate only one fulfillment upstream and fail the second upstream
HTLC, even though each matching upstream HTLC is independently claimable
once we have the preimage. Because the counterparty broadcasted a
revoked commitment we still recover the channel balance via the
revocation path, so this doesn't leave us out of pocket, but it does
give up an upstream claim we were entitled to.

Resolving the outputs against distinct sources means resolving every
matching source when a spend reveals a preimage and deterministically
matching duplicate outputs to sources otherwise, which is more than the
lookup here can do. Describe the behavior in a comment instead so the
next reader doesn't have to rediscover it.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Fixes #4904

Requested-by: @matt
Link: https://git.rust-bitcoin.org/lightningdevkit/rust-lightning/issues/4904#issuecomment-442538

98/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Explains rationale or failure mode✓ Links an issue, advisory, or supporting reference✓ Names security-relevant behavior explicitly
Why it was queued
explicit security language
AI analysis · Low 28/100

This commit only adds a code comment explaining an existing quirk: if a revoked old channel transaction contains two identical-looking payment forwards and the other side claims both, the software may only claim one upstream while letting the other fail. The commit itself does not change behavior, and the comment notes the user still recovers funds through the revocation penalty path, so no money is lost. It is a documentation-only change for a known, low-consequence edge case.

Security candidateAbort active splice RBF when prior candidate confirmsby Wilmer Paulino · 7587d2cd · Aug 25, 2026 · 4 filesMessage 73 · AdequateModerate 60Details
Commit message · Wilmer Paulino

Abort active splice RBF when prior candidate confirms

Rejecting new RBF attempts after confirmation does not cover an RBF
negotiation which began while the prior candidate was still unconfirmed.
When an earlier candidate confirms, inspect any active RBF and reset it
if is still safe and holder funding signatures have not been provided.
Propagate a structured abort through the chain-event path so
ChannelManager can notify a connected peer, fail any local contribution,
and release holding-cell updates. If signing has advanced too far,
retain the RBF until it completes, as splice promotion is blocked on its
completion.

Co-Authored-By: Codex <noreply@openai.com>

73/100 · AdequateMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context
Why it was queued
signing boundary
AI analysis · Moderate 60/100

This commit fixes a state-handling bug in Lightning Dev Kit's splicing feature. When a user tries to speed up or replace a pending splice (an 'RBF' attempt) and the older splice transaction unexpectedly gets confirmed on-chain, the software could get stuck with two conflicting splice attempts active. The patch detects that situation, safely cancels the newer RBF attempt, tells the peer, returns any locked-up funds, and resumes normal channel operation. If signing has already progressed too far, it keeps the RBF alive until it finishes to avoid unsafe cancellation.

Security candidateClear pending signer state when aborting splice RBFby Wilmer Paulino · cb81afaa · Aug 25, 2026 · 2 filesMessage 78 · AdequateLow 44Details
Commit message · Wilmer Paulino

Clear pending signer state when aborting splice RBF

If an asynchronous signer blocks the initial commitment signature for an
RBF, aborting the `AwaitingSignatures` negotiation discards its signing
session but previously left `signer_pending_funding` set. A later
`signer_unblocked` callback would then retry signing funding state which
no longer exists.

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 44/100

This commit fixes a state-cleanup bug in Lightning Dev Kit's splice RBF (fee-bump) flow. When a user aborts a splice while waiting for an asynchronous hardware signer, the code now properly clears an internal 'signer still has pending funding work' flag. Before the fix, that flag could remain set, causing a later 'signer is ready' callback to try to continue signing a funding transaction that no longer exists. The patch is small and defensive; the main risk is a confused internal state leading to unexpected retries or errors, not direct theft of funds.

Security candidateIgnore messages from aborted splice negotiationsby Wilmer Paulino · 76791c85 · Aug 25, 2026 · 2 filesMessage 73 · AdequateLow 37Details
Commit message · Wilmer Paulino

Ignore messages from aborted splice negotiations

An aborted splice negotiation exits quiescence before the `tx_abort`
exchange has fully completed. An in-flight `interactive-tx` or
`commitment_signed` message for the discarded negotiation may therefore
arrive after the splice state has been removed, and treating them as
active-protocol violations can disconnect unnecessarily.

Ignore `interactive-tx` messages once the channel is no longer
quiescent, while retaining a warning disconnect for unexpected messages
received during quiescence. Check a single `commitment_signed` message's
funding txid before enforcing batch delivery so a signature for
discarded funding is ignored.

73/100 · AdequateMessage clarity
✓ 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 37/100

This patch fixes a bug where a Lightning node could unnecessarily disconnect from a peer after a splice negotiation was aborted. When both sides agree to stop a splice, some related messages can still be in flight. Previously, those late messages were treated as protocol violations and caused a disconnect. Now the node ignores the stale messages instead, keeping the channel open. There is no direct evidence this was exploitable to steal funds, but unnecessary disconnects can hurt reliability.

Security candidateDisconnect on overlapping splice RBF negotiationby Wilmer Paulino · d6e24380 · Aug 25, 2026 · 3 filesMessage 78 · AdequateLow 45Details
Commit message · Wilmer Paulino

Disconnect on overlapping splice RBF negotiation

An inbound `tx_init_rbf` cannot identify a separate negotiation while
another funding negotiation is active. Sending `tx_abort` would
ambiguously abort the active negotiation and exit quiescence while
retaining its protocol state.

Return `WarnAndDisconnect` instead, preserving an `AwaitingSignatures`
negotiation for resumption across the disconnect rather than treating
the duplicate request as an abort. Remove the now-unused
NegotiationInProgress abort reason and update the existing
simultaneous-RBF regression coverage accordingly.

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 boundary
AI analysis · Low 45/100

This change fixes a protocol edge case in Lightning splicing where receiving a second overlapping RBF (fee-bump) request during an active funding negotiation could accidentally abort the wrong negotiation. Instead of sending tx_abort, which would ambiguously cancel the ongoing negotiation, the node now disconnects with a warning and keeps the existing negotiation state so it can resume after reconnecting. This prevents a remote peer from potentially disrupting an in-progress splice/RBF by sending a conflicting request.

Security candidateAdd cross-version tests for queued splice failure eventsby Jeffrey Czyz · 04252a94 · Aug 24, 2026 · 1 fileMessage 83 · StrongInformational 22Details
Commit message · Jeffrey Czyz

Add cross-version tests for queued splice failure events

A ChannelManager written with a splice contribution still queued
waiting on quiescence embeds synthesized failure events. Verify that a
downgraded 0.2 node reads such a manager and surfaces the failure as
its own SpliceFailed event carrying the contributed outputs, and that
a manager written by 0.2 with a queued splice -- which 0.2 persisted
in a legacy form current versions do not read -- loads with the queued
intent dropped and no events.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

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
update trust
AI analysis · Informational 22/100

This commit only adds new regression tests for upgrading and downgrading Lightning node state across software versions. It does not change any production code. The tests verify that a splice contribution stuck waiting for network quietness is handled safely when moving between LDK 0.2 and current versions: an older 0.2 node reading newer state gets a failure event so the user can reclaim funds, while a newer node reading an older 0.2 state simply drops the stale queued splice with no harmful effects. There is no vulnerability being introduced or fixed here.

Security candidateWrite SpliceNegotiationFailed contributions for 0.2by Jeffrey Czyz · 88ed3f41 · Aug 21, 2026 · 8 filesMessage 93 · StrongLow 33Details
Commit message · Jeffrey Czyz

Write SpliceNegotiationFailed contributions for 0.2

When downgrading to 0.2 with a splice negotiation pending, the
synthesized `Event::DiscardFunding` containing the contribution is
ignored (see previous commit), leaving a 0.2 user without the set of
UTXOs freed by the abandoned negotiation.

0.2 read those UTXOs from the `contributed_inputs` and
`contributed_outputs` fields of `Event::SpliceFailed`, which it wrote
at TLV types 11 and 13 of event type 52. Write the inputs and outputs
released by the failure there too -- excluding any still committed to
an existing splice attempt -- so a downgraded node surfaces the same
event 0.2 would have written itself.

To that end, the event's `contribution` field is now an
`Option<FailedSpliceContribution>`, which holds the released inputs and
outputs alongside the `FundingContribution` available for retry. The
released inputs and outputs are also read back so that they survive
re-serialization.

Note that this makes a `ChannelManager` written with a splice failure
event pending unreadable by v0.3.0-beta1, which used those TLV types
for other fields.

Completes the fix for #4919.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

93/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Explains rationale or failure mode✓ Links an issue, advisory, or supporting reference
Why it was queued
update trust
AI analysis · Low 33/100

This commit fixes a backward-compatibility bug in the Lightning Dev Kit (LDK) when a user downgrades from a newer version to version 0.2 while a splice negotiation is in progress. Without the fix, the newer version would generate an event telling the wallet to discard freed UTXOs, but version 0.2 could not understand that event, so those coins would appear stuck or lost to the downgraded node. The patch makes the newer version also write the freed UTXOs in the older event format that 0.2 understands, so the downgraded node surfaces the same information. It is a compatibility/data-loss fix, not a remote-exploitable vulnerability.

Security candidateWrite DiscardFunding contributions as an odd event typeby Jeffrey Czyz · bad9e47b · Aug 21, 2026 · 1 fileMessage 81 · StrongLow 35Details
Commit message · Jeffrey Czyz

Write DiscardFunding contributions as an odd event type

`FundingInfo::Contribution` was added in 0.3, but 0.2 fails to read
unknown `FundingInfo` variants. A `ChannelManager` or `ChannelMonitor`
serialized while an `Event::DiscardFunding` containing one was pending
-- the former whenever serialized during an incomplete splice
negotiation with a local contribution, the latter upon discarding a
negotiated splice with a recorded contribution -- could therefore never
be read by 0.2.

Write such events under a new odd event type, which prior versions
ignore, restoring the ability to downgrade. A downgraded node loses the
event; the next commit compensates for the negotiation-failure case by
including the discarded UTXOs in `Event::SpliceNegotiationFailed`.

Partially addresses #4919.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

81/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Links an issue, advisory, or supporting reference
Why it was queued
update trust
AI analysis · Low 35/100

This commit fixes a backward-compatibility bug in how a particular wallet event is saved to disk. A new type of funding contribution introduced in version 0.3 could not be read by version 0.2, which would crash or fail when loading a wallet that had been saved while a 'DiscardFunding' event was pending. The fix writes that specific case under a new, odd-numbered event type that older versions safely ignore, allowing users to downgrade from 0.3 to 0.2 without their wallet becoming unloadable. There is no attacker-controlled exploit here; it is a reliability/downgrade fix.

Security candidateFix SpliceNegotiationFailed TLV collision with 0.2by Jeffrey Czyz · c34a4e77 · Aug 21, 2026 · 3 filesMessage 81 · StrongLow 39Details
Commit message · Jeffrey Czyz

Fix SpliceNegotiationFailed TLV collision with 0.2

`Event::SpliceFailed` was released in 0.2 writing `contributed_inputs`
and `contributed_outputs` at TLV types 11 and 13. When those fields
were removed, the freed types were reused for the new `reason` and
`contribution` fields of the renamed `Event::SpliceNegotiationFailed`.

Consequently, a `ChannelManager` written by 0.2 while such an event was
pending -- the case whenever one is serialized during an incomplete
splice negotiation with a local contribution -- fails to read on 0.3,
as the legacy fields are misparsed as the new ones. Conversely, 0.2
fails to read a `ChannelManager` written by 0.3 while such an event was
pending.

Write `reason` and `contribution` at fresh odd TLV types, restoring the
compatibility behavior documented when the fields were removed; the
legacy types are odd, so unknown-type handling skips them on read. Note
that a `ChannelManager` written by v0.3.0-beta1 while such an event was
pending is no longer readable, as beta1 wrote `reason` and
`contribution` at the colliding types.

Partially addresses #4919; a pending `Event::DiscardFunding` with
`FundingInfo::Contribution` still prevents downgrade to 0.2.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

81/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Links an issue, advisory, or supporting reference
Why it was queued
update trust
AI analysis · Low 39/100

This commit fixes a data-format compatibility bug between versions 0.2 and 0.3 of the Lightning Dev Kit. When a pending splice-failure event was saved to disk by one version, the other version could misread it because new fields reused old numeric identifiers (TLV types). The patch assigns fresh identifiers so old and new data no longer collide. It is a backward-compatibility fix, not an exploitable security vulnerability, and it includes tests to confirm old data can now be read correctly.

Security candidateMerge PR 'Defer splice_locked during RBF signing' (#4891)by Matt Corallo · 89c9e5f4 · Aug 20, 2026 · 5 filesMessage 81 · StrongLow 44Details
Commit message · Matt Corallo

Merge PR 'Defer splice_locked during RBF signing' (#4891)

from delay-splice-promotion-inflight-rbf-negotiation into main

Reviewed-on: https://git.rust-bitcoin.org/lightningdevkit/rust-lightning/pulls/4891
Reviewed-by: Matt Corallo <matt@noreply.git.rust-bitcoin.org>

81/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Links an issue, advisory, or supporting reference
Why it was queued
signing boundarymerge-commit duplicate discount
AI analysis · Low 44/100

This commit fixes a timing bug in Lightning Dev Kit's splicing code. Previously, a node could prematurely send a 'splice_locked' message and promote an older splice transaction to active while a replacement transaction was still being signed through RBF. The patch defers sending splice_locked until the RBF signing round completes and the channel is no longer quiescent, then releases the lock on a timer tick. This prevents inconsistent channel states between peers and avoids potential fund loss or channel closure from conflicting funding transactions.

Security candidateMerge PR 'Checkpoint deferred ChannelManager with AwaitingSignatures splice' (#4911)by Matt Corallo · a42e29b1 · Aug 20, 2026 · 1 fileMessage 91 · StrongLow 29Details
Commit message · Matt Corallo

Merge PR 'Checkpoint deferred ChannelManager with AwaitingSignatures splice' (#4911)

from fuzz-checkpoint-splice-signing-session into main

Reviewed-on: https://git.rust-bitcoin.org/lightningdevkit/rust-lightning/pulls/4911
Reviewed-by: Matt Corallo <matt@noreply.git.rust-bitcoin.org>

91/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Mentions testing or verification✓ Links an issue, advisory, or supporting reference
Why it was queued
signing boundaryfuzzing or regression evidencemerge-commit duplicate discount
AI analysis · Low 29/100

This commit adds a workaround in a fuzz test harness for a known limitation in how Lightning Dev Kit saves its state during a splice operation. When a node is in a 'deferred persistence' test mode and has a splice waiting for signatures, the test now forces a state checkpoint before restarting. Without this, a fuzz test could simulate a restart at a moment where the signing session has not yet been saved, causing the node to disagree with its peer and force-close the channel. The change is in test/fuzz code, not production logic, but it documents a real edge case in production state management.

Security candidateCheckpoint deferred ChannelManager with AwaitingSignatures spliceby Wilmer Paulino · e1c3fec5 · Aug 20, 2026 · 1 fileMessage 83 · StrongLow 33Details
Commit message · Wilmer Paulino

Checkpoint deferred ChannelManager with AwaitingSignatures splice

We don't currently checkpoint our signing session prior to sending
`commitment_signed`. The fuzzer has shown that it's possible that we
commit to a splice candidate and reload with an outdated manager prior
to the signing session existing. If the counterparty commits to the
splice back, and is expecting to resume, we'll end up aborting
erroneously leading to a force close. We defer the real fix for now and
instead prevent the fuzzer from running into this case.

Fixes fuzz payload:

7f0200000000004211a10081bd4a191f1119401f001118100f1810411f00111810101b10401f00111810101810411f00111810101810401f00111fb170b170ff

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 evidence
AI analysis · Low 33/100

This commit is a temporary workaround in a fuzz-testing harness for the Lightning Dev Kit. It forces a save of the channel manager before restarting a test node when a specific in-progress splice state exists. The underlying issue is that the signing session for a splice isn't checkpointed before sending a commitment message, so if the node restarts at the wrong moment, it can reload stale state and force-close a channel unnecessarily. The commit does not fix the root cause; it only prevents the fuzzer from hitting the case.

AI review queuedtx-sync: parallelize esplora status queriesby Max Fang · 262ebae0 · Aug 20, 2026 · 1 fileMessage 68 · AdequateInformational 21Details
Commit message · Max Fang

tx-sync: parallelize esplora status queries

The esplora sync loop awaited each HTTP query sequentially: one
get_block_status per relevant txid, 3 round trips (merkle block, tx,
block status) per watched transaction, and one get_output_status per
watched output. With many channels this pure latency dominates sync
wall-clock time, particularly during the first sync after a restart.

In async builds, run the per-block, per-transaction, and per-output
queries concurrently via buffer_unordered, bounded at 16 in-flight
requests by default and configurable via with_concurrency.
Confirmed transactions are already sorted by (height, in-block
position) before being fed to the confirmables, so completion order
does not matter. The blocking client variant remains sequential.

Also dedup block status queries by block hash (multiple relevant txids
can share a block), and drop a redundant duplicate-txid check when
iterating watched_transactions: it is a HashSet, so txids are unique.

Note that items are moved into the concurrently-polled futures as owned
values (txids copied, watched outputs cloned). Borrowing them compiles
within this crate but trips rustc's "implementation of FnOnce is not
general enough" false positive in downstream callers that box the
returned sync future.

68/100 · AdequateMessage clarity
✓ Descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context
Why it was queued
signing or wallet pathsecond-pass: security-sensitive path
AI analysis · Informational 21/100

This commit is a performance improvement, not a security fix. It speeds up how rust-lightning asks an Esplora server about transaction and block status by running many requests at once instead of one at a time. The change also removes a duplicate check and deduplicates repeated block-status lookups. There is no indication in the commit that it fixes a vulnerability or that the old code was unsafe.

Security candidatelightning-payer-proof: flag the uniffi record's untrusted stringsby auto-pr-bot · 71de48ab · Aug 19, 2026 · 1 fileMessage 73 · AdequateLow 30Details
Commit message · auto-pr-bot

lightning-payer-proof: flag the uniffi record's untrusted strings

The uniffi record hands its three free-text fields back as plain
`String`s, copied straight out of the proof with no sanitization, but
only `offer_description` warned about that. `offer_issuer` and
`proof_note` are just as attacker-controlled, so carry the same warning
on both.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

73/100 · AdequateMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context
Why it was queued
explicit security languagedefensive validation
AI analysis · Low 30/100

This commit only adds documentation comments warning developers that two text fields returned by a UniFFI record are untrusted and should be sanitized before display. It does not change any code behavior, add sanitization, or fix an active vulnerability. It is a defensive documentation improvement for a potential injection/display-risk issue.

AI review queuedMerge PR 'Add a BOLT 12 payer proof verification crate' (#4839)by Matt Corallo · 6df1057f · Aug 19, 2026 · 20 filesMessage 91 · StrongInformational 17Details
Commit message · Matt Corallo

Merge PR 'Add a BOLT 12 payer proof verification crate' (#4839)

from lightning-payer-proof into main

Reviewed-on: https://git.rust-bitcoin.org/lightningdevkit/rust-lightning/pulls/4839
Reviewed-by: Matt Corallo <matt@noreply.git.rust-bitcoin.org>

91/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Mentions testing or verification✓ Links an issue, advisory, or supporting reference
Why it was queued
defensive validationmerge-commit duplicate discountsecond-pass: unusually broad change
AI analysis · Informational 17/100

This commit adds a brand-new, optional crate called lightning-payer-proof to the rust-lightning workspace. It provides a public library (and separate UniFFI bindings) for verifying BOLT 12 'payer proofs' — cryptographic receipts that a Lightning payment was made. The change is purely additive: it introduces new code, test vectors, CI build entries, and workspace membership. There is no patch to existing logic and nothing in the commit message or diff indicates a security bug was fixed.

AI review queuedMerge PR 'Ban non-dust HTLCs if dust limit would be breached' (#4890)by Matt Corallo · b198733e · Aug 14, 2026 · 2 filesMessage 81 · StrongModerate 57Details
Commit message · Matt Corallo

Merge PR 'Ban non-dust HTLCs if dust limit would be breached' (#4890)

from 2026-08-ban-nondust-htlcs into main

Reviewed-on: https://git.rust-bitcoin.org/lightningdevkit/rust-lightning/pulls/4890
Reviewed-by: Matt Corallo <matt@noreply.git.rust-bitcoin.org>

81/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Links an issue, advisory, or supporting reference
Why it was queued
signing or wallet pathmerge-commit duplicate discountsecond-pass: security-sensitive path
AI analysis · Moderate 57/100

This change tightens how Lightning payment limits are calculated when transaction fees are high. Previously, the code could allow a non-dust HTLC (a payment large enough to normally appear on-chain) to be offered even when the combined dust-exposure risk pushed the channel past its safety limit. The patch lowers the allowed outbound amount by one millisatoshi in that edge case so the HTLC is treated as dust and rejected, preventing a situation where a miner-fee spike could make an HTLC uneconomical to claim on-chain. The practical effect is a small, defensive correction to fee-based channel safety logic.

AI review queuedFix outdated PersistenceNotifierGuard commentby elnosh · af3d07d1 · Aug 12, 2026 · 1 fileMessage 35 · OpaqueInformational 15Details
Commit message · elnosh

Fix outdated PersistenceNotifierGuard comment

35/100 · OpaqueMessage clarity
✓ Descriptive subject! No meaningful explanatory body
Why it was queued
second-pass: opaque commit message
AI analysis · Informational 15/100

This commit only updates an internal code comment to match the current API names. No code behavior changes, no security relevance.

AI review queuedCorrect 0.2.5 and 0.1.12 CHANGELOG entriesby Matt Corallo · 8322fc4e · Aug 11, 2026 · 1 fileMessage 73 · AdequateInformational 15Details
Commit message · Matt Corallo

Correct 0.2.5 and 0.1.12 CHANGELOG entries

* The response panic issue is when accepting *onion messages*
which merit a response, not HTLCs,
* 0.1 was not vulnerable to the panic-on-reorg issue Kyle reported
as it did not contain the new package merging logic.

73/100 · AdequateMessage clarity
✓ Descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Names security-relevant behavior explicitly
Why it was queued
documentation-only discountsecond-pass: broader security terminology
AI analysis · Informational 15/100

This commit only edits the project's CHANGELOG text. It corrects earlier release notes: one panic issue actually involved 'onion messages' (not HTLCs), and an older 0.1 release was not actually vulnerable to a reorg-related panic because it lacked the relevant code. No code behavior changes.

AI review queuedAdd 0.1.12 release notesby Matt Corallo · 9bc0dc50 · Aug 11, 2026 · 1 fileMessage 38 · OpaqueHigh 78Details
Commit message · Matt Corallo

Add 0.1.12 release notes

38/100 · OpaqueMessage clarity
✓ Subject identifies a change✓ Names a concrete action or component! No meaningful explanatory body
Why it was queued
documentation-only discountsecond-pass: opaque commit message
AI analysis · High 78/100

This commit adds release notes for rust-lightning version 0.1.12, describing several security fixes. The most serious is an on-chain funds-theft vulnerability for nodes that forward Lightning payments through channels opened by untrusted peers. Other fixes address denial-of-service crashes, including cases involving invalid onion message reply paths, oversized protocol messages, reorgs during on-chain HTLC claims, and peer flooding of channel-open requests. The release notes credit Project Loupe and Kyle W. Santiago for reporting the security issues.

Security candidateMerge PR 'Fix warnings on `nightly`' (#4864)by tankyleo · 9606d2fa · Aug 11, 2026 · 31 filesMessage 76 · AdequateInformational 15Details
Commit message · tankyleo

Merge PR 'Fix warnings on `nightly`' (#4864)

from 2026-08-fix-nightly-warnings into main

Reviewed-on: https://git.rust-bitcoin.org/lightningdevkit/rust-lightning/pulls/4864
Reviewed-by: tankyleo <tankyleo@noreply.git.rust-bitcoin.org>

76/100 · AdequateMessage clarity
✓ Descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Links an issue, advisory, or supporting reference
Why it was queued
cryptography-sensitive pathsigning or wallet pathmerge-commit duplicate discount
AI analysis · Informational 15/100

This commit is a routine cleanup that fixes Rust compiler warnings on the nightly toolchain. It replaces deprecated ways of writing maximum integer values (like `u64::max_value()` and `std::usize::MAX`) with the modern equivalents (`u64::MAX`, `usize::MAX`), adds a missing semicolon in a log statement, and updates related comments. These changes do not alter program behavior or fix any security issue.

Lower-priorityMerge PR 'Only fetch TXIDs instead of entire block during gossip verification' (#4846)by Matt Corallo · ebe7a447 · Aug 5, 2026 · 5 filesMessage 91 · StrongLow 32Details
Commit message · Matt Corallo

Merge PR 'Only fetch TXIDs instead of entire block during gossip verification' (#4846)

from gossip-verify-rpc into main

Reviewed-on: https://git.rust-bitcoin.org/lightningdevkit/rust-lightning/pulls/4846
Reviewed-by: Matt Corallo <matt@noreply.git.rust-bitcoin.org>

91/100 · StrongMessage clarity
✓ Specific, descriptive subject✓ Names a concrete action or component✓ Provides detailed explanatory context✓ Mentions testing or verification✓ Links an issue, advisory, or supporting reference
Why it was queued
defensive validationmerge-commit duplicate discount
AI analysis · Low 32/100

This commit changes how the Lightning Dev Kit's block-sync module verifies Lightning network gossip announcements. Instead of downloading entire Bitcoin blocks (which can be large), it now downloads only the list of transaction IDs for a block and then separately fetches the specific unspent transaction output it needs. This is primarily a performance and bandwidth optimization, not a security fix. The change also updates the public API of the UtxoSource trait, requiring custom implementations to add new methods.