Fix future unknown `Event` variant backwards compatibility

In 8ffc2d1742ff1171a87b0410b21cbbd557ff8247, in 0.0.100, we added
a backwards compatibility feature to the reading of `Event`s - if
the type was unknown and odd, we'd simply ignore the event and
treat it as no event. However, we failed to read the
length-prefixed TLV stream when doing so, resulting in us reading
some of the skipped-event data as the next event or other data in
the ChannelManager.

We fix this by reading the varint length prefix written, then
skipping that many bytes when we come across an unknown odd event
type.

Merge pull request #997 from ariard/2021-07-add-chan-closed

Add Event::ChannelClosed generation

Add `pending_events` deadlock detection in `handle_error`

Add ChannelClosed generation at cooperative/force-close/error processing

When we detect a channel `is_shutdown()` or call on it
`force_shutdown()`, we notify the user with a Event::ChannelClosed
informing about the id and closure reason.

Extend MsgHandleErrInternal with a new chan_id field Option<[u8; 32]>

This field is used in next commit to generate appropriate
ChannelClosed event at `handle_error()` processing.

Rename MonitorEvent::CommitmentTxBroadcasted to CommitmentTxConfirmed

Add Event::ChannelClosed generation at channel shutdown

Merge pull request #1082 from vss96/process_events_docs

Update docs to specify where PeerManager::process_events is called

Merge pull request #1063 from galderz/t_total_fee_999

Add method to count total fees in a Route #999

Update docs to specify where process events is called

Add methods to count total fees and total amount in a Route #999

* Added `get_total_fees` method to route,
to calculate all the fees paid accross each path.
* Added `get_total_amount` method to route,
to calculate the total of actual amounts paid in each path.

Merge pull request #1068 from TheBlueMatt/2021-09-ser-cleanup

Simplify Message Serialization and Parse TLV Suffix

Convert most P2P msg serialization to a new macro with TLV suffixes

The network serialization format for all messages was changed some
time ago to include a TLV suffix for all messages, however we never
bothered to implement it as there isn't a lot of use validating a
TLV stream with nothing to do with it. However, messages are
increasingly utilizing the TLV suffix feature, and there are some
compatibility concerns with messages written as a part of other
structs having their format changed (see previous commit).

Thus, here we go ahead and convert most message serialization to a
new macro which includes a TLV suffix after a series of fields,
simplifying several serialization implementations in the process.

Add forward-compat due serialization variants of HTLCFailureMsg

Going forward, all lightning messages have a TLV stream suffix,
allowing new fields to be added as needed. In the P2P protocol,
messages have an explicit length, so there is no implied length in
the TLV stream itself. HTLCFailureMsg enum variants have messages
in them, but without a size prefix or any explicit end. Thus, if a
HTLCFailureMsg is read as a part of a ChannelManager, with a TLV
stream at the end, there is no way to differentiate between the end
of the message and the next field(s) in the ChannelManager.

Here we add two new variant values for HTLCFailureMsg variants in
the read path, allowing us to switch to the new values if/when we
add new TLV fields in UpdateFailHTLC or UpdateFailMalformedHTLC so
that older versions can still read the new TLV fields.

[fuzz] Swap mode on most messages to account for TLV suffix

Drop writer size hinting/message vec preallocation

In order to avoid significant malloc traffic, messages previously
explicitly stated their serialized length allowing for Vec
preallocation during the message serialization pipeline. This added
some amount of complexity in the serialization code, but did avoid
some realloc() calls.

Instead, here, we drop all the complexity in favor of a fixed 2KiB
buffer for all message serialization. This should not only be
simpler with a similar reduction in realloc() traffic, but also
may reduce heap fragmentation by allocating identically-sized
buffers more often.

Merge pull request #1053 from valentinewallace/2021-08-dedup-payment-sent

Deduplicate PaymentSent events for MPP payments

Add all_paths_failed field to PaymentFailed

see field docs for details

Prevent duplicate PaymentSent events

by removing all pending outbound payments associated with the same
MPP payment after the preimage is received

Add MPP ID to pending_outbound_htlcs

We'll use this to correlate MPP shards in upcoming commits

Implement Readable/Writeable for HashSet

To be used in upcoming commits for MPP ID storage

Add MppId field to HTLCSource as a way to correlate mpp payment paths

test utils: refactor fail_payment_along_route for mpp

