2018-02-20 20:59:04 +00:00
|
|
|
#include <bitcoin/privkey.h>
|
|
|
|
|
#include <bitcoin/script.h>
|
|
|
|
|
#include <ccan/tal/str/str.h>
|
|
|
|
|
#include <common/channel_config.h>
|
|
|
|
|
#include <common/funding_tx.h>
|
|
|
|
|
#include <common/key_derive.h>
|
2018-04-05 20:19:47 +01:00
|
|
|
#include <common/wallet_tx.h>
|
2018-02-20 20:59:04 +00:00
|
|
|
#include <common/wire_error.h>
|
2018-07-24 07:18:58 +01:00
|
|
|
#include <connectd/gen_connect_wire.h>
|
2018-02-20 20:59:04 +00:00
|
|
|
#include <errno.h>
|
|
|
|
|
#include <hsmd/gen_hsm_client_wire.h>
|
|
|
|
|
#include <lightningd/chaintopology.h>
|
2018-02-20 20:59:09 +00:00
|
|
|
#include <lightningd/channel_control.h>
|
|
|
|
|
#include <lightningd/closing_control.h>
|
2018-02-20 20:59:04 +00:00
|
|
|
#include <lightningd/hsm_control.h>
|
2018-03-16 03:45:08 +00:00
|
|
|
#include <lightningd/json.h>
|
2018-02-20 20:59:04 +00:00
|
|
|
#include <lightningd/jsonrpc.h>
|
2018-05-24 22:40:18 +01:00
|
|
|
#include <lightningd/jsonrpc_errors.h>
|
2018-02-20 20:59:04 +00:00
|
|
|
#include <lightningd/lightningd.h>
|
|
|
|
|
#include <lightningd/log.h>
|
|
|
|
|
#include <lightningd/opening_control.h>
|
2018-07-20 02:14:02 +01:00
|
|
|
#include <lightningd/param.h>
|
2018-02-20 20:59:04 +00:00
|
|
|
#include <lightningd/peer_control.h>
|
|
|
|
|
#include <lightningd/subd.h>
|
|
|
|
|
#include <openingd/gen_opening_wire.h>
|
2018-03-16 23:37:02 +00:00
|
|
|
#include <wire/wire.h>
|
2018-02-20 20:59:04 +00:00
|
|
|
#include <wire/wire_sync.h>
|
|
|
|
|
|
|
|
|
|
/* Channel we're still opening. */
|
|
|
|
|
struct uncommitted_channel {
|
|
|
|
|
/* peer->uncommitted_channel == this */
|
|
|
|
|
struct peer *peer;
|
|
|
|
|
|
|
|
|
|
/* openingd which is running now */
|
|
|
|
|
struct subd *openingd;
|
|
|
|
|
|
|
|
|
|
/* Reserved dbid for if we become a real struct channel */
|
|
|
|
|
u64 dbid;
|
|
|
|
|
|
|
|
|
|
/* For logging */
|
|
|
|
|
struct log *log;
|
|
|
|
|
|
2018-02-23 05:53:47 +00:00
|
|
|
/* Openingd can tell us stuff. */
|
|
|
|
|
const char *transient_billboard;
|
|
|
|
|
|
2018-02-20 20:59:04 +00:00
|
|
|
/* If we offered channel, this contains information, otherwise NULL */
|
|
|
|
|
struct funding_channel *fc;
|
|
|
|
|
|
2018-07-23 03:23:02 +01:00
|
|
|
/* Our basepoints for the channel. */
|
|
|
|
|
struct basepoints local_basepoints;
|
|
|
|
|
|
|
|
|
|
/* Public key for funding tx. */
|
|
|
|
|
struct pubkey local_funding_pubkey;
|
|
|
|
|
|
2018-02-20 20:59:04 +00:00
|
|
|
/* These are *not* filled in by new_uncommitted_channel: */
|
|
|
|
|
|
|
|
|
|
/* Minimum funding depth (if funder == REMOTE). */
|
|
|
|
|
u32 minimum_depth;
|
|
|
|
|
|
|
|
|
|
/* Our channel config. */
|
|
|
|
|
struct channel_config our_config;
|
|
|
|
|
};
|
|
|
|
|
|
2018-04-05 20:19:47 +01:00
|
|
|
|
2018-02-20 20:59:04 +00:00
|
|
|
struct funding_channel {
|
|
|
|
|
struct command *cmd; /* Which also owns us. */
|
2018-04-05 20:19:47 +01:00
|
|
|
struct wallet_tx wtx;
|
|
|
|
|
u64 push_msat;
|
|
|
|
|
u8 channel_flags;
|
2018-02-20 20:59:04 +00:00
|
|
|
|
|
|
|
|
/* Peer we're trying to reach. */
|
|
|
|
|
struct pubkey peerid;
|
|
|
|
|
|
|
|
|
|
/* Channel. */
|
|
|
|
|
struct uncommitted_channel *uc;
|
|
|
|
|
};
|
|
|
|
|
|
2018-07-24 07:18:58 +01:00
|
|
|
static void uncommitted_channel_disconnect(struct uncommitted_channel *uc,
|
|
|
|
|
const char *desc)
|
|
|
|
|
{
|
2018-07-24 07:18:58 +01:00
|
|
|
u8 *msg = towire_connectctl_peer_disconnected(tmpctx, &uc->peer->id);
|
2018-07-24 07:18:58 +01:00
|
|
|
log_info(uc->log, "%s", desc);
|
2018-07-24 07:18:58 +01:00
|
|
|
subd_send_msg(uc->peer->ld->connectd, msg);
|
2018-07-24 07:18:58 +01:00
|
|
|
if (uc->fc)
|
|
|
|
|
command_fail(uc->fc->cmd, LIGHTNINGD, "%s", desc);
|
|
|
|
|
}
|
|
|
|
|
|
2018-02-20 20:59:04 +00:00
|
|
|
void kill_uncommitted_channel(struct uncommitted_channel *uc,
|
|
|
|
|
const char *why)
|
|
|
|
|
{
|
|
|
|
|
log_info(uc->log, "Killing openingd: %s", why);
|
|
|
|
|
|
|
|
|
|
/* Close openingd. */
|
|
|
|
|
subd_release_channel(uc->openingd, uc);
|
2018-04-23 11:08:01 +01:00
|
|
|
uc->openingd = NULL;
|
2018-02-20 20:59:04 +00:00
|
|
|
|
2018-07-24 07:18:58 +01:00
|
|
|
uncommitted_channel_disconnect(uc, why);
|
2018-02-20 20:59:04 +00:00
|
|
|
tal_free(uc);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void json_add_uncommitted_channel(struct json_result *response,
|
|
|
|
|
const struct uncommitted_channel *uc)
|
|
|
|
|
{
|
openingd: take peer before we're opening, wait for explicit funding msg.
Prior to this, lightningd would hand uninteresting peers back to connectd,
which would then return it to lightningd if it sent a non-gossip msg,
or if lightningd asked it to release the peer.
Now connectd hands the peer to lightningd once we've done the init
handshake, which hands it off to openingd.
This is a deep structural change, so we do the minimum here and cleanup
in the following patches.
Lightningd:
1. Remove peer_nongossip handling from connect_control and peer_control.
2. Remove list of outstanding fundchannel command; it was only needed to
find the race between us asking connectd to release the peer and it
reconnecting.
3. We can no longer tell if the remote end has started trying to fund a
channel (until it has succeeded): it's very transitory anyway so not
worth fixing.
4. We now always have a struct peer, and allocate an uncommitted_channel
for it, though it may never be used if neither end funds a channel.
5. We start funding on messages for openingd: we can get a funder_reply
or a fundee, or an error in response to our request to fund a channel.
so we handle all of them.
6. A new peer_start_openingd() is called after connectd hands us a peer.
7. json_fund_channel just looks through local peers; there are none
hidden in connectd any more.
8. We sometimes start a new openingd just to send an error message.
Openingd:
1. We always have information we need to accept them funding a channel (in
the init message).
2. We have to listen for three fds: peer, gossip and master, so we opencode
the poll.
3. We have an explicit message to start trying to fund a channel.
4. We can be told to send a message in our init message.
Testing:
1. We don't handle some things gracefully yet, so two tests are disabled.
2. 'hand_back_peer .*: now local again' from connectd is no longer a message,
openingd says 'Handed peer, entering loop' once its managing it.
3. peer['state'] used to be set to 'GOSSIPING' (otherwise this field doesn't
exist; 'state' is now per-channel. It doesn't exist at all now.
4. Some tests now need to turn on IO logging in openingd, not connectd.
5. There's a gap between connecting on one node and having connectd on
the peer hand over the connection to openingd. Our tests sometimes
checked getpeers() on the peer, and didn't see anything, so line_graph
needed updating.
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2018-08-08 15:10:58 +01:00
|
|
|
u64 msatoshi_total, our_msatoshi;
|
2018-02-20 20:59:04 +00:00
|
|
|
if (!uc)
|
|
|
|
|
return;
|
|
|
|
|
|
openingd: take peer before we're opening, wait for explicit funding msg.
Prior to this, lightningd would hand uninteresting peers back to connectd,
which would then return it to lightningd if it sent a non-gossip msg,
or if lightningd asked it to release the peer.
Now connectd hands the peer to lightningd once we've done the init
handshake, which hands it off to openingd.
This is a deep structural change, so we do the minimum here and cleanup
in the following patches.
Lightningd:
1. Remove peer_nongossip handling from connect_control and peer_control.
2. Remove list of outstanding fundchannel command; it was only needed to
find the race between us asking connectd to release the peer and it
reconnecting.
3. We can no longer tell if the remote end has started trying to fund a
channel (until it has succeeded): it's very transitory anyway so not
worth fixing.
4. We now always have a struct peer, and allocate an uncommitted_channel
for it, though it may never be used if neither end funds a channel.
5. We start funding on messages for openingd: we can get a funder_reply
or a fundee, or an error in response to our request to fund a channel.
so we handle all of them.
6. A new peer_start_openingd() is called after connectd hands us a peer.
7. json_fund_channel just looks through local peers; there are none
hidden in connectd any more.
8. We sometimes start a new openingd just to send an error message.
Openingd:
1. We always have information we need to accept them funding a channel (in
the init message).
2. We have to listen for three fds: peer, gossip and master, so we opencode
the poll.
3. We have an explicit message to start trying to fund a channel.
4. We can be told to send a message in our init message.
Testing:
1. We don't handle some things gracefully yet, so two tests are disabled.
2. 'hand_back_peer .*: now local again' from connectd is no longer a message,
openingd says 'Handed peer, entering loop' once its managing it.
3. peer['state'] used to be set to 'GOSSIPING' (otherwise this field doesn't
exist; 'state' is now per-channel. It doesn't exist at all now.
4. Some tests now need to turn on IO logging in openingd, not connectd.
5. There's a gap between connecting on one node and having connectd on
the peer hand over the connection to openingd. Our tests sometimes
checked getpeers() on the peer, and didn't see anything, so line_graph
needed updating.
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2018-08-08 15:10:58 +01:00
|
|
|
/* If we're chatting but no channel, that's shown by connected: True */
|
|
|
|
|
if (!uc->fc)
|
|
|
|
|
return;
|
|
|
|
|
|
2018-02-20 20:59:04 +00:00
|
|
|
json_object_start(response, NULL);
|
|
|
|
|
json_add_string(response, "state", "OPENINGD");
|
|
|
|
|
json_add_string(response, "owner", "lightning_openingd");
|
openingd: take peer before we're opening, wait for explicit funding msg.
Prior to this, lightningd would hand uninteresting peers back to connectd,
which would then return it to lightningd if it sent a non-gossip msg,
or if lightningd asked it to release the peer.
Now connectd hands the peer to lightningd once we've done the init
handshake, which hands it off to openingd.
This is a deep structural change, so we do the minimum here and cleanup
in the following patches.
Lightningd:
1. Remove peer_nongossip handling from connect_control and peer_control.
2. Remove list of outstanding fundchannel command; it was only needed to
find the race between us asking connectd to release the peer and it
reconnecting.
3. We can no longer tell if the remote end has started trying to fund a
channel (until it has succeeded): it's very transitory anyway so not
worth fixing.
4. We now always have a struct peer, and allocate an uncommitted_channel
for it, though it may never be used if neither end funds a channel.
5. We start funding on messages for openingd: we can get a funder_reply
or a fundee, or an error in response to our request to fund a channel.
so we handle all of them.
6. A new peer_start_openingd() is called after connectd hands us a peer.
7. json_fund_channel just looks through local peers; there are none
hidden in connectd any more.
8. We sometimes start a new openingd just to send an error message.
Openingd:
1. We always have information we need to accept them funding a channel (in
the init message).
2. We have to listen for three fds: peer, gossip and master, so we opencode
the poll.
3. We have an explicit message to start trying to fund a channel.
4. We can be told to send a message in our init message.
Testing:
1. We don't handle some things gracefully yet, so two tests are disabled.
2. 'hand_back_peer .*: now local again' from connectd is no longer a message,
openingd says 'Handed peer, entering loop' once its managing it.
3. peer['state'] used to be set to 'GOSSIPING' (otherwise this field doesn't
exist; 'state' is now per-channel. It doesn't exist at all now.
4. Some tests now need to turn on IO logging in openingd, not connectd.
5. There's a gap between connecting on one node and having connectd on
the peer hand over the connection to openingd. Our tests sometimes
checked getpeers() on the peer, and didn't see anything, so line_graph
needed updating.
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2018-08-08 15:10:58 +01:00
|
|
|
json_add_string(response, "funding", "LOCAL");
|
2018-02-23 05:53:47 +00:00
|
|
|
if (uc->transient_billboard) {
|
|
|
|
|
json_array_start(response, "status");
|
|
|
|
|
json_add_string(response, NULL, uc->transient_billboard);
|
|
|
|
|
json_array_end(response);
|
|
|
|
|
}
|
2018-02-20 20:59:04 +00:00
|
|
|
|
openingd: take peer before we're opening, wait for explicit funding msg.
Prior to this, lightningd would hand uninteresting peers back to connectd,
which would then return it to lightningd if it sent a non-gossip msg,
or if lightningd asked it to release the peer.
Now connectd hands the peer to lightningd once we've done the init
handshake, which hands it off to openingd.
This is a deep structural change, so we do the minimum here and cleanup
in the following patches.
Lightningd:
1. Remove peer_nongossip handling from connect_control and peer_control.
2. Remove list of outstanding fundchannel command; it was only needed to
find the race between us asking connectd to release the peer and it
reconnecting.
3. We can no longer tell if the remote end has started trying to fund a
channel (until it has succeeded): it's very transitory anyway so not
worth fixing.
4. We now always have a struct peer, and allocate an uncommitted_channel
for it, though it may never be used if neither end funds a channel.
5. We start funding on messages for openingd: we can get a funder_reply
or a fundee, or an error in response to our request to fund a channel.
so we handle all of them.
6. A new peer_start_openingd() is called after connectd hands us a peer.
7. json_fund_channel just looks through local peers; there are none
hidden in connectd any more.
8. We sometimes start a new openingd just to send an error message.
Openingd:
1. We always have information we need to accept them funding a channel (in
the init message).
2. We have to listen for three fds: peer, gossip and master, so we opencode
the poll.
3. We have an explicit message to start trying to fund a channel.
4. We can be told to send a message in our init message.
Testing:
1. We don't handle some things gracefully yet, so two tests are disabled.
2. 'hand_back_peer .*: now local again' from connectd is no longer a message,
openingd says 'Handed peer, entering loop' once its managing it.
3. peer['state'] used to be set to 'GOSSIPING' (otherwise this field doesn't
exist; 'state' is now per-channel. It doesn't exist at all now.
4. Some tests now need to turn on IO logging in openingd, not connectd.
5. There's a gap between connecting on one node and having connectd on
the peer hand over the connection to openingd. Our tests sometimes
checked getpeers() on the peer, and didn't see anything, so line_graph
needed updating.
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2018-08-08 15:10:58 +01:00
|
|
|
msatoshi_total = uc->fc->wtx.amount * 1000;
|
|
|
|
|
our_msatoshi = msatoshi_total - uc->fc->push_msat;
|
|
|
|
|
json_add_u64(response, "msatoshi_to_us", our_msatoshi);
|
|
|
|
|
json_add_u64(response, "msatoshi_total", msatoshi_total);
|
2018-02-20 20:59:04 +00:00
|
|
|
json_object_end(response);
|
|
|
|
|
}
|
|
|
|
|
|
2018-03-07 00:06:07 +00:00
|
|
|
/* Steals fields from uncommitted_channel: returns NULL if can't generate a
|
|
|
|
|
* key for this channel (shouldn't happen!). */
|
2018-02-20 20:59:04 +00:00
|
|
|
static struct channel *
|
|
|
|
|
wallet_commit_channel(struct lightningd *ld,
|
|
|
|
|
struct uncommitted_channel *uc,
|
|
|
|
|
struct bitcoin_tx *remote_commit,
|
|
|
|
|
secp256k1_ecdsa_signature *remote_commit_sig,
|
|
|
|
|
const struct bitcoin_txid *funding_txid,
|
|
|
|
|
u16 funding_outnum,
|
|
|
|
|
u64 funding_satoshi,
|
|
|
|
|
u64 push_msat,
|
|
|
|
|
u8 channel_flags,
|
|
|
|
|
struct channel_info *channel_info,
|
|
|
|
|
u32 feerate)
|
|
|
|
|
{
|
|
|
|
|
struct channel *channel;
|
|
|
|
|
u64 our_msatoshi;
|
2018-03-07 00:06:07 +00:00
|
|
|
s64 final_key_idx;
|
|
|
|
|
|
|
|
|
|
/* Get a key to use for closing outputs from this tx */
|
|
|
|
|
final_key_idx = wallet_get_newindex(ld);
|
|
|
|
|
if (final_key_idx == -1) {
|
|
|
|
|
log_broken(uc->log, "Can't get final key index");
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
2018-02-20 20:59:04 +00:00
|
|
|
|
|
|
|
|
if (uc->fc)
|
|
|
|
|
our_msatoshi = funding_satoshi * 1000 - push_msat;
|
|
|
|
|
else
|
|
|
|
|
our_msatoshi = push_msat;
|
|
|
|
|
|
|
|
|
|
/* Feerates begin identical. */
|
|
|
|
|
channel_info->feerate_per_kw[LOCAL]
|
|
|
|
|
= channel_info->feerate_per_kw[REMOTE]
|
|
|
|
|
= feerate;
|
|
|
|
|
|
|
|
|
|
/* old_remote_per_commit not valid yet, copy valid one. */
|
|
|
|
|
channel_info->old_remote_per_commit = channel_info->remote_per_commit;
|
|
|
|
|
|
|
|
|
|
channel = new_channel(uc->peer, uc->dbid,
|
|
|
|
|
NULL, /* No shachain yet */
|
|
|
|
|
CHANNELD_AWAITING_LOCKIN,
|
|
|
|
|
uc->fc ? LOCAL : REMOTE,
|
|
|
|
|
uc->log,
|
2018-02-23 05:53:47 +00:00
|
|
|
take(uc->transient_billboard),
|
2018-02-20 20:59:04 +00:00
|
|
|
channel_flags,
|
|
|
|
|
&uc->our_config,
|
|
|
|
|
uc->minimum_depth,
|
|
|
|
|
1, 1, 0,
|
|
|
|
|
funding_txid,
|
|
|
|
|
funding_outnum,
|
|
|
|
|
funding_satoshi,
|
|
|
|
|
push_msat,
|
|
|
|
|
false, /* !remote_funding_locked */
|
|
|
|
|
NULL, /* no scid yet */
|
2018-03-31 01:21:13 +01:00
|
|
|
/* The three arguments below are msatoshi_to_us,
|
|
|
|
|
* msatoshi_to_us_min, and msatoshi_to_us_max.
|
|
|
|
|
* Because, this is a newly-funded channel,
|
|
|
|
|
* all three are same value. */
|
2018-02-20 20:59:04 +00:00
|
|
|
our_msatoshi,
|
2018-03-31 01:21:13 +01:00
|
|
|
our_msatoshi, /* msatoshi_to_us_min */
|
|
|
|
|
our_msatoshi, /* msatoshi_to_us_max */
|
2018-02-20 20:59:04 +00:00
|
|
|
remote_commit,
|
|
|
|
|
remote_commit_sig,
|
|
|
|
|
NULL, /* No HTLC sigs yet */
|
|
|
|
|
channel_info,
|
|
|
|
|
NULL, /* No remote_shutdown_scriptpubkey yet */
|
2018-03-07 00:06:07 +00:00
|
|
|
final_key_idx, false,
|
2018-02-20 20:59:04 +00:00
|
|
|
NULL, /* No commit sent yet */
|
2018-08-02 07:49:56 +01:00
|
|
|
/* If we're fundee, could be a little before this
|
|
|
|
|
* in theory, but it's only used for timing out. */
|
|
|
|
|
get_block_height(ld->topology),
|
2018-04-26 05:51:01 +01:00
|
|
|
feerate, feerate,
|
|
|
|
|
/* We are connected */
|
2018-07-23 03:23:02 +01:00
|
|
|
true,
|
|
|
|
|
&uc->local_basepoints,
|
2018-08-17 06:06:36 +01:00
|
|
|
&uc->local_funding_pubkey,
|
|
|
|
|
NULL);
|
2018-02-20 20:59:04 +00:00
|
|
|
|
|
|
|
|
/* Now we finally put it in the database. */
|
|
|
|
|
wallet_channel_insert(ld->wallet, channel);
|
|
|
|
|
|
|
|
|
|
return channel;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void funding_broadcast_failed(struct channel *channel,
|
|
|
|
|
int exitstatus, const char *err)
|
|
|
|
|
{
|
|
|
|
|
channel_internal_error(channel,
|
|
|
|
|
"Funding broadcast exited with %i: %s",
|
|
|
|
|
exitstatus, err);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void opening_funder_finished(struct subd *openingd, const u8 *resp,
|
|
|
|
|
const int *fds,
|
|
|
|
|
struct funding_channel *fc)
|
|
|
|
|
{
|
|
|
|
|
u8 *msg, *linear;
|
|
|
|
|
struct channel_info channel_info;
|
|
|
|
|
struct bitcoin_tx *fundingtx;
|
|
|
|
|
struct bitcoin_txid funding_txid, expected_txid;
|
|
|
|
|
struct pubkey changekey;
|
|
|
|
|
struct crypto_state cs;
|
|
|
|
|
secp256k1_ecdsa_signature remote_commit_sig;
|
|
|
|
|
struct bitcoin_tx *remote_commit;
|
|
|
|
|
u16 funding_outnum;
|
|
|
|
|
u32 feerate;
|
|
|
|
|
u64 change_satoshi;
|
|
|
|
|
struct channel *channel;
|
|
|
|
|
struct json_result *response;
|
|
|
|
|
struct lightningd *ld = openingd->ld;
|
2018-03-16 23:37:02 +00:00
|
|
|
struct channel_id cid;
|
2018-02-20 20:59:04 +00:00
|
|
|
|
|
|
|
|
assert(tal_count(fds) == 2);
|
|
|
|
|
|
|
|
|
|
/* This is a new channel_info.their_config so set its ID to 0 */
|
|
|
|
|
channel_info.their_config.id = 0;
|
|
|
|
|
|
2018-02-20 20:59:09 +00:00
|
|
|
if (!fromwire_opening_funder_reply(resp, resp,
|
2018-02-20 20:59:04 +00:00
|
|
|
&channel_info.their_config,
|
|
|
|
|
&remote_commit,
|
|
|
|
|
&remote_commit_sig,
|
|
|
|
|
&cs,
|
|
|
|
|
&channel_info.theirbase.revocation,
|
|
|
|
|
&channel_info.theirbase.payment,
|
|
|
|
|
&channel_info.theirbase.htlc,
|
|
|
|
|
&channel_info.theirbase.delayed_payment,
|
|
|
|
|
&channel_info.remote_per_commit,
|
|
|
|
|
&fc->uc->minimum_depth,
|
|
|
|
|
&channel_info.remote_fundingkey,
|
|
|
|
|
&expected_txid,
|
2018-07-31 05:34:42 +01:00
|
|
|
&feerate,
|
|
|
|
|
&fc->uc->our_config.channel_reserve_satoshis)) {
|
2018-02-20 20:59:04 +00:00
|
|
|
log_broken(fc->uc->log,
|
|
|
|
|
"bad OPENING_FUNDER_REPLY %s",
|
|
|
|
|
tal_hex(resp, resp));
|
2018-05-24 22:40:18 +01:00
|
|
|
command_fail(fc->cmd, LIGHTNINGD, "bad OPENING_FUNDER_REPLY %s",
|
2018-02-20 20:59:04 +00:00
|
|
|
tal_hex(fc->cmd, resp));
|
|
|
|
|
goto failed;
|
|
|
|
|
}
|
|
|
|
|
log_debug(ld->log,
|
2018-03-15 04:30:39 +00:00
|
|
|
"%s", type_to_string(tmpctx, struct pubkey,
|
2018-02-20 20:59:04 +00:00
|
|
|
&channel_info.remote_per_commit));
|
|
|
|
|
|
|
|
|
|
/* Generate the funding tx. */
|
2018-04-05 20:19:47 +01:00
|
|
|
if (fc->wtx.change
|
2018-02-20 20:59:04 +00:00
|
|
|
&& !bip32_pubkey(ld->wallet->bip32_base,
|
2018-04-05 20:19:47 +01:00
|
|
|
&changekey, fc->wtx.change_key_index))
|
|
|
|
|
fatal("Error deriving change key %u", fc->wtx.change_key_index);
|
2018-02-20 20:59:04 +00:00
|
|
|
|
|
|
|
|
fundingtx = funding_tx(tmpctx, &funding_outnum,
|
2018-04-05 20:19:47 +01:00
|
|
|
fc->wtx.utxos, fc->wtx.amount,
|
2018-07-23 03:23:02 +01:00
|
|
|
&fc->uc->local_funding_pubkey,
|
2018-02-20 20:59:04 +00:00
|
|
|
&channel_info.remote_fundingkey,
|
2018-04-05 20:19:47 +01:00
|
|
|
fc->wtx.change, &changekey,
|
2018-02-20 20:59:04 +00:00
|
|
|
ld->wallet->bip32_base);
|
|
|
|
|
|
|
|
|
|
log_debug(fc->uc->log, "Funding tx has %zi inputs, %zu outputs:",
|
|
|
|
|
tal_count(fundingtx->input),
|
|
|
|
|
tal_count(fundingtx->output));
|
|
|
|
|
|
|
|
|
|
for (size_t i = 0; i < tal_count(fundingtx->input); i++) {
|
|
|
|
|
log_debug(fc->uc->log, "%zi: %"PRIu64" satoshi (%s) %s\n",
|
2018-04-05 20:19:47 +01:00
|
|
|
i, fc->wtx.utxos[i]->amount,
|
|
|
|
|
fc->wtx.utxos[i]->is_p2sh ? "P2SH" : "SEGWIT",
|
2018-03-15 04:30:39 +00:00
|
|
|
type_to_string(tmpctx, struct bitcoin_txid,
|
2018-02-20 20:59:04 +00:00
|
|
|
&fundingtx->input[i].txid));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bitcoin_txid(fundingtx, &funding_txid);
|
|
|
|
|
|
2018-07-04 06:30:02 +01:00
|
|
|
if (!bitcoin_txid_eq(&funding_txid, &expected_txid)) {
|
2018-02-20 20:59:04 +00:00
|
|
|
log_broken(fc->uc->log,
|
|
|
|
|
"Funding txid mismatch:"
|
|
|
|
|
" satoshi %"PRIu64" change %"PRIu64
|
|
|
|
|
" changeidx %u"
|
|
|
|
|
" localkey %s remotekey %s",
|
2018-04-05 20:19:47 +01:00
|
|
|
fc->wtx.amount,
|
|
|
|
|
fc->wtx.change, fc->wtx.change_key_index,
|
2018-02-20 20:59:04 +00:00
|
|
|
type_to_string(fc, struct pubkey,
|
2018-07-23 03:23:02 +01:00
|
|
|
&fc->uc->local_funding_pubkey),
|
2018-02-20 20:59:04 +00:00
|
|
|
type_to_string(fc, struct pubkey,
|
|
|
|
|
&channel_info.remote_fundingkey));
|
2018-05-24 22:40:18 +01:00
|
|
|
command_fail(fc->cmd, JSONRPC2_INVALID_PARAMS,
|
2018-02-20 20:59:04 +00:00
|
|
|
"Funding txid mismatch:"
|
|
|
|
|
" satoshi %"PRIu64" change %"PRIu64
|
|
|
|
|
" changeidx %u"
|
|
|
|
|
" localkey %s remotekey %s",
|
2018-04-05 20:19:47 +01:00
|
|
|
fc->wtx.amount,
|
|
|
|
|
fc->wtx.change, fc->wtx.change_key_index,
|
2018-02-20 20:59:04 +00:00
|
|
|
type_to_string(fc, struct pubkey,
|
2018-07-23 03:23:02 +01:00
|
|
|
&fc->uc->local_funding_pubkey),
|
2018-02-20 20:59:04 +00:00
|
|
|
type_to_string(fc, struct pubkey,
|
|
|
|
|
&channel_info.remote_fundingkey));
|
|
|
|
|
goto failed;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Steals fields from uc */
|
|
|
|
|
channel = wallet_commit_channel(ld, fc->uc,
|
|
|
|
|
remote_commit,
|
|
|
|
|
&remote_commit_sig,
|
|
|
|
|
&funding_txid,
|
|
|
|
|
funding_outnum,
|
2018-04-05 20:19:47 +01:00
|
|
|
fc->wtx.amount,
|
2018-02-20 20:59:04 +00:00
|
|
|
fc->push_msat,
|
|
|
|
|
fc->channel_flags,
|
|
|
|
|
&channel_info,
|
|
|
|
|
feerate);
|
2018-03-07 00:06:07 +00:00
|
|
|
if (!channel) {
|
2018-05-24 22:40:18 +01:00
|
|
|
command_fail(fc->cmd, LIGHTNINGD,
|
|
|
|
|
"Key generation failure");
|
2018-03-07 00:06:07 +00:00
|
|
|
goto failed;
|
|
|
|
|
}
|
2018-02-20 20:59:04 +00:00
|
|
|
|
|
|
|
|
/* Get HSM to sign the funding tx. */
|
|
|
|
|
log_debug(channel->log, "Getting HSM to sign funding tx");
|
|
|
|
|
|
|
|
|
|
msg = towire_hsm_sign_funding(tmpctx, channel->funding_satoshi,
|
2018-04-05 20:19:47 +01:00
|
|
|
fc->wtx.change, fc->wtx.change_key_index,
|
2018-07-23 03:23:02 +01:00
|
|
|
&fc->uc->local_funding_pubkey,
|
2018-02-20 20:59:04 +00:00
|
|
|
&channel_info.remote_fundingkey,
|
2018-04-05 20:19:47 +01:00
|
|
|
fc->wtx.utxos);
|
2018-02-20 20:59:04 +00:00
|
|
|
|
|
|
|
|
if (!wire_sync_write(ld->hsm_fd, take(msg)))
|
|
|
|
|
fatal("Could not write to HSM: %s", strerror(errno));
|
|
|
|
|
|
2018-07-09 12:17:59 +01:00
|
|
|
msg = wire_sync_read(fc, ld->hsm_fd);
|
2018-02-20 20:59:09 +00:00
|
|
|
if (!fromwire_hsm_sign_funding_reply(tmpctx, msg, &fundingtx))
|
2018-02-20 20:59:04 +00:00
|
|
|
fatal("HSM gave bad sign_funding_reply %s",
|
|
|
|
|
tal_hex(msg, resp));
|
|
|
|
|
|
|
|
|
|
/* Extract the change output and add it to the DB */
|
2018-02-26 10:36:48 +00:00
|
|
|
wallet_extract_owned_outputs(ld->wallet, fundingtx, NULL, &change_satoshi);
|
2018-02-20 20:59:04 +00:00
|
|
|
|
2018-03-21 22:39:21 +00:00
|
|
|
/* Make sure we recognize our change output by its scriptpubkey in
|
|
|
|
|
* future. This assumes that we have only two outputs, may not be true
|
|
|
|
|
* if we add support for multifundchannel */
|
|
|
|
|
if (tal_count(fundingtx->output) == 2)
|
|
|
|
|
txfilter_add_scriptpubkey(ld->owned_txfilter, fundingtx->output[!funding_outnum].script);
|
|
|
|
|
|
2018-02-20 20:59:04 +00:00
|
|
|
/* Send it out and watch for confirms. */
|
|
|
|
|
broadcast_tx(ld->topology, channel, fundingtx, funding_broadcast_failed);
|
|
|
|
|
|
|
|
|
|
channel_watch_funding(ld, channel);
|
|
|
|
|
|
|
|
|
|
/* Start normal channel daemon. */
|
2018-04-26 05:51:01 +01:00
|
|
|
peer_start_channeld(channel, &cs, fds[0], fds[1], NULL, false);
|
2018-02-20 20:59:04 +00:00
|
|
|
|
2018-04-05 20:19:47 +01:00
|
|
|
wallet_confirm_utxos(ld->wallet, fc->wtx.utxos);
|
2018-02-20 20:59:04 +00:00
|
|
|
|
|
|
|
|
response = new_json_result(fc->cmd);
|
|
|
|
|
json_object_start(response, NULL);
|
|
|
|
|
linear = linearize_tx(response, fundingtx);
|
2018-07-28 06:53:33 +01:00
|
|
|
json_add_hex_talarr(response, "tx", linear);
|
2018-02-20 20:59:04 +00:00
|
|
|
json_add_txid(response, "txid", &channel->funding_txid);
|
2018-03-16 23:37:02 +00:00
|
|
|
derive_channel_id(&cid, &channel->funding_txid, funding_outnum);
|
|
|
|
|
json_add_string(response, "channel_id",
|
|
|
|
|
type_to_string(tmpctx, struct channel_id, &cid));
|
2018-02-20 20:59:04 +00:00
|
|
|
json_object_end(response);
|
|
|
|
|
command_success(fc->cmd, response);
|
|
|
|
|
|
|
|
|
|
subd_release_channel(openingd, fc->uc);
|
2018-04-23 11:08:01 +01:00
|
|
|
fc->uc->openingd = NULL;
|
|
|
|
|
|
2018-02-20 20:59:04 +00:00
|
|
|
/* Frees fc too, and tmpctx */
|
|
|
|
|
tal_free(fc->uc);
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
failed:
|
|
|
|
|
close(fds[0]);
|
|
|
|
|
close(fds[1]);
|
|
|
|
|
subd_release_channel(openingd, fc->uc);
|
2018-04-23 11:08:01 +01:00
|
|
|
fc->uc->openingd = NULL;
|
2018-02-20 20:59:04 +00:00
|
|
|
/* Frees fc too, and tmpctx */
|
|
|
|
|
tal_free(fc->uc);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void opening_fundee_finished(struct subd *openingd,
|
|
|
|
|
const u8 *reply,
|
|
|
|
|
const int *fds,
|
|
|
|
|
struct uncommitted_channel *uc)
|
|
|
|
|
{
|
|
|
|
|
u8 *funding_signed;
|
|
|
|
|
struct channel_info channel_info;
|
|
|
|
|
struct crypto_state cs;
|
|
|
|
|
secp256k1_ecdsa_signature remote_commit_sig;
|
|
|
|
|
struct bitcoin_tx *remote_commit;
|
|
|
|
|
struct lightningd *ld = openingd->ld;
|
|
|
|
|
struct bitcoin_txid funding_txid;
|
|
|
|
|
u16 funding_outnum;
|
|
|
|
|
u64 funding_satoshi, push_msat;
|
|
|
|
|
u32 feerate;
|
|
|
|
|
u8 channel_flags;
|
|
|
|
|
struct channel *channel;
|
|
|
|
|
|
|
|
|
|
log_debug(uc->log, "Got opening_fundee_finish_response");
|
|
|
|
|
assert(tal_count(fds) == 2);
|
|
|
|
|
|
|
|
|
|
/* This is a new channel_info.their_config, set its ID to 0 */
|
|
|
|
|
channel_info.their_config.id = 0;
|
|
|
|
|
|
openingd: take peer before we're opening, wait for explicit funding msg.
Prior to this, lightningd would hand uninteresting peers back to connectd,
which would then return it to lightningd if it sent a non-gossip msg,
or if lightningd asked it to release the peer.
Now connectd hands the peer to lightningd once we've done the init
handshake, which hands it off to openingd.
This is a deep structural change, so we do the minimum here and cleanup
in the following patches.
Lightningd:
1. Remove peer_nongossip handling from connect_control and peer_control.
2. Remove list of outstanding fundchannel command; it was only needed to
find the race between us asking connectd to release the peer and it
reconnecting.
3. We can no longer tell if the remote end has started trying to fund a
channel (until it has succeeded): it's very transitory anyway so not
worth fixing.
4. We now always have a struct peer, and allocate an uncommitted_channel
for it, though it may never be used if neither end funds a channel.
5. We start funding on messages for openingd: we can get a funder_reply
or a fundee, or an error in response to our request to fund a channel.
so we handle all of them.
6. A new peer_start_openingd() is called after connectd hands us a peer.
7. json_fund_channel just looks through local peers; there are none
hidden in connectd any more.
8. We sometimes start a new openingd just to send an error message.
Openingd:
1. We always have information we need to accept them funding a channel (in
the init message).
2. We have to listen for three fds: peer, gossip and master, so we opencode
the poll.
3. We have an explicit message to start trying to fund a channel.
4. We can be told to send a message in our init message.
Testing:
1. We don't handle some things gracefully yet, so two tests are disabled.
2. 'hand_back_peer .*: now local again' from connectd is no longer a message,
openingd says 'Handed peer, entering loop' once its managing it.
3. peer['state'] used to be set to 'GOSSIPING' (otherwise this field doesn't
exist; 'state' is now per-channel. It doesn't exist at all now.
4. Some tests now need to turn on IO logging in openingd, not connectd.
5. There's a gap between connecting on one node and having connectd on
the peer hand over the connection to openingd. Our tests sometimes
checked getpeers() on the peer, and didn't see anything, so line_graph
needed updating.
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2018-08-08 15:10:58 +01:00
|
|
|
if (!fromwire_opening_fundee(tmpctx, reply,
|
2018-02-20 20:59:04 +00:00
|
|
|
&channel_info.their_config,
|
|
|
|
|
&remote_commit,
|
|
|
|
|
&remote_commit_sig,
|
|
|
|
|
&cs,
|
|
|
|
|
&channel_info.theirbase.revocation,
|
|
|
|
|
&channel_info.theirbase.payment,
|
|
|
|
|
&channel_info.theirbase.htlc,
|
|
|
|
|
&channel_info.theirbase.delayed_payment,
|
|
|
|
|
&channel_info.remote_per_commit,
|
|
|
|
|
&channel_info.remote_fundingkey,
|
|
|
|
|
&funding_txid,
|
|
|
|
|
&funding_outnum,
|
|
|
|
|
&funding_satoshi,
|
|
|
|
|
&push_msat,
|
|
|
|
|
&channel_flags,
|
|
|
|
|
&feerate,
|
2018-07-31 05:34:42 +01:00
|
|
|
&funding_signed,
|
|
|
|
|
&uc->our_config.channel_reserve_satoshis)) {
|
2018-02-20 20:59:04 +00:00
|
|
|
log_broken(uc->log, "bad OPENING_FUNDEE_REPLY %s",
|
|
|
|
|
tal_hex(reply, reply));
|
2018-08-09 01:25:29 +01:00
|
|
|
uncommitted_channel_disconnect(uc, "bad OPENING_FUNDEE_REPLY");
|
|
|
|
|
goto failed;
|
2018-02-20 20:59:04 +00:00
|
|
|
}
|
|
|
|
|
|
2018-08-09 01:25:29 +01:00
|
|
|
/* openingd should never accept them funding channel in this case. */
|
openingd: take peer before we're opening, wait for explicit funding msg.
Prior to this, lightningd would hand uninteresting peers back to connectd,
which would then return it to lightningd if it sent a non-gossip msg,
or if lightningd asked it to release the peer.
Now connectd hands the peer to lightningd once we've done the init
handshake, which hands it off to openingd.
This is a deep structural change, so we do the minimum here and cleanup
in the following patches.
Lightningd:
1. Remove peer_nongossip handling from connect_control and peer_control.
2. Remove list of outstanding fundchannel command; it was only needed to
find the race between us asking connectd to release the peer and it
reconnecting.
3. We can no longer tell if the remote end has started trying to fund a
channel (until it has succeeded): it's very transitory anyway so not
worth fixing.
4. We now always have a struct peer, and allocate an uncommitted_channel
for it, though it may never be used if neither end funds a channel.
5. We start funding on messages for openingd: we can get a funder_reply
or a fundee, or an error in response to our request to fund a channel.
so we handle all of them.
6. A new peer_start_openingd() is called after connectd hands us a peer.
7. json_fund_channel just looks through local peers; there are none
hidden in connectd any more.
8. We sometimes start a new openingd just to send an error message.
Openingd:
1. We always have information we need to accept them funding a channel (in
the init message).
2. We have to listen for three fds: peer, gossip and master, so we opencode
the poll.
3. We have an explicit message to start trying to fund a channel.
4. We can be told to send a message in our init message.
Testing:
1. We don't handle some things gracefully yet, so two tests are disabled.
2. 'hand_back_peer .*: now local again' from connectd is no longer a message,
openingd says 'Handed peer, entering loop' once its managing it.
3. peer['state'] used to be set to 'GOSSIPING' (otherwise this field doesn't
exist; 'state' is now per-channel. It doesn't exist at all now.
4. Some tests now need to turn on IO logging in openingd, not connectd.
5. There's a gap between connecting on one node and having connectd on
the peer hand over the connection to openingd. Our tests sometimes
checked getpeers() on the peer, and didn't see anything, so line_graph
needed updating.
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2018-08-08 15:10:58 +01:00
|
|
|
if (peer_active_channel(uc->peer)) {
|
2018-08-09 01:25:29 +01:00
|
|
|
log_broken(uc->log, "openingd accepted peer funding channel");
|
2018-08-09 01:25:29 +01:00
|
|
|
uncommitted_channel_disconnect(uc, "already have active channel");
|
|
|
|
|
goto failed;
|
openingd: take peer before we're opening, wait for explicit funding msg.
Prior to this, lightningd would hand uninteresting peers back to connectd,
which would then return it to lightningd if it sent a non-gossip msg,
or if lightningd asked it to release the peer.
Now connectd hands the peer to lightningd once we've done the init
handshake, which hands it off to openingd.
This is a deep structural change, so we do the minimum here and cleanup
in the following patches.
Lightningd:
1. Remove peer_nongossip handling from connect_control and peer_control.
2. Remove list of outstanding fundchannel command; it was only needed to
find the race between us asking connectd to release the peer and it
reconnecting.
3. We can no longer tell if the remote end has started trying to fund a
channel (until it has succeeded): it's very transitory anyway so not
worth fixing.
4. We now always have a struct peer, and allocate an uncommitted_channel
for it, though it may never be used if neither end funds a channel.
5. We start funding on messages for openingd: we can get a funder_reply
or a fundee, or an error in response to our request to fund a channel.
so we handle all of them.
6. A new peer_start_openingd() is called after connectd hands us a peer.
7. json_fund_channel just looks through local peers; there are none
hidden in connectd any more.
8. We sometimes start a new openingd just to send an error message.
Openingd:
1. We always have information we need to accept them funding a channel (in
the init message).
2. We have to listen for three fds: peer, gossip and master, so we opencode
the poll.
3. We have an explicit message to start trying to fund a channel.
4. We can be told to send a message in our init message.
Testing:
1. We don't handle some things gracefully yet, so two tests are disabled.
2. 'hand_back_peer .*: now local again' from connectd is no longer a message,
openingd says 'Handed peer, entering loop' once its managing it.
3. peer['state'] used to be set to 'GOSSIPING' (otherwise this field doesn't
exist; 'state' is now per-channel. It doesn't exist at all now.
4. Some tests now need to turn on IO logging in openingd, not connectd.
5. There's a gap between connecting on one node and having connectd on
the peer hand over the connection to openingd. Our tests sometimes
checked getpeers() on the peer, and didn't see anything, so line_graph
needed updating.
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2018-08-08 15:10:58 +01:00
|
|
|
}
|
|
|
|
|
|
2018-02-20 20:59:04 +00:00
|
|
|
/* Consumes uc */
|
|
|
|
|
channel = wallet_commit_channel(ld, uc,
|
|
|
|
|
remote_commit,
|
|
|
|
|
&remote_commit_sig,
|
|
|
|
|
&funding_txid,
|
|
|
|
|
funding_outnum,
|
|
|
|
|
funding_satoshi,
|
|
|
|
|
push_msat,
|
|
|
|
|
channel_flags,
|
|
|
|
|
&channel_info,
|
|
|
|
|
feerate);
|
2018-03-07 00:06:07 +00:00
|
|
|
if (!channel) {
|
2018-08-09 01:25:29 +01:00
|
|
|
uncommitted_channel_disconnect(uc, "Commit channel failed");
|
|
|
|
|
goto failed;
|
2018-03-07 00:06:07 +00:00
|
|
|
}
|
2018-02-20 20:59:04 +00:00
|
|
|
|
|
|
|
|
log_debug(channel->log, "Watching funding tx %s",
|
|
|
|
|
type_to_string(reply, struct bitcoin_txid,
|
|
|
|
|
&channel->funding_txid));
|
|
|
|
|
|
|
|
|
|
channel_watch_funding(ld, channel);
|
|
|
|
|
|
|
|
|
|
/* On to normal operation! */
|
2018-04-26 05:51:01 +01:00
|
|
|
peer_start_channeld(channel, &cs,
|
2018-02-20 20:59:04 +00:00
|
|
|
fds[0], fds[1], funding_signed, false);
|
|
|
|
|
|
|
|
|
|
subd_release_channel(openingd, uc);
|
2018-04-23 11:08:01 +01:00
|
|
|
uc->openingd = NULL;
|
2018-02-20 20:59:04 +00:00
|
|
|
tal_free(uc);
|
2018-08-09 01:25:29 +01:00
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
failed:
|
|
|
|
|
close(fds[0]);
|
|
|
|
|
close(fds[1]);
|
|
|
|
|
tal_free(uc);
|
2018-02-20 20:59:04 +00:00
|
|
|
}
|
|
|
|
|
|
2018-08-09 01:25:29 +01:00
|
|
|
static void opening_funder_failed(struct subd *openingd, const u8 *msg,
|
|
|
|
|
struct uncommitted_channel *uc)
|
|
|
|
|
{
|
|
|
|
|
char *desc;
|
|
|
|
|
|
|
|
|
|
if (!fromwire_opening_funder_failed(msg, msg, &desc)) {
|
|
|
|
|
log_broken(uc->log,
|
|
|
|
|
"bad OPENING_FUNDER_FAILED %s",
|
|
|
|
|
tal_hex(tmpctx, msg));
|
|
|
|
|
command_fail(uc->fc->cmd, LIGHTNINGD,
|
|
|
|
|
"bad OPENING_FUNDER_FAILED %s",
|
|
|
|
|
tal_hex(uc->fc->cmd, msg));
|
|
|
|
|
tal_free(uc);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
command_fail(uc->fc->cmd, LIGHTNINGD, "%s", desc);
|
|
|
|
|
|
|
|
|
|
/* Clear uc->fc, so we can try again, and so we don't fail twice
|
|
|
|
|
* if they close. */
|
|
|
|
|
uc->fc = tal_free(uc->fc);
|
|
|
|
|
}
|
|
|
|
|
|
2018-02-20 20:59:04 +00:00
|
|
|
static void opening_channel_errmsg(struct uncommitted_channel *uc,
|
|
|
|
|
int peer_fd, int gossip_fd,
|
|
|
|
|
const struct crypto_state *cs,
|
2018-03-05 16:40:50 +00:00
|
|
|
const struct channel_id *channel_id UNUSED,
|
2018-02-20 20:59:04 +00:00
|
|
|
const char *desc,
|
2018-08-09 01:25:29 +01:00
|
|
|
const u8 *err_for_them UNUSED)
|
2018-02-20 20:59:04 +00:00
|
|
|
{
|
openingd: take peer before we're opening, wait for explicit funding msg.
Prior to this, lightningd would hand uninteresting peers back to connectd,
which would then return it to lightningd if it sent a non-gossip msg,
or if lightningd asked it to release the peer.
Now connectd hands the peer to lightningd once we've done the init
handshake, which hands it off to openingd.
This is a deep structural change, so we do the minimum here and cleanup
in the following patches.
Lightningd:
1. Remove peer_nongossip handling from connect_control and peer_control.
2. Remove list of outstanding fundchannel command; it was only needed to
find the race between us asking connectd to release the peer and it
reconnecting.
3. We can no longer tell if the remote end has started trying to fund a
channel (until it has succeeded): it's very transitory anyway so not
worth fixing.
4. We now always have a struct peer, and allocate an uncommitted_channel
for it, though it may never be used if neither end funds a channel.
5. We start funding on messages for openingd: we can get a funder_reply
or a fundee, or an error in response to our request to fund a channel.
so we handle all of them.
6. A new peer_start_openingd() is called after connectd hands us a peer.
7. json_fund_channel just looks through local peers; there are none
hidden in connectd any more.
8. We sometimes start a new openingd just to send an error message.
Openingd:
1. We always have information we need to accept them funding a channel (in
the init message).
2. We have to listen for three fds: peer, gossip and master, so we opencode
the poll.
3. We have an explicit message to start trying to fund a channel.
4. We can be told to send a message in our init message.
Testing:
1. We don't handle some things gracefully yet, so two tests are disabled.
2. 'hand_back_peer .*: now local again' from connectd is no longer a message,
openingd says 'Handed peer, entering loop' once its managing it.
3. peer['state'] used to be set to 'GOSSIPING' (otherwise this field doesn't
exist; 'state' is now per-channel. It doesn't exist at all now.
4. Some tests now need to turn on IO logging in openingd, not connectd.
5. There's a gap between connecting on one node and having connectd on
the peer hand over the connection to openingd. Our tests sometimes
checked getpeers() on the peer, and didn't see anything, so line_graph
needed updating.
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2018-08-08 15:10:58 +01:00
|
|
|
if (peer_fd != -1) {
|
|
|
|
|
close(peer_fd);
|
|
|
|
|
close(gossip_fd);
|
2018-02-20 20:59:04 +00:00
|
|
|
}
|
openingd: take peer before we're opening, wait for explicit funding msg.
Prior to this, lightningd would hand uninteresting peers back to connectd,
which would then return it to lightningd if it sent a non-gossip msg,
or if lightningd asked it to release the peer.
Now connectd hands the peer to lightningd once we've done the init
handshake, which hands it off to openingd.
This is a deep structural change, so we do the minimum here and cleanup
in the following patches.
Lightningd:
1. Remove peer_nongossip handling from connect_control and peer_control.
2. Remove list of outstanding fundchannel command; it was only needed to
find the race between us asking connectd to release the peer and it
reconnecting.
3. We can no longer tell if the remote end has started trying to fund a
channel (until it has succeeded): it's very transitory anyway so not
worth fixing.
4. We now always have a struct peer, and allocate an uncommitted_channel
for it, though it may never be used if neither end funds a channel.
5. We start funding on messages for openingd: we can get a funder_reply
or a fundee, or an error in response to our request to fund a channel.
so we handle all of them.
6. A new peer_start_openingd() is called after connectd hands us a peer.
7. json_fund_channel just looks through local peers; there are none
hidden in connectd any more.
8. We sometimes start a new openingd just to send an error message.
Openingd:
1. We always have information we need to accept them funding a channel (in
the init message).
2. We have to listen for three fds: peer, gossip and master, so we opencode
the poll.
3. We have an explicit message to start trying to fund a channel.
4. We can be told to send a message in our init message.
Testing:
1. We don't handle some things gracefully yet, so two tests are disabled.
2. 'hand_back_peer .*: now local again' from connectd is no longer a message,
openingd says 'Handed peer, entering loop' once its managing it.
3. peer['state'] used to be set to 'GOSSIPING' (otherwise this field doesn't
exist; 'state' is now per-channel. It doesn't exist at all now.
4. Some tests now need to turn on IO logging in openingd, not connectd.
5. There's a gap between connecting on one node and having connectd on
the peer hand over the connection to openingd. Our tests sometimes
checked getpeers() on the peer, and didn't see anything, so line_graph
needed updating.
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2018-08-08 15:10:58 +01:00
|
|
|
uncommitted_channel_disconnect(uc, desc);
|
2018-02-20 20:59:04 +00:00
|
|
|
tal_free(uc);
|
|
|
|
|
}
|
|
|
|
|
|
2018-02-23 05:53:47 +00:00
|
|
|
/* There's nothing permanent in an unconfirmed transaction */
|
|
|
|
|
static void opening_channel_set_billboard(struct uncommitted_channel *uc,
|
|
|
|
|
bool perm UNUSED,
|
|
|
|
|
const char *happenings TAKES)
|
|
|
|
|
{
|
2018-02-23 05:53:47 +00:00
|
|
|
uc->transient_billboard = tal_free(uc->transient_billboard);
|
|
|
|
|
if (happenings)
|
|
|
|
|
uc->transient_billboard = tal_strdup(uc, happenings);
|
2018-02-23 05:53:47 +00:00
|
|
|
}
|
|
|
|
|
|
2018-02-20 20:59:04 +00:00
|
|
|
static void destroy_uncommitted_channel(struct uncommitted_channel *uc)
|
|
|
|
|
{
|
2018-04-23 11:08:01 +01:00
|
|
|
if (uc->openingd) {
|
|
|
|
|
struct subd *openingd = uc->openingd;
|
|
|
|
|
uc->openingd = NULL;
|
|
|
|
|
subd_release_channel(openingd, uc);
|
|
|
|
|
}
|
|
|
|
|
|
2018-08-02 07:49:55 +01:00
|
|
|
/* This is how shutdown_subdaemons tells us not to delete from db! */
|
|
|
|
|
if (!uc->peer->uncommitted_channel)
|
|
|
|
|
return;
|
|
|
|
|
|
2018-02-20 20:59:04 +00:00
|
|
|
uc->peer->uncommitted_channel = NULL;
|
|
|
|
|
|
2018-08-02 07:49:55 +01:00
|
|
|
maybe_delete_peer(uc->peer);
|
2018-02-20 20:59:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static struct uncommitted_channel *
|
openingd: take peer before we're opening, wait for explicit funding msg.
Prior to this, lightningd would hand uninteresting peers back to connectd,
which would then return it to lightningd if it sent a non-gossip msg,
or if lightningd asked it to release the peer.
Now connectd hands the peer to lightningd once we've done the init
handshake, which hands it off to openingd.
This is a deep structural change, so we do the minimum here and cleanup
in the following patches.
Lightningd:
1. Remove peer_nongossip handling from connect_control and peer_control.
2. Remove list of outstanding fundchannel command; it was only needed to
find the race between us asking connectd to release the peer and it
reconnecting.
3. We can no longer tell if the remote end has started trying to fund a
channel (until it has succeeded): it's very transitory anyway so not
worth fixing.
4. We now always have a struct peer, and allocate an uncommitted_channel
for it, though it may never be used if neither end funds a channel.
5. We start funding on messages for openingd: we can get a funder_reply
or a fundee, or an error in response to our request to fund a channel.
so we handle all of them.
6. A new peer_start_openingd() is called after connectd hands us a peer.
7. json_fund_channel just looks through local peers; there are none
hidden in connectd any more.
8. We sometimes start a new openingd just to send an error message.
Openingd:
1. We always have information we need to accept them funding a channel (in
the init message).
2. We have to listen for three fds: peer, gossip and master, so we opencode
the poll.
3. We have an explicit message to start trying to fund a channel.
4. We can be told to send a message in our init message.
Testing:
1. We don't handle some things gracefully yet, so two tests are disabled.
2. 'hand_back_peer .*: now local again' from connectd is no longer a message,
openingd says 'Handed peer, entering loop' once its managing it.
3. peer['state'] used to be set to 'GOSSIPING' (otherwise this field doesn't
exist; 'state' is now per-channel. It doesn't exist at all now.
4. Some tests now need to turn on IO logging in openingd, not connectd.
5. There's a gap between connecting on one node and having connectd on
the peer hand over the connection to openingd. Our tests sometimes
checked getpeers() on the peer, and didn't see anything, so line_graph
needed updating.
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2018-08-08 15:10:58 +01:00
|
|
|
new_uncommitted_channel(struct peer *peer)
|
2018-02-20 20:59:04 +00:00
|
|
|
{
|
openingd: take peer before we're opening, wait for explicit funding msg.
Prior to this, lightningd would hand uninteresting peers back to connectd,
which would then return it to lightningd if it sent a non-gossip msg,
or if lightningd asked it to release the peer.
Now connectd hands the peer to lightningd once we've done the init
handshake, which hands it off to openingd.
This is a deep structural change, so we do the minimum here and cleanup
in the following patches.
Lightningd:
1. Remove peer_nongossip handling from connect_control and peer_control.
2. Remove list of outstanding fundchannel command; it was only needed to
find the race between us asking connectd to release the peer and it
reconnecting.
3. We can no longer tell if the remote end has started trying to fund a
channel (until it has succeeded): it's very transitory anyway so not
worth fixing.
4. We now always have a struct peer, and allocate an uncommitted_channel
for it, though it may never be used if neither end funds a channel.
5. We start funding on messages for openingd: we can get a funder_reply
or a fundee, or an error in response to our request to fund a channel.
so we handle all of them.
6. A new peer_start_openingd() is called after connectd hands us a peer.
7. json_fund_channel just looks through local peers; there are none
hidden in connectd any more.
8. We sometimes start a new openingd just to send an error message.
Openingd:
1. We always have information we need to accept them funding a channel (in
the init message).
2. We have to listen for three fds: peer, gossip and master, so we opencode
the poll.
3. We have an explicit message to start trying to fund a channel.
4. We can be told to send a message in our init message.
Testing:
1. We don't handle some things gracefully yet, so two tests are disabled.
2. 'hand_back_peer .*: now local again' from connectd is no longer a message,
openingd says 'Handed peer, entering loop' once its managing it.
3. peer['state'] used to be set to 'GOSSIPING' (otherwise this field doesn't
exist; 'state' is now per-channel. It doesn't exist at all now.
4. Some tests now need to turn on IO logging in openingd, not connectd.
5. There's a gap between connecting on one node and having connectd on
the peer hand over the connection to openingd. Our tests sometimes
checked getpeers() on the peer, and didn't see anything, so line_graph
needed updating.
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2018-08-08 15:10:58 +01:00
|
|
|
struct lightningd *ld = peer->ld;
|
2018-02-20 20:59:04 +00:00
|
|
|
struct uncommitted_channel *uc = tal(ld, struct uncommitted_channel);
|
|
|
|
|
char *idname;
|
|
|
|
|
|
openingd: take peer before we're opening, wait for explicit funding msg.
Prior to this, lightningd would hand uninteresting peers back to connectd,
which would then return it to lightningd if it sent a non-gossip msg,
or if lightningd asked it to release the peer.
Now connectd hands the peer to lightningd once we've done the init
handshake, which hands it off to openingd.
This is a deep structural change, so we do the minimum here and cleanup
in the following patches.
Lightningd:
1. Remove peer_nongossip handling from connect_control and peer_control.
2. Remove list of outstanding fundchannel command; it was only needed to
find the race between us asking connectd to release the peer and it
reconnecting.
3. We can no longer tell if the remote end has started trying to fund a
channel (until it has succeeded): it's very transitory anyway so not
worth fixing.
4. We now always have a struct peer, and allocate an uncommitted_channel
for it, though it may never be used if neither end funds a channel.
5. We start funding on messages for openingd: we can get a funder_reply
or a fundee, or an error in response to our request to fund a channel.
so we handle all of them.
6. A new peer_start_openingd() is called after connectd hands us a peer.
7. json_fund_channel just looks through local peers; there are none
hidden in connectd any more.
8. We sometimes start a new openingd just to send an error message.
Openingd:
1. We always have information we need to accept them funding a channel (in
the init message).
2. We have to listen for three fds: peer, gossip and master, so we opencode
the poll.
3. We have an explicit message to start trying to fund a channel.
4. We can be told to send a message in our init message.
Testing:
1. We don't handle some things gracefully yet, so two tests are disabled.
2. 'hand_back_peer .*: now local again' from connectd is no longer a message,
openingd says 'Handed peer, entering loop' once its managing it.
3. peer['state'] used to be set to 'GOSSIPING' (otherwise this field doesn't
exist; 'state' is now per-channel. It doesn't exist at all now.
4. Some tests now need to turn on IO logging in openingd, not connectd.
5. There's a gap between connecting on one node and having connectd on
the peer hand over the connection to openingd. Our tests sometimes
checked getpeers() on the peer, and didn't see anything, so line_graph
needed updating.
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2018-08-08 15:10:58 +01:00
|
|
|
uc->peer = peer;
|
|
|
|
|
assert(!peer->uncommitted_channel);
|
2018-02-20 20:59:04 +00:00
|
|
|
|
2018-02-23 05:53:47 +00:00
|
|
|
uc->transient_billboard = NULL;
|
2018-02-20 20:59:04 +00:00
|
|
|
uc->dbid = wallet_get_channel_dbid(ld->wallet);
|
|
|
|
|
|
|
|
|
|
idname = type_to_string(uc, struct pubkey, &uc->peer->id);
|
|
|
|
|
uc->log = new_log(uc, uc->peer->log_book, "%s chan #%"PRIu64":",
|
|
|
|
|
idname, uc->dbid);
|
|
|
|
|
tal_free(idname);
|
|
|
|
|
|
openingd: take peer before we're opening, wait for explicit funding msg.
Prior to this, lightningd would hand uninteresting peers back to connectd,
which would then return it to lightningd if it sent a non-gossip msg,
or if lightningd asked it to release the peer.
Now connectd hands the peer to lightningd once we've done the init
handshake, which hands it off to openingd.
This is a deep structural change, so we do the minimum here and cleanup
in the following patches.
Lightningd:
1. Remove peer_nongossip handling from connect_control and peer_control.
2. Remove list of outstanding fundchannel command; it was only needed to
find the race between us asking connectd to release the peer and it
reconnecting.
3. We can no longer tell if the remote end has started trying to fund a
channel (until it has succeeded): it's very transitory anyway so not
worth fixing.
4. We now always have a struct peer, and allocate an uncommitted_channel
for it, though it may never be used if neither end funds a channel.
5. We start funding on messages for openingd: we can get a funder_reply
or a fundee, or an error in response to our request to fund a channel.
so we handle all of them.
6. A new peer_start_openingd() is called after connectd hands us a peer.
7. json_fund_channel just looks through local peers; there are none
hidden in connectd any more.
8. We sometimes start a new openingd just to send an error message.
Openingd:
1. We always have information we need to accept them funding a channel (in
the init message).
2. We have to listen for three fds: peer, gossip and master, so we opencode
the poll.
3. We have an explicit message to start trying to fund a channel.
4. We can be told to send a message in our init message.
Testing:
1. We don't handle some things gracefully yet, so two tests are disabled.
2. 'hand_back_peer .*: now local again' from connectd is no longer a message,
openingd says 'Handed peer, entering loop' once its managing it.
3. peer['state'] used to be set to 'GOSSIPING' (otherwise this field doesn't
exist; 'state' is now per-channel. It doesn't exist at all now.
4. Some tests now need to turn on IO logging in openingd, not connectd.
5. There's a gap between connecting on one node and having connectd on
the peer hand over the connection to openingd. Our tests sometimes
checked getpeers() on the peer, and didn't see anything, so line_graph
needed updating.
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2018-08-08 15:10:58 +01:00
|
|
|
uc->fc = NULL;
|
2018-02-20 20:59:04 +00:00
|
|
|
uc->our_config.id = 0;
|
|
|
|
|
|
2018-07-23 03:23:03 +01:00
|
|
|
get_channel_basepoints(ld, &uc->peer->id, uc->dbid,
|
|
|
|
|
&uc->local_basepoints, &uc->local_funding_pubkey);
|
2018-07-23 03:23:02 +01:00
|
|
|
|
2018-02-20 20:59:04 +00:00
|
|
|
uc->peer->uncommitted_channel = uc;
|
|
|
|
|
tal_add_destructor(uc, destroy_uncommitted_channel);
|
|
|
|
|
|
|
|
|
|
return uc;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void channel_config(struct lightningd *ld,
|
|
|
|
|
struct channel_config *ours,
|
|
|
|
|
u32 *max_to_self_delay,
|
|
|
|
|
u64 *min_effective_htlc_capacity_msat)
|
|
|
|
|
{
|
|
|
|
|
/* FIXME: depend on feerate. */
|
|
|
|
|
*max_to_self_delay = ld->config.locktime_max;
|
|
|
|
|
/* This is 1c at $1000/BTC */
|
|
|
|
|
*min_effective_htlc_capacity_msat = 1000000;
|
|
|
|
|
|
|
|
|
|
/* BOLT #2:
|
|
|
|
|
*
|
2018-06-17 11:13:44 +01:00
|
|
|
* The sending node SHOULD:
|
|
|
|
|
*...
|
|
|
|
|
* - set `dust_limit_satoshis` to a sufficient value to allow
|
|
|
|
|
* commitment transactions to propagate through the Bitcoin network.
|
2018-02-20 20:59:04 +00:00
|
|
|
*/
|
|
|
|
|
ours->dust_limit_satoshis = 546;
|
|
|
|
|
ours->max_htlc_value_in_flight_msat = UINT64_MAX;
|
|
|
|
|
|
|
|
|
|
/* Don't care */
|
|
|
|
|
ours->htlc_minimum_msat = 0;
|
|
|
|
|
|
|
|
|
|
/* BOLT #2:
|
|
|
|
|
*
|
2018-06-17 11:13:44 +01:00
|
|
|
* The sending node SHOULD:
|
|
|
|
|
* - set `to_self_delay` sufficient to ensure the sender can
|
|
|
|
|
* irreversibly spend a commitment transaction output, in case of
|
|
|
|
|
* misbehavior by the receiver.
|
2018-02-20 20:59:04 +00:00
|
|
|
*/
|
|
|
|
|
ours->to_self_delay = ld->config.locktime_blocks;
|
|
|
|
|
|
|
|
|
|
/* BOLT #2:
|
|
|
|
|
*
|
2018-06-17 11:13:44 +01:00
|
|
|
* The receiving node MUST fail the channel if:
|
|
|
|
|
*...
|
|
|
|
|
* - `max_accepted_htlcs` is greater than 483.
|
2018-02-20 20:59:04 +00:00
|
|
|
*/
|
|
|
|
|
ours->max_accepted_htlcs = 483;
|
|
|
|
|
|
|
|
|
|
/* This is filled in by lightning_openingd, for consistency. */
|
2018-07-31 05:34:42 +01:00
|
|
|
ours->channel_reserve_satoshis = -1;
|
|
|
|
|
}
|
2018-02-20 20:59:04 +00:00
|
|
|
|
openingd: take peer before we're opening, wait for explicit funding msg.
Prior to this, lightningd would hand uninteresting peers back to connectd,
which would then return it to lightningd if it sent a non-gossip msg,
or if lightningd asked it to release the peer.
Now connectd hands the peer to lightningd once we've done the init
handshake, which hands it off to openingd.
This is a deep structural change, so we do the minimum here and cleanup
in the following patches.
Lightningd:
1. Remove peer_nongossip handling from connect_control and peer_control.
2. Remove list of outstanding fundchannel command; it was only needed to
find the race between us asking connectd to release the peer and it
reconnecting.
3. We can no longer tell if the remote end has started trying to fund a
channel (until it has succeeded): it's very transitory anyway so not
worth fixing.
4. We now always have a struct peer, and allocate an uncommitted_channel
for it, though it may never be used if neither end funds a channel.
5. We start funding on messages for openingd: we can get a funder_reply
or a fundee, or an error in response to our request to fund a channel.
so we handle all of them.
6. A new peer_start_openingd() is called after connectd hands us a peer.
7. json_fund_channel just looks through local peers; there are none
hidden in connectd any more.
8. We sometimes start a new openingd just to send an error message.
Openingd:
1. We always have information we need to accept them funding a channel (in
the init message).
2. We have to listen for three fds: peer, gossip and master, so we opencode
the poll.
3. We have an explicit message to start trying to fund a channel.
4. We can be told to send a message in our init message.
Testing:
1. We don't handle some things gracefully yet, so two tests are disabled.
2. 'hand_back_peer .*: now local again' from connectd is no longer a message,
openingd says 'Handed peer, entering loop' once its managing it.
3. peer['state'] used to be set to 'GOSSIPING' (otherwise this field doesn't
exist; 'state' is now per-channel. It doesn't exist at all now.
4. Some tests now need to turn on IO logging in openingd, not connectd.
5. There's a gap between connecting on one node and having connectd on
the peer hand over the connection to openingd. Our tests sometimes
checked getpeers() on the peer, and didn't see anything, so line_graph
needed updating.
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2018-08-08 15:10:58 +01:00
|
|
|
static unsigned int openingd_msg(struct subd *openingd,
|
|
|
|
|
const u8 *msg, const int *fds)
|
|
|
|
|
{
|
|
|
|
|
enum opening_wire_type t = fromwire_peektype(msg);
|
|
|
|
|
struct uncommitted_channel *uc = openingd->channel;
|
|
|
|
|
|
|
|
|
|
switch (t) {
|
|
|
|
|
case WIRE_OPENING_FUNDER_REPLY:
|
|
|
|
|
if (!uc->fc) {
|
|
|
|
|
log_broken(openingd->log, "Unexpected FUNDER_REPLY %s",
|
|
|
|
|
tal_hex(tmpctx, msg));
|
|
|
|
|
tal_free(openingd);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
if (tal_count(fds) != 2)
|
|
|
|
|
return 2;
|
|
|
|
|
opening_funder_finished(openingd, msg, fds, uc->fc);
|
|
|
|
|
return 0;
|
|
|
|
|
|
2018-08-09 01:25:29 +01:00
|
|
|
case WIRE_OPENING_FUNDER_FAILED:
|
|
|
|
|
if (!uc->fc) {
|
|
|
|
|
log_broken(openingd->log, "Unexpected FUNDER_FAILED %s",
|
|
|
|
|
tal_hex(tmpctx, msg));
|
|
|
|
|
tal_free(openingd);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
opening_funder_failed(openingd, msg, uc);
|
|
|
|
|
return 0;
|
|
|
|
|
|
openingd: take peer before we're opening, wait for explicit funding msg.
Prior to this, lightningd would hand uninteresting peers back to connectd,
which would then return it to lightningd if it sent a non-gossip msg,
or if lightningd asked it to release the peer.
Now connectd hands the peer to lightningd once we've done the init
handshake, which hands it off to openingd.
This is a deep structural change, so we do the minimum here and cleanup
in the following patches.
Lightningd:
1. Remove peer_nongossip handling from connect_control and peer_control.
2. Remove list of outstanding fundchannel command; it was only needed to
find the race between us asking connectd to release the peer and it
reconnecting.
3. We can no longer tell if the remote end has started trying to fund a
channel (until it has succeeded): it's very transitory anyway so not
worth fixing.
4. We now always have a struct peer, and allocate an uncommitted_channel
for it, though it may never be used if neither end funds a channel.
5. We start funding on messages for openingd: we can get a funder_reply
or a fundee, or an error in response to our request to fund a channel.
so we handle all of them.
6. A new peer_start_openingd() is called after connectd hands us a peer.
7. json_fund_channel just looks through local peers; there are none
hidden in connectd any more.
8. We sometimes start a new openingd just to send an error message.
Openingd:
1. We always have information we need to accept them funding a channel (in
the init message).
2. We have to listen for three fds: peer, gossip and master, so we opencode
the poll.
3. We have an explicit message to start trying to fund a channel.
4. We can be told to send a message in our init message.
Testing:
1. We don't handle some things gracefully yet, so two tests are disabled.
2. 'hand_back_peer .*: now local again' from connectd is no longer a message,
openingd says 'Handed peer, entering loop' once its managing it.
3. peer['state'] used to be set to 'GOSSIPING' (otherwise this field doesn't
exist; 'state' is now per-channel. It doesn't exist at all now.
4. Some tests now need to turn on IO logging in openingd, not connectd.
5. There's a gap between connecting on one node and having connectd on
the peer hand over the connection to openingd. Our tests sometimes
checked getpeers() on the peer, and didn't see anything, so line_graph
needed updating.
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2018-08-08 15:10:58 +01:00
|
|
|
case WIRE_OPENING_FUNDEE:
|
|
|
|
|
if (tal_count(fds) != 2)
|
|
|
|
|
return 2;
|
|
|
|
|
opening_fundee_finished(openingd, msg, fds, uc);
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
/* We send these! */
|
|
|
|
|
case WIRE_OPENING_INIT:
|
|
|
|
|
case WIRE_OPENING_FUNDER:
|
2018-08-09 01:25:29 +01:00
|
|
|
case WIRE_OPENING_CAN_ACCEPT_CHANNEL:
|
openingd: take peer before we're opening, wait for explicit funding msg.
Prior to this, lightningd would hand uninteresting peers back to connectd,
which would then return it to lightningd if it sent a non-gossip msg,
or if lightningd asked it to release the peer.
Now connectd hands the peer to lightningd once we've done the init
handshake, which hands it off to openingd.
This is a deep structural change, so we do the minimum here and cleanup
in the following patches.
Lightningd:
1. Remove peer_nongossip handling from connect_control and peer_control.
2. Remove list of outstanding fundchannel command; it was only needed to
find the race between us asking connectd to release the peer and it
reconnecting.
3. We can no longer tell if the remote end has started trying to fund a
channel (until it has succeeded): it's very transitory anyway so not
worth fixing.
4. We now always have a struct peer, and allocate an uncommitted_channel
for it, though it may never be used if neither end funds a channel.
5. We start funding on messages for openingd: we can get a funder_reply
or a fundee, or an error in response to our request to fund a channel.
so we handle all of them.
6. A new peer_start_openingd() is called after connectd hands us a peer.
7. json_fund_channel just looks through local peers; there are none
hidden in connectd any more.
8. We sometimes start a new openingd just to send an error message.
Openingd:
1. We always have information we need to accept them funding a channel (in
the init message).
2. We have to listen for three fds: peer, gossip and master, so we opencode
the poll.
3. We have an explicit message to start trying to fund a channel.
4. We can be told to send a message in our init message.
Testing:
1. We don't handle some things gracefully yet, so two tests are disabled.
2. 'hand_back_peer .*: now local again' from connectd is no longer a message,
openingd says 'Handed peer, entering loop' once its managing it.
3. peer['state'] used to be set to 'GOSSIPING' (otherwise this field doesn't
exist; 'state' is now per-channel. It doesn't exist at all now.
4. Some tests now need to turn on IO logging in openingd, not connectd.
5. There's a gap between connecting on one node and having connectd on
the peer hand over the connection to openingd. Our tests sometimes
checked getpeers() on the peer, and didn't see anything, so line_graph
needed updating.
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2018-08-08 15:10:58 +01:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
log_broken(openingd->log, "Unexpected msg %s: %s",
|
|
|
|
|
opening_wire_type_name(t), tal_hex(tmpctx, msg));
|
|
|
|
|
tal_free(openingd);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void peer_start_openingd(struct peer *peer,
|
|
|
|
|
const struct crypto_state *cs,
|
|
|
|
|
int peer_fd, int gossip_fd,
|
|
|
|
|
const u8 *send_msg)
|
2018-02-20 20:59:04 +00:00
|
|
|
{
|
openingd: take peer before we're opening, wait for explicit funding msg.
Prior to this, lightningd would hand uninteresting peers back to connectd,
which would then return it to lightningd if it sent a non-gossip msg,
or if lightningd asked it to release the peer.
Now connectd hands the peer to lightningd once we've done the init
handshake, which hands it off to openingd.
This is a deep structural change, so we do the minimum here and cleanup
in the following patches.
Lightningd:
1. Remove peer_nongossip handling from connect_control and peer_control.
2. Remove list of outstanding fundchannel command; it was only needed to
find the race between us asking connectd to release the peer and it
reconnecting.
3. We can no longer tell if the remote end has started trying to fund a
channel (until it has succeeded): it's very transitory anyway so not
worth fixing.
4. We now always have a struct peer, and allocate an uncommitted_channel
for it, though it may never be used if neither end funds a channel.
5. We start funding on messages for openingd: we can get a funder_reply
or a fundee, or an error in response to our request to fund a channel.
so we handle all of them.
6. A new peer_start_openingd() is called after connectd hands us a peer.
7. json_fund_channel just looks through local peers; there are none
hidden in connectd any more.
8. We sometimes start a new openingd just to send an error message.
Openingd:
1. We always have information we need to accept them funding a channel (in
the init message).
2. We have to listen for three fds: peer, gossip and master, so we opencode
the poll.
3. We have an explicit message to start trying to fund a channel.
4. We can be told to send a message in our init message.
Testing:
1. We don't handle some things gracefully yet, so two tests are disabled.
2. 'hand_back_peer .*: now local again' from connectd is no longer a message,
openingd says 'Handed peer, entering loop' once its managing it.
3. peer['state'] used to be set to 'GOSSIPING' (otherwise this field doesn't
exist; 'state' is now per-channel. It doesn't exist at all now.
4. Some tests now need to turn on IO logging in openingd, not connectd.
5. There's a gap between connecting on one node and having connectd on
the peer hand over the connection to openingd. Our tests sometimes
checked getpeers() on the peer, and didn't see anything, so line_graph
needed updating.
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2018-08-08 15:10:58 +01:00
|
|
|
int hsmfd;
|
2018-05-17 05:46:22 +01:00
|
|
|
u32 max_to_self_delay;
|
2018-02-20 20:59:04 +00:00
|
|
|
u64 min_effective_htlc_capacity_msat;
|
|
|
|
|
struct uncommitted_channel *uc;
|
openingd: take peer before we're opening, wait for explicit funding msg.
Prior to this, lightningd would hand uninteresting peers back to connectd,
which would then return it to lightningd if it sent a non-gossip msg,
or if lightningd asked it to release the peer.
Now connectd hands the peer to lightningd once we've done the init
handshake, which hands it off to openingd.
This is a deep structural change, so we do the minimum here and cleanup
in the following patches.
Lightningd:
1. Remove peer_nongossip handling from connect_control and peer_control.
2. Remove list of outstanding fundchannel command; it was only needed to
find the race between us asking connectd to release the peer and it
reconnecting.
3. We can no longer tell if the remote end has started trying to fund a
channel (until it has succeeded): it's very transitory anyway so not
worth fixing.
4. We now always have a struct peer, and allocate an uncommitted_channel
for it, though it may never be used if neither end funds a channel.
5. We start funding on messages for openingd: we can get a funder_reply
or a fundee, or an error in response to our request to fund a channel.
so we handle all of them.
6. A new peer_start_openingd() is called after connectd hands us a peer.
7. json_fund_channel just looks through local peers; there are none
hidden in connectd any more.
8. We sometimes start a new openingd just to send an error message.
Openingd:
1. We always have information we need to accept them funding a channel (in
the init message).
2. We have to listen for three fds: peer, gossip and master, so we opencode
the poll.
3. We have an explicit message to start trying to fund a channel.
4. We can be told to send a message in our init message.
Testing:
1. We don't handle some things gracefully yet, so two tests are disabled.
2. 'hand_back_peer .*: now local again' from connectd is no longer a message,
openingd says 'Handed peer, entering loop' once its managing it.
3. peer['state'] used to be set to 'GOSSIPING' (otherwise this field doesn't
exist; 'state' is now per-channel. It doesn't exist at all now.
4. Some tests now need to turn on IO logging in openingd, not connectd.
5. There's a gap between connecting on one node and having connectd on
the peer hand over the connection to openingd. Our tests sometimes
checked getpeers() on the peer, and didn't see anything, so line_graph
needed updating.
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2018-08-08 15:10:58 +01:00
|
|
|
const u8 *msg;
|
2018-02-20 20:59:04 +00:00
|
|
|
|
openingd: take peer before we're opening, wait for explicit funding msg.
Prior to this, lightningd would hand uninteresting peers back to connectd,
which would then return it to lightningd if it sent a non-gossip msg,
or if lightningd asked it to release the peer.
Now connectd hands the peer to lightningd once we've done the init
handshake, which hands it off to openingd.
This is a deep structural change, so we do the minimum here and cleanup
in the following patches.
Lightningd:
1. Remove peer_nongossip handling from connect_control and peer_control.
2. Remove list of outstanding fundchannel command; it was only needed to
find the race between us asking connectd to release the peer and it
reconnecting.
3. We can no longer tell if the remote end has started trying to fund a
channel (until it has succeeded): it's very transitory anyway so not
worth fixing.
4. We now always have a struct peer, and allocate an uncommitted_channel
for it, though it may never be used if neither end funds a channel.
5. We start funding on messages for openingd: we can get a funder_reply
or a fundee, or an error in response to our request to fund a channel.
so we handle all of them.
6. A new peer_start_openingd() is called after connectd hands us a peer.
7. json_fund_channel just looks through local peers; there are none
hidden in connectd any more.
8. We sometimes start a new openingd just to send an error message.
Openingd:
1. We always have information we need to accept them funding a channel (in
the init message).
2. We have to listen for three fds: peer, gossip and master, so we opencode
the poll.
3. We have an explicit message to start trying to fund a channel.
4. We can be told to send a message in our init message.
Testing:
1. We don't handle some things gracefully yet, so two tests are disabled.
2. 'hand_back_peer .*: now local again' from connectd is no longer a message,
openingd says 'Handed peer, entering loop' once its managing it.
3. peer['state'] used to be set to 'GOSSIPING' (otherwise this field doesn't
exist; 'state' is now per-channel. It doesn't exist at all now.
4. Some tests now need to turn on IO logging in openingd, not connectd.
5. There's a gap between connecting on one node and having connectd on
the peer hand over the connection to openingd. Our tests sometimes
checked getpeers() on the peer, and didn't see anything, so line_graph
needed updating.
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2018-08-08 15:10:58 +01:00
|
|
|
assert(!peer->uncommitted_channel);
|
2018-02-20 20:59:04 +00:00
|
|
|
|
openingd: take peer before we're opening, wait for explicit funding msg.
Prior to this, lightningd would hand uninteresting peers back to connectd,
which would then return it to lightningd if it sent a non-gossip msg,
or if lightningd asked it to release the peer.
Now connectd hands the peer to lightningd once we've done the init
handshake, which hands it off to openingd.
This is a deep structural change, so we do the minimum here and cleanup
in the following patches.
Lightningd:
1. Remove peer_nongossip handling from connect_control and peer_control.
2. Remove list of outstanding fundchannel command; it was only needed to
find the race between us asking connectd to release the peer and it
reconnecting.
3. We can no longer tell if the remote end has started trying to fund a
channel (until it has succeeded): it's very transitory anyway so not
worth fixing.
4. We now always have a struct peer, and allocate an uncommitted_channel
for it, though it may never be used if neither end funds a channel.
5. We start funding on messages for openingd: we can get a funder_reply
or a fundee, or an error in response to our request to fund a channel.
so we handle all of them.
6. A new peer_start_openingd() is called after connectd hands us a peer.
7. json_fund_channel just looks through local peers; there are none
hidden in connectd any more.
8. We sometimes start a new openingd just to send an error message.
Openingd:
1. We always have information we need to accept them funding a channel (in
the init message).
2. We have to listen for three fds: peer, gossip and master, so we opencode
the poll.
3. We have an explicit message to start trying to fund a channel.
4. We can be told to send a message in our init message.
Testing:
1. We don't handle some things gracefully yet, so two tests are disabled.
2. 'hand_back_peer .*: now local again' from connectd is no longer a message,
openingd says 'Handed peer, entering loop' once its managing it.
3. peer['state'] used to be set to 'GOSSIPING' (otherwise this field doesn't
exist; 'state' is now per-channel. It doesn't exist at all now.
4. Some tests now need to turn on IO logging in openingd, not connectd.
5. There's a gap between connecting on one node and having connectd on
the peer hand over the connection to openingd. Our tests sometimes
checked getpeers() on the peer, and didn't see anything, so line_graph
needed updating.
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2018-08-08 15:10:58 +01:00
|
|
|
uc = peer->uncommitted_channel = new_uncommitted_channel(peer);
|
2018-02-20 20:59:04 +00:00
|
|
|
|
openingd: take peer before we're opening, wait for explicit funding msg.
Prior to this, lightningd would hand uninteresting peers back to connectd,
which would then return it to lightningd if it sent a non-gossip msg,
or if lightningd asked it to release the peer.
Now connectd hands the peer to lightningd once we've done the init
handshake, which hands it off to openingd.
This is a deep structural change, so we do the minimum here and cleanup
in the following patches.
Lightningd:
1. Remove peer_nongossip handling from connect_control and peer_control.
2. Remove list of outstanding fundchannel command; it was only needed to
find the race between us asking connectd to release the peer and it
reconnecting.
3. We can no longer tell if the remote end has started trying to fund a
channel (until it has succeeded): it's very transitory anyway so not
worth fixing.
4. We now always have a struct peer, and allocate an uncommitted_channel
for it, though it may never be used if neither end funds a channel.
5. We start funding on messages for openingd: we can get a funder_reply
or a fundee, or an error in response to our request to fund a channel.
so we handle all of them.
6. A new peer_start_openingd() is called after connectd hands us a peer.
7. json_fund_channel just looks through local peers; there are none
hidden in connectd any more.
8. We sometimes start a new openingd just to send an error message.
Openingd:
1. We always have information we need to accept them funding a channel (in
the init message).
2. We have to listen for three fds: peer, gossip and master, so we opencode
the poll.
3. We have an explicit message to start trying to fund a channel.
4. We can be told to send a message in our init message.
Testing:
1. We don't handle some things gracefully yet, so two tests are disabled.
2. 'hand_back_peer .*: now local again' from connectd is no longer a message,
openingd says 'Handed peer, entering loop' once its managing it.
3. peer['state'] used to be set to 'GOSSIPING' (otherwise this field doesn't
exist; 'state' is now per-channel. It doesn't exist at all now.
4. Some tests now need to turn on IO logging in openingd, not connectd.
5. There's a gap between connecting on one node and having connectd on
the peer hand over the connection to openingd. Our tests sometimes
checked getpeers() on the peer, and didn't see anything, so line_graph
needed updating.
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2018-08-08 15:10:58 +01:00
|
|
|
hsmfd = hsm_get_client_fd(peer->ld, &uc->peer->id, uc->dbid,
|
2018-07-23 03:23:03 +01:00
|
|
|
HSM_CAP_COMMITMENT_POINT
|
|
|
|
|
| HSM_CAP_SIGN_REMOTE_TX);
|
|
|
|
|
|
openingd: take peer before we're opening, wait for explicit funding msg.
Prior to this, lightningd would hand uninteresting peers back to connectd,
which would then return it to lightningd if it sent a non-gossip msg,
or if lightningd asked it to release the peer.
Now connectd hands the peer to lightningd once we've done the init
handshake, which hands it off to openingd.
This is a deep structural change, so we do the minimum here and cleanup
in the following patches.
Lightningd:
1. Remove peer_nongossip handling from connect_control and peer_control.
2. Remove list of outstanding fundchannel command; it was only needed to
find the race between us asking connectd to release the peer and it
reconnecting.
3. We can no longer tell if the remote end has started trying to fund a
channel (until it has succeeded): it's very transitory anyway so not
worth fixing.
4. We now always have a struct peer, and allocate an uncommitted_channel
for it, though it may never be used if neither end funds a channel.
5. We start funding on messages for openingd: we can get a funder_reply
or a fundee, or an error in response to our request to fund a channel.
so we handle all of them.
6. A new peer_start_openingd() is called after connectd hands us a peer.
7. json_fund_channel just looks through local peers; there are none
hidden in connectd any more.
8. We sometimes start a new openingd just to send an error message.
Openingd:
1. We always have information we need to accept them funding a channel (in
the init message).
2. We have to listen for three fds: peer, gossip and master, so we opencode
the poll.
3. We have an explicit message to start trying to fund a channel.
4. We can be told to send a message in our init message.
Testing:
1. We don't handle some things gracefully yet, so two tests are disabled.
2. 'hand_back_peer .*: now local again' from connectd is no longer a message,
openingd says 'Handed peer, entering loop' once its managing it.
3. peer['state'] used to be set to 'GOSSIPING' (otherwise this field doesn't
exist; 'state' is now per-channel. It doesn't exist at all now.
4. Some tests now need to turn on IO logging in openingd, not connectd.
5. There's a gap between connecting on one node and having connectd on
the peer hand over the connection to openingd. Our tests sometimes
checked getpeers() on the peer, and didn't see anything, so line_graph
needed updating.
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2018-08-08 15:10:58 +01:00
|
|
|
uc->openingd = new_channel_subd(peer->ld,
|
|
|
|
|
"lightning_openingd",
|
|
|
|
|
uc, uc->log,
|
|
|
|
|
true, opening_wire_type_name,
|
|
|
|
|
openingd_msg,
|
2018-02-20 20:59:04 +00:00
|
|
|
opening_channel_errmsg,
|
2018-02-23 05:53:47 +00:00
|
|
|
opening_channel_set_billboard,
|
2018-02-20 20:59:04 +00:00
|
|
|
take(&peer_fd), take(&gossip_fd),
|
2018-07-23 03:23:03 +01:00
|
|
|
take(&hsmfd), NULL);
|
2018-02-20 20:59:04 +00:00
|
|
|
if (!uc->openingd) {
|
openingd: take peer before we're opening, wait for explicit funding msg.
Prior to this, lightningd would hand uninteresting peers back to connectd,
which would then return it to lightningd if it sent a non-gossip msg,
or if lightningd asked it to release the peer.
Now connectd hands the peer to lightningd once we've done the init
handshake, which hands it off to openingd.
This is a deep structural change, so we do the minimum here and cleanup
in the following patches.
Lightningd:
1. Remove peer_nongossip handling from connect_control and peer_control.
2. Remove list of outstanding fundchannel command; it was only needed to
find the race between us asking connectd to release the peer and it
reconnecting.
3. We can no longer tell if the remote end has started trying to fund a
channel (until it has succeeded): it's very transitory anyway so not
worth fixing.
4. We now always have a struct peer, and allocate an uncommitted_channel
for it, though it may never be used if neither end funds a channel.
5. We start funding on messages for openingd: we can get a funder_reply
or a fundee, or an error in response to our request to fund a channel.
so we handle all of them.
6. A new peer_start_openingd() is called after connectd hands us a peer.
7. json_fund_channel just looks through local peers; there are none
hidden in connectd any more.
8. We sometimes start a new openingd just to send an error message.
Openingd:
1. We always have information we need to accept them funding a channel (in
the init message).
2. We have to listen for three fds: peer, gossip and master, so we opencode
the poll.
3. We have an explicit message to start trying to fund a channel.
4. We can be told to send a message in our init message.
Testing:
1. We don't handle some things gracefully yet, so two tests are disabled.
2. 'hand_back_peer .*: now local again' from connectd is no longer a message,
openingd says 'Handed peer, entering loop' once its managing it.
3. peer['state'] used to be set to 'GOSSIPING' (otherwise this field doesn't
exist; 'state' is now per-channel. It doesn't exist at all now.
4. Some tests now need to turn on IO logging in openingd, not connectd.
5. There's a gap between connecting on one node and having connectd on
the peer hand over the connection to openingd. Our tests sometimes
checked getpeers() on the peer, and didn't see anything, so line_graph
needed updating.
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2018-08-08 15:10:58 +01:00
|
|
|
uncommitted_channel_disconnect(uc,
|
|
|
|
|
tal_fmt(tmpctx,
|
|
|
|
|
"Running lightning_openingd: %s",
|
|
|
|
|
strerror(errno)));
|
|
|
|
|
return;
|
2018-02-20 20:59:04 +00:00
|
|
|
}
|
|
|
|
|
|
openingd: take peer before we're opening, wait for explicit funding msg.
Prior to this, lightningd would hand uninteresting peers back to connectd,
which would then return it to lightningd if it sent a non-gossip msg,
or if lightningd asked it to release the peer.
Now connectd hands the peer to lightningd once we've done the init
handshake, which hands it off to openingd.
This is a deep structural change, so we do the minimum here and cleanup
in the following patches.
Lightningd:
1. Remove peer_nongossip handling from connect_control and peer_control.
2. Remove list of outstanding fundchannel command; it was only needed to
find the race between us asking connectd to release the peer and it
reconnecting.
3. We can no longer tell if the remote end has started trying to fund a
channel (until it has succeeded): it's very transitory anyway so not
worth fixing.
4. We now always have a struct peer, and allocate an uncommitted_channel
for it, though it may never be used if neither end funds a channel.
5. We start funding on messages for openingd: we can get a funder_reply
or a fundee, or an error in response to our request to fund a channel.
so we handle all of them.
6. A new peer_start_openingd() is called after connectd hands us a peer.
7. json_fund_channel just looks through local peers; there are none
hidden in connectd any more.
8. We sometimes start a new openingd just to send an error message.
Openingd:
1. We always have information we need to accept them funding a channel (in
the init message).
2. We have to listen for three fds: peer, gossip and master, so we opencode
the poll.
3. We have an explicit message to start trying to fund a channel.
4. We can be told to send a message in our init message.
Testing:
1. We don't handle some things gracefully yet, so two tests are disabled.
2. 'hand_back_peer .*: now local again' from connectd is no longer a message,
openingd says 'Handed peer, entering loop' once its managing it.
3. peer['state'] used to be set to 'GOSSIPING' (otherwise this field doesn't
exist; 'state' is now per-channel. It doesn't exist at all now.
4. Some tests now need to turn on IO logging in openingd, not connectd.
5. There's a gap between connecting on one node and having connectd on
the peer hand over the connection to openingd. Our tests sometimes
checked getpeers() on the peer, and didn't see anything, so line_graph
needed updating.
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2018-08-08 15:10:58 +01:00
|
|
|
channel_config(peer->ld, &uc->our_config,
|
|
|
|
|
&max_to_self_delay,
|
|
|
|
|
&min_effective_htlc_capacity_msat);
|
|
|
|
|
|
2018-02-20 20:59:04 +00:00
|
|
|
/* BOLT #2:
|
|
|
|
|
*
|
2018-06-17 11:13:44 +01:00
|
|
|
* The sender:
|
|
|
|
|
* - SHOULD set `minimum_depth` to a number of blocks it considers
|
|
|
|
|
* reasonable to avoid double-spending of the funding transaction.
|
2018-02-20 20:59:04 +00:00
|
|
|
*/
|
openingd: take peer before we're opening, wait for explicit funding msg.
Prior to this, lightningd would hand uninteresting peers back to connectd,
which would then return it to lightningd if it sent a non-gossip msg,
or if lightningd asked it to release the peer.
Now connectd hands the peer to lightningd once we've done the init
handshake, which hands it off to openingd.
This is a deep structural change, so we do the minimum here and cleanup
in the following patches.
Lightningd:
1. Remove peer_nongossip handling from connect_control and peer_control.
2. Remove list of outstanding fundchannel command; it was only needed to
find the race between us asking connectd to release the peer and it
reconnecting.
3. We can no longer tell if the remote end has started trying to fund a
channel (until it has succeeded): it's very transitory anyway so not
worth fixing.
4. We now always have a struct peer, and allocate an uncommitted_channel
for it, though it may never be used if neither end funds a channel.
5. We start funding on messages for openingd: we can get a funder_reply
or a fundee, or an error in response to our request to fund a channel.
so we handle all of them.
6. A new peer_start_openingd() is called after connectd hands us a peer.
7. json_fund_channel just looks through local peers; there are none
hidden in connectd any more.
8. We sometimes start a new openingd just to send an error message.
Openingd:
1. We always have information we need to accept them funding a channel (in
the init message).
2. We have to listen for three fds: peer, gossip and master, so we opencode
the poll.
3. We have an explicit message to start trying to fund a channel.
4. We can be told to send a message in our init message.
Testing:
1. We don't handle some things gracefully yet, so two tests are disabled.
2. 'hand_back_peer .*: now local again' from connectd is no longer a message,
openingd says 'Handed peer, entering loop' once its managing it.
3. peer['state'] used to be set to 'GOSSIPING' (otherwise this field doesn't
exist; 'state' is now per-channel. It doesn't exist at all now.
4. Some tests now need to turn on IO logging in openingd, not connectd.
5. There's a gap between connecting on one node and having connectd on
the peer hand over the connection to openingd. Our tests sometimes
checked getpeers() on the peer, and didn't see anything, so line_graph
needed updating.
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2018-08-08 15:10:58 +01:00
|
|
|
uc->minimum_depth = peer->ld->config.anchor_confirms;
|
2018-02-20 20:59:04 +00:00
|
|
|
|
openingd: take peer before we're opening, wait for explicit funding msg.
Prior to this, lightningd would hand uninteresting peers back to connectd,
which would then return it to lightningd if it sent a non-gossip msg,
or if lightningd asked it to release the peer.
Now connectd hands the peer to lightningd once we've done the init
handshake, which hands it off to openingd.
This is a deep structural change, so we do the minimum here and cleanup
in the following patches.
Lightningd:
1. Remove peer_nongossip handling from connect_control and peer_control.
2. Remove list of outstanding fundchannel command; it was only needed to
find the race between us asking connectd to release the peer and it
reconnecting.
3. We can no longer tell if the remote end has started trying to fund a
channel (until it has succeeded): it's very transitory anyway so not
worth fixing.
4. We now always have a struct peer, and allocate an uncommitted_channel
for it, though it may never be used if neither end funds a channel.
5. We start funding on messages for openingd: we can get a funder_reply
or a fundee, or an error in response to our request to fund a channel.
so we handle all of them.
6. A new peer_start_openingd() is called after connectd hands us a peer.
7. json_fund_channel just looks through local peers; there are none
hidden in connectd any more.
8. We sometimes start a new openingd just to send an error message.
Openingd:
1. We always have information we need to accept them funding a channel (in
the init message).
2. We have to listen for three fds: peer, gossip and master, so we opencode
the poll.
3. We have an explicit message to start trying to fund a channel.
4. We can be told to send a message in our init message.
Testing:
1. We don't handle some things gracefully yet, so two tests are disabled.
2. 'hand_back_peer .*: now local again' from connectd is no longer a message,
openingd says 'Handed peer, entering loop' once its managing it.
3. peer['state'] used to be set to 'GOSSIPING' (otherwise this field doesn't
exist; 'state' is now per-channel. It doesn't exist at all now.
4. Some tests now need to turn on IO logging in openingd, not connectd.
5. There's a gap between connecting on one node and having connectd on
the peer hand over the connection to openingd. Our tests sometimes
checked getpeers() on the peer, and didn't see anything, so line_graph
needed updating.
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2018-08-08 15:10:58 +01:00
|
|
|
msg = towire_opening_init(NULL, get_chainparams(peer->ld)->index,
|
2018-02-20 20:59:04 +00:00
|
|
|
&uc->our_config,
|
|
|
|
|
max_to_self_delay,
|
|
|
|
|
min_effective_htlc_capacity_msat,
|
2018-07-23 03:23:03 +01:00
|
|
|
cs, &uc->local_basepoints,
|
openingd: take peer before we're opening, wait for explicit funding msg.
Prior to this, lightningd would hand uninteresting peers back to connectd,
which would then return it to lightningd if it sent a non-gossip msg,
or if lightningd asked it to release the peer.
Now connectd hands the peer to lightningd once we've done the init
handshake, which hands it off to openingd.
This is a deep structural change, so we do the minimum here and cleanup
in the following patches.
Lightningd:
1. Remove peer_nongossip handling from connect_control and peer_control.
2. Remove list of outstanding fundchannel command; it was only needed to
find the race between us asking connectd to release the peer and it
reconnecting.
3. We can no longer tell if the remote end has started trying to fund a
channel (until it has succeeded): it's very transitory anyway so not
worth fixing.
4. We now always have a struct peer, and allocate an uncommitted_channel
for it, though it may never be used if neither end funds a channel.
5. We start funding on messages for openingd: we can get a funder_reply
or a fundee, or an error in response to our request to fund a channel.
so we handle all of them.
6. A new peer_start_openingd() is called after connectd hands us a peer.
7. json_fund_channel just looks through local peers; there are none
hidden in connectd any more.
8. We sometimes start a new openingd just to send an error message.
Openingd:
1. We always have information we need to accept them funding a channel (in
the init message).
2. We have to listen for three fds: peer, gossip and master, so we opencode
the poll.
3. We have an explicit message to start trying to fund a channel.
4. We can be told to send a message in our init message.
Testing:
1. We don't handle some things gracefully yet, so two tests are disabled.
2. 'hand_back_peer .*: now local again' from connectd is no longer a message,
openingd says 'Handed peer, entering loop' once its managing it.
3. peer['state'] used to be set to 'GOSSIPING' (otherwise this field doesn't
exist; 'state' is now per-channel. It doesn't exist at all now.
4. Some tests now need to turn on IO logging in openingd, not connectd.
5. There's a gap between connecting on one node and having connectd on
the peer hand over the connection to openingd. Our tests sometimes
checked getpeers() on the peer, and didn't see anything, so line_graph
needed updating.
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2018-08-08 15:10:58 +01:00
|
|
|
&uc->local_funding_pubkey,
|
|
|
|
|
uc->minimum_depth,
|
2018-08-23 00:27:25 +01:00
|
|
|
feerate_min(peer->ld, NULL),
|
|
|
|
|
feerate_max(peer->ld, NULL),
|
2018-08-09 01:25:29 +01:00
|
|
|
!peer_active_channel(peer),
|
openingd: take peer before we're opening, wait for explicit funding msg.
Prior to this, lightningd would hand uninteresting peers back to connectd,
which would then return it to lightningd if it sent a non-gossip msg,
or if lightningd asked it to release the peer.
Now connectd hands the peer to lightningd once we've done the init
handshake, which hands it off to openingd.
This is a deep structural change, so we do the minimum here and cleanup
in the following patches.
Lightningd:
1. Remove peer_nongossip handling from connect_control and peer_control.
2. Remove list of outstanding fundchannel command; it was only needed to
find the race between us asking connectd to release the peer and it
reconnecting.
3. We can no longer tell if the remote end has started trying to fund a
channel (until it has succeeded): it's very transitory anyway so not
worth fixing.
4. We now always have a struct peer, and allocate an uncommitted_channel
for it, though it may never be used if neither end funds a channel.
5. We start funding on messages for openingd: we can get a funder_reply
or a fundee, or an error in response to our request to fund a channel.
so we handle all of them.
6. A new peer_start_openingd() is called after connectd hands us a peer.
7. json_fund_channel just looks through local peers; there are none
hidden in connectd any more.
8. We sometimes start a new openingd just to send an error message.
Openingd:
1. We always have information we need to accept them funding a channel (in
the init message).
2. We have to listen for three fds: peer, gossip and master, so we opencode
the poll.
3. We have an explicit message to start trying to fund a channel.
4. We can be told to send a message in our init message.
Testing:
1. We don't handle some things gracefully yet, so two tests are disabled.
2. 'hand_back_peer .*: now local again' from connectd is no longer a message,
openingd says 'Handed peer, entering loop' once its managing it.
3. peer['state'] used to be set to 'GOSSIPING' (otherwise this field doesn't
exist; 'state' is now per-channel. It doesn't exist at all now.
4. Some tests now need to turn on IO logging in openingd, not connectd.
5. There's a gap between connecting on one node and having connectd on
the peer hand over the connection to openingd. Our tests sometimes
checked getpeers() on the peer, and didn't see anything, so line_graph
needed updating.
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2018-08-08 15:10:58 +01:00
|
|
|
send_msg);
|
2018-02-20 20:59:04 +00:00
|
|
|
subd_send_msg(uc->openingd, take(msg));
|
2018-04-23 11:08:01 +01:00
|
|
|
}
|
|
|
|
|
|
2018-08-09 01:25:29 +01:00
|
|
|
void opening_peer_no_active_channels(struct peer *peer)
|
|
|
|
|
{
|
|
|
|
|
assert(!peer_active_channel(peer));
|
|
|
|
|
if (peer->uncommitted_channel) {
|
|
|
|
|
subd_send_msg(peer->uncommitted_channel->openingd,
|
|
|
|
|
take(towire_opening_can_accept_channel(NULL)));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2018-03-20 23:06:04 +00:00
|
|
|
/**
|
|
|
|
|
* json_fund_channel - Entrypoint for funding a channel
|
|
|
|
|
*/
|
2018-02-20 20:59:04 +00:00
|
|
|
static void json_fund_channel(struct command *cmd,
|
|
|
|
|
const char *buffer, const jsmntok_t *params)
|
|
|
|
|
{
|
openingd: take peer before we're opening, wait for explicit funding msg.
Prior to this, lightningd would hand uninteresting peers back to connectd,
which would then return it to lightningd if it sent a non-gossip msg,
or if lightningd asked it to release the peer.
Now connectd hands the peer to lightningd once we've done the init
handshake, which hands it off to openingd.
This is a deep structural change, so we do the minimum here and cleanup
in the following patches.
Lightningd:
1. Remove peer_nongossip handling from connect_control and peer_control.
2. Remove list of outstanding fundchannel command; it was only needed to
find the race between us asking connectd to release the peer and it
reconnecting.
3. We can no longer tell if the remote end has started trying to fund a
channel (until it has succeeded): it's very transitory anyway so not
worth fixing.
4. We now always have a struct peer, and allocate an uncommitted_channel
for it, though it may never be used if neither end funds a channel.
5. We start funding on messages for openingd: we can get a funder_reply
or a fundee, or an error in response to our request to fund a channel.
so we handle all of them.
6. A new peer_start_openingd() is called after connectd hands us a peer.
7. json_fund_channel just looks through local peers; there are none
hidden in connectd any more.
8. We sometimes start a new openingd just to send an error message.
Openingd:
1. We always have information we need to accept them funding a channel (in
the init message).
2. We have to listen for three fds: peer, gossip and master, so we opencode
the poll.
3. We have an explicit message to start trying to fund a channel.
4. We can be told to send a message in our init message.
Testing:
1. We don't handle some things gracefully yet, so two tests are disabled.
2. 'hand_back_peer .*: now local again' from connectd is no longer a message,
openingd says 'Handed peer, entering loop' once its managing it.
3. peer['state'] used to be set to 'GOSSIPING' (otherwise this field doesn't
exist; 'state' is now per-channel. It doesn't exist at all now.
4. Some tests now need to turn on IO logging in openingd, not connectd.
5. There's a gap between connecting on one node and having connectd on
the peer hand over the connection to openingd. Our tests sometimes
checked getpeers() on the peer, and didn't see anything, so line_graph
needed updating.
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2018-08-08 15:10:58 +01:00
|
|
|
const jsmntok_t *sattok;
|
2018-04-05 20:19:47 +01:00
|
|
|
struct funding_channel * fc = tal(cmd, struct funding_channel);
|
2018-08-14 22:19:31 +01:00
|
|
|
struct pubkey *id;
|
openingd: take peer before we're opening, wait for explicit funding msg.
Prior to this, lightningd would hand uninteresting peers back to connectd,
which would then return it to lightningd if it sent a non-gossip msg,
or if lightningd asked it to release the peer.
Now connectd hands the peer to lightningd once we've done the init
handshake, which hands it off to openingd.
This is a deep structural change, so we do the minimum here and cleanup
in the following patches.
Lightningd:
1. Remove peer_nongossip handling from connect_control and peer_control.
2. Remove list of outstanding fundchannel command; it was only needed to
find the race between us asking connectd to release the peer and it
reconnecting.
3. We can no longer tell if the remote end has started trying to fund a
channel (until it has succeeded): it's very transitory anyway so not
worth fixing.
4. We now always have a struct peer, and allocate an uncommitted_channel
for it, though it may never be used if neither end funds a channel.
5. We start funding on messages for openingd: we can get a funder_reply
or a fundee, or an error in response to our request to fund a channel.
so we handle all of them.
6. A new peer_start_openingd() is called after connectd hands us a peer.
7. json_fund_channel just looks through local peers; there are none
hidden in connectd any more.
8. We sometimes start a new openingd just to send an error message.
Openingd:
1. We always have information we need to accept them funding a channel (in
the init message).
2. We have to listen for three fds: peer, gossip and master, so we opencode
the poll.
3. We have an explicit message to start trying to fund a channel.
4. We can be told to send a message in our init message.
Testing:
1. We don't handle some things gracefully yet, so two tests are disabled.
2. 'hand_back_peer .*: now local again' from connectd is no longer a message,
openingd says 'Handed peer, entering loop' once its managing it.
3. peer['state'] used to be set to 'GOSSIPING' (otherwise this field doesn't
exist; 'state' is now per-channel. It doesn't exist at all now.
4. Some tests now need to turn on IO logging in openingd, not connectd.
5. There's a gap between connecting on one node and having connectd on
the peer hand over the connection to openingd. Our tests sometimes
checked getpeers() on the peer, and didn't see anything, so line_graph
needed updating.
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2018-08-08 15:10:58 +01:00
|
|
|
struct peer *peer;
|
|
|
|
|
struct channel *channel;
|
2018-08-27 06:13:57 +01:00
|
|
|
unsigned int *feerate;
|
|
|
|
|
enum feerate_style *style;
|
|
|
|
|
u32 feerate_per_kw;
|
2018-02-20 20:59:04 +00:00
|
|
|
u8 *msg;
|
|
|
|
|
|
2018-04-05 20:19:47 +01:00
|
|
|
fc->cmd = cmd;
|
|
|
|
|
fc->uc = NULL;
|
|
|
|
|
wtx_init(cmd, &fc->wtx);
|
2018-07-20 02:14:02 +01:00
|
|
|
if (!param(fc->cmd, buffer, params,
|
2018-08-15 16:16:02 +01:00
|
|
|
p_req("id", json_tok_pubkey, &id),
|
|
|
|
|
p_req("satoshi", json_tok_tok, &sattok),
|
2018-08-27 06:13:57 +01:00
|
|
|
p_opt("feerate", json_tok_number, &feerate),
|
|
|
|
|
p_opt("feeratestyle", json_tok_feerate_style, &style),
|
2018-07-20 02:14:02 +01:00
|
|
|
NULL))
|
2018-02-20 20:59:04 +00:00
|
|
|
return;
|
2018-07-20 02:14:02 +01:00
|
|
|
|
2018-07-29 06:51:38 +01:00
|
|
|
if (!json_tok_wtx(&fc->wtx, buffer, sattok, MAX_FUNDING_SATOSHI))
|
2018-02-20 20:59:04 +00:00
|
|
|
return;
|
openingd: take peer before we're opening, wait for explicit funding msg.
Prior to this, lightningd would hand uninteresting peers back to connectd,
which would then return it to lightningd if it sent a non-gossip msg,
or if lightningd asked it to release the peer.
Now connectd hands the peer to lightningd once we've done the init
handshake, which hands it off to openingd.
This is a deep structural change, so we do the minimum here and cleanup
in the following patches.
Lightningd:
1. Remove peer_nongossip handling from connect_control and peer_control.
2. Remove list of outstanding fundchannel command; it was only needed to
find the race between us asking connectd to release the peer and it
reconnecting.
3. We can no longer tell if the remote end has started trying to fund a
channel (until it has succeeded): it's very transitory anyway so not
worth fixing.
4. We now always have a struct peer, and allocate an uncommitted_channel
for it, though it may never be used if neither end funds a channel.
5. We start funding on messages for openingd: we can get a funder_reply
or a fundee, or an error in response to our request to fund a channel.
so we handle all of them.
6. A new peer_start_openingd() is called after connectd hands us a peer.
7. json_fund_channel just looks through local peers; there are none
hidden in connectd any more.
8. We sometimes start a new openingd just to send an error message.
Openingd:
1. We always have information we need to accept them funding a channel (in
the init message).
2. We have to listen for three fds: peer, gossip and master, so we opencode
the poll.
3. We have an explicit message to start trying to fund a channel.
4. We can be told to send a message in our init message.
Testing:
1. We don't handle some things gracefully yet, so two tests are disabled.
2. 'hand_back_peer .*: now local again' from connectd is no longer a message,
openingd says 'Handed peer, entering loop' once its managing it.
3. peer['state'] used to be set to 'GOSSIPING' (otherwise this field doesn't
exist; 'state' is now per-channel. It doesn't exist at all now.
4. Some tests now need to turn on IO logging in openingd, not connectd.
5. There's a gap between connecting on one node and having connectd on
the peer hand over the connection to openingd. Our tests sometimes
checked getpeers() on the peer, and didn't see anything, so line_graph
needed updating.
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2018-08-08 15:10:58 +01:00
|
|
|
|
2018-08-27 06:13:57 +01:00
|
|
|
if (!json_feerate_and_style(cmd, feerate, style,
|
|
|
|
|
opening_feerate(cmd->ld->topology),
|
|
|
|
|
&feerate_per_kw))
|
2018-08-23 00:27:25 +01:00
|
|
|
return;
|
|
|
|
|
|
2018-08-14 22:19:31 +01:00
|
|
|
peer = peer_by_id(cmd->ld, id);
|
openingd: take peer before we're opening, wait for explicit funding msg.
Prior to this, lightningd would hand uninteresting peers back to connectd,
which would then return it to lightningd if it sent a non-gossip msg,
or if lightningd asked it to release the peer.
Now connectd hands the peer to lightningd once we've done the init
handshake, which hands it off to openingd.
This is a deep structural change, so we do the minimum here and cleanup
in the following patches.
Lightningd:
1. Remove peer_nongossip handling from connect_control and peer_control.
2. Remove list of outstanding fundchannel command; it was only needed to
find the race between us asking connectd to release the peer and it
reconnecting.
3. We can no longer tell if the remote end has started trying to fund a
channel (until it has succeeded): it's very transitory anyway so not
worth fixing.
4. We now always have a struct peer, and allocate an uncommitted_channel
for it, though it may never be used if neither end funds a channel.
5. We start funding on messages for openingd: we can get a funder_reply
or a fundee, or an error in response to our request to fund a channel.
so we handle all of them.
6. A new peer_start_openingd() is called after connectd hands us a peer.
7. json_fund_channel just looks through local peers; there are none
hidden in connectd any more.
8. We sometimes start a new openingd just to send an error message.
Openingd:
1. We always have information we need to accept them funding a channel (in
the init message).
2. We have to listen for three fds: peer, gossip and master, so we opencode
the poll.
3. We have an explicit message to start trying to fund a channel.
4. We can be told to send a message in our init message.
Testing:
1. We don't handle some things gracefully yet, so two tests are disabled.
2. 'hand_back_peer .*: now local again' from connectd is no longer a message,
openingd says 'Handed peer, entering loop' once its managing it.
3. peer['state'] used to be set to 'GOSSIPING' (otherwise this field doesn't
exist; 'state' is now per-channel. It doesn't exist at all now.
4. Some tests now need to turn on IO logging in openingd, not connectd.
5. There's a gap between connecting on one node and having connectd on
the peer hand over the connection to openingd. Our tests sometimes
checked getpeers() on the peer, and didn't see anything, so line_graph
needed updating.
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2018-08-08 15:10:58 +01:00
|
|
|
if (!peer) {
|
|
|
|
|
command_fail(cmd, LIGHTNINGD, "Unknown peer");
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
channel = peer_active_channel(peer);
|
|
|
|
|
if (channel) {
|
|
|
|
|
command_fail(cmd, LIGHTNINGD, "Peer already %s",
|
|
|
|
|
channel_state_name(channel));
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!peer->uncommitted_channel) {
|
|
|
|
|
command_fail(cmd, LIGHTNINGD, "Peer not connected");
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (peer->uncommitted_channel->fc) {
|
|
|
|
|
command_fail(cmd, LIGHTNINGD, "Already funding channel");
|
2018-02-20 20:59:04 +00:00
|
|
|
return;
|
|
|
|
|
}
|
2018-04-05 20:19:47 +01:00
|
|
|
|
2018-02-20 20:59:04 +00:00
|
|
|
/* FIXME: Support push_msat? */
|
|
|
|
|
fc->push_msat = 0;
|
|
|
|
|
fc->channel_flags = OUR_CHANNEL_FLAGS;
|
|
|
|
|
|
2018-04-05 20:19:47 +01:00
|
|
|
if (!wtx_select_utxos(&fc->wtx, feerate_per_kw,
|
|
|
|
|
BITCOIN_SCRIPTPUBKEY_P2WSH_LEN))
|
|
|
|
|
return;
|
2018-03-20 23:06:04 +00:00
|
|
|
|
2018-07-29 06:51:38 +01:00
|
|
|
assert(fc->wtx.amount <= MAX_FUNDING_SATOSHI);
|
2018-02-20 20:59:04 +00:00
|
|
|
|
openingd: take peer before we're opening, wait for explicit funding msg.
Prior to this, lightningd would hand uninteresting peers back to connectd,
which would then return it to lightningd if it sent a non-gossip msg,
or if lightningd asked it to release the peer.
Now connectd hands the peer to lightningd once we've done the init
handshake, which hands it off to openingd.
This is a deep structural change, so we do the minimum here and cleanup
in the following patches.
Lightningd:
1. Remove peer_nongossip handling from connect_control and peer_control.
2. Remove list of outstanding fundchannel command; it was only needed to
find the race between us asking connectd to release the peer and it
reconnecting.
3. We can no longer tell if the remote end has started trying to fund a
channel (until it has succeeded): it's very transitory anyway so not
worth fixing.
4. We now always have a struct peer, and allocate an uncommitted_channel
for it, though it may never be used if neither end funds a channel.
5. We start funding on messages for openingd: we can get a funder_reply
or a fundee, or an error in response to our request to fund a channel.
so we handle all of them.
6. A new peer_start_openingd() is called after connectd hands us a peer.
7. json_fund_channel just looks through local peers; there are none
hidden in connectd any more.
8. We sometimes start a new openingd just to send an error message.
Openingd:
1. We always have information we need to accept them funding a channel (in
the init message).
2. We have to listen for three fds: peer, gossip and master, so we opencode
the poll.
3. We have an explicit message to start trying to fund a channel.
4. We can be told to send a message in our init message.
Testing:
1. We don't handle some things gracefully yet, so two tests are disabled.
2. 'hand_back_peer .*: now local again' from connectd is no longer a message,
openingd says 'Handed peer, entering loop' once its managing it.
3. peer['state'] used to be set to 'GOSSIPING' (otherwise this field doesn't
exist; 'state' is now per-channel. It doesn't exist at all now.
4. Some tests now need to turn on IO logging in openingd, not connectd.
5. There's a gap between connecting on one node and having connectd on
the peer hand over the connection to openingd. Our tests sometimes
checked getpeers() on the peer, and didn't see anything, so line_graph
needed updating.
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2018-08-08 15:10:58 +01:00
|
|
|
peer->uncommitted_channel->fc = tal_steal(peer->uncommitted_channel, fc);
|
|
|
|
|
fc->uc = peer->uncommitted_channel;
|
|
|
|
|
|
|
|
|
|
msg = towire_opening_funder(NULL,
|
|
|
|
|
fc->wtx.amount,
|
|
|
|
|
fc->push_msat,
|
2018-08-23 00:27:25 +01:00
|
|
|
feerate_per_kw,
|
openingd: take peer before we're opening, wait for explicit funding msg.
Prior to this, lightningd would hand uninteresting peers back to connectd,
which would then return it to lightningd if it sent a non-gossip msg,
or if lightningd asked it to release the peer.
Now connectd hands the peer to lightningd once we've done the init
handshake, which hands it off to openingd.
This is a deep structural change, so we do the minimum here and cleanup
in the following patches.
Lightningd:
1. Remove peer_nongossip handling from connect_control and peer_control.
2. Remove list of outstanding fundchannel command; it was only needed to
find the race between us asking connectd to release the peer and it
reconnecting.
3. We can no longer tell if the remote end has started trying to fund a
channel (until it has succeeded): it's very transitory anyway so not
worth fixing.
4. We now always have a struct peer, and allocate an uncommitted_channel
for it, though it may never be used if neither end funds a channel.
5. We start funding on messages for openingd: we can get a funder_reply
or a fundee, or an error in response to our request to fund a channel.
so we handle all of them.
6. A new peer_start_openingd() is called after connectd hands us a peer.
7. json_fund_channel just looks through local peers; there are none
hidden in connectd any more.
8. We sometimes start a new openingd just to send an error message.
Openingd:
1. We always have information we need to accept them funding a channel (in
the init message).
2. We have to listen for three fds: peer, gossip and master, so we opencode
the poll.
3. We have an explicit message to start trying to fund a channel.
4. We can be told to send a message in our init message.
Testing:
1. We don't handle some things gracefully yet, so two tests are disabled.
2. 'hand_back_peer .*: now local again' from connectd is no longer a message,
openingd says 'Handed peer, entering loop' once its managing it.
3. peer['state'] used to be set to 'GOSSIPING' (otherwise this field doesn't
exist; 'state' is now per-channel. It doesn't exist at all now.
4. Some tests now need to turn on IO logging in openingd, not connectd.
5. There's a gap between connecting on one node and having connectd on
the peer hand over the connection to openingd. Our tests sometimes
checked getpeers() on the peer, and didn't see anything, so line_graph
needed updating.
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2018-08-08 15:10:58 +01:00
|
|
|
fc->wtx.change,
|
|
|
|
|
fc->wtx.change_key_index,
|
|
|
|
|
fc->channel_flags,
|
|
|
|
|
fc->wtx.utxos,
|
|
|
|
|
cmd->ld->wallet->bip32_base);
|
2018-04-23 11:08:01 +01:00
|
|
|
|
openingd: take peer before we're opening, wait for explicit funding msg.
Prior to this, lightningd would hand uninteresting peers back to connectd,
which would then return it to lightningd if it sent a non-gossip msg,
or if lightningd asked it to release the peer.
Now connectd hands the peer to lightningd once we've done the init
handshake, which hands it off to openingd.
This is a deep structural change, so we do the minimum here and cleanup
in the following patches.
Lightningd:
1. Remove peer_nongossip handling from connect_control and peer_control.
2. Remove list of outstanding fundchannel command; it was only needed to
find the race between us asking connectd to release the peer and it
reconnecting.
3. We can no longer tell if the remote end has started trying to fund a
channel (until it has succeeded): it's very transitory anyway so not
worth fixing.
4. We now always have a struct peer, and allocate an uncommitted_channel
for it, though it may never be used if neither end funds a channel.
5. We start funding on messages for openingd: we can get a funder_reply
or a fundee, or an error in response to our request to fund a channel.
so we handle all of them.
6. A new peer_start_openingd() is called after connectd hands us a peer.
7. json_fund_channel just looks through local peers; there are none
hidden in connectd any more.
8. We sometimes start a new openingd just to send an error message.
Openingd:
1. We always have information we need to accept them funding a channel (in
the init message).
2. We have to listen for three fds: peer, gossip and master, so we opencode
the poll.
3. We have an explicit message to start trying to fund a channel.
4. We can be told to send a message in our init message.
Testing:
1. We don't handle some things gracefully yet, so two tests are disabled.
2. 'hand_back_peer .*: now local again' from connectd is no longer a message,
openingd says 'Handed peer, entering loop' once its managing it.
3. peer['state'] used to be set to 'GOSSIPING' (otherwise this field doesn't
exist; 'state' is now per-channel. It doesn't exist at all now.
4. Some tests now need to turn on IO logging in openingd, not connectd.
5. There's a gap between connecting on one node and having connectd on
the peer hand over the connection to openingd. Our tests sometimes
checked getpeers() on the peer, and didn't see anything, so line_graph
needed updating.
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
2018-08-08 15:10:58 +01:00
|
|
|
/* Openingd will either succeed, or fail, or tell us the other side
|
|
|
|
|
* funded first. */
|
|
|
|
|
subd_send_msg(peer->uncommitted_channel->openingd, take(msg));
|
2018-02-20 20:59:04 +00:00
|
|
|
command_still_pending(cmd);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static const struct json_command fund_channel_command = {
|
|
|
|
|
"fundchannel",
|
|
|
|
|
json_fund_channel,
|
2018-08-27 06:13:57 +01:00
|
|
|
"Fund channel with {id} using {satoshi} (or 'all') satoshis, at optional {feerate}"
|
2018-02-20 20:59:04 +00:00
|
|
|
};
|
|
|
|
|
AUTODATA(json_command, &fund_channel_command);
|
