Fix an incorrect assertion in tlv stream encoding

Types must be unique and monotonically increasing (using < instead of <=)

Expose `impl_writeable_tlv_based` macro

Every exported macro needed to have all the macros used inside it:
1- to be exported as well.
2- be called from the `$crate` namespace so it works in other crates.

Some structs in `lightning::util::ser` needed to be made public as they were used inside the exported macros.

Use the macros like this:
```Rust
lightning::impl_writeable_tlv_based!(...)
```

Merge pull request #1812 from valentinewallace/2022-10-chanman-router-param

Parameterize `ChannelManager` by a `Router`

Test utils: allow queueing >2 persistence update results

ser_macros: rename check_tlv_order

.. to disamgibutate from check_encoded_tlv_order

Provide a `static_value` TLV field serialization type

This is useful in the type serialization definition macros to avoid
writing or reading a field at all, simply using a static value on
each reload.

Parameterize Simple*ChannelManager with DefaultRouter and ProbScorer

Take in-flight HTLCs by reference in Router::find_route

Useful in upcoming work when for payment retries.

Implement routing against the netgraph in tests

Merge pull request #1935 from TheBlueMatt/2022-12-no-non-time-panic

Ensure derive_channel_keys doesn't panic if per-run seed is high

Parameterize ChannelManager by a Router trait

This will be used in upcoming work to fetch routes on-the-fly for payment
retries, which will no longer be the responsibility of InvoicePayer.

Ensure the per-channel key derivation counter doesn't role over

Previously, the `derive_channel_keys` derivation ID asserted that
the high bit of the per-channel key derivation counter doesn't
role over as it checked the 31st bit was zero. As we no longer do
that, we should ensure the assertion in `generate_channel_keys_id`
asserts that we don't role over.

Merge pull request #1934 from TheBlueMatt/2022-12-113-bindings-upstream

Trivial Bindings Updates

Merge pull request #1936 from TheBlueMatt/2023-01-in-flight-clone

`#[derive(Clone)]` for `InFlightHtlcs`

`#[derive(Clone)]` for `InFlightHtlcs`

This is useful for bindings, and generally isn't a bad thing for
users to have access to.

Ensure `derive_channel_keys` doesn't panic if per-run seed is high

b04d1b868fe28bea2e4c711e6e6d2470d2b98d77 changed the way we
calculate the `channel_keys_id` to include the 128-bit
`user_channel_id` as well, shifting the counter up four bytes and
the `starting_time_nanos` field up into the second four bytes.

In `derive_channel_keys` we hash the full `channel_keys_id` with an
HD-derived key from our master seed. Previously, that key was
derived with an index of the per-restart counter, re-calculated by
pulling the second four bytes out of the `user_channel_id`. Because
the `channel_keys_id` fields were shifted up four bytes, that is
now a reference to the `starting_time_nanos` value. This should be
fine, the derivation doesn't really add any value here, its all
being hashed anyway, except that derivation IDs must be below 2^31.
This implies that we panic if the user passes a
`starting_time_nanos` which has the high bit set. For those using
the nanosecond part of the current time this isn't an issue - the
value cannot exceed 1_000_000, which does not have the high bit
set, however, some users may use some other per-run seed.

Thus, here we simply drop the high bit from the seed, ensuring we
don't panic. Note that this is backwards compatible as it only
changes the key derivation in cases where we previously panicked.

Ideally we'd drop the derivation entirely, but that would break
backwards compatibility of key derivation.

No-export `&self` methods on non-cloneable enum(s)

Specifically, `OnionMessageContents` is a non-cloneable enum, which
isn't stored opaque so we cannot call `&self` methods on it.
Because its methods aren't critical to the API for now, we simply
no-export them rather than trying to work out an alternative
approach.

Store an owned `Score` in `ScorerAccountingForInFlightHtlcs`

