Merge pull request #1481 from TheBlueMatt/2022-05-new-chain-tests

Test coverage for `transaction_unconfirmed`

Merge pull request #1499 from tnull/2022-05-fix-unreachable-warning

Fix `rapid-gossip-sync` warning and version number

Merge pull request #1491 from tnull/2022-05-build-route-from-pubkeys

Build route from hop pubkey list.

Fix `rapid-gossip-sync` warning and version number

Allow building of a route from given hops

Implements `build_route_from_hops`, which provides a simple way to build
a route from us (payer) to the target node (payee) via the given hops
(which should exclude the payer, but include the payee). This may be
useful, e.g., for probing the chosen path.

Merge pull request #1494 from TheBlueMatt/2022-05-mon-cleanups-renames

Correct variable names in `ChannelMonitor` and DRY tests

Correct bogus references to `revocation_point` in `ChannelMonitor`

The `ChannelMonitor` had a field for the counterparty's
`cur_revocation_points`. Somewhat confusingly, this actually stored
the counterparty's *per-commitment* points, not the (derived)
revocation points.

Here we correct this by simply renaming the references as
appropriate. Note the update in `channel.rs` makes the variable
names align correctly.

Rename HTLC `onchain_value_satoshis` to `htlc_value_satoshis`

In `HTLCUpdate` and `OnchainEvent` tracking, we store the HTLC
value (rounded down to whole satoshis). This is somewhat
confusingly referred to as the `onchain_value_satoshis` even though
it refers to the commitment transaction output value, not the value
available on chain (which may have been reduced by an
HTLC-Timeout/HTLC-Success transaction).

DRY SpendableOutput tests in `monitor_tests.rs`

Merge pull request #1155 from arik-so/graph_sync_crate

Introduce graph sync crate

Merge pull request #1478 from mattfaltyn/issue1462

Document `lightning` crate features

Introduce graph sync crate for fast-forwarding through gossip data downloaded from a server.

Document lightning crate features

Rename HTLC `input_idx` fields to `commitment_tx_output_idx`

Several fields used in tracking on-chain HTLC outputs were
named `input_idx` despite referring to the output index in the
commitment transaction. Here they are all renamed
`commitment_tx_output_idx` for clarity.

Merge pull request #1490 from arik-so/rust_beta_doc_fix

Fix rust beta docs for lightning-invoice crate.

Merge pull request #1492 from tnull/2022-05-fix-bolts-url

Docs: Update to 'new' spec repository URL.

Merge pull request #1456 from jkczyz/2022-04-effective-capacity

Use `EffectiveCapacity` in `Score` trait

Fix rust beta docs lightning-invoice crate.

Use new spec repository URL.

Score without uncertainty for exact liquidity

For direct channels, the channel liquidity is known with certainty. Use
this knowledge in ProbabilisticScorer by either penalizing with the
per-hop penalty or u64::max_value depending on the amount.

Pass effective capacity to scorer

Scorers could benefit from having the channel's EffectiveCapacity rather
than a u64 msat value. For instance, ProbabilisticScorer can give a more
accurate penalty when given the ExactLiquidity variant. Pass a struct
wrapping the effective capacity, the proposed amount, and any in-flight
HTLC value.

Use correct penalty and CLTV delta in route hints

For route hints, the aggregate next hops path penalty and CLTV delta
should be computed after considering each hop rather than before.
Otherwise, these aggregate values will include values from the current
hop, too.

Use the correct amount when scoring route hints

When scoring route hints, the amount passed to the scorer should include
any fees needed for subsequent hops. This worked correctly for single-
hop hints since there are no further hops, but not for multi-hint hops
(except the final one).

Distinguish maximum HTLC from effective capacity

Using EffectiveCapacity in scoring gives more accurate success
probabilities when the maximum HTLC value is less than the channel
capacity. Change EffectiveCapacity to prefer the channel's capacity
over its maximum HTLC limit, but still use the latter for route finding.

PathBuildingHop::value_contribution_msat in Debug

Merge pull request #1476 from tnull/2022-05-maximum-path-length

