Merge pull request #2187 from benthecarman/invoice-serde-no-std

Add CI test for compile no-std serde lightning-invoice

Fix compiling lightning-invoice for no-std + serde

Merge pull request #2172 from TheBlueMatt/2023-04-fix-panicy-debug-assert

Remove a race-y debug assertion in new channel update handling

Merge pull request #2180 from benthecarman/impl-pk-to-node-id

Implement to and from for PublicKey and NodeId

Impl FromStr for NodeId

Merge pull request #2179 from benthecarman/use-node-alias-type

Use NodeAlias type in NodeAnnouncement

Use NodeAlias type in NodeAnnouncement

Implement to and from for PublicKey and NodeId

Merge pull request #2142 from alecchendev/2023-03-expose-fail-reason-in-payment-failure

Expose a failure reason in `PaymentFailed`

Add reason to `Event::PaymentFailed`

This includes adding a reason to `PendingOutboundPayment::Abandoned` and
using that reason when pushing an `Event::PaymentFailed`.

Merge pull request #2173 from benthecarman/convert-currency-to-netowkr

Convert Network to and from Currency

Convert Network to and from Currency

Remove a race-y debug assertion in new channel update handling

In 6090d9e6a862a2010eb80be56b7449947bc08374 we swapped out old
debug assertions that checked that a lock was `try_lock`able to
test that certain locks weren't held when we needed to be able to
take them in some near branch. However, another slipped in after in
the `ChannelMonitorUpdate` handling rework, which is replaced with
the new debug assertions here.

Merge pull request #2161 from benthecarman/prune-stale-channels-rgs

Prune stale channels from network graph after RGS sync.

Merge pull request #2158 from TheBlueMatt/2023-04-handle_err_more-check

Test for extra locks held in `handle_error` unconditionally

Merge pull request #2023 from futurepaul/fallback-to-address

add `Fallback` getter that returns `Address`

Create `PaymentFailureReason` enum

Merge pull request #2170 from TheBlueMatt/2023-04-silent-merge-conflict

Fix silent merge conflict between new test and payment refactor

Merge pull request #2162 from jkczyz/2023-04-invoice-hash

Fix silent merge conflict between new test and payment refactor

Merge pull request #2148 from TheBlueMatt/2023-04-claim-from-closed

Allow claiming a payment if a channel with an HTLC has closed

Merge pull request #2139 from TheBlueMatt/2023-03-metadata-prefactors

Add a new `RecipientOnionFields` and replace `PaymentSecret` with it

Merge pull request #2165 from wpaulino/fix-bp-channel-pending-panic-flake

Use signal for handling ChannelPending in test_background_event_handling

Split up comically long error return

Expose a BOLT 12 Invoice's signable_hash

This is useful as an identifier for downstream clients like VLS.

Expose a BOLT 11 Invoice's signable_hash

Otherwise, an Invoice must first be converted to a SignedRawInvoice to
obtain the hash.

Linkify lightning-invoice docs

Lift std check to function definition

Use signal for handling ChannelPending in test_background_event_handling

This fixes two potential panics within the test if the
`BackgroundProcessor` for `nodes[0]` consumed the `ChannelPending` event
prior to us consuming it manually in `end_open_channel`. The first panic
would happen within the event handler, since `ChannelPending` was not
being handled. The second panic would happen upon expecting the
`ChannelPending` event after handling `nodes[1]`'s `funding_signed` if
the `BackgroundProcessor` handled the event first. To ensure we still
reliably receive a `ChannelPending` event once possible, we let the
`BackgroundProcessor` consume the event and notify it.

Merge pull request #2163 from TheBlueMatt/2023-04-less-lock

Avoid holding a `per_peer_state` lock while claiming from a monitor

Prune stale channels from network graph after RGS sync

Add a `claim_deadline` field to `PaymentClaimable` with guarantees

Now that we guarantee `claim_payment` will always succeed we have
to let the user know what the deadline is. We still fail payments
if they haven't been claimed in time, which we now expose in
`PaymentClaimable`.

Avoid holding a `per_peer_state` lock while claiming from a monitor