Merge pull request #1070 from TheBlueMatt/2021-09-fix-bindings-ignore

Move CounterpartyForwardingInfo from channel to channelmanager

Merge pull request #1066 from valentinewallace/2021-08-fix-double-temp-failure

Allow multiple calls to `monitor_update_failed`

Allow multiple monitor_update_failed calls

without requiring calls to channel_monitor_updated in between.

Found by the fuzzer

Update fuzz README with latest instructions

Merge pull request #1074 from p2pderivatives/add-node-id-to-custom-msg-cb

Add node id to custom message callback

Merge pull request #1034 from TheBlueMatt/2021-07-maturing-claims

Expose in-flight claim balances

Merge pull request #1043 from jkczyz/2021-07-network-update-handler

Handle network updates from failed payments in BackgroundProcessor

Expand `ANTI_REORG_DELAY` docs to say its a library-wide assumption

Add an accessor to `ChainMonitor` to get the claimable balances

The common user desire is to get the set of claimable balances for
all non-closed channels. In order to do so, they really want to
just ask their `ChainMonitor` for the set of balances, which they
can do here by passing the `ChannelManager::list_channels` output
to `ChainMonitor::get_claimable_balances`.

Expose the amount of funds available for claim in ChannelMonitor

In general, we should always allow users to query for how much is
currently in-flight being claimed on-chain at any time.

This does so by examining the confirmed claims on-chain and
breaking down what is left to be claimed into a new
`ClaimableBalance` enum.

Fixes #995.

Fix indentation in ChannelMonitor

Track how our HTLCs are resolved on-chain persistently

This tracks how any HTLC outputs in broadcast commitment
transactions are resolved on-chain, storing the result of the HTLC
resolution persistently in the ChannelMonitor.

This can be used to determine which outputs may still be available
for claiming on-chain.

Track the tx which spends our funding output in ChannelMonitor

This allows us to easily look up how our channel was closed and
track which balances may be spendable on-chain.

Rename CounterpartyCommitmentTransaction to Params as it is static

Drop unused CounterpartyCommitmentTransaction::per_htlc HashMap

Store to-self value in the current commitment tx in ChannelMonitor

Update NetworkGraph in BackgroundProcessor

Decorate the user-supplied EventHandler with NetGraphMsgHandler in
the BackgroundProcessor. The resulting handler will intercept
PaymentFailed events in order to update the NetworkGraph in the
background before delegating to the user's event handler.

Expand and format BackgroundProcessor docs

EventHandler for applying NetworkUpdate

PaymentFailed events contain an optional NetworkUpdate describing
changes to the NetworkGraph as conveyed by a node along a failed payment
path according to BOLT 4. An EventHandler should apply the update to the
graph so that future routing decisions can account for it.

Implement EventHandler for NetGraphMsgHandler to update NetworkGraph.
Previously, NetGraphMsgHandler::handle_htlc_fail_channel_update
implemented this behavior.

Refactor PaymentFailureNetworkUpdate event

MessageSendEvent::PaymentFailureNetworkUpdate served as a hack to pass
an HTLCFailChannelUpdate from ChannelManager to NetGraphMsgHandler via
PeerManager. Instead, remove the event entirely and move the contained
data (renamed NetworkUpdate) to Event::PaymentFailed to be processed by
an event handler.

Add node id to custom message callback

Move CounterpartyForwardingInfo from channel to channelmanager

CounterpartyForwardingInfo is public (previously exposed with a
`pub use`), and used inside of ChannelCounterparty in
channelmanager.rs. However, it is defined in channel.rs, away from
where it is used.

This would be fine, except that the bindings generator is somewhat
confused by this - it doesn't currently support interpreting
`pub use` as a struct to expose, instead ignoring it.

Fixes https://github.com/lightningdevkit/ldk-garbagecollected/issues/44

Merge pull request #1072 from TheBlueMatt/2021-09-tighter-max_fee-constant

Reduce our stated max closing-transaction fee to be the true value

Merge pull request #1073 from gilescope/less-deps

Not needed now. We refer to std::futures.

Fail with PERM|8 (permanent_channel_failure)

This affects the htlc_fail_async_shutdown test.

Remove test_invalid_channel_announcement

It doesn't seem to be testing anything useful that isn't covered
elsewhere.

Add a read-only view of NetworkGraph

