Merge pull request #2549 from yanganto/socket-addr

Rename SocketAddress from NetAddress

Struct-ify blinded payment path intermediate node info

Remove unnecessary doc links

Fix blinded payment TLV ser to not length-prefix

impl_writeable_tlv_based includes a length prefix to the TLV stream, which we
don't want.

Derive Clone and Debug for blinded payment TLV structs

Make blinded payment TLV fields public.

These should've been made public when they were added for use in
BlindedPath::new_for_payment.

Support aggregating htlc_maximum_msat for BlindedPayInfo

Support aggregating htlc_minimum_msat for BlindedPayInfo

Compute aggregated BlindedPayInfo in path construction

Rename SocketAddress from NetAddress

Introduce `ChannelPhase` enum

We introduce the `ChannelPhase` enum which will contain the different
channel structs wrapped by each of its variants so that we can place
these within a single `channel_by_id` map in `peer_state` in the
following commits. This will reduce the number of map lookup operations
we need to do in `ChannelManager`'s various methods. It will also make
certain channel counting logic easier to reason about with less risk of
forgetting to modify logic when new channels structs are introduced for
V2 channel establishment.

Remove outdated `Channel` TODO

Have `path_to_windows_str` take reference to avoid `clone`s

Merge pull request #2371 from jkczyz/2023-06-offer-message-handling

BOLT 12 Invoice payments

Merge pull request #2472 from tnull/2023-08-add-kvstore

Replace `KVStorePersister` with `KVStore`

Configure BOLT 12 invoice payment retry strategy

Replace a constant three retry attempts for BOLT 12 invoice payments
with a retry strategy specified when creating a pending outbound
payment. This is configured by users in a later commit when constructing
an InvoiceRequest or a Refund.

Use u32 instead of usize in Retry::Attempts

An upcoming commit requires serializing Retry, so use a type with a
fixed byte length. Otherwise, using eight bytes to serialize a usize
would fail to read on 32-bit machines.

Add tests for send_payment_for_bolt12_invoice

pub(crate) visibility for offers/test_utils.rs

The test utilities for Offers are needed for testing message handling in
ChannelManager and OutboundPayments.

Support paying BOLT 12 invoices

Add a send_payment_for_bolt12_invoice method to OutboundPayments for
initiating payment of a BOLT 12 invoice. This will be called from an
OffersMessageHandler, after which any retries are handled using the
Retryable logic.

Rename OutboundPayments::retry_payment_internal

It will be used for initial attempts at paying BOLT 12 invoices, so
rename it something that covers both that and retries.

Refactor OutboundPayments::retry_payment_internal

Consolidate the creation and insertion of onion_session_privs to the
PendingOutboundPayment::Retryable arm. In an upcoming commit, this
method will be reused for an initial BOLT 12 invoice payment. However,
onion_session_privs are created using a different helper.

Add PendingOutboundPayment::InvoiceReceived

When a BOLT 12 invoice has been received, a payment attempt is made and
any errors result in abandoning the PendingOutboundPayment. This results
in generating at PaymentFailed event, which has a PaymentHash. Thus,
when receiving an invoice, transition from AwaitingInvoice to a new
InvoiceReceived state, the latter of which contains a PaymentHash such
the abandon_payment helper can still be used.

Test removing abandoned AwaitingInvoice payments

Test for removing stale AwaitingInvoice payments

Move IDEMPOTENCY_TIMEOUT_TICKS to where it is used

Add PendingOutboundPayment::AwaitingInvoice

When a BOLT 12 invoice has been requested, in order to guarantee
invoice payment idempotency the future payment needs to be tracked. Add
an AwaitingInvoice variant to PendingOutboundPayment such that only
requested invoices are paid only once. Timeout after a few timer ticks
if a request has not been received.

Add `TestStore` implementation of `KVStore`

Add benchmarking for `FilesystemStore`