There's no reason to hold a lock on `per_peer_state` while we're
claiming from a since-closed channel via a `ChannelMonitorUpdate`,
which we stop doing here.

Merge pull request #2101 from TheBlueMatt/2023-03-one-less-sig

Support future removal of redundant per-HTLC signatures in `CMU`s

`Fallback`: add `Address` getter and use bitcoin types

Test for extra locks held in `handle_error` unconditionally

`handle_error` must be called without `per_peer_state` mutex or
`pending_events` mutex locks held or we may risk deadlocks.
Previously we checked this in debug builds in the error path, but
not in the success path.

As it turns out, `funding_transaction_generated`'s error path does
hold a `per_peer_state` lock, which we fix here as well as move the
tests to happen unconditionally.

Merge pull request #2145 from TheBlueMatt/2023-04-async-bp-cleanups

Add test coverage of async BP and fix minor bug

Correct documentation of `payment_id` in events

Pipe the new `RecipientOnionFields` through send pipeline

This passes the new `RecipientOnionFields` through the internal
sending APIs, ensuring we have access to the full struct when we
go to construct the sending onion so that we can include any new
fields added there.

Add a `RecipientOnionFields` argument to spontaneous payment sends

While most lightning nodes don't (currently) support providing a
payment secret or payment metadata for spontaneous payments,
there's no specific technical reason why we shouldn't support
sending those fields to a recipient.

Further, when we eventually move to allowing custom TLV entries in
the recipient's onion TLV stream, we'll want to support it for
spontaneous payments as well.

Here we simply add the new `RecipientOnionFields` struct as an
argument to the spontaneous payment send methods. We don't yet
plumb it through the payment sending logic, which will come when we
plumb the new struct through the sending logic to replace the
existing payment secret arguments.

Replace `PaymentSecret` with `RecipientOnionFields` in the pub API

This moves the public payment sending API from passing an explicit
`PaymentSecret` to a new `RecipientOnionFields` struct (which
currently only contains the `PaymentSecret`). This gives us
substantial additional flexibility as we look at add both
`PaymentMetadata`, a new (well, year-or-two-old) BOLT11 invoice
extension to provide additional data sent to the recipient.

In the future, we should also add the ability to add custom TLV
entries in the `RecipientOnionFields` struct.

Remove the `PaymentSecret` field from `HTLCSource::OutboundRoute`

Many of the fields in `HTLCSource::OutboundRoute` are used to
rebuild the pending-outbound-payment map on reload if the
`ChannelManager` was not serialized though `ChannelMonitor`(s)
were after an HTLC was sent. As of 0.0.114, however, such payments
are not retryable without allowing them to fail and doing a full,
fresh, send.

Thus, some of the fields can be safely removed - we only really
care about having enough information to provide the user a failure
event, not being able to retry.

Here we drop one such field - the `payment_secret`, making our
`ChannelMonitorUpdate`s another handful of bytes smaller.

Allow claiming a payment if a channel with an HTLC has closed

Previously, LDK would refuse to claim a payment if a channel on
which the payment was received had been closed between when the
HTLC was received and when we went to claim it. This makes sense in
the payment case - why pay an on-chain fee to claim the HTLC when
presumably the sender may retry later. Long ago it also reduced
total code in the claim pipeline.

However, this doesn't make sense if you're trying to do an atomic
swap or some other protocol that requires atomicity with some other
action - if your money got claimed elsewhere you need to be able to
claim the HTLC in lightning no matter what. Further, this is an
over-optimization - there should be a very, very low likelihood
that a channel closes between when we receive the last HTLC for a
payment and the user goes to claim the payment. Since we now have
code to handle this anyway we should allow it.

Fixes #2017.

Add an async version of BP's test_channel_manager_persist_error

This gives us coverage of an async BP returning an error.

Make BP's `not_pruning_network_graph_until...` test dual async-sync

Make BP's `test_payment_path_scoring` dual sync/async.

This finally gives us a bit of test coverage of the async BP, which
was embarrassingly missing until now.

Ensure `background-processor` exits after any sleep future says to