Consider maximum path length during path finding.

Consider maximum path length during path finding.

Randomize the `ConnectStyle` during tests

We have a bunch of fancy infrastructure to ensure we can connect
blocks using all our different connection interfaces, but we only
bother to use it in a few select tests.

This expands our use of `ConnectStyle` to most of our tests by
simply randomizing the style in each test. This makes our tests
non-deterministic, but we print the connection style at start so
that it's easy to reproduce a failure deterministically.

Make tests more robust against different connection styles

In the next commit we'll randomize the `ConnectStyle` used in each
test. However, some tests are slightly too prescriptive, which we
address here in a few places.

Add new block `ConnectionStyle`s for `transaction_unconfirmed`

Previously `transaction_unconfirmed` was never called in tests!

Merge pull request #1472 from TheBlueMatt/2022-06-less-secp-ctx

Pull secp256k1 contexts from per-peer to per-PeerManager

Merge pull request #1418 from bruteforcecat/timeout-outbound-paymnet-retires-instead-of-count-out

add timeout retry strategy to outbound payment

add timeout retry strategy to outbound payment

Merge pull request #1485 from ViktorTigerstrom/2022-05-add-force-close-param

Add missing `counterparty_node_id` in `force_close_channel` calls

Add missing `counterparty_node_id` in `force_close_channel` calls

Merge pull request #1479 from ViktorTigerstrom/2022-05-pass-counterparty-id-to-functions

Pass `counterparty_node_id` to `ChannelManager` functions

Merge pull request #1475 from atalw/2022-04-paymentforwarded-event

Expose `next_channel_id` in `PaymentForwarded` event

Store full blocks in the test blockchain tracker instead of headers

Add `next_channel_id` in `PaymentForwarded` event

This update also includes a minor refactor. The return type of
`pending_monitor_events` has been changed to a `Vec` tuple with the
`OutPoint` type. This associates a `Vec` of `MonitorEvent`s with a
funding outpoint.

We've also renamed `source/sink_channel_id` to `prev/next_channel_id` in
the favour of clarity.

Merge pull request #1429 from TheBlueMatt/2022-04-drop-no-conn-possible

Update `OpenChannelRequest` documentation

As the `counterparty_node_id` is now required to be passed back to the
`ChannelManager` to accept or reject an inbound channel request, the
documentation is updated to reflect that.

Pass `counterparty_node_id` to `accept_inbound_channel`

Pass `counterparty_node_id` to `funding_transaction_generated`

Pass `counterparty_node_id` to `force_close_channel`

Pass `counterparty_node_id` to `close_channel` functions

move Time trait from scoring mod to util::time and set it visibile within crate

Add `counterparty_node_id` to `FundingGenerationReady`

Merge pull request #1480 from tnull/2022-05-fix-test-warnings

Fix unused code warnings test.

Fix unused code warnings.

Pull secp256k1 contexts from per-peer to per-PeerManager

Instead of including a `Secp256k1` context per
`PeerChannelEncryptor`, which is relatively expensive memory-wise
and nontrivial CPU-wise to construct, we should keep one for all
peers and simply reuse it.

This is relatively trivial so we do so in this commit.

Since its trivial to do so, we also take this opportunity to
randomize the new PeerManager context.

Merge pull request #1023 from TheBlueMatt/2021-07-par-gossip-processing

Merge pull request #1477 from dunxen/2022-05-invoice-expiry-nits

Address post-ACK formatting nits from #1474

Add a few more simple tests of the PeerHandler

These increase coverage and caught previous lockorder inversions.

Add support for testing recvd messages in TestChannelMessageHandler

Require `PartialEq` for `wire::Message` in `cfg(test)`

...and implement wire::Type for `()` for `feature = "_test_utils"`.

Drop a needless match in favor of an `if let`

[net-tokio] Explicitly yield after processing messages from a peer

This reduces instances of disconnect peers after single timer
intervals somewhat, at least on Tokio 1.14.

Drop `PeerHolder` as it now only has one field

Keep the same read buffer unless the last message was overly large