We re-add benchmarking for `FilesystemStore` now that we switched over
to it.

Migrate `FilesystemPersister` tests to `FilesystemStore`

Migrate to `KVStore`/`FilesystemStore`

Firstly, we switch our BP over to use `FilesystemStore`, which also gives us test
coverage and ensures the compatibility.

Then, we remove the superseded `KVStorePersister` trait and
the `FilesystemPersister` code.

Add `read_channel_monitors` utility

This replaces the `FilesystemPersister::read_channelmonitors` method, as
we can now implement a single utility for all `KVStore`s.

Add `FilesystemStore`

We upstream the `FilesystemStore` implementation, which is backwards
compatible with `lightning-persister::FilesystemPersister`.

Add `test_utils`

We add a utility function needed by upcoming `KVStore` implementation
tests.

Update `lightning-persister` crate

Add `KVStore` interface trait

We upstream the `KVStore` interface trait from LDK Node, which will
replace `KVStorePersister` in the coming commits.

Besides persistence, `KVStore` implementations will also offer to `list`
keys present in a given `namespace` and `read` the stored values.

Add an InvoiceRequestFailed event

When an invoice is requested but either receives an error or never
receives a response, surface an event to indicate to the user that the
corresponding future payment has failed.

Merge pull request #2134 from jbesraa/add_fromstr_to_netaddress

implement fromstr trait to netaddress

Merge pull request #2557 from waterson/stale-monitor-force-close-debugging

Log each condition that was violated for a stale monitor

Fix misspelling, s/and/but/.

Merge pull request #2555 from tnull/2023-08-have-get-route-take-params

Have `get_route` and `Route` take `RouteParameters`

Improve `Route::get_total_amount` docs

Include overpaid value in `Route::get_total_fees`

Have `Route` hold `RouteParameters`

Have `get_route` take `RouteParameters`

Implement `from_str` trait for `NetAddress`

    - Add fuzz test for `NetAddress` `from_str` function

Log each condition that was violated for a stale monitor

There are several conditions that can be violated which indicate a stale
monitor. This logs each that doesn't hold.

Fix indent in `message_signing.rs`

Move `zbase32` implementation to `base32` file

Add RFC4648 base32 `encode` and `decode` functions

Merge pull request #1924 from benthecarman/handle-coinbase-funding-channel

Handle if funding output is in a coinbase transaction

Merge pull request #2548 from JosephGoulden/chain-monitor-logging

Downgrade log message "Channel Monitor sync is still in progress" from info to debug

Add test for coinbase funding transactions

Support creating coinbase funding transactions in tests

Handle if funding output is in a coinbase transaction

Downgrade log message regarding Channel Monitor sync still being in progress from info to debug

Merge pull request #2522 from sr-gi/202308-set-feature

Adds a set of convenience methods to set non-custom features

Merge pull request #2543 from optout21/txabort-typo

[minor] Fix wrong msg type in SendTxAbort, typo

Adds a set of convenience methods to set non-custom features

Currently only custom features can be set by specifying the feature bit. Add also the
ability to do so for regular features.

Add constructor to `RouteParameters`

Fix wrong msg type in SendTxAbort, typo

Merge pull request #2468 from jkczyz/2023-08-offer-payment-id

Offer outbound payments

Include PaymentId in payer metadata

When receiving a BOLT 12 invoice originating from either an invoice
request or a refund, the invoice should only be paid once. To accomplish
this, require that the invoice includes an encrypted payment id in the
payer metadata. This allows ChannelManager to track a payment when
requesting but prior to receiving the invoice. Thus, it can determine if
the invoice has already been paid.

Add a ChaCha20 utility for encrypting in place

Similar to ChaCha20::encrypt_single_block only encrypts in-place.

Add a ChaCha20 utility for encrypting a block

This hides an encryption implementation detail from callers.

Add an encryption key to ExpandedKey for Offers

