WIP

Add anchor output when we have HTLCs or a to_local output

This is the first step in implementing anchor outputs - namely
adding the anchor outputs themselves. We don't ever spend them,
and this commit doesn't update other commitent transaction scripts
with the new CSV timelocks.

This commit temporarily disables the
ln::channel::tests::outbound_commitment_test test, as we don't have
test vectors for anchor-outputs-without-updated-scripts upstream.

Assertions in update_fee_that_funder_cannot_afford to check consts

Correct initial commitment check in inbound channel-open handling.

Previously, we would reject inbound channels if the funder wasn't
able to afford both the initial commitment transaction fee and the
initial commitment didn't meet both our and our counterparty's
reserve value.

We never bothered to check if it was impossible for them to meet
both reserve values, and meeting their own reserve is perfectly
acceptable anyway (as long as they eventually meet it).

The easy fix is to just check that they at least have enough funds
back to themselves on the initial commitment to meet our reserve,
though we could be more careful in the future.

Add TODOs

TESTING

TESTING

Make full_stack_target more absurdly huge and check for funds loss

Connect blocks at the end

Additional asserts to include in fuzztesting (though may get hit?)

Demonstrate mutating functions which are not fully test-covered

empty_commit: not-yet-PR-d commits follow

Revert "Test that txn pay at least a minimum relay fee in functional tests"

This reverts commit cc038cc28796d04335f9705858cdfb74ee6f0d72.

Test that txn pay at least a minimum relay fee in functional tests

empty_commit: critical bugfixes follow

Don't send padding bytes for pings

We (somewhat needlessly) send an extra 64 bytes with every ping.
While this isn't exactly a big deal, I saw it and figured we
shouldn't waste bytes on the wire given some of the constraints of
potential users.

Add an fn to get a ChannelMonitor reference from a ManyChannelMonitor

This is really awkwrd, and relies on some (at least rather simple)
unsafe code (essentially avoiding the need for Pin), but it works
pretty well.

empty_commit: not-yet-PR-d commits follow

Add a Headers-over-DNS client to lightning-block-sync.

This is useful to kick on backup BlockSources.

Add subcrate which impls a simple SPV client from Bitcoin Core RPC

This adds a new subcrate `lightning-block-sync` which is designed
to make it easier to get up-and-running by removing the effort of
building an SPV client and fetching the chain.

Instead of building a P2P client (and all the address management
that entails), this focuses on building a trivial SPV client which
can fetch from several instances of an abstract BlockSource. Then,
we provide two example BlockSource implementations that can fetch
from Bitcoin Core's RPC interface and Bitcoin Core's REST interface.

The code here is taken with heavy modifications from
rust-lightning-bitcoinrpc.

Expose ChannelMonitor::block_[dis]connected as pub

These are essentially required to make rescan-at-reload doable as
individual ChannelMonitors may be synced to different chain states
and thus need to have blocks replayed separately.

empty_commit: PR 614 follows

Dont hold peers lock when calling user code

Pretty-shitty implement TODOs for msg forwarding

empty_commit: Obviously-useful commits follow

Run with mutagen on travis.

Sadly our test coverage isn't very good and I had to hunt for
functions to mutate where we fail tests on every mutation mutagen
creates, but committing the framework is a start.

empty_commit: PR 453 follows

empty_commit: PR 539 follows

Merge pull request #624 from arik-so/encode_and_send_msg_method_refactor

Extract encode_and_send_msg into a method.

Extract encode_and_send_msg into a method.

This is a response to splitting #585 into smaller components. This extraction will permit a future extraction of all message handling into a separate method, and then later even into a separate trait that will be accessible through language bindings.

Merge pull request #622 from valentinewallace/chanmgr-logger-arc-to-deref

ChannelManager+Router++ Logger Arc --> Deref

PeerManager Logger Arc --> Deref

ChannelManager+Router++ Logger Arc --> Deref