Hide the internal locking of NetworkGraph by providing a read-only
view. This way the locking order is handled internally.

Remove RwLock from around NetworkGraph

Now that NetworkGraph uses interior mutability, the RwLock used around
it in NetGraphMsgHandler is no longer needed. This allows for shared
ownership without a lock.

Individually lock NetworkGraph fields

In preparation for giving NetworkGraph shared ownership, wrap individual
fields in RwLock. This allows removing the outer RwLock used in
NetGraphMsgHandler.

Pass Event by reference to EventHandler

Passing an Event by reference rather and by move gives more flexibility
for composing event handlers without needing to clone events.

Reduce our stated max closing-transaction fee to be the true value

When communicating the maximum fee we're willing to accept on a
cooperative closing transaction to our peer, we currently tell them
we'll accept `u64::max_value()` if they're the ones who have to pay
it. Spec-wise this is fine - they aren't allowed to try to claim
our balance, and we don't care how much of their own funds they
want to spend on transaction fees.

However, the Eclair folks prefer to check all values on the wire
do not exceed 21 million BTC, which seems like generally good
practice to avoid overflows and such issues. Thus, our close
messages are rejected by Eclair.

Here we simply relax our stated maximum to be the real value - our
counterparty's current balance in satoshis.

Fixes #1071

Merge pull request #1064 from lightning-signer/2021-08-closing-tx-phase2

Use ClosingTransaction in BaseSign

Introduce ClosingTransaction

Merge pull request #1047 from TheBlueMatt/2021-08-985-followups

Add further comments around fee update handling in channel

These were suggested to clarify behavior in post-merge review of #985.

Update docs for pending_update_fee and holding_cell_update_fee

The docs were left stale after the logic was updated in #985 as
pointed out in post-merge review.

Factor out low-level build_closing_transaction

Merge pull request #1055 from lightning-signer/2021-08-anchor-tx

Add anchor outputs pair in CommitmentTransaction

The anchor ouputs pair is added if there are pending HTLCs. Or a
a per-party anchor is added if the party has a pending balance.

Merge pull request #1057 from TheBlueMatt/2021-08-invoice-fails

Fix and modernize lightning-invoice API

Require payment secrets when building and reading invoices

Use new BOLT 11 test vectors with payment_secrets and feature flags

This pulls the BOLT 11 test vectors from
https://github.com/lightningnetwork/lightning-rfc/pull/898,
tweaking our tests to properly handle them.

[invoice] Ignore InvalidLength fields

BOLT 11 states that a reader "MUST skip over...`p`, `h`, `s` or `n`
fields that do NOT have data_lengths of 52, 52, 52 or 53,
respectively." Here we do so by simply ignoring any invalid-length
field.

Implement core::hash::Hash more incl invoice::RawTaggedField

Check if invoices contain unknown required features

This adds the final missing BOLT 11 failure test, checking for
unknown required feature flags before accepting an invoice.

Convert the invoice creation API to millisats and req it for parse

The BOLT 11 invalid invoice test vectors suggest failing to parse
invoices which have an amount which is not a whole number of
millisatoshis. lightning-invoice, however, happily parses such
invoices. While we could continue to parse them, failing them makes
for one less check on the user code side, so we might as well.

In order to keep the invoice creation less likely to fail, we also
switch the Builder amount-setting function to use millisatoshis.

[invoice] Fix non-recoverable sig handling and bogus SI prefix err

This adds two additional tests from the BOLT 11 invalid invoice
tests, fixing the two errors that broke them. It fixes a panic on
the "nonrecoverable signature" test and makes the error variant
more sensible on the bogus SI prefix test.

[invoice] Add the BOLT 11 failure unit tests that we already pass

Merge pull request #1040 from abhik-99/Issue#945

Multi-Hop Route Hint now considered. Added in unit tests for same.

Multi-Hop Route Hint as per Bolt 12 now considered

Bolt 12 details the process of picking up route hints from payee
using the lightning invoice. This PR brings the changes to use
multiple route hints from payee picked from the invoice.

The route hints are processed in the following manner:-
 - `get_route()` receives the hints in `last_hops`.
 - Every `RouteHintHop` in `RouteHint` is processed based on
   feasiblity of channel capacity and fees.
 - If a `RouteHintHop` then preceeding `RouteHintHop`s are not
   processed.
 - A direct route is checked from `first_hops_targets` to the
   first `RouteHintHop` if the respective `RouteHint` is
   processed from the payee's end till the first `RouteHintHop`.