Metadata such as the PaymentId should be encrypted when included in an
InvoiceRequest or a Refund, as it is user data and is exposed to the
payment recipient. Add an encryption key to ExpandedKey for this purpose
instead of reusing offers_base_key.

Remove unnecessary #[allow(unused)]

Split InvoiceRequest::verify_and_respond_using_derived_keys

InvoiceRequest::verify_and_respond_using_derived_keys takes a payment
hash. To avoid generating one for invoice requests that ultimately
cannot be verified, split the method into one for verifying and another
for responding.

Merge pull request #2531 from optout21/channel-id-breaking

Add ChannelId pending change note; formatting

Merge pull request #2537 from TheBlueMatt/2023-08-one-less-feature-dep

Drop dep `tokio`'s `io-util` feat as it broke MSRV and isn't useful

Pin the `memchr` test-only transitive dependency of `regex`

Drop dep `tokio`'s `io-util` feat as it broke MSRV and isn't useful

We use `tokio`'s `io-util` feature to provide the
`Async{Read,Write}Ext` traits, which allow us to simply launch a
read future or `poll_write` directly as well as `split` the
`TcpStream` into a read/write half. However, these traits aren't
actually doing much for us - they are really just wrapping the
`readable` future (which we can trivially use ourselves) and
`poll_write` isn't doing anything for us that `poll_write_ready`
can't.

Similarly, the split logic is actually just `Arc`ing the
`TcpStream` and busy-waiting when an operation is busy to prevent
concurrent reads/writes. However, there's no reason to prevent
concurrent access at the stream level - we aren't ever concurrently
writing or reading (though we may concurrently read and write,
which is fine).

Worse, the `io-util` feature broke MSRV (though they're likely to
fix this upstream) and carries two additional dependencies (only
one on the latest upstream tokio).

Thus, we simply drop the dependency here.

Fixes #2527.

Merge pull request #2536 from waterson/test-channel-signer

Rename EnforcingSigner to TestChannelSigner

Fix BlindedPath::new_for_payment docs

Merge pull request #2528 from arik-so/arik/2023-08-2470-shorter-term-monitor-locks

Release monitor write lock in between update iterations

Rename EnforcingSigner to TestChannelSigner

Since the advent of VLS, EnforcingSigner is only used now for testing.

Add ChannelId pending change note; formatting

Fix flaky aggregated HTLC revocation test.

Releasing write locks in between monitor updates
requires storing a set of cloned keys to iterate
over. For efficiency purposes, that set of keys
is an actual set, as opposed to array, which means
that the iteration order may not be consistent.

The test was relying on an event array index to
access the revocation transaction. We change that
to accessing a hash map keyed by the txid, fixing
the test.

Release write lock between monitor update iterations.

Previously, updating block data on a chain monitor
would acquire a write lock on all of its associated
channel monitors and not release it until the loop
completed.

Now, we instead acquire it on each iteration,
fixing #2470.

Merge pull request #2485 from optout21/channel-id-4struct1

Introduce new ChannelId struct

Use new ChannelId type

Add new ChannelId type; unused

Merge pull request #2197 from jbesraa/feat/lockable_score_rw

add another lock to lockable_score

Merge pull request #2248 from TheBlueMatt/2023-04-gossip-check

Implement the UtxoSource interface for REST/RPC clients

Merge pull request #2503 from valentinewallace/2023-08-fix-router-debug-panic

Fix debug panic in the case where a first hop has a channel with an introduction node

Merge pull request #2466 from TheBlueMatt/2023-07-expose-success-prob

Expose the historical success probability calculation itself