If the user's sleep future passed to an async background processor
only returns true for exiting once and then reverts back to false,
we should exit anyway when we get a chance to. We do to this here
by always ensuring we check the exit flag even when only polling
sleep futures with no intent to (yet) exit. This is utilized in the
tests added in the coming commit(s).

Don't immediately exit BP if `ChannelManager` is persistable

If `ChannelManager` is persistable before the async background
processor even starts, it may not even get around to overwriting
the `should_exit` flag before testing it, and the default value is
(incorrectly) true, causing an immediate unconditional exit.

The default value should simply be false.

Fixes #2140

Make `lightning-background-processor` test failures more debugable

Instead of asserting a `Result` `is_ok`, we should always simply
`unwrap` to get a backgrace, and we should avoid doing so if the
thread is already panicking.

Merge pull request #2150 from TonyGiorgio/esplora-0.4

lightning-transaction-sync: Bump esplora to 0.4

Merge pull request #2147 from TheBlueMatt/2023-04-rgs-log-some

Add some trivial logging during RGS update processing.

lightning-transaction-sync: Bump esplora to 0.4

Merge pull request #2005 from arik-so/2023-01-taproot-message-types

Update messages for Taproot types.

Add some trivial logging during RGS update processing.

Rather than being totally silent, we need to at least note that we
are processing an RGS update when doing so in the logs, which we do
here.

Fixes #1981.

Add Taproot CI test.

Update the `RevokeAndACK` message for Taproot support.

Update the `CommitmentSigned` message for Taproot support.

Update the `FundingSigned` message for Taproot support.

Update the `FundingCreated` message for Taproot support.

Update the `AcceptChannel` message for Taproot support.

Introduce MuSig2-related types for Taproot channels.

Merge pull request #2090 from TheBlueMatt/2023-03-mon-wake-bp

Wake background-processor on async monitor update completion

Merge pull request #2098 from tnull/2023-03-add-channel-pending-event

Add `ChannelPending` event emitted upon `funding_signed`

Merge pull request #2143 from get10101/chore/convenient-confirm

Implement `chain::Confirm` without mandating any owned values

Add `ChannelPending` event emitted upon `funding_signed`

Currently, users don't have good way of being notified when channel open
negotiations have succeeded and new channels are pending confirmation on
chain. To this end, we add a new `ChannelPending` event that is emitted
when send or receive a `funding_signed` message, i.e., at the last
moment before waiting for the confirmation period.

We track whether the event had previously been emitted in `Channel` and
remove it from `internal_funding_created` entirely. Hence, we now
only emit the event after ChannelMonitorUpdate completion, or upon
channel reestablish. This mitigates a race condition where where we
wouldn't persist the event *and* wouldn't regenerate it on restart,
therefore potentially losing it, if async CMU wouldn't complete before
ChannelManager persistence.

Expose an option to substantially reduce sleep time in futures BP

Some users have suggested that waking every 100ms can be
CPU-intensive in deployments with hundreds or thousands of nodes
all running on the same machine. Thus, we add an option to the
futures-based `background-processor` to avoid waking every 100ms to
check for iOS having backgrounded our app and cut our TCP sockets.

This cuts the normal sleep time down from 100ms to 10s, for those
who turn it on.

Wake the background processor if an async monitor update completes

If the `ChainMonitor` gets an async monitor update completion, this
means the `ChannelManager` needs to be polled for event processing.
Here we wake it using the new multi-`Future`-await `Sleeper`, or
the existing `select` block in the async BP.

Fixes #2052.

Drop the dummy no-std `Condvar` which never sleeps

In `no-std`, we exposed `wait` functions which rely on a dummy
`Condvar` which never actually sleeps. This is somwhat nonsensical,
not to mention confusing to users. Instead, we simply remove the
`wait` methods in `no-std` builds.

Move the pub `wait` methods from `ChannelManager` to `Future`

Rather than having three ways to await a `ChannelManager` being
persistable, this moves to just exposing the awaitable `Future` and
having sleep functions on that.

Implement the ability to block on multiple futures at once

