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.

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

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.

Don't rely on `calculate_success_probability*` to handle amt > cap

Currently we let an `htlc_amount >= channel_capacity` pass through
from `penalty_msat` to
`calculate_success_probability_times_billion`, but only if its only
marginally bigger (less than 65/64ths). This is fine as
`calculate_success_probability_times_billion` handles bogus values
just fine (it will always return a zero probability in such cases).

However, this is risky, and in fact breaks in the coming commits,
so instead check it before ever calling through to the historical
bucket probability calculations.

Merge pull request #2337 from alecchendev/2023-06-watchtower-support

Support third-party watchtowers in persistence pipeline

Merge pull request #2412 from valentinewallace/2023-07-construct-blinded-paths

Add API for constructing blinded payment paths

Test justice tx formation from persistence

Here we implement `WatchtowerPersister`, which provides a test-only
sample implementation of `Persist` similar to how we might imagine a
user to build watchtower-like functionality in the persistence pipeline.

We test that the `WatchtowerPersister` is able to successfully build and
sign a valid justice transaction that sweeps a counterparty's funds if
they broadcast an old commitment.

Enable signing a justice tx using the channel monitor

Expose revokeable output index and building a justice tx from commitment

For watchtowers to be able to build justice transactions for our
counterparty's revoked commitments, they need to be able to find the
revokeable output for them to sweep. Here we cache `to_self_delay` in
`CommitmentTransaction` to allow for finding this output on the struct
directly. We also add a simple helper method to aid in building the
initial spending transaction.

This also adds a unit test for both of these helpers, and
refactors a bit of a previous `CommitmentTransaction` unit test to make
adding these easier.

Enable monitor to rebuild initial counterparty commitment tx

Upon creating a channel monitor, it is provided with the initial
counterparty commitment transaction info directly before the very first
time it is persisted. Because of this, the very first counterparty
commitment is not seen as an update in the persistence pipeline, and so
our previous changes to the monitor and updates cannot be used to
reconstruct this commitment.

To be able to expose the counterparty's transaction for the very first
commitment, we add a thin wrapper around
`provide_latest_counterparty_commitment_tx`, that stores the necessary
data needed to reconstruct the initial commitment transaction in the
monitor.

Build and expose counterparty commitments from monitor update

Remove redundant payment preimag hashing in HTLC claim pipeline

Currently, when we receive an HTLC claim from a peer, we first hash
the preimage they gave us before removing the HTLC, then
immediately pass the preimage to the inbound channel and hash the
preimage again before removing the HTLC and sending our peer an
`update_fulfill_htlc`. This second hash is actually only asserted
on, never used in any meaningful way as we have the htlc data
present in the same code.

Here we simply drop this second hash and move it into a
`debug_assert`.

Include payment hash in more early payment logs

If a user has issues with a payment, the most obvious thing they'll
do is check logs for the payment hash. Thus, we should ensure our
logs that show a payment's lifecycle include the payment hash and
are emitted (a) as soon as LDK learns of the payment, (b) once the
payment goes out to the peer (which is already reasonably covered
in the commitment transaction building logs) and (c) when the
payment ultimately is fulfilled or fails.

Here we improve our logs for both (a) and (c).

Add feerate and balances to `LatestCounterpartyCommitmentTXInfo`

This adds the feerate and local and remote output values to this channel
monitor update step so that a monitor can reconstruct the counterparty's
commitment transaction from an update. These commitment transactions
will be exposed to users in the following commits to support third-party
watchtowers in the persistence pipeline.

With only the HTLC outputs currently available in the monitor update, we
can tell how much of the channel balance is in-flight and towards which
side, however it doesn't tell us the amount that resides on either side.
Because of dust, we can't reliably derive the remote value from the
local value and visa versa. Thus, it seems these are the minimum fields
that need to be added.

Merge pull request #2492 from optout21/payment-hash-display

[minor] Add Display to Payment ID types

Document _init_and_read_* ser macro requirements

Fix documentation on onion message packet ControlTlvs

Blinded paths: rename encrypted_tlvs_ss to *_rho for precision

The previous name can be confused for the shared secret that the rho is derived
from.

Support constructing BlindedPaths for payments.

Simplify onion message blinded hop construction

Also adds a util for general blinded hop creation to be reused for blinded
payment paths.

Add new _init_and_read_tlv_stream ser macro

Useful for when you want to use _init_and_read_len_prefixed_tlv_fields but there is no
length byte at the start of the TLV stream.

Use Display of PaymentId&PaymentPreimage; avoid log_bytes macro

Merge pull request #2441 from arik-so/2023-07-taproot-signer-wrapped

Wrapped Channel Signer Type

Remove unused imports.

Remove a bunch of unnecessary ChannelManager
imports.

Introduce ChannelSignerType.

