Be less aggressive in outbound HTLC CLTV timeout checks

We currently assume our counterparty is naive and misconfigured and
may force-close a channel to get an HTLC we just forwarded them.

There shouldn't be any reason to do this - we don't have any such
bug, and we shouldn't start by assuming our counterparties are
buggy. Worse, this results in refusing to forward payments today,
failing HTLCs for largely no reason.

Instead, we keep a fairly conservative check, but not one which
will fail HTLC forwarding spuriously - testing only that the HTLC
doesn't expire for a few blocks from now.

Fixes #1114.

Merge pull request #1077 from jkczyz/2021-09-failing-route-hop

Include short channel id in PaymentPathFailed

Add failing short channel id to PaymentPathFailed

This will be useful for scoring channels when a payment fails.

Merge pull request #1116 from TheBlueMatt/2021-10-test-local-chan-routing

Use local channel state when constructing routes in test macro  + Fix compile-warning

Fix loop label shadowing warning

Use local channel state when constructing routes in test macro

This is a bit more realistic and needed to route over non-public
channels.

Clean up fee_insufficient computation

Merge pull request #1098 from 1nF0rmed/2021-09-adds-discard-funding-event

Add Event::DiscardFunding generation

Adds DiscardFunding event

During the event of a channel close, if the funding transaction
is yet to be broadcasted then a DiscardFunding event is issued
along with the ChannelClose event.

Merge pull request #1107 from dunxen/2021-10-swap-pubkey-for-bytearray

Replace PublicKey with [u8; 33] in NetworkGraph

Merge pull request #1062 from galderz/t_payment_hash_999

Replace PublicKey with [u8; 33] in NetworkGraph

Add payment_hash to PaymentSent #999

Merge pull request #1109 from TheBlueMatt/2021-10-init-fail-payment-retry-leak

Move pending payment tracking to after the new HTLC flies

Correct error returned when `retry_payment` doesn't have a payment

Move pending payment tracking to after the new HTLC flies

If we attempt to send a payment, but the HTLC cannot be send due to
local channel limits, we'll provide the user an error but end up
with an entry in our pending payment map. This will result in a
memory leak as we'll never reclaim the pending payment map entry.

Pass hop index in construct_onion_keys_callback

This simplifies failing route hop calculation, which will be useful for
later identifying the failing hop for PaymentFailed events.

Remove special case for onion error expiry_too_far

With channel scoring and payment retries, it is no longer necessary to
have expiry_too_far imply a payment failure.

Merge pull request #1079 from TheBlueMatt/2021-09-stale-docs

Update Event::PaymentReceived docs since we require payment secret

Update Event::PaymentReceived docs since we require payment secret

Users no longer need to verify the amounts of received payments as
the payment secret will protect us against the probing attacks such
verification was intended to fix.

Move tests of payment retries into a new module

Merge pull request #1100 from TheBlueMatt/2021-09-multihop-route-hint-fix

Consider many first-hop paths to the same counterparty in routing

Merge pull request #1096 from valentinewallace/2021-09-mpp-retries

Expire outbound payments after 3 blocks if no parts are pending

Don't remove failed payments when all paths fail

This is because we want the ability to retry completely failed
payments.

Upcoming commits will remove these payments on timeout to prevent
DoS issues

Also test that this removal allows retrying single-path payments

Add method to retry payments

Merge pull request #1080 from valentinewallace/2021-09-dup-chan-outpoint

Fix fuzzer-found panic from duplicate channel outpoint

f readability improvements from val

Merge pull request #1076 from TheBlueMatt/2021-09-forwardable-regen

Regenerate PendingHTLCsForwardable on reload instead of serializing

When we are prepared to forward HTLCs, we generate a
PendingHTLCsForwardable event with a time in the future when the
user should tell us to forward. This provides some basic batching
of forward events, improving privacy slightly.

After we generate the event, we expect users to spawn a timer in
the background and let us know when it finishes. However, if the
user shuts down before the timer fires, the user will restart and
have no idea that HTLCs are waiting to be forwarded/received.

To fix this, instead of serializing PendingHTLCsForwardable events
to disk while they're pending (before the user starts the timer),
we simply regenerate them when a ChannelManager is deserialized
with HTLCs pending.

Fixes #1042

Consider many first-hop paths to the same counterparty in routing