`ScorerAccountingForInFlightHtlcs` generally stores a `Score`
reference generated by calling `LockableScore::lock`, which
actually returns an arbitrary `Score`. Given `Score` is implemented
directly on lock types, it makes sense to simply hold a fully owned
`Score` in `ScorerAccountingForInFlightHtlcs` rather than a mutable
reference to one.

Merge pull request #1929 from valentinewallace/2022-12-outbound-payment-mod-followup

Outbound payment module follow-up

outbound_payment: put method signature closing paren on next line

in long method signatures

Merge pull request #1931 from TheBlueMatt/2022-12-1910-followups

Trivial #1910 Followups

Fix capitalization broken in 9d7bb73b599a7a9d8468a2f0c54d28f0ce6cf5

9d7bb73b599a7a9d8468a2f0c54d28f0ce6cf543 broke some capitalization
in docs for `sign_invoice`, which we fix here as well as taking
this opportunity to clean up the `sign_invoice` docs more
generally.

Clean up use ordering introduced in 9d7bb73b599a7a9d8468a2f0c54d28f

9d7bb73b599a7a9d8468a2f0c54d28f0ce6cf543 moved some code around
unnecessarily, which we fix here.

Fix cfg(test) indentation

Make add_new_pending_payment private to module

And expose it in testing only, for safety

Merge pull request #1928 from valentinewallace/2022-12-fix-main

Fix `main` build

Fix main build

Merge pull request #1910 from arik-so/2022-12-keys-interface-name-split

Split KeysInterface into EntropySource, NodeSigner, and SignerProvider

Merge pull request #1923 from valentinewallace/2022-12-outbound-payment-mod

Abstract `ChannelManager` outbound payment logic

Split out KeysInterface into EntropySource, NodeSigner, and SignerProvider.

Rename send_payment and retry_payment for retries

Once ChannelManager supports payment retries, it will make more sense for its
current send_payment method to be named send_payment_with_route because
retrying should be the default. Here we get a head start on this by making the
rename in outbound_payment, but not changing the public interface yet.

Reduce visibility of outbound payment methods

Start parameters on a newline if they don't fit

Separating out this commit to keep the main refactor move-only

Remove unnecessary mut in finalize_claims

Swap pending_outbound_payments for OutboundPayments struct

This allows us to move a lot of outbound payment logic out of ChannelManager
and into the new outbound_payment module, and helps avoid growing
ChannelManager when we add retry logic to it in upcoming work.

Move PaymentSendFailure into outbound_payment module

And re-export it in channelmanager.rs so it can remain public

Move PendingOutboundPayment to new outbound_payment module

We want to move all outbound payment-related things to this new module, to help
break up ChannelManager so future payment retries work doesn't increase the
size of ChannelManager.

Merge pull request #1922 from wpaulino/avoid-remaining-redundant-commitment-broadcasts

Avoid redundant broadcast of local commitment transaction

Merge pull request #1908 from jkczyz/2022-11-refund

BOLT 12 refund encoding and building

Avoid redundant broadcast of local commitment transaction

This change follows the rationale of commit 62236c7 and addresses the
last remaining redundant local commitment broadcast.

There's no need to broadcast our local commitment transaction if we've
already seen a confirmed one as it'll be immediately rejected as a
duplicate/conflict.

This will also help prevent dispatching spurious events for bumping
commitment and HTLC transactions through anchor outputs since the
dispatch for said events follows the same flow as our usual commitment
broadcast.

Merge pull request #1920 from TheBlueMatt/2022-12-rel-date

Update release date on 0.0.113 in changelog

Merge pull request #1903 from TheBlueMatt/2022-12-1867-followups

Clarify docs on `provide_channel_parameters`

Update release date on 0.0.113 in changelog

Merge pull request #1917 from TheBlueMatt/2022-12-0.0.113

Cut 0.0.113

Bump crate versions to 0.0.113/invoice 0.21

Add release notes for 0.0.113

Fixes #1890

Only do backtrace builds on stable to fix MSRV break in CI