Split LockableScore responsibilities between read & write operations

    - Split Score from LockableScore to ScoreLookUp to handle read
      operations and ScoreUpdate to handle write operations
    - Change all struct that implemented Score to implement ScoreLookUp
      and/or ScoreUpdate
    - Change Mutex's to RwLocks to allow multiple data readers
    - Change LockableScore to Deref in ScorerAccountingForInFlightHtlcs
      as we only need to read
    - Add ScoreLookUp and ScoreUpdate docs
    - Remove reference(&'a) and Sized from Score in ScorerAccountingForInFlightHtlcs
      as Score implements Deref
    - Split MultiThreadedScoreLock into MultiThreadedScoreLockWrite and MultiThreadedScoreLockRead.
      After splitting LockableScore, we split MultiThreadedScoreLock following
      the same way, splitting a single score into two srtucts, one for read and
      other for write.
      MultiThreadedScoreLock is used in c_bindings.

Merge pull request #2519 from Sharmalm/main

Print contents of our own channel updates for broadcast in non-gossip logs

Router: account for blinded path fee, etc on first_hop<>intro hop add

This previously led to a debug panic in the router because we wouldn't account
for the blinded path fee when calculating first_hop<>intro_node hop's available
liquidity and construct an invalid path that forwarded more over said hop than
was actually available.

This also led to us hitting unreachable code, see direct_to_matching_intro_nodes
test description.

improving message in log

Fail UTXO lookups if the block doesn't have five confirmations

The BOLT spec mandates that channels not be announced until they
have at least six confirmations. This is important to enforce not
because we particularly care about any specific DoS concerns, but
because if we do not we may have to handle reorgs of channel
funding transactions which change their SCID or have conflicting
SCIDs.

Add a simple naive block cache in gossip sync lookups

Make the `P2PGossipSync` `UtxoLookup` exchangable without &mut self

Because a `UtxoLookup` implementation is likely to need a reference
to the `PeerManager` which contains a reference to the
`P2PGossipSync`, it is likely to be impossible to get a mutable
reference to the `P2PGossipSync` by the time we want to add a
`UtxoLookup` without a ton of boilerplate and trait wrapping.

Instead, we simply place the `UtxoLookup` in a `RwLock`, allowing
us to modify it without a mutable self reference.

The lifetime bounds updates in tests required in this commit are
entirely unclear to me, but do allow tests to continue building, so
somehow make rustc happier.

Implement the `UtxoSource` interface for REST/RPC clients

In LDK, we expect users operating nodes on the public network to
implement the `UtxoSource` interface in order to validate the
gossip they receive from the network.

Sadly, because the DoS attack of flooding a node's gossip store
isn't a common issue, and because we do not provide an
implementation off-the-shelf to make doing so easily, many of our
downstream users do not have a `UtxoSource` implementation.

In order to change that, here we implement an async `UtxoSource`
in the `lightning-block-sync` crate, providing one for users who
sync the chain from Bitcoin Core's RPC or REST interfaces.

Merge pull request #2515 from TheBlueMatt/2023-08-earlier-payment-hash-log

Include payment hash in more early payment logs

Store a `HistoricalMinMaxBuckets` in `DirectedChannelLiquidity`

This removes the need to reconstruct the struct in a number of
places by simply creating it up front.

Move the bucketed history tracking logic into a scoring submodule

Expose the historical success probability calculation itself

In 3f32f60ae7e75a4be96d3d5adc8d18b53445e5e5 we exposed the
historical success probability buckets directly, with a long method
doc explaining how to use it. While this is great for logging
exactly what the internal model thinks, its also helpful to let
users know what the internal model thinks the success probability
is directly, allowing them to compare route success probabilities.

Here we do so but only for the historical tracking buckets.

Find payment bucket in calculate_success_probability_times_billion

This simply moves code which will simplify the next commit
somewhat.

Correctly apply penalty bounds on the per-amount penalties

When we attempt to score a channel which has a success probability
very low, we may have a log well above our cut-off of two. For the
liquidity penalties this works great, we bound it by
`NEGATIVE_LOG10_UPPER_BOUND` and `min` the two scores. For the
amount liquidity penalty we didn't do any `min`ing at all.

This fix is to min the log itself first and then reuse the min'd
log in both calculations.