This caused a bunch of cascading changes, including
passing loggers down to Channels in function calls
rather than having each Channel have a pointer to the
ChannelManager's Logger (which was a circular reference).
Other structs that the Channel had passed its Logger to also
had their loggers removed. Other newly unused Loggers were
also removed, especially when keeping them would've caused
a bunch of extra test changes to be necessary, e.g. with
the ChainWatchInterfaceUtil's Logger.

Merge pull request #617 from sourabhmarathe/serialize-channelmanager-events

Serialize ChannelManager events

Serialize ChannelManager events

Also adds a test for de/serializing events

Merge pull request #621 from TheBlueMatt/2020-05-592-nits

592+a few fixes

Fix some new indentation nits

Fix a few new (and one old) issues in the new channel_update

We need to always set lowest_inbound_channel_fees to None if there
are no channels (and we should ignore the channels which are
disabled for the purpose of lowest-fee calculations). Further, we
cannot unwrap the channel lookups as they may be for channels which
are not related to the channel we are processing an update for.
Finally, we can satisfy borrowck much easier since things are on
self instead of on a MutexGuard.

Add assertion since we now have a pub field that is PartialEq

We previously were only able to assert that the route graph
serialization roundtrips were good by comparing the network
messages returned from them, but we can now do better as the graph
is exposed publicly via a simple datastructure that implements
PartialEq.

Add missing comment on why last_update_message is None

Move get_addresses to network_graph and drop now-useless log_trace

Because we expose the internals we don't need a method to log
their contents anymore, and get_addresses can now avoid copying as
we expose the RwLock directly

Drop new test Node field introduced in 8ce2223b6952567b28adfcc11c2

8ce2223b6952567b28adfcc11c23c9f19c4c0324 introduced a new field in
the "Node" objects used in our functional tests - the node_id. Its
not a bad idea to cache it, but unless we want to commit and use it
everywhere, we should avoid duplicating data, especially in tests
where we'd rather exercise the underlying code than bypass it.

Improve routing-related documentation

Remove NetGraphMsgHandler serialization

Make DirectionalChannelInfo optional

Move node announcement fields into a separate struct

Expose some network graph methods

Split routing from getting network messages

Remove non-bitcoin chain helpers

Move router to a separate module

Merge pull request #539 from TheBlueMatt/2020-03-static-remotekey

Require static_remotekey

Merge pull request #613 from valentinewallace/less-confusing-chan-reserve-names

Make channel reserve variable names less confusing.

Rename payment_basepoint/key to simply payment_point/key.

We no longer derive any keys from the payment point, so they aren't
a "base" but simply a point/key.

Require option_static_remotekey in channel/channelmonitor.

This simplifies channelmonitor quite nicely (as expected) as we
never have to be concerned with learning data in a DataLossProtect
which is require for us to claim our funds from the latest remote
commitment transaction.

Add detection of feature_static_remotekey support and print

This adds the ability to check for static_remotekey in appropriate
feature contexts and prints it at connect time. It is still
considered unknown for the purposes of requires_unknown_bits() as
we don't yet implement it.

Make channel reserve variable names less confusing.

Previous to this commit, variables such as their_channel_reserve
referred to the channel reserve that _we_ are required to keep,
(the value is initially set by the remote). Similarly,
variables such as our_channel_reserve referred to the channel
reserve that we require the remote to keep.

Change this to use local_channel_reserve / remote_channel_reserve
to refer to the the channel reserve that the local is required to keep
and the channel reserve that the remote is required to keep, respectively.

Check local signtures explicitly in channel tx-generation tests

It appears the local signatures which are specified in the channel
transaction-generation tests were never checked directly (though
they were checked as a part of the overall fully-signed-transaction
tests).

Check them explicitly so that they can be updated for static remote
key.

Add additional trace logging in channel signature validation

This makes it easier to amend the full_stack_target
test_no_existing_test_breakage test by always providing the
neccessary data in the log.

Merge pull request #590 from jkczyz/2020-04-feature-flags

Features module improvements

Sanity check that known features are not required

Expand testing of unknown feature bits