Merge pull request #1918 from TheBlueMatt/2022-12-one-blinded-path

Unify blinding nomenclature to call them "paths" not "routes".

Refund parsing tests

Tests for checking refund semantics when parsing invoice_request bytes
as defined by BOLT 12.

Refund building tests

Tests for checking invoice_request message semantics when building a
refund as defined by BOLT 12.

Builder for creating refunds

Add a builder for creating refunds given a payer_id and other required
fields. Other settings are optional and duplicative settings will
override previous settings. Building produces a semantically valid
`invoice_request` message representing the refund, which then may be
communicated out of band (e.g., via QR code).

Refund parsing from bech32 strings

Implement Bech32Encode for Refund, which supports creating and parsing
QR codes for the merchant-pays-user (i.e., offer for money) flow.

Refund encoding and parsing

Define an interface for BOLT 12 refunds (i.e., an `invoice_request`
message without an `offer_node_id`). A refund is more generally an
"offer for money". While it is encoded using the same TLV streams as an
`invoice_request` message, it has different semantics.

Update references to "blinded route" to "blinded path"

Finishing the work from the previous two commits.

Rename `blinded_route` variables and module to `blinded_path`

Following up on the previous commit, this also renames variables
and the module used to `blinded_path`.

Unify blinding nomenclature to call them "paths" not "routes".

Currently the `onion_message` module exposes the blinded route
object as *both* `BlindedRoute` and `BlindedPath`. This is somewhat
confusing, and given they are really paths, not routes (at least in
the sense that a route could be multi-path, though for OMs they are
not), here we unify to only call them paths.

Remove Option from OfferContents::signing_pubkey

Refunds (i.e., `invoice_request` without an `offer`) will have its own
contents type, so OfferContents::signing_pubkey can be required.

Correct docs on `generate_channel_keys`

03de0598afd032e9fd5dbbaca0aabc6a367ce4f5 appeared to revert updated
docs due to a rebase error. This reverts the docs on
`generate_channel_keys` to the state they were in prior to that
commit, with one additional doc.

Clarify docs on `provide_channel_parameters`

Its very confusing to say that LDK will call
`provide_channel_parameters` more than once - its true for a
channel, but not for a given instance. Instead, phrase the docs
with reference to a specific instance, which is much clearer.

Merge pull request #1915 from TheBlueMatt/2022-12-jit-reload-consistency

Drop forwarded HTLCs which were still pending at persist-time

Drop forwarded HTLCs which were still pending at persist-time

If, after forwarding an intercepted payment to our counterparty, we
restart with a ChannelMonitor update having been persisted, but the
corresponding ChannelManager update not having been persisted,
we'll still have the intercepted HTLC in the
`pending_intercepted_htlcs` map on start (and potentially a pending
`HTLCIntercepted` event). This will cause us to allow the user to
handle the forwarded HTLC twice, potentially double-forwarding it.

This builds on 0bb87ddad71d2e33199ebad79e9f709f869f2130, which
provided a preemptive fix for the general relay case (though it was
not an actual issue at the time). We simply check for the HTLCs
having been forwarded on startup and remove them from the map.

Fixes #1858

Remove unused fetch in `lightning_invoice` tests.

Merge pull request #1894 from ssbright/2022-12-custom_payment_hash

Add invoice constructor with custom payment hash

Merge pull request #1900 from tnull/2022-12-improve-confirm-docs

Improve `Confirm` docs

Merge pull request #1892 from tnull/2022-12-spendableoutputdescriptor-doccs

Clean up docs in `keysinterface.rs`

Merge pull request #1907 from TheBlueMatt/2022-12-abandon-crash-reset

Note that abandon_payment does not persist the state update in docs

Add invoice constructor with custom payment hash

Improve `Confirm` docs

Clean up docs in `keysinterface.rs`

Note that abandon_payment does not persist the state update in docs