This avoids repeatedly deallocating-allocating a Vec for the peer
read buffer after every message/header.

Create a simple `FairRwLock` to avoid readers starving writers

Because we handle messages (which can take some time, persisting
things to disk or validating cryptographic signatures) with the
top-level read lock, but require the top-level write lock to
connect new peers or handle disconnection, we are particularly
sensitive to writer starvation issues.

Rust's libstd RwLock does not provide any fairness guarantees,
using whatever the OS provides as-is. On Linux, pthreads defaults
to starving writers, which Rust's RwLock exposes to us (without
any configurability).

Here we work around that issue by blocking readers if there are
pending writers, optimizing for readable code over
perfectly-optimized blocking.

Wake reader future when we fail to flush socket buffer

This avoids any extra calls to `read_event` after a write fails to
flush the write buffer fully, as is required by the PeerManager
API (though it isn't critical).

Limit blocked PeerManager::process_events waiters to two

Only one instance of PeerManager::process_events can run at a time,
and each run always finishes all available work before returning.
Thus, having several threads blocked on the process_events lock
doesn't accomplish anything but blocking more threads.

Here we limit the number of blocked calls on process_events to two
- one processing events and one blocked at the top which will
process all available events after the first completes.

Avoid the peers write lock unless we need it in timer_tick_occurred

Similar to the previous commit, this avoids "blocking the world" on
every timer tick unless we need to disconnect peers.

Avoid taking the peers write lock during event processing

Because the peers write lock "blocks the world", and happens after
each read event, always taking the write lock has pretty severe
impacts on parallelism. Instead, here, we only take the global
write lock if we have to disconnect a peer.

[net-tokio] Call PeerManager::process_events without blocking reads

Unlike very ancient versions of lightning-net-tokio, this does not
rely on a single global process_events future, but instead has one
per connection. This could still cause significant contention, so
we'll ensure only two process_events calls can exist at once in
the next few commits.

Process messages with only the top-level read lock held

Users are required to only ever call `read_event` serially
per-peer, thus we actually don't need any locks while we're
processing messages - we can only be processing messages in one
thread per-peer.

That said, we do need to ensure that another thread doesn't
disconnect the peer we're processing messages for, as that could
result in a peer_disconencted call while we're processing a
message for the same peer - somewhat nonsensical.

This significantly improves parallelism especially during gossip
processing as it avoids waiting on the entire set of individual
peer locks to forward a gossip message while several other threads
are validating gossip messages with their individual peer locks
held.

Process messages from peers in parallel in `PeerManager`.

This adds the required locking to process messages from different
peers simultaneously in `PeerManager`. Note that channel messages
are still processed under a global lock in `ChannelManager`, and
most work is still processed under a global lock in gossip message
handling, but parallelizing message deserialization and message
decryption is somewhat helpful.

Merge pull request #1474 from dunxen/2022-05-actually-add-expiry

lightning-invoice/utils: Actually add expiry to invoices

Add expiry to non-phantom invoice utils

Actually add expiry to phantom invoice utils

Merge pull request #1465 from tnull/2022-05-encode-update-type-bytes

Encode & test `channel_update` message type in failure messages.

Merge pull request #1471 from ViktorTigerstrom/2022-05-test-disconnected-before-funding-broadcasted

Add test coverage for `ClosureReason::DisconnectedPeer`

Merge pull request #1467 from arik-so/fuzz_new_target_docs

Add documentation for creating new fuzz test targets.

Add test for `ClosureReason::DisconnectedPeer`

Add test that ensures that channels are closed with
`ClosureReason::DisconnectedPeer` if the peer disconnects before the
funding transaction has been broadcasted.

Encode channel update type in failure messages.

Merge pull request #1389 from lightning-signer/2022-03-bitcoin

Update bitcoin crate to 0.28.1

Add documentation for creating new fuzz test targets.

Improve ShutdownScript::new_witness_program

bitcoin crate 0.28.1

Merge pull request #1468 from johnpc/fix-contributing-typo

fix typos in CONTRIBUTING.md

fix typos in CONTRIBUTING.md

Merge pull request #1463 from TheBlueMatt/2022-05-lol-more-underflow

Reject outbound channels if the total reserve is larger than funding

Merge pull request #1449 from TheBlueMatt/2022-04-fix-remote_ip_race

[lightning-net-tokio] Fix race-y unwrap fetching peer socket address

Merge pull request #1430 from vincenzopalazzo/macros/channel_reestablish_v2

send warning when we receive a old commitment transaction

Merge pull request #1416 from jurvis/jurvis/persist-scorer

Add utils to persist scorer in BackgroundProcessor

send warning when we receive a old commitment transaction

During a `channel_reestablish` now we send a warning message when we receive a old commitment transaction from the peer.

In addition, this commit include the update of functional test to make sure that the receiver will generate warn messages.

Signed-off-by: Vincenzo Palazzo <vincenzopalazzodev@gmail.com>

Merge pull request #1461 from TheBlueMatt/2022-05-unconf-0-not-half

Force-close channels on reorg only if the funding is unconfirmed

Merge pull request #1444 from ViktorTigerstrom/2022-04-use-counterparty-htlc-max-for-chan-updates

Set `ChannelUpdate` `htlc_maximum_msat` using the peer's value

Set last_prune_call outside of persistence block

Add utils to persist scorer in BackgroundProcessor

move last_prune_call back

Add correct `ChannelUpdate` `htlc_maximum_msat` test

Set `ChannelUpdate` `htlc_maximum_msat` using the peer's value

Use the `counterparty_max_htlc_value_in_flight_msat` value, and not the
`holder_max_htlc_value_in_flight_msat` value when creating the
`htlc_maximum_msat` value for `ChannelUpdate` messages.

BOLT 7 specifies that the field MUST be less than or equal to
`max_htlc_value_in_flight_msat` received from the peer, which we
currently are not guaranteed to adhere to by using the holder value.

Add test for configurable in-flight limit

Make our in-flight limit percentage configurable

Add a config field
`ChannelHandshakeConfig::max_inbound_htlc_value_in_flight_percent_of_channel`
which sets the percentage of the channel value we cap the total value of
outstanding inbound HTLCs to.

This field can be set to a value between 1-100, where the value
corresponds to the percent of the channel value in whole percentages.

Note that:
* If configured to another value than the default value 10, any new
channels created with the non default value will cause versions of LDK
prior to 0.0.104 to refuse to read the `ChannelManager`.

* This caps the total value for inbound HTLCs in-flight only, and
there's currently no way to configure the cap for the total value of
outbound HTLCs in-flight.

* The requirements for your node being online to ensure the safety of
HTLC-encumbered funds are different from the non-HTLC-encumbered funds.
This makes this an important knob to restrict exposure to loss due to
being offline for too long. See
`ChannelHandshakeConfig::our_to_self_delay` and
`ChannelConfig::cltv_expiry_delta` for more information.

Default value: 10.
Minimum value: 1, any values less than 1 will be treated as 1 instead.
Maximum value: 100, any values larger than 100 will be treated as 100
instead.

Merge pull request #1452 from tnull/2022-04-honor-gossip-timestamp-filters

Initiate gossip sync only after receiving GossipTimestampFilter.

Tweak `test_unconf_chan` to test that we don't prematurely close

Merge pull request #1460 from TheBlueMatt/2022-04-liquidity-log

Provide a utility to log the ProbabilisticScorer's contents

Initiate sync only after receiving `GossipTimestampFilter`.

Reject outbound channels if the total reserve is larger than funding

In 2826af75a5761859dedcddc870de0753ae4ecde4 we fixed a fuzz crash
in which the total reserve values in a channel were greater than
the funding amount, checked when an incoming channel is accepted.

This, however, did not fix the same issue for outbound channels,
where a peer can accept a channel with a nonsense reserve value in
the `accept_channel` message. The `full_stack_target` fuzzer
eventually found its way into the same issue, which this resolves.

Thanks (again) to Chaincode Labs for providing the fuzzing
resources which found this bug!