`partial_route_hint_test`, `ignores_empty_last_hops_test`,
`multi_hint_last_hops_test` and `last_hops_with_public_channel_test`
test usage of partial route hints for building optimal route,
processing empty route hint hops, complete usage of private route
hints and presence of public channels in route hints respectively.

Resolves: #945

Merge pull request #1039 from lightning-signer/2021-08-more-enforcement

Introduce EnforcementState, validate release of revocation secret

Add get_anchor_script

This is a script builder to generate anchor output ones. They can be
satisfied either by a signature for the committed funding pubkey or anyone
after CSV delay expiration.

This is used at anchor output addition while generating commitment transaction.

Allow BaseSign validation functions to return an Err

Improve documentation for validate_holder_commitment and sign_counterparty_commitment

Always use KeysInterface.read_chan_signer for de-serializing EnforcingSigner in tests

Enforce signing counterparty commitment only after revocation

Enforce that revocation can only occur after we validated a new commitment

Introduce EnforcementState for EnforcingSigner

as we add more enforcement state variables, we want to keep track of them under a single structure

Merge pull request #1060 from JosephGoulden/function_test_utils_logs

tests: use origin node logger instead of creating new TestLogger

Remove DynamicOutputP2WPKH ref in logger

Merge pull request #1031 from p2pderivatives/dlc-version-generic

Dlc version generic

Remove wire::MessageType in favor of u16

With custom messages, wire::Type was introduced. wire::MessageType is a
bit redundant, so use u16 instead and move is_even to wire::Message.

Add custom message handler to peer manager

Merge pull request #1037 from sr-gi/add-txid-convert

Adds Txid to lighting-block-sync::convert

Don't initialise Vecs being read with VecReadWrapper explicitly

This simplifies the tlv serialization read macro somewhat by
allowing callsites to simply read into an `Option<Vec>` instead of
needing to read into an `Option<VecReadWrapper>` when using
`vec_type`.

tests: use origin node logger instead of creating new TestLogger in functional_test_utils

Adds Txid to lighting-block-sync::convert

[invoice] Update doctest example invoices to real LDK invoices

This swaps out our doctest example invoices for real LDK-generated
invoices on a real LDK node.

Merge pull request #1051 from JosephGoulden/fix_ping_disconnect

fix: peer is disconnected for not responding to ping

test: increase ping timeout when running in debug mode

Merge pull request #1049 from TheBlueMatt/2021-08-nightly-warnings

Fix trailing semicolon warnings on latest rustc nightly

Fix trailing semicolon warnings on latest rustc nightly

Latest rustc nightly compiles are filled with warnings like the
following, which we fix here:

```
warning: trailing semicolon in macro used in expression position
   --> lightning/src/util/macro_logger.rs:163:114
    |
163 |         $logger.log(&$crate::util::logger::Record::new($lvl, format_args!($($arg)+), module_path!(), file!(), line!()));
    |                                                                                                                        ^
    |
   ::: lightning/src/chain/chainmonitor.rs:165:9
    |
165 |         log_debug!(self.logger, "New best block {} at height {} provided via block_connected", header.block_hash(), height);
    |         -------------------------------------------------------------------------------------------------------------------- in this macro invocation
    |
    = note: `#[warn(semicolon_in_expressions_from_macros)]` on by default
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #79813 <https://github.com/rust-lang/rust/issues/79813>
    = note: this warning originates in the macro `log_internal` (in Nightly builds, run with -Z macro-backtrace for more info)
```

Merge pull request #1048 from TheBlueMatt/2021-08-no-net-print

Remove explicit print in lightning-net-tokio, reduce redundant block connection logging

Clarify docs on ShutdownScript::new_witness_program somewhat

This is especially important for C or other language bindings
clients as the `version` field may be exported as a `u8`.

Log chain calls in ChainMonitor, reducing logs in ChannelMonitor

For users with many ChannelMonitors, we log a large volume per
block simply because each ChannelMonitor lots several times per
block. Instead, we move to log only once at the TRACE level per
block call in ChannelMonitors, relying instead on a DEBUG level
log in ChainMonitor before we call any ChannelMonitor functions.

For most users, this will reduce redundant logging and also log at
the DEBUG level for block events, which is appropriate.

Fixes #980.