If a user calls `abandon_payment`, then restarts without freshly
persisting the `ChannelManager`, the payment will still be pending
on restart. This was unclear from the docs (and the docs seemed to
imply otherwise). Because this doesn't materially impact the
usability of `abandon_payment` (users shouldn't be called
`retry_payment` on an abandoned one anyway), we simply document it.

Fixes #1804.

Merge pull request #1904 from TheBlueMatt/2022-12-1825-followups

Trivial Followups to #1825

Merge pull request #1738 from jkczyz/2022-09-invoice-request

BOLT 12 `invoice_request` encoding and building

Merge pull request #1906 from wpaulino/prevent-downgrade-from-anchors

Use even types for opt_anchors

Merge pull request #1886 from TheBlueMatt/2022-11-claim-relock

Relock `channel_state` in for each HTLC in `claim_funds` and lay the groundwork for async event generation

Check entire TLV stream instead of by field

This causes a compilation error if a new field is added but missed in
the tests.

Add BOLT 12 merkle root test for `invoice_request`

A BOLT 12 test vector uses an `invoice_request` message that has a
currency, which aren't supported, so using OfferBuilder::build_unchecked
is required to avoid a panic.

Invoice request parsing tests

Tests for checking invoice_request message semantics when parsing bytes
as defined by BOLT 12.

Invoice request building tests

Tests for checking invoice_request message semantics when building as
defined by BOLT 12.

Builder for creating invoice requests

Add a builder for creating invoice requests for an offer given a
payer_id. Other settings may be optional depending on the offer and
duplicative settings will override previous settings. Building produces
a semantically valid `invoice_request` message for the offer, which then
can be signed for the payer_id.

Invoice request raw byte encoding and decoding

When reading an offer, an `invoice_request` message is sent over the
wire. Implement Writeable for encoding the message and TryFrom for
decoding it by defining in terms of TLV streams. These streams represent
content for the payer metadata (0), reflected `offer` (1-79),
`invoice_request` (80-159), and signature (240).

Merkle root hash computation

Offers uses a merkle root hash construction for signature calculation
and verification. Add a submodule implementing this so that it can be
used when parsing and signing invoice_request and invoice messages.

Schnorr Signature serialization

BOLT 12 uses Schnorr signatures for signing offers messages, which need
to be serialized.

Invoice request message interface and data format

Define an interface for BOLT 12 `invoice_request` messages. The
underlying format consists of the original bytes and the parsed
contents.

The bytes are later needed when constructing an `invoice` message. This
is because it must mirror all the `offer` and `invoice_request` TLV
records, including unknown ones, which aren't represented in the
contents.

The contents will be used in `invoice` messages to avoid duplication.
Some fields while required in a typical user-pays-merchant flow may not
be necessary in the merchant-pays-user flow (e.g., refund, ATM).

Add second TODO when claiming to mirror the existing TODO on claim fail

Drop unused link in `claim_funds`

Drop now-unused `ClaimFundsFromHop` enum and replace with an `Err`

Handle claim result event generation in claim_funds_from_hop

Currently `claim_funds` and `claim_funds_internal` call
`claim_funds_from_hop` and then surface and `Event` to the user
informing them of the forwarded/claimed payment based on it's
result. In both places we assume that a claim "completed" even if
a monitor update is being done async.

Instead, here we push that event generation through a
`MonitorUpdateCompletionAction` and a call to
`handle_monitor_update_completion_action`. This will allow us to
hold the event(s) until async monitor updates complete in the
future.

Don't hold `channel_state` lock for entire duration of claim_funds

When `claim_funds` has to claim multiple HTLCs as a part of a
single MPP payment, it currently does so holding the
`channel_state` lock for the entire duration of the claim loop.
Here we swap that for taking the lock once for each HTLC. This
allows us to be more flexible with locks going forward, and
ultimately isn't a huge change - if our counterparty intends to
force-close a channel, us choosing to ignore it by holding the
`channel_state` lock for the duration of the claim isn't going to
result in a commitment update, it will just result in the preimage
already being in the `ChannelMonitor`.