Previously we'd simply overwritten "the" first hop path to each
counterparty when routing, however this results in us ignoring all
channels except the last one in the `ChannelDetails` list per
counterparty.

Correct step number in `get_route`

channelmanager: Add retry data to pending_outbound_payments

Refactor send_payment internals for retries 2

Retrying a partial payment means send_payment_internal needs to be parameterized
by a total payment amount, else 'HTLC values do not match' errors

Refactor send_payment internals for retries

We want to reuse send_payment internal functions for retries,
so some need to now be parameterized by PaymentId to avoid
generating a new PaymentId on retry

Return PaymentId from send_*payment functions

Used in upcoming commits for retries

Rename MppId to PaymentId

Leftover from previous PR Jeff feedback.

Useful in upcoming commits as we'll expose this to users for payment retries

Merge pull request #1065 from TheBlueMatt/2021-08-bump-dust

Increase our default/minimum dust limit and decrease our max

Rename MIN_DUST_LIMIT_SATOSHIS constant to disambiguate chan vs P2P

While channel and P2P network dust limits are related, they're
ultimately two different things, and thus their constant names
should reference that.

Force-close channels if closing transactions may be non-standard

If a counterparty (or an old channel of ours) uses a non-segwit
script for their cooperative close payout, they may include an
output which is unbroadcastable due to not meeting the network dust
limit.

Here we check for this condition, force-closing the channel instead
if we find an output in the closing transaction which does not meet
the limit.

Require user cooperative close payout scripts to be Segwit

There is little reason for users to be paying out to non-Segwit
scripts when closing channels at this point. Given we will soon, in
rare cases, force-close during shutdown when a counterparty closes
to a non-Segwit script, we should also require it of our own users.

Reduce the maximum allowed counterparty dust limit to 546 sat/vbyte

546 sat/vbyte is the current default dust limit on most
implementations, matching the network dust limit for P2SH outputs.
Implementations don't currently appear to send any larger dust
limits, and allowing a larger dust limit implies higher payment
failure risk, so we'd like to be as tight as we can here.

Merge pull request #1097 from TheBlueMatt/2021-09-clonable-netgraph

Make `NetworkGraph` Clone-able again

Make `NetworkGraph` Clone-able again

There isn't a lot of user-utility for cloning `NetworkGraph`
directly (its a rather large struct, and there probably isn't a lot
of reason to have *multiple* `NetworkGraph`s). Thus, when locks
were pushed down into it, the `Clone`-ability of it was dropped as
well.

Sadly, mapping the Java memory model onto:
 * `Read`-ing a `NetworkGraph`, creating a Java-owned
   `NetworkGraph` object that the JVM will destruct for us,
 * Passing it to a `NetGraphMsgHandler`, which now expects to own
   the `NetworkGraph`, including destructing it,
isn't really practical without adding a clone in between.

Given this, and the fact that there's nothing inherently wrong with
clone-ing a `NetworkGraph`, we simply re-add `Clone` here.

Merge pull request #1095 from TheBlueMatt/2021-09-0.0.101

Bump Crate versions to 0.0.101 (and invoice to 0.9)

Bump Crate versions to 0.0.101 (and invoice to 0.9)

Merge pull request #1085 from TheBlueMatt/2021-09-0.0.101

Cut 0.0.101

Update CHANGELOG for 0.0.101

Merge pull request #1094 from TheBlueMatt/2021-09-type-explicit-bounds

Use Infallible for the unconstructable default custom message type

Make method time on trait impl explitit to help bindings generator

Associated types in C bindings is somewhat of a misnomer - we
concretize each trait to a single struct. Thus, different trait
implementations must still have the same type, which defeats the
point of associated types.

In this particular case, however, we can reasonably special-case
the `Infallible` type, as an instance of it existing implies
something has gone horribly wrong.

In order to help our bindings code figure out how to do so when
referencing a parent trait's associated type, we specify the
explicit type in the implementation method signature.

Drop redundant generic bounds when the trait requires the bounds

Use Infallible for the unconstructable default custom message type

When we landed custom messages, we used the empty tuple for the
custom message type for `IgnoringMessageHandler`. This was fine,
except that we also implemented `Writeable` to panic when writing
a `()`. Later, we added support for anchor output construction in
CommitmentTransaction, signified by setting a field to `Some(())`,
which is serialized as-is.