Rather than using a holder_signer of a specific
signer type in Channel and ChannelContext, this
allows us to hold an enum such that depending on
the type of channel, the appropriate signer could
be held in its respective variant.

Doing so required the reparametrization of Channel
from using a Signer to using the SignerProvider
trait. This percolated down to the ChannelManager
and multiple tests.

Now, when accessign various signer methods, there
is a distinction between accessing methods defined
for all signers on ChannelSigner, and accessing
type-specific methods using accessors such as
`as_ecdsa`.

Fix bench lifetimes.

Benchmarks were failing because node config and
channel monitor configs were tied to the same
lifetime.

Introducing a separate lifetime allows to avoid
out-of-order deallocation errors.

Add Taproot feature support.

Introduce a Taproot feature on bits 30/31 for
initialization, node, and channel type contexts.

Fix persister/chain_monitor lifetimes.

The persister and chain_monitor variables must
be declared before the node channel manager is
initialized to avoid out of order deallocation.

Merge pull request #2511 from jbesraa/add-channel-id-to-spendableoutputs-event

Add channel_id to SpendableOutputs event

Merge pull request #2432 from jkczyz/2023-07-bolt12-node-signer

Support signing BOLT 12 messages in `NodeSigner`

Rename ser macro

We want a similar macro for reading TLV streams without a length prefix, so
rename this one to disambiguate.

Minor BlindedHop docs update

Update blinded path util to take iterator instead of slice

Useful for blinded payment path construction.

Move Padding into blinded_path module for use in blinded payments

Move blinded message path util into message submodule

Move some blinded path message code into message submodule.

We'll similarly separate blinded path payments code into its own module.

Move blinded path util into blinded_path::utils

This way it can be more easily reused for blinded payment paths.

Merge pull request #2411 from valentinewallace/2023-07-blinded-onion-keys

Support constructing blinded path onion keys

Add Display to PaymentId & PaymentPreimage

Use Display of PaymentHash; avoid log_bytes macro

Add Display to PaymentHash

Add channel_id to SpendableOutputs event
    This will make it possible to
    link between SpendableOuts and ChannelMonitor

    - change channel_id to option so we dont break upgrade
    - remove unused channel_id
    - document channel_id
    - extract channel id dynamically to pass test
    - use contains to check channel_id in test as the events are not ordered
    - update docs framing
    - specify ldk version channel_id will be introduced in

Co-authored-by: Elias Rohrer <dev@tnull.de>
Update lightning/src/events/mod.rs

Co-authored-by: Elias Rohrer <dev@tnull.de>

Merge pull request #2507 from TheBlueMatt/2023-08-lnd-6039

Work around LND bug 6039

Support signing BOLT 12 invoices in NodeSigner

BOLT 12 messages need to be signed in the following scenarios:
- constructing an InvoiceRequest after scanning an Offer,
- constructing an Invoice after scanning a Refund, and
- constructing an Invoice when handling an InvoiceRequest.

Extend the NodeSigner trait to support signing BOLT 12 invoices such
that it can be used in the latter contexts. The method could be used
in an OffersMessageHandler.

Use TaggedHash in merkle::verify_signature

An earlier commit introduced TaggedHash for use in sign_message. For
consistency, use it in verify_signature, too.

Expose Offer/InvoiceRequest methods in Invoice

Bolt12Invoice can either be for an Offer (via an InvoiceRequest) or a
Refund. It wraps those types, so expose their methods on both
Bolt12Invoice and UnsignedBolt12Invoice.

Since Refund does not have all the Offer/InvoiceRequest methods, use an
Option return type such that None can returned for refund-based
invoices.

For methods that are duplicated between Offer/InvoiceRequest and
Bolt12Invoice, prefer the (non-Option, if applicable) method from
Bolt12Invoice (e.g., amount_msats, signing_pubkey).

Expose invoice accessors in UnsignedBolt12Invoice

Expose Offer accessor functions in InvoiceRequest

Also, expose both Offer and InvoiceRequest functions in
UnsignedInvoiceRequest.

Macro-ize InvoiceRequest accessors for reuse

Various messages wrap InvoiceRequestContents, which shouldn't be exposed
as it is an implementation detail. Define a macro for InvoiceRequest
accessor methods so that these messages can also define them.

Macro-ize Offer accessors for reuse

InvoiceRequest wraps OfferContents, which shouldn't be exposed as it is
an implementation detail. Define a macro for Offer accessor methods so
that InvoiceRequest and UnsignedInvoiceRequest can also define them.

Move BOLT 12 invoice method implementations

Move BOLT 12 InvoiceRequest method implementations

Move BOLT 12 offer method implementations

Unsigned BOLT 12 message parsing and serialization

Rename field of unsigned BOLT message contents

Using `contents` for the field name is more consistent with the signed
messages.