Include tests for requires_unknown_bits and supports_unknown_bits when
an unknown even bit, odd bit, or neither is set. Refactor bit clearing
such that tests and production code share the same code path. Fix a
potential spec incompatibility (currently only exposed in testing code)
where trailing zero bytes are not removed after a bit is cleared.

Generalize with_known_relevant_init_flags

Converting from InitFeatures to other Features is accomplished using
Features::with_known_relevant_init_flags. Define a more general
to_context method which converts from Features of one Context to
another.

Additionally, ensure the source context only has known flags before
selecting flags for the target context.

Generalize feature methods to work in any context

Refactoring the features module allowed for making code specific to
certain contexts generalizable. Specifically, KNOWN_FEATURE_MASK
is defined on Context instead of hardcoded in each method
specialization. Thus, such methods are no longer required.

Remove duplicate specification of features

Features for a given context are duplicated throughout the features
module. Use a macro for defining a Context and the applicable features
such that features only need to be defined for a Context in one place.
The Context provides bitmasks for selecting known and unknown feature
flags.

BOLT 1 and BOLT 9 refer to features as "known" if a peer understands
them. They also use the term "supported" to mean either optional or
required.

Update the features module to use similar terminology.
- Define contexts in terms of required and optional features rather than
  just supported features
- Define known features as those that are optional or required
- Rename supported() constructor to known()

For completeness, clear_optional_bit for each feature is now called
clear_bits and clears both optional and required bits.

Improve features module documentation

Encapsulate feature flag checking and manipulation

Each feature is represented by two bits within Features' flags field.
Working with these flags requires bitwise operations, which can be error
prone. Rather than directly checking and manipulating bits, encapsulate
the bits within each feature trait and provide mechanisms for doing so.

This removes the need to comment on which features correspond to bitwise
expressions since the expressions use feature trait identifiers instead.

With this approach, byte literals and expressions can be evaluated at
compile time still. However, for these cases, knowing which byte within
the flags that a feature corresponds to still must be determined by the
implementor.

Remove the special case where initial_routing_sync has no even bit. Now,
it (bit 2) is considered known by the implementation.

Set initial_routing_sync in InitFeatures

The initial_routing_sync feature is set by peer_handler whenever a full
sync of the network graph is desired. It is not explicitly set when
creating features with InitFeatures::supported().

An upcoming refactor will change supported() to known(), which will
return all features known by the implementation. Thus, the
initial_routing_sync flag will need to be set by default. This commit
makes the behavior change ahead of the refactor.

Merge pull request #609 from LNP-BP/refactor-deps

Refactor dependencies

Adopting (W)PubkeyHash types

Adopting new bitcoin hash types and crate version

BDR: Linearizing secp256k1 deps

Bitcoin deps refactoring (BDR): Linearizing bitcoin_hash deps

Unset upfront_shutdown_script using bit clearing

The test_upfront_shutdown_script functional test clears this feature
flag. However, the method used to clear the flag is implemented by bit
toggling. Thus, if the flag is not set the method would actually set it.
Implement the method using bit clearing instead.

Merge pull request #608 from TheBlueMatt/2020-04-0.0.11

0.0.11

Merge pull request #598 from TheBlueMatt/2020-04-559-cleanups

Clean up ChannelKeys API

Bump versions to 0.0.11/net-tokio 0.0.3

Remove trivial assertions in LocalCommitmentTransaction fns

We don't need to assert that transaction structure is what we
expect when the transaction is created by a function twenty lines
up in the same file.

Remove TODOs from documentation in keysinterface

We should never be exposing our own TODOs to the world.

Don't modify LocalCommitmemntTransaction after construction

Instead of adding signatures to LocalCommitmentTransactions, we
instead leave them unsigned and use them to construct signed
Transactions when we want them. This cleans up the guts of
LocalCommitmentTransaction enough that we can, and do, expose its
state to the world, allowing external signers to have a basic
awareness of what they're signing.

Batch-sign local HTLC txn with a well-doc'd API, returning sigs

1107ab06c33bd360bdee7ee64f4b690e753003f6 introduced an API to have a
ChannelKeys implementer sign HTLC transactions by calling into the
LocalCommitmentTransaction object, which would then store the tx.