This causes us to panic when writing a `CommitmentTransaction`
with `opt_anchors` set. Note that we never set it inside of LDK,
but downstream users may.

Instead, we implement `Writeable` to write nothing for `()` and use
`core::convert::Infallible` for the default custom message type as
it is, appropriately, unconstructable.

This also makes it easier to implement various things in bindings,
as we can always assume `Infallible`-conversion logic is
unreachable.

Merge pull request #1093 from TheBlueMatt/2021-09-type-explicit-bounds

Make `ChainMonitor::get_claimable_balances` take a slice of refs

Make `ChainMonitor::get_claimable_balances` take a slice of refs

For the same reason as `get_route`, a slice of objects isn't
practical to map to bindings - the objects in the bindings space
are structs with a pointer and some additional metadata. Thus, to
create a slice of them, we'd need to take ownership of the objects
behind the pointer, place them into a slace, and then restore them
to the pointer.

This would be a lot of memory copying and marshalling, not to
mention wouldn't be thread-safe, which the same function otherwise
would be if we used a slice of references instead of a slice of
objects.

Merge pull request #1092 from TheBlueMatt/2021-09-type-explicit-bounds

Move trait bounds on `wire::Type` from use to the trait itself

Move trait bounds on `wire::Type` from use to the trait itself

`wire::Type` is only (publicly) used as the `CustomMessage`
associated type in `CustomMessageReader`, where it has additional
trait bounds on `Debug` and `Writeable`. The documentation for
`Type` even mentions that you need to implement `Writeable` because
this is the one place it is used.

To make this more clear, we move the type bounds onto the trait
itself and not on the associated type.

This is also the only practical way to build C bindings for `Type`
as we cannot have a concrete, single, `Type` struct in C which only
optionally implements various subtraits, at least not without
runtime checking of the type bounds.

Merge pull request #1091 from TheBlueMatt/2021-09-997-winblowz

Fix windows-only test failure added in #997

Merge pull request #1084 from valentinewallace/2021-09-rename-paymentfailed

Rename Event PaymentFailed -> PaymentPathFailed

Merge pull request #1061 from sr-gi/add-transaction-convert

Adds Transaction to lighting-block-sync::convert

Merge pull request #1088 from TheBlueMatt/2021-09-1063-fixups

Fix a panic in Route's new fee-calculation methods and clean up

Add path field to PaymentPathFailed event

Rename PaymentFailed -> PaymentPathFailed

Since we don't want to imply to users that a payment has
completely failed when it really has just partially
failed

Merge pull request #1087 from TheBlueMatt/2021-09-event-backwards-compat-fix

Fix future unknown `Event` variant backwards compatibility

Fix windows-only test failure added in #997

This is a trivial bugfix to add a missing test updated required in
PR 997.

Merge pull request #1090 from TheBlueMatt/2021-09-absurd-timeouts

Bump HTTP read timeout to match reality of Bitcoin Core blocking

Adds Transaction to lighting-block-sync::convert

Includes disclaimer in docs, see https://github.com/rust-bitcoin/rust-lightning/pull/1061#issuecomment-911960862

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

Bump HTTP read timeout to match reality of Bitcoin Core blocking

Fix a panic in Route's new fee-calculation methods and clean up

This addresses Val's feedback on the new Route fee- and
amount-calculation methods, including fixing the panic she
identified and cleaning up various docs and comments.

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

Increase our default/minimum dust limit to 354 sat/vbytes

330 sat/vbyte, the current value, is not sufficient to ensure a
future segwit script longer than 32 bytes meets the dust limit if
used for a shutdown script. Thus, we can either check the value
on shutdown or we can simply require segwit outputs and require a
dust value of no less than 354 sat/vbyte.

We swap the minimum dust value to 354 sat/vbyte here, requiring
segwit scripts in a future commit.

See https://github.com/lightningnetwork/lightning-rfc/issues/905

Drop broken test that is unfixable due to being undocumented

This should be reverted at some point, but the test is deficient
and breaks on later changes that are important to land ASAP.

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

Update Watch docs to disallow dup channel outpoints

on watch_channel

Don't apply monitor updates after watch_channel PermFail

The full stack fuzzer found an unreachable panic where we receive a
FundingSigned with a duplicate channel outpoint.

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