In the next commits we'll be adding a second notify pipeline - from
the `ChainMonitor` back to the background processor. This will
cause the `background-processor` to need to await multiple wakers
at once, which we cannot do in the current scheme without taking on
a full async runtime.

Building a multi-future waiter isn't so bad, and notably will allow
us to remove the existing sleep pipeline entirely, reducing the
complexity of our wakers implementation by only having one notify
path to consider.

Do not bound callbacks by `Send` when building for `no-std`

`Send` is rather useless on a `no-std` target - we don't have
threads and are just needlessly restricting ourselves, so here we
skip it for the wakers callback.

Add `CondVar::wait_{timeout_,}while` to `debug_sync`

These are useful, but we previously couldn't use them due to our
MSRV. Now that we can, we should use them, so we expose them via
our normal debug_sync wrappers.

Implement chain::Confirm without mandating any owned values

Correct `lightning-net-tokio` documentation, remove stale example

The `lightning-net-tokio` crate-level example contained a carryover
from when it was the primary notifier of the background processor
and now just shows an "example" of creating a method to call
another method with the same parameters and then do event
processing (which doesn't make sense, the BP should do that).

Instead, the examples are simply removed and the documentation is
tweaked to include recent changes.

Merge pull request #2141 from TheBlueMatt/2023-03-fuck-rust

Drop `futures` dependency from `lightning-block-sync`

Remove `futures` dependency in `lightning-background-processor`

As `futures` apparently makes no guarantees on MSRVs even in patch
releases we really can't rely on it at all, and while it currently
has an acceptable MSRV without the macros feature, its best to just
remove it wholesale.

Luckily, removing it is relatively trivial, even if it requires
the most trivial of unsafe tags.

Replace `futures` `select` with our own select enum to fix MSRV

`futures` recently broke our MSRV by bumping the `syn` major
version in a patch release. This makes it impractical for us to
use, instead here we replace the usage of its `select_biased` macro
with a trivial enum.

Given its simplicity we likely should have done this without ever
taking the dependency.

Avoid connection-per-RPC-call again by caching connections

In general, only one request will be in flight at a time in
`lightning-block-sync`. Ideally we'd only have one connection, but
without using the `futures` mutex type.

Here we solve this narrowly for the one-request-at-a-time case by
caching the connection and takeing the connection out of the cache
while we work on it.

Drop `futures` dependency from `lightning-block-sync`

Some how I'd understood that `futures` had reasonable MSRV
guarantees (e.g. at least Debian stable), but apparently that isn't
actually the case, as they bumped it to upgrade to syn (with
apparently no actual features or bugfixes added as a result?) with
no minor version bump or any available alternative (unlike Tokio,
which does LTS releases).

Luckily its relatively easy to just drop the `futures` dependency -
it means a new connection for each request, which is annoying, but
certainly not the end of the world, and its easier than trying to
deal with pinning `futures`.

See https://github.com/rust-lang/futures-rs/pull/2733

Merge pull request #2136 from marctyndel/2023-03-paymentforwarded-expose-amount-forwarded

Expose amount forwarded in `PaymentForwarded` event

Merge pull request #2059 from wpaulino/broadcast-missing-anchors-event

Queue BackgroundEvent to force close channels upon ChannelManager::read

add outbound_amount_forwarded_msat field to PaymentForwarded event

Merge pull request #2062 from alecchendev/2023-02-allow-overshoot-mpp

Allow overshooting final htlc amount and expiry

Add pending changelog noting possible backwards compat panic

Ignore lockorder violation on same callsite with different construction

As long as the lock order on such locks is still valid, we should allow
them regardless of whether they were constructed at the same location or
not. Note that we can only really enforce this if we require one lock
call per line, or if we have access to symbol columns (as we do on Linux
and macOS). We opt for a smaller patch by relying on the latter.

This was previously triggered by some recent test changes to
`test_manager_serialize_deserialize_inconsistent_monitor`. When the
test ends and a node is dropped causing us to persist each, we'd detect
a possible lockorder violation deadlock across three different `Mutex`
instances that are held at the same location when serializing our
`per_peer_states` in `ChannelManager::write`.

The presumed lockorder violation happens because the first `Mutex` held
shares the same construction location with the third one, while the
second `Mutex` has a different construction location. When we hold the
second one, we consider the first as a dependency, and then consider the
second as a dependency when holding the third, causing a circular
dependency (since the third shares the same construction location as the
first).

This isn't considered a lockorder violation that could result in a
deadlock as the comment suggests inline though, since we are under a
dependent write lock which no one else can have access to.

Merge pull request #2082 from wpaulino/bump-htlc-resolution-tx-locktime

Expose HTLC transaction locktime in BumpTransactionEvent::HTLCResolution

Use onion amount `amt_to_forward` for MPP set calculation

If routing nodes take less fees and pay the final node more than
`amt_to_forward`, the receiver may see that `total_msat` has been met
before all of the sender's intended HTLCs have arrived. The receiver
may then prematurely claim the payment and release the payment hash,
allowing routing nodes to claim the remaining HTLCs. Using the onion
value `amt_to_forward` to determine when `total_msat` has been met
allows the sender to control the set total.

Allow overshooting final cltv_expiry

Final nodes previously had stricter requirements on HTLC contents
matching onion value compared to intermediate nodes. This allowed
for probing, i.e. the last intermediate node could overshoot the
value by a small amount and conclude from the acceptance or rejection
of the HTLC whether the next node was the destination. This also
applies to the msat amount, however this change was already present.

Allow overshooting `total_msat` for an MPP

While retrying a failed path of an MPP, a node may want to overshoot
the `total_msat` in order to use a path with an `htlc_minimum_msat`
greater than the remaining value being sent. This commit no longer
fails MPPs that overshoot the `total_msat`, however it does fail
HTLCs with the same payment hash that are received *after* a
payment has become claimable.

Add `total_value_received` to `ClaimableHTLC` for claim validation

This is pre-work for allowing nodes to overshoot onion values and
changing validation for MPP completion. This adds a field to
`ClaimableHTLC` that is separate from the onion values, which
represents the actual received amount reported in `PaymentClaimable`
which is what we want to validate against when a user goes to claim.

Expose HTLC transaction locktime in BumpTransactionEvent::HTLCResolution

While users could easily figure it out based on the set of HTLC
descriptors included within, we already track it within the
`OnchainTxHandler`, so we might as well expose it to users as a
nice-to-have. It's also yet another thing they must get right to ensure
their HTLC transaction broadcasts are valid.

Set transaction locktime on malleable packages to discourage fee sniping

This only applies to all malleable packages on channels pre-dating
anchors and malleables packages for counterparty commitments
post-anchors. Malleables packages for holder commitments post-anchors
should have their transaction locktime applied manually by the consumer
of `BumpTransactionEvent::HTLCResolution` events.

Re-work PackageSolvingData::absolute_tx_timelock

Previously, this would return the earliest height the output could be
confirmed, which seems to no longer be useful. The only use of the
method was to determine whether we should delay a package to a future
block. Instead, we choose to return the absolute locktime the
transaction spending the output should have, which better corresponds to
the method name and still supports the delay functionality mentioned.

Doing so also allows us to expose the locktime required for HTLC
transactions we need to broadcast based on our own commitments for
anchor channels.

Merge pull request #2133 from tnull/2023-03-pin-syn

Pin`tokio` to fix CI

Merge pull request #2132 from tnull/2023-03-tx-sync-even-more-robustness

Drop `OnceCell` in `lightning-transaction-sync` tests

Merge pull request #2083 from wpaulino/events-module

Move events.rs into its own top-level module

Pin `tokio` to fix CI

Recently `tokio` got updated to 1.27.0, which bumped MSRV from 1.49 to
1.56.

Here we pin `tokio` accordingly to unbreak CI.

Remove unnecessary restriction on `esplora-client` version

Move test `bitcoind`/`electrsd` out of `OnceCell`

`OnceCell` doesn't call `drop`, which makes the spawned
`bitcoind`/`electrsd` instances linger around after our tests have
finished. To fix this, we move them out of `OnceCell` and let every test
that needs them spawn their own instances. This additional let us drop
the `OnceCell` dev dependency.