Handle closed-chan HTLC claims in `claim_funds_from_hop`

Currently `claim_funds` does all HTLC claims in one `channel_state`
lock, ensuring that we always make claims from channels which are
open. It can thus avoid ever having to generate a
`ChannelMonitorUpdate` containing a preimage for a closed channel,
which we only do in `claim_funds_internal` (for forwarded payments).

In the next commit we'll change the locking of
`claim_funds_from_hop` so that `claim_funds` is no longer under a
single lock but takes a lock for each claim. This allows us to be
more flexible with locks going forward, and ultimately isn't a huge
change - if our counterparty intends to force-close a channel, us
choosing to ignore it by holding the `channel_state` lock for the
duration of the claim isn't going to result in a commitment update,
it will just result in the preimage already being in the
`ChannelMonitor`.

Add support for handling "actions" after a monitor update completes

This adds a new enum, `MonitorUpdateCompletionAction` and a method
to execute the "actions". They are intended to be done once a
(potentially-async) `ChannelMonitorUpdate` persistence completes,
however this behavior will be implemented in a future PR. For now,
this adds the relevant infrastructure which will allow us to
prepare `claim_funds` for better monitor async handling.

Store pending claims awaiting monitor update in a separate map

In the next commits we'll move to generating `PaymentClaimed`
events while handling `ChannelMonitorUpdate`s rather than directly
in line. Thus, as a prerequisite, here we move to storing the info
required to generate the `PaymentClaimed` event in a separate map.

Note that while this does introduce a new map which is written as
an even value which users cannot opt out of, the map is only filled
in when users use the asynchronous `ChannelMonitor` updates and
after a future PR. As these are still considered beta, breaking
downgrades for such users is considered acceptable in the future PR
(which will likely be one LDK version later).

Slightly clarify comment on safety of only processing HTLCs once

Ensure `Event::BumpTransaction` is forwards-compatible

`Event`s with an odd type are ignored by older versions of LDK,
however they rely on the `write_tlv_fields` call to know how many
bytes to read and discard. We were missing that call in our writing
of `Event::BumpTransaction`, which we add here.

Use `Witness::push_bitcoin_signature` where relevant

Drop excess mut on `OnchainTxHandler::generate_external_htlc_claim`

DRY the comparison blocks in `update_claims_view_from_matched_txn`

In `update_claims_view_from_matched_txn` we have two different
tx-equivalence checks which do the same thing - both check that the
tx which appeared on chain spent all of the outpoints which we
intended to spend in a given package. While one is more effecient
than the other (but only usable in a subset of cases), the
difference between O(N) and O(N^2) when N is 1-5 is trivial.

Still, it is possible we hit this code with just shy of 900 HTLC
outputs in a channel, and a transaction with a ton of inputs.

While having to spin through a few million entries if our
counterparty wastes a full block isn't really a big deal, we go
ahead and use a sorted vec and binary searches because its trivial.

Use `PackageId` rather than `Txid` in `OnchainEvent::Claim`

In 19daccf7fb5ea81c8d235c1628a91efe0aa07b96, a `PackageId` type was
added to differentiate between an opaque Id for packages and the
`Txid` type which was being used for that purpose. It, however,
failed to also replace the single inner field in
`OnchainEvent::Claim` which was also a package ID. We do so here.

Use even types for opt_anchors

This prevents downgrading to older versions of LDK that are not capable
of supporting anchor channels when the field is serialized (i.e.,
opt_anchors is `Some`).

Merge pull request #1863 from TheBlueMatt/2022-11-holding-cell-batch-update

Lean on the holding cell when batch-forwarding/failing HTLCs

Merge pull request #1825 from wpaulino/anchors-bump-htlc-resolution-event

Introduce new BumpTransactionEvent variant HTLCResolution