This API was incredibly awkward, both because it required an
external signer trust our own internal interfaces, but also because
it didn't allow for any inspection of what was about to be signed.

Further, it signed the HTLC transactions one-by-one in a somewhat
inefficient way, and there isn't a clear way to resolve this (as
the which-HTLC parameter has to refer to something in between the
HTLC's arbitrary index, and its index in the commitment tx, which
has "holes" for the non-HTLC outputs and skips some HTLCs).

We replace it with a new function in ChannelKeys which allows us
to sign all HTLCs in a given commitment transaction (which allows
for a bit more effeciency on the signers' part, as well as
sidesteps the which-HTLC issue). This may also simplify the signer
implementation as we will always want to sign all HTLCs spending a
given commitment transaction at once anyway.

We also de-mut the LocalCommitmentTransaction passed to the
ChanKeys, instead opting to make LocalCommitmentTransaction const
and avoid storing any new HTLC-related data in it.

Return Result<Signature> instead of modifying args in ChannelKeys

This cleans up sign_local_commitment somewhat by returning a
Result<Signaure, ()> over the local commitment transaction instead
of modifying the struct which was passed in.

This is the first step in making LocalCommitmentTransaction a
completely pub struct, using it just to communicate enough
information to the user to allow them to construct a signaure
instead of having it contain a bunch of logic.

This should make it much easier to implement a custom ChannelKeys
by disconnecting the local commitment transaction signing from our
own datastructures.

Track signing of local txn in channelmonitor and refuse updates

In e46e183084ed858f41aa304acd78503aea1a96ed we began tracking
whether a local commitment transaction had been signed and
broadcast in OnchainTxHandler, refusing to update the local
commitment transaction state in the ChannelMonitor on that basis.

This is fine, except that it doesn't make a lot of sense to store
the full local transaction state in OnchainTxHandler - we should be
providing it the unsigned local transaction at the time we wish to
broadcast and no more (just like we do all other transaction data).

Dry-up InputMaterial::Funding

As channel_value last usage was for computing feerate but as this
one is static per-commitment and will always-be following specification,
we remove it.

Merge pull request #579 from ariard/2020-04-sanitize-cltv-delay

Sanititze and document incoming HTLC cltv_expiry handling

Sanitize outgoing HTLC cltv_value

Document exactly our CLTV sanitization policy for final incoming HTLCs

We want to avoid a third-party channel closure, where a random node
by sending us a payment expiring at current height, would trigger our
onchain logic to close the channel due to a near-expiration.

Merge pull request #607 from TheBlueMatt/2020-04-more-cleanups

CI and rustc warning cleanup

Include color when building fuzz targets in CI

Disable timeout for full_stack_target runs in CI

It seems we've recently been seeing sporadic long-running
full_stack_target cases when running honggfuzz in CI. These
shouldn't be killed (as its possible they hit an error or a deadlock,
especially since the longest-running tests probably have the most
coverage).

Silence fuzz build unused import warnings

Address new rustc warnings.

Fix step naming in fuzz tests in GitHub Actions

Run Github Actions on PRs, too

Merge pull request #593 from TheBlueMatt/2020-04-par-fuzz-check

Thread fuzz test cases

Document exactly our CLTV sanitization policy for incoming HTLCs

Thread fuzz test cases

Adds threading (with logger capture) to fuzz targets so that we can
more effeciently test a failing fuzz corpus on new code changes.

Merge pull request #587 from TheBlueMatt/2020-04-mpp-timeout

Time out HTLCs before they expire

Add test for timing out HTLCs which are in the holding cell

Time out AwatingRemoteRAA outgoing HTLCs when we reach cltv_expiry

In case of committing out-of-time outgoing HTLCs, we force
ourselves to close the channel to avoid remote peer claims on a
non-backed HTLC

Add test for partial-send MPP due to monitor update failure

Relatively simple test that, after a monitor update fails, we get
the right return value and continue with the bits of the MPP that
did not send after the monitor updating is restored.