2018-10-11 07:41:48 +01:00
|
|
|
#include "bitcoin/feerate.h"
|
2018-02-20 20:59:04 +00:00
|
|
|
#include <bitcoin/privkey.h>
|
|
|
|
|
#include <bitcoin/script.h>
|
|
|
|
|
#include <ccan/tal/str/str.h>
|
2019-05-22 22:20:14 +01:00
|
|
|
#include <common/addr.h>
|
2018-02-20 20:59:04 +00:00
|
|
|
#include <common/channel_config.h>
|
2019-09-10 03:23:27 +01:00
|
|
|
#include <common/features.h>
|
2019-12-12 17:18:25 +00:00
|
|
|
#include <common/fee_states.h>
|
2018-02-20 20:59:04 +00:00
|
|
|
#include <common/funding_tx.h>
|
2018-12-08 00:39:28 +00:00
|
|
|
#include <common/json_command.h>
|
2020-05-15 11:30:25 +01:00
|
|
|
#include <common/json_helpers.h>
|
2018-12-08 00:39:28 +00:00
|
|
|
#include <common/jsonrpc_errors.h>
|
2018-02-20 20:59:04 +00:00
|
|
|
#include <common/key_derive.h>
|
2018-12-08 00:39:28 +00:00
|
|
|
#include <common/param.h>
|
2020-05-07 01:43:42 +01:00
|
|
|
#include <common/penalty_base.h>
|
2019-06-03 19:11:25 +01:00
|
|
|
#include <common/per_peer_state.h>
|
2019-10-15 11:58:30 +01:00
|
|
|
#include <common/utils.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>
|
2020-08-25 03:16:22 +01:00
|
|
|
#include <connectd/connectd_wiregen.h>
|
2018-02-20 20:59:04 +00:00
|
|
|
#include <errno.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>
|
|
|
|
|
#include <lightningd/lightningd.h>
|
|
|
|
|
#include <lightningd/log.h>
|
2018-12-13 12:58:40 +00:00
|
|
|
#include <lightningd/notification.h>
|
2018-02-20 20:59:04 +00:00
|
|
|
#include <lightningd/opening_control.h>
|
2019-09-19 19:50:58 +01:00
|
|
|
#include <lightningd/options.h>
|
2019-05-20 23:45:20 +01:00
|
|
|
#include <lightningd/plugin_hook.h>
|
2018-02-20 20:59:04 +00:00
|
|
|
#include <lightningd/subd.h>
|
2020-08-25 03:12:18 +01:00
|
|
|
#include <openingd/openingd_wiregen.h>
|
lightningd/opening_control.c: Remove 'Try fundchannel_cancel again' error.
Changelog-Changed: `fundchannel_cancel` will now succeed even when executed while a `fundchannel_complete` is ongoing; in that case, it will be considered as cancelling the funding *after* the `fundchannel_complete` succeeds.
Let me introduce the concept of "Sequential Consistency":
All operations on parallel processes form a single total order agreed upon by all processes.
So for example, suppose we have parallel invocations of `fundchannel_complete` and `fundchannel_cancel`:
+--[fundchannel_complete]-->
|
--[fundchannel_start]-+
|
+--[fundchannel_cancel]---->
What "Sequential Consistency" means is that the above parallel operations can be serialized as a single total order as:
--[fundchannel_start]--[fundchannel_complete]--[fundchannel_cancel]-->
Or:
--[fundchannel_start]--[fundchannel_cancel]--[fundchannel_complete]-->
In the first case, `fundchannel_complete` succeeds, and the `fundchannel_cancel` invocation also succeeds, sending an `error` to the peer to make them forget the chanel.
In the second case, `fundchannel_cancel` succeeds, and the succeeding `fundchannel_complete` invocation fails, since the funding is already cancelled and there is nothing to complete.
Note that in both cases, `fundchannel_cancel` **always** succeeds.
Unfortunately, prior to this commit, `fundchannel_cancel` could fail with a `Try fundchannel_cancel again` error if the `fundchannel_complete` is ongoing when the `fundchannel_cancel` is initiated.
This violates Sequential Consistency, as there is no single total order that would have caused `fundchannel_cancel` to fail.
This commit is a minimal patch which just reschedules `fundchannel_cancel` to occur after any `fundchannel_complete` that is ongoing.
2020-06-18 04:49:17 +01:00
|
|
|
#include <string.h>
|
2019-11-28 18:07:52 +00:00
|
|
|
#include <wire/gen_common_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: */
|
|
|
|
|
|
2019-09-09 17:11:24 +01:00
|
|
|
/* Minimum funding depth (if opener == REMOTE). */
|
2018-02-20 20:59:04 +00:00
|
|
|
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 {
|
2019-01-16 13:24:30 +00:00
|
|
|
struct command *cmd; /* Which initially owns us until openingd request */
|
|
|
|
|
|
2019-06-05 06:29:05 +01:00
|
|
|
struct wallet_tx *wtx;
|
2019-02-21 03:45:55 +00:00
|
|
|
struct amount_msat push;
|
2019-05-24 01:15:53 +01:00
|
|
|
struct amount_sat funding;
|
2018-04-05 20:19:47 +01:00
|
|
|
u8 channel_flags;
|
2019-10-15 02:08:33 +01:00
|
|
|
const u8 *our_upfront_shutdown_script;
|
2018-02-20 20:59:04 +00:00
|
|
|
|
2019-01-16 13:24:30 +00:00
|
|
|
/* Variables we need to compose fields in cmd's response */
|
2019-02-14 10:34:32 +00:00
|
|
|
const char *hextx;
|
2019-01-16 13:24:30 +00:00
|
|
|
struct channel_id cid;
|
|
|
|
|
|
2018-02-20 20:59:04 +00:00
|
|
|
/* Peer we're trying to reach. */
|
|
|
|
|
struct pubkey peerid;
|
|
|
|
|
|
2019-01-16 13:24:30 +00:00
|
|
|
/* Channel, subsequent owner of us */
|
2018-02-20 20:59:04 +00:00
|
|
|
struct uncommitted_channel *uc;
|
2019-05-31 22:40:31 +01:00
|
|
|
|
|
|
|
|
/* Whether or not this is in the middle of getting funded */
|
|
|
|
|
bool inflight;
|
2019-06-13 05:26:51 +01:00
|
|
|
|
|
|
|
|
/* Any commands trying to cancel us. */
|
|
|
|
|
struct command **cancels;
|
2018-02-20 20:59:04 +00:00
|
|
|
};
|
|
|
|
|
|
2018-07-24 07:18:58 +01:00
|
|
|
static void uncommitted_channel_disconnect(struct uncommitted_channel *uc,
|
2020-03-25 04:26:44 +00:00
|
|
|
enum log_level level,
|
2018-07-24 07:18:58 +01:00
|
|
|
const char *desc)
|
|
|
|
|
{
|
2020-08-25 03:16:22 +01:00
|
|
|
u8 *msg = towire_connectd_peer_disconnected(tmpctx, &uc->peer->id);
|
2020-03-25 04:26:44 +00:00
|
|
|
log_(uc->log, level, NULL, false, "%s", desc);
|
2018-07-24 07:18:58 +01:00
|
|
|
subd_send_msg(uc->peer->ld->connectd, msg);
|
2019-08-09 06:59:12 +01:00
|
|
|
if (uc->fc && uc->fc->cmd)
|
2018-12-16 04:53:06 +00:00
|
|
|
was_pending(command_fail(uc->fc->cmd, LIGHTNINGD, "%s", desc));
|
2018-12-13 12:58:40 +00:00
|
|
|
notify_disconnect(uc->peer->ld, &uc->peer->id);
|
2018-07-24 07:18:58 +01:00
|
|
|
}
|
|
|
|
|
|
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
|
|
|
|
2020-03-25 04:26:44 +00:00
|
|
|
uncommitted_channel_disconnect(uc, LOG_INFORM, why);
|
2018-02-20 20:59:04 +00:00
|
|
|
tal_free(uc);
|
|
|
|
|
}
|
|
|
|
|
|
2018-10-19 02:17:49 +01:00
|
|
|
void json_add_uncommitted_channel(struct json_stream *response,
|
2018-02-20 20:59:04 +00:00
|
|
|
const struct uncommitted_channel *uc)
|
|
|
|
|
{
|
2019-02-21 03:45:55 +00:00
|
|
|
struct amount_msat total, ours;
|
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
|
|
|
|
2019-02-21 03:45:55 +00:00
|
|
|
/* These should never fail. */
|
2019-05-24 01:15:53 +01:00
|
|
|
if (amount_sat_to_msat(&total, uc->fc->funding)
|
2019-02-21 03:45:55 +00:00
|
|
|
&& amount_msat_sub(&ours, total, uc->fc->push)) {
|
2019-05-20 06:07:40 +01:00
|
|
|
json_add_amount_msat_compat(response, ours,
|
|
|
|
|
"msatoshi_to_us", "to_us_msat");
|
|
|
|
|
json_add_amount_msat_compat(response, total,
|
|
|
|
|
"msatoshi_total", "total_msat");
|
2019-02-21 03:45:55 +00:00
|
|
|
}
|
2020-08-21 02:57:20 +01:00
|
|
|
|
|
|
|
|
json_array_start(response, "features");
|
|
|
|
|
if (feature_negotiated(uc->peer->ld->our_features,
|
|
|
|
|
uc->peer->their_features,
|
|
|
|
|
OPT_STATIC_REMOTEKEY))
|
|
|
|
|
json_add_string(response, NULL, "option_static_remotekey");
|
|
|
|
|
|
|
|
|
|
if (feature_negotiated(uc->peer->ld->our_features,
|
|
|
|
|
uc->peer->their_features,
|
|
|
|
|
OPT_ANCHOR_OUTPUTS))
|
|
|
|
|
json_add_string(response, NULL, "option_anchor_outputs");
|
|
|
|
|
json_array_end(response);
|
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,
|
2018-12-02 23:15:06 +00:00
|
|
|
struct bitcoin_signature *remote_commit_sig,
|
2018-02-20 20:59:04 +00:00
|
|
|
const struct bitcoin_txid *funding_txid,
|
|
|
|
|
u16 funding_outnum,
|
2019-02-21 03:45:55 +00:00
|
|
|
struct amount_sat funding,
|
|
|
|
|
struct amount_msat push,
|
2018-02-20 20:59:04 +00:00
|
|
|
u8 channel_flags,
|
|
|
|
|
struct channel_info *channel_info,
|
2019-04-30 23:58:09 +01:00
|
|
|
u32 feerate,
|
2019-10-15 02:08:33 +01:00
|
|
|
const u8 *our_upfront_shutdown_script,
|
2019-04-30 23:58:09 +01:00
|
|
|
const u8 *remote_upfront_shutdown_script)
|
2018-02-20 20:59:04 +00:00
|
|
|
{
|
|
|
|
|
struct channel *channel;
|
2019-02-21 03:45:55 +00:00
|
|
|
struct amount_msat our_msat;
|
2019-09-30 22:47:16 +01:00
|
|
|
struct amount_sat local_funding;
|
2018-03-07 00:06:07 +00:00
|
|
|
s64 final_key_idx;
|
2019-09-10 03:23:27 +01:00
|
|
|
bool option_static_remotekey;
|
2020-08-13 18:41:02 +01:00
|
|
|
bool option_anchor_outputs;
|
2018-03-07 00:06:07 +00:00
|
|
|
|
|
|
|
|
/* 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
|
|
|
|
2019-02-21 03:45:55 +00:00
|
|
|
if (uc->fc) {
|
|
|
|
|
if (!amount_sat_sub_msat(&our_msat, funding, push)) {
|
|
|
|
|
log_broken(uc->log, "push %s exceeds funding %s",
|
|
|
|
|
type_to_string(tmpctx, struct amount_msat,
|
|
|
|
|
&push),
|
|
|
|
|
type_to_string(tmpctx, struct amount_sat,
|
|
|
|
|
&funding));
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
2019-09-30 22:47:16 +01:00
|
|
|
local_funding = funding;
|
|
|
|
|
} else {
|
2019-02-21 03:45:55 +00:00
|
|
|
our_msat = push;
|
2019-09-30 22:47:16 +01:00
|
|
|
local_funding = AMOUNT_SAT(0);
|
|
|
|
|
}
|
2018-02-20 20:59:04 +00:00
|
|
|
|
2019-12-12 17:18:25 +00:00
|
|
|
channel_info->fee_states = new_fee_states(uc, uc->fc ? LOCAL : REMOTE,
|
|
|
|
|
&feerate);
|
2018-02-20 20:59:04 +00:00
|
|
|
|
|
|
|
|
/* old_remote_per_commit not valid yet, copy valid one. */
|
|
|
|
|
channel_info->old_remote_per_commit = channel_info->remote_per_commit;
|
|
|
|
|
|
2020-08-13 18:41:02 +01:00
|
|
|
/* BOLT-a12da24dd0102c170365124782b46d9710950ac1 #2:
|
2019-09-10 03:23:27 +01:00
|
|
|
* 1. type: 35 (`funding_signed`)
|
|
|
|
|
* 2. data:
|
|
|
|
|
* * [`channel_id`:`channel_id`]
|
|
|
|
|
* * [`signature`:`signature`]
|
|
|
|
|
*
|
|
|
|
|
* #### Requirements
|
|
|
|
|
*
|
|
|
|
|
* Both peers:
|
2020-08-13 18:41:02 +01:00
|
|
|
* - if `option_static_remotekey` or `option_anchor_outputs` was negotiated:
|
|
|
|
|
* - `option_static_remotekey` or `option_anchor_outputs` applies to all commitment
|
2019-09-10 03:23:27 +01:00
|
|
|
* transactions
|
|
|
|
|
* - otherwise:
|
2020-08-13 18:41:02 +01:00
|
|
|
* - `option_static_remotekey` or `option_anchor_outputs` does not apply to any commitment
|
2019-09-10 03:23:27 +01:00
|
|
|
* transactions
|
|
|
|
|
*/
|
|
|
|
|
/* i.e. We set it now for the channel permanently. */
|
|
|
|
|
option_static_remotekey
|
2020-04-03 01:03:59 +01:00
|
|
|
= feature_negotiated(ld->our_features,
|
|
|
|
|
uc->peer->their_features,
|
|
|
|
|
OPT_STATIC_REMOTEKEY);
|
2020-08-13 18:41:02 +01:00
|
|
|
option_anchor_outputs
|
|
|
|
|
= feature_negotiated(ld->our_features,
|
|
|
|
|
uc->peer->their_features,
|
|
|
|
|
OPT_ANCHOR_OUTPUTS);
|
2019-09-10 03:23:27 +01:00
|
|
|
|
2018-02-20 20:59:04 +00:00
|
|
|
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,
|
2019-02-21 03:45:55 +00:00
|
|
|
funding,
|
|
|
|
|
push,
|
2019-09-30 22:47:16 +01:00
|
|
|
local_funding,
|
2018-02-20 20:59:04 +00:00
|
|
|
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. */
|
2019-02-21 03:45:55 +00:00
|
|
|
our_msat,
|
|
|
|
|
our_msat, /* msat_to_us_min */
|
|
|
|
|
our_msat, /* msat_to_us_max */
|
2018-02-20 20:59:04 +00:00
|
|
|
remote_commit,
|
|
|
|
|
remote_commit_sig,
|
|
|
|
|
NULL, /* No HTLC sigs yet */
|
|
|
|
|
channel_info,
|
2019-09-29 08:35:45 +01:00
|
|
|
NULL, /* No shutdown_scriptpubkey[REMOTE] yet */
|
2019-10-15 02:08:33 +01:00
|
|
|
our_upfront_shutdown_script,
|
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. */
|
2020-08-03 12:26:44 +01:00
|
|
|
get_network_blockheight(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,
|
2019-02-21 00:01:33 +00:00
|
|
|
NULL,
|
|
|
|
|
ld->config.fee_base,
|
2019-04-30 23:57:09 +01:00
|
|
|
ld->config.fee_per_satoshi,
|
2019-09-10 03:22:27 +01:00
|
|
|
remote_upfront_shutdown_script,
|
2020-08-13 18:41:02 +01:00
|
|
|
option_static_remotekey,
|
|
|
|
|
option_anchor_outputs);
|
2018-02-20 20:59:04 +00:00
|
|
|
|
|
|
|
|
/* Now we finally put it in the database. */
|
|
|
|
|
wallet_channel_insert(ld->wallet, channel);
|
|
|
|
|
|
|
|
|
|
return channel;
|
|
|
|
|
}
|
|
|
|
|
|
lightningd/opening_control.c: Remove 'Try fundchannel_cancel again' error.
Changelog-Changed: `fundchannel_cancel` will now succeed even when executed while a `fundchannel_complete` is ongoing; in that case, it will be considered as cancelling the funding *after* the `fundchannel_complete` succeeds.
Let me introduce the concept of "Sequential Consistency":
All operations on parallel processes form a single total order agreed upon by all processes.
So for example, suppose we have parallel invocations of `fundchannel_complete` and `fundchannel_cancel`:
+--[fundchannel_complete]-->
|
--[fundchannel_start]-+
|
+--[fundchannel_cancel]---->
What "Sequential Consistency" means is that the above parallel operations can be serialized as a single total order as:
--[fundchannel_start]--[fundchannel_complete]--[fundchannel_cancel]-->
Or:
--[fundchannel_start]--[fundchannel_cancel]--[fundchannel_complete]-->
In the first case, `fundchannel_complete` succeeds, and the `fundchannel_cancel` invocation also succeeds, sending an `error` to the peer to make them forget the chanel.
In the second case, `fundchannel_cancel` succeeds, and the succeeding `fundchannel_complete` invocation fails, since the funding is already cancelled and there is nothing to complete.
Note that in both cases, `fundchannel_cancel` **always** succeeds.
Unfortunately, prior to this commit, `fundchannel_cancel` could fail with a `Try fundchannel_cancel again` error if the `fundchannel_complete` is ongoing when the `fundchannel_cancel` is initiated.
This violates Sequential Consistency, as there is no single total order that would have caused `fundchannel_cancel` to fail.
This commit is a minimal patch which just reschedules `fundchannel_cancel` to occur after any `fundchannel_complete` that is ongoing.
2020-06-18 04:49:17 +01:00
|
|
|
/** cancel_after_fundchannel_complete_success
|
|
|
|
|
*
|
|
|
|
|
* @brief Called to cancel a `fundchannel` after
|
|
|
|
|
* a `fundchannel_complete` succeeds.
|
|
|
|
|
*
|
|
|
|
|
* @desc Specifically, this is called when a
|
|
|
|
|
* `fundchannel_cancel` is blocked due to a
|
|
|
|
|
* parallel `fundchannel_complete` still running.
|
|
|
|
|
* After the `fundchannel_complete` succeeds, we
|
|
|
|
|
* invoke this function to cancel the funding
|
|
|
|
|
* after all.
|
|
|
|
|
*
|
|
|
|
|
* In effect, this forces the `fundchannel_cancel`
|
|
|
|
|
* to be invoked after the `fundchannel_complete`
|
|
|
|
|
* succeeds, leading to a reasonable serial
|
|
|
|
|
* execution.
|
|
|
|
|
*
|
|
|
|
|
* @param cmd - The `fundchannel_cancel` command
|
|
|
|
|
* that wants to cancel this.
|
|
|
|
|
* @param channel - The channel being cancelled.
|
|
|
|
|
*/
|
|
|
|
|
static void
|
|
|
|
|
cancel_after_fundchannel_complete_success(struct command *cmd,
|
|
|
|
|
struct channel *channel)
|
|
|
|
|
{
|
2020-06-24 05:34:26 +01:00
|
|
|
was_pending(cancel_channel_before_broadcast(cmd, channel->peer));
|
lightningd/opening_control.c: Remove 'Try fundchannel_cancel again' error.
Changelog-Changed: `fundchannel_cancel` will now succeed even when executed while a `fundchannel_complete` is ongoing; in that case, it will be considered as cancelling the funding *after* the `fundchannel_complete` succeeds.
Let me introduce the concept of "Sequential Consistency":
All operations on parallel processes form a single total order agreed upon by all processes.
So for example, suppose we have parallel invocations of `fundchannel_complete` and `fundchannel_cancel`:
+--[fundchannel_complete]-->
|
--[fundchannel_start]-+
|
+--[fundchannel_cancel]---->
What "Sequential Consistency" means is that the above parallel operations can be serialized as a single total order as:
--[fundchannel_start]--[fundchannel_complete]--[fundchannel_cancel]-->
Or:
--[fundchannel_start]--[fundchannel_cancel]--[fundchannel_complete]-->
In the first case, `fundchannel_complete` succeeds, and the `fundchannel_cancel` invocation also succeeds, sending an `error` to the peer to make them forget the chanel.
In the second case, `fundchannel_cancel` succeeds, and the succeeding `fundchannel_complete` invocation fails, since the funding is already cancelled and there is nothing to complete.
Note that in both cases, `fundchannel_cancel` **always** succeeds.
Unfortunately, prior to this commit, `fundchannel_cancel` could fail with a `Try fundchannel_cancel again` error if the `fundchannel_complete` is ongoing when the `fundchannel_cancel` is initiated.
This violates Sequential Consistency, as there is no single total order that would have caused `fundchannel_cancel` to fail.
This commit is a minimal patch which just reschedules `fundchannel_cancel` to occur after any `fundchannel_complete` that is ongoing.
2020-06-18 04:49:17 +01:00
|
|
|
}
|
|
|
|
|
|
2019-05-31 22:46:04 +01:00
|
|
|
static void funding_success(struct channel *channel)
|
|
|
|
|
{
|
|
|
|
|
struct json_stream *response;
|
|
|
|
|
struct funding_channel *fc = channel->peer->uncommitted_channel->fc;
|
|
|
|
|
struct command *cmd = fc->cmd;
|
|
|
|
|
|
lightningd/opening_control.c: Remove 'Try fundchannel_cancel again' error.
Changelog-Changed: `fundchannel_cancel` will now succeed even when executed while a `fundchannel_complete` is ongoing; in that case, it will be considered as cancelling the funding *after* the `fundchannel_complete` succeeds.
Let me introduce the concept of "Sequential Consistency":
All operations on parallel processes form a single total order agreed upon by all processes.
So for example, suppose we have parallel invocations of `fundchannel_complete` and `fundchannel_cancel`:
+--[fundchannel_complete]-->
|
--[fundchannel_start]-+
|
+--[fundchannel_cancel]---->
What "Sequential Consistency" means is that the above parallel operations can be serialized as a single total order as:
--[fundchannel_start]--[fundchannel_complete]--[fundchannel_cancel]-->
Or:
--[fundchannel_start]--[fundchannel_cancel]--[fundchannel_complete]-->
In the first case, `fundchannel_complete` succeeds, and the `fundchannel_cancel` invocation also succeeds, sending an `error` to the peer to make them forget the chanel.
In the second case, `fundchannel_cancel` succeeds, and the succeeding `fundchannel_complete` invocation fails, since the funding is already cancelled and there is nothing to complete.
Note that in both cases, `fundchannel_cancel` **always** succeeds.
Unfortunately, prior to this commit, `fundchannel_cancel` could fail with a `Try fundchannel_cancel again` error if the `fundchannel_complete` is ongoing when the `fundchannel_cancel` is initiated.
This violates Sequential Consistency, as there is no single total order that would have caused `fundchannel_cancel` to fail.
This commit is a minimal patch which just reschedules `fundchannel_cancel` to occur after any `fundchannel_complete` that is ongoing.
2020-06-18 04:49:17 +01:00
|
|
|
/* Well, those cancels now need to trigger! */
|
2019-06-13 05:26:51 +01:00
|
|
|
for (size_t i = 0; i < tal_count(fc->cancels); i++)
|
lightningd/opening_control.c: Remove 'Try fundchannel_cancel again' error.
Changelog-Changed: `fundchannel_cancel` will now succeed even when executed while a `fundchannel_complete` is ongoing; in that case, it will be considered as cancelling the funding *after* the `fundchannel_complete` succeeds.
Let me introduce the concept of "Sequential Consistency":
All operations on parallel processes form a single total order agreed upon by all processes.
So for example, suppose we have parallel invocations of `fundchannel_complete` and `fundchannel_cancel`:
+--[fundchannel_complete]-->
|
--[fundchannel_start]-+
|
+--[fundchannel_cancel]---->
What "Sequential Consistency" means is that the above parallel operations can be serialized as a single total order as:
--[fundchannel_start]--[fundchannel_complete]--[fundchannel_cancel]-->
Or:
--[fundchannel_start]--[fundchannel_cancel]--[fundchannel_complete]-->
In the first case, `fundchannel_complete` succeeds, and the `fundchannel_cancel` invocation also succeeds, sending an `error` to the peer to make them forget the chanel.
In the second case, `fundchannel_cancel` succeeds, and the succeeding `fundchannel_complete` invocation fails, since the funding is already cancelled and there is nothing to complete.
Note that in both cases, `fundchannel_cancel` **always** succeeds.
Unfortunately, prior to this commit, `fundchannel_cancel` could fail with a `Try fundchannel_cancel again` error if the `fundchannel_complete` is ongoing when the `fundchannel_cancel` is initiated.
This violates Sequential Consistency, as there is no single total order that would have caused `fundchannel_cancel` to fail.
This commit is a minimal patch which just reschedules `fundchannel_cancel` to occur after any `fundchannel_complete` that is ongoing.
2020-06-18 04:49:17 +01:00
|
|
|
cancel_after_fundchannel_complete_success(fc->cancels[i],
|
|
|
|
|
channel);
|
2019-06-13 05:26:51 +01:00
|
|
|
|
2019-05-31 22:46:04 +01:00
|
|
|
response = json_stream_success(cmd);
|
|
|
|
|
json_add_string(response, "channel_id",
|
|
|
|
|
type_to_string(tmpctx, struct channel_id, &fc->cid));
|
|
|
|
|
json_add_bool(response, "commitments_secured", true);
|
|
|
|
|
was_pending(command_success(cmd, response));
|
|
|
|
|
}
|
|
|
|
|
|
2019-05-23 00:25:22 +01:00
|
|
|
static void funding_started_success(struct funding_channel *fc,
|
2019-10-15 02:08:33 +01:00
|
|
|
u8 *scriptPubkey,
|
|
|
|
|
bool supports_shutdown)
|
2019-05-22 00:51:52 +01:00
|
|
|
{
|
2019-05-23 00:25:22 +01:00
|
|
|
struct json_stream *response;
|
|
|
|
|
struct command *cmd = fc->cmd;
|
|
|
|
|
char *out;
|
|
|
|
|
|
|
|
|
|
response = json_stream_success(cmd);
|
|
|
|
|
out = encode_scriptpubkey_to_addr(cmd,
|
2019-10-15 11:58:30 +01:00
|
|
|
chainparams,
|
2019-05-23 00:25:22 +01:00
|
|
|
scriptPubkey);
|
2019-08-28 04:33:55 +01:00
|
|
|
if (out) {
|
2019-05-23 00:25:22 +01:00
|
|
|
json_add_string(response, "funding_address", out);
|
2019-08-28 04:33:55 +01:00
|
|
|
json_add_hex_talarr(response, "scriptpubkey", scriptPubkey);
|
2019-10-15 02:08:33 +01:00
|
|
|
if (fc->our_upfront_shutdown_script)
|
|
|
|
|
json_add_hex_talarr(response, "close_to", fc->our_upfront_shutdown_script);
|
2019-08-28 04:33:55 +01:00
|
|
|
}
|
2019-06-12 07:23:24 +01:00
|
|
|
|
|
|
|
|
/* Clear this so cancel doesn't think it's still in progress */
|
|
|
|
|
fc->cmd = NULL;
|
2019-05-23 00:25:22 +01:00
|
|
|
was_pending(command_success(cmd, response));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void opening_funder_start_replied(struct subd *openingd, const u8 *resp,
|
|
|
|
|
const int *fds,
|
|
|
|
|
struct funding_channel *fc)
|
|
|
|
|
{
|
|
|
|
|
u8 *funding_scriptPubkey;
|
2019-10-15 02:08:33 +01:00
|
|
|
bool supports_shutdown_script;
|
2019-05-23 00:25:22 +01:00
|
|
|
|
2020-08-25 03:12:18 +01:00
|
|
|
if (!fromwire_openingd_funder_start_reply(resp, resp,
|
2019-10-15 02:08:33 +01:00
|
|
|
&funding_scriptPubkey,
|
|
|
|
|
&supports_shutdown_script)) {
|
2019-05-23 00:25:22 +01:00
|
|
|
log_broken(fc->uc->log,
|
|
|
|
|
"bad OPENING_FUNDER_REPLY %s",
|
|
|
|
|
tal_hex(resp, resp));
|
|
|
|
|
was_pending(command_fail(fc->cmd, LIGHTNINGD,
|
|
|
|
|
"bad OPENING_FUNDER_REPLY %s",
|
|
|
|
|
tal_hex(fc->cmd, resp)));
|
|
|
|
|
goto failed;
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-15 02:08:33 +01:00
|
|
|
/* If we're not using the upfront shutdown script, forget it */
|
|
|
|
|
if (!supports_shutdown_script)
|
|
|
|
|
fc->our_upfront_shutdown_script =
|
|
|
|
|
tal_free(fc->our_upfront_shutdown_script);
|
|
|
|
|
|
|
|
|
|
funding_started_success(fc, funding_scriptPubkey, supports_shutdown_script);
|
2019-05-31 22:40:31 +01:00
|
|
|
|
|
|
|
|
/* Mark that we're in-flight */
|
|
|
|
|
fc->inflight = true;
|
2019-05-23 00:25:22 +01:00
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
failed:
|
|
|
|
|
subd_release_channel(openingd, fc->uc);
|
|
|
|
|
fc->uc->openingd = NULL;
|
|
|
|
|
/* Frees fc too, and tmpctx */
|
|
|
|
|
tal_free(fc->uc);
|
2019-05-22 00:51:52 +01:00
|
|
|
}
|
|
|
|
|
|
2019-05-31 22:46:04 +01:00
|
|
|
static void opening_funder_finished(struct subd *openingd, const u8 *resp,
|
|
|
|
|
const int *fds,
|
|
|
|
|
struct funding_channel *fc)
|
|
|
|
|
{
|
|
|
|
|
struct channel_info channel_info;
|
|
|
|
|
struct bitcoin_txid funding_txid;
|
|
|
|
|
u16 funding_txout;
|
|
|
|
|
struct bitcoin_signature remote_commit_sig;
|
|
|
|
|
struct bitcoin_tx *remote_commit;
|
|
|
|
|
u32 feerate;
|
|
|
|
|
struct channel *channel;
|
|
|
|
|
struct lightningd *ld = openingd->ld;
|
|
|
|
|
u8 *remote_upfront_shutdown_script;
|
|
|
|
|
struct per_peer_state *pps;
|
2020-05-07 01:43:42 +01:00
|
|
|
struct penalty_base *pbase;
|
2019-05-31 22:46:04 +01:00
|
|
|
|
|
|
|
|
/* This is a new channel_info.their_config so set its ID to 0 */
|
|
|
|
|
channel_info.their_config.id = 0;
|
|
|
|
|
|
2020-08-25 03:12:18 +01:00
|
|
|
if (!fromwire_openingd_funder_reply(resp, resp,
|
2019-05-31 22:46:04 +01:00
|
|
|
&channel_info.their_config,
|
|
|
|
|
&remote_commit,
|
2020-05-07 01:43:42 +01:00
|
|
|
&pbase,
|
2019-05-31 22:46:04 +01:00
|
|
|
&remote_commit_sig,
|
|
|
|
|
&pps,
|
|
|
|
|
&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,
|
|
|
|
|
&funding_txid,
|
|
|
|
|
&funding_txout,
|
|
|
|
|
&feerate,
|
|
|
|
|
&fc->uc->our_config.channel_reserve,
|
|
|
|
|
&remote_upfront_shutdown_script)) {
|
|
|
|
|
log_broken(fc->uc->log,
|
|
|
|
|
"bad OPENING_FUNDER_REPLY %s",
|
|
|
|
|
tal_hex(resp, resp));
|
|
|
|
|
was_pending(command_fail(fc->cmd, LIGHTNINGD,
|
|
|
|
|
"bad OPENING_FUNDER_REPLY %s",
|
|
|
|
|
tal_hex(fc->cmd, resp)));
|
|
|
|
|
goto cleanup;
|
|
|
|
|
}
|
2019-10-15 11:58:30 +01:00
|
|
|
remote_commit->chainparams = chainparams;
|
2019-05-31 22:46:04 +01:00
|
|
|
per_peer_state_set_fds_arr(pps, fds);
|
|
|
|
|
|
|
|
|
|
log_debug(ld->log,
|
|
|
|
|
"%s", type_to_string(tmpctx, struct pubkey,
|
|
|
|
|
&channel_info.remote_per_commit));
|
|
|
|
|
|
|
|
|
|
/* Steals fields from uc */
|
|
|
|
|
channel = wallet_commit_channel(ld, fc->uc,
|
|
|
|
|
remote_commit,
|
|
|
|
|
&remote_commit_sig,
|
|
|
|
|
&funding_txid,
|
|
|
|
|
funding_txout,
|
|
|
|
|
fc->funding,
|
|
|
|
|
fc->push,
|
|
|
|
|
fc->channel_flags,
|
|
|
|
|
&channel_info,
|
|
|
|
|
feerate,
|
2019-10-15 02:08:33 +01:00
|
|
|
fc->our_upfront_shutdown_script,
|
2019-05-31 22:46:04 +01:00
|
|
|
remote_upfront_shutdown_script);
|
|
|
|
|
if (!channel) {
|
|
|
|
|
was_pending(command_fail(fc->cmd, LIGHTNINGD,
|
|
|
|
|
"Key generation failure"));
|
|
|
|
|
goto cleanup;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Watch for funding confirms */
|
|
|
|
|
channel_watch_funding(ld, channel);
|
|
|
|
|
|
|
|
|
|
/* Needed for the success statement */
|
|
|
|
|
derive_channel_id(&fc->cid, &channel->funding_txid, funding_txout);
|
|
|
|
|
|
2020-05-07 01:49:38 +01:00
|
|
|
if (pbase)
|
|
|
|
|
wallet_penalty_base_add(ld->wallet, channel->dbid, pbase);
|
|
|
|
|
|
2019-08-28 22:28:26 +01:00
|
|
|
funding_success(channel);
|
2019-06-03 19:11:25 +01:00
|
|
|
peer_start_channeld(channel, pps, NULL, false);
|
2018-02-20 20:59:04 +00:00
|
|
|
|
2019-05-31 22:46:04 +01:00
|
|
|
cleanup:
|
2018-02-20 20:59:04 +00:00
|
|
|
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;
|
2018-12-02 23:15:06 +00:00
|
|
|
struct bitcoin_signature remote_commit_sig;
|
2018-02-20 20:59:04 +00:00
|
|
|
struct bitcoin_tx *remote_commit;
|
|
|
|
|
struct lightningd *ld = openingd->ld;
|
|
|
|
|
struct bitcoin_txid funding_txid;
|
|
|
|
|
u16 funding_outnum;
|
2019-02-21 03:45:55 +00:00
|
|
|
struct amount_sat funding;
|
|
|
|
|
struct amount_msat push;
|
2018-02-20 20:59:04 +00:00
|
|
|
u32 feerate;
|
|
|
|
|
u8 channel_flags;
|
|
|
|
|
struct channel *channel;
|
2019-11-21 00:47:44 +00:00
|
|
|
u8 *remote_upfront_shutdown_script, *local_upfront_shutdown_script;
|
2019-06-03 19:11:25 +01:00
|
|
|
struct per_peer_state *pps;
|
2020-05-07 01:43:42 +01:00
|
|
|
struct penalty_base *pbase;
|
2018-02-20 20:59:04 +00:00
|
|
|
|
|
|
|
|
log_debug(uc->log, "Got opening_fundee_finish_response");
|
|
|
|
|
|
|
|
|
|
/* This is a new channel_info.their_config, set its ID to 0 */
|
|
|
|
|
channel_info.their_config.id = 0;
|
|
|
|
|
|
2020-08-25 03:12:18 +01:00
|
|
|
if (!fromwire_openingd_fundee(tmpctx, reply,
|
2020-05-07 01:43:42 +01:00
|
|
|
&channel_info.their_config,
|
|
|
|
|
&remote_commit,
|
|
|
|
|
&pbase,
|
|
|
|
|
&remote_commit_sig,
|
|
|
|
|
&pps,
|
|
|
|
|
&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,
|
|
|
|
|
&push,
|
|
|
|
|
&channel_flags,
|
|
|
|
|
&feerate,
|
|
|
|
|
&funding_signed,
|
|
|
|
|
&uc->our_config.channel_reserve,
|
|
|
|
|
&local_upfront_shutdown_script,
|
|
|
|
|
&remote_upfront_shutdown_script)) {
|
2018-02-20 20:59:04 +00:00
|
|
|
log_broken(uc->log, "bad OPENING_FUNDEE_REPLY %s",
|
|
|
|
|
tal_hex(reply, reply));
|
2020-03-25 04:26:44 +00:00
|
|
|
uncommitted_channel_disconnect(uc, LOG_BROKEN,
|
|
|
|
|
"bad OPENING_FUNDEE_REPLY");
|
2018-08-09 01:25:29 +01:00
|
|
|
goto failed;
|
2018-02-20 20:59:04 +00:00
|
|
|
}
|
2019-07-30 21:04:55 +01:00
|
|
|
|
2019-10-15 11:58:30 +01:00
|
|
|
remote_commit->chainparams = chainparams;
|
2019-06-03 19:11:25 +01:00
|
|
|
per_peer_state_set_fds_arr(pps, fds);
|
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)) {
|
2020-03-25 04:26:44 +00:00
|
|
|
uncommitted_channel_disconnect(uc,
|
|
|
|
|
LOG_BROKEN,
|
|
|
|
|
"already have active channel");
|
2018-08-09 01:25:29 +01:00
|
|
|
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,
|
2019-02-21 03:45:55 +00:00
|
|
|
funding,
|
|
|
|
|
push,
|
2018-02-20 20:59:04 +00:00
|
|
|
channel_flags,
|
|
|
|
|
&channel_info,
|
2019-04-30 23:58:09 +01:00
|
|
|
feerate,
|
2019-11-21 00:47:44 +00:00
|
|
|
local_upfront_shutdown_script,
|
2019-04-30 23:58:09 +01:00
|
|
|
remote_upfront_shutdown_script);
|
2018-03-07 00:06:07 +00:00
|
|
|
if (!channel) {
|
2020-03-25 04:26:44 +00:00
|
|
|
uncommitted_channel_disconnect(uc, LOG_BROKEN,
|
|
|
|
|
"Commit channel failed");
|
2018-08-09 01:25:29 +01:00
|
|
|
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",
|
2019-10-01 00:32:15 +01:00
|
|
|
type_to_string(reply, struct bitcoin_txid,
|
|
|
|
|
&channel->funding_txid));
|
2018-02-20 20:59:04 +00:00
|
|
|
|
|
|
|
|
channel_watch_funding(ld, channel);
|
|
|
|
|
|
2019-07-25 15:11:44 +01:00
|
|
|
/* Tell plugins about the success */
|
|
|
|
|
notify_channel_opened(ld, &channel->peer->id, &channel->funding,
|
2019-10-01 00:32:15 +01:00
|
|
|
&channel->funding_txid, &channel->remote_funding_locked);
|
2019-07-25 15:11:44 +01:00
|
|
|
|
2020-05-07 01:49:38 +01:00
|
|
|
if (pbase)
|
|
|
|
|
wallet_penalty_base_add(ld->wallet, channel->dbid, pbase);
|
|
|
|
|
|
2018-02-20 20:59:04 +00:00
|
|
|
/* On to normal operation! */
|
2019-06-03 19:11:25 +01:00
|
|
|
peer_start_channeld(channel, pps, funding_signed, false);
|
2018-02-20 20:59:04 +00:00
|
|
|
|
|
|
|
|
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]);
|
2019-05-04 06:53:13 +01:00
|
|
|
close(fds[3]);
|
2018-08-09 01:25:29 +01:00
|
|
|
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;
|
|
|
|
|
|
2020-08-25 03:12:18 +01:00
|
|
|
if (!fromwire_openingd_funder_failed(msg, msg, &desc)) {
|
2018-08-09 01:25:29 +01:00
|
|
|
log_broken(uc->log,
|
|
|
|
|
"bad OPENING_FUNDER_FAILED %s",
|
|
|
|
|
tal_hex(tmpctx, msg));
|
2018-12-16 04:53:06 +00:00
|
|
|
was_pending(command_fail(uc->fc->cmd, LIGHTNINGD,
|
|
|
|
|
"bad OPENING_FUNDER_FAILED %s",
|
|
|
|
|
tal_hex(uc->fc->cmd, msg)));
|
2018-08-09 01:25:29 +01:00
|
|
|
tal_free(uc);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2019-06-13 05:26:51 +01:00
|
|
|
/* Tell anyone who was trying to cancel */
|
|
|
|
|
for (size_t i = 0; i < tal_count(uc->fc->cancels); i++) {
|
2019-06-13 05:26:56 +01:00
|
|
|
struct json_stream *response;
|
|
|
|
|
|
|
|
|
|
response = json_stream_success(uc->fc->cancels[i]);
|
|
|
|
|
json_add_string(response, "cancelled", desc);
|
|
|
|
|
was_pending(command_success(uc->fc->cancels[i], response));
|
2019-05-31 22:51:56 +01:00
|
|
|
}
|
2018-08-09 01:25:29 +01:00
|
|
|
|
2019-06-13 05:26:51 +01:00
|
|
|
/* Tell any fundchannel_complete or fundchannel command */
|
|
|
|
|
if (uc->fc->cmd)
|
|
|
|
|
was_pending(command_fail(uc->fc->cmd, LIGHTNINGD, "%s", desc));
|
|
|
|
|
|
2018-08-09 01:25:29 +01:00
|
|
|
/* 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,
|
2019-06-03 19:11:25 +01:00
|
|
|
struct per_peer_state *pps,
|
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,
|
2019-07-26 03:11:19 +01:00
|
|
|
bool soft_error UNUSED,
|
2018-08-09 01:25:29 +01:00
|
|
|
const u8 *err_for_them UNUSED)
|
2018-02-20 20:59:04 +00:00
|
|
|
{
|
2019-05-04 06:53:12 +01:00
|
|
|
/* Close fds, if any. */
|
2019-06-03 19:11:25 +01:00
|
|
|
tal_free(pps);
|
2020-03-25 04:26:44 +00:00
|
|
|
uncommitted_channel_disconnect(uc, LOG_INFORM, 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);
|
|
|
|
|
|
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);
|
|
|
|
|
|
2019-11-18 00:27:15 +00:00
|
|
|
uc->log = new_log(uc, ld->log_book, &uc->peer->id,
|
2019-11-18 00:27:18 +00:00
|
|
|
"chan#%"PRIu64, uc->dbid);
|
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->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,
|
2019-02-21 03:45:54 +00:00
|
|
|
struct amount_msat *min_effective_htlc_capacity)
|
2018-02-20 20:59:04 +00:00
|
|
|
{
|
2019-04-15 21:48:12 +01:00
|
|
|
struct amount_msat dust_limit;
|
|
|
|
|
|
2018-02-20 20:59:04 +00:00
|
|
|
/* FIXME: depend on feerate. */
|
|
|
|
|
*max_to_self_delay = ld->config.locktime_max;
|
2019-04-03 09:20:38 +01:00
|
|
|
|
|
|
|
|
/* Take minimal effective capacity from config min_capacity_sat */
|
2020-08-05 04:55:15 +01:00
|
|
|
if (!amount_sat_to_msat(min_effective_htlc_capacity,
|
|
|
|
|
amount_sat(ld->config.min_capacity_sat)))
|
2019-04-15 21:48:08 +01:00
|
|
|
fatal("amount_msat overflow for config.min_capacity_sat");
|
2019-04-15 21:48:12 +01:00
|
|
|
/* Substract 2 * dust_limit, so fundchannel with min value is possible */
|
2019-10-15 11:58:30 +01:00
|
|
|
if (!amount_sat_to_msat(&dust_limit, chainparams->dust_limit))
|
2019-04-15 21:48:12 +01:00
|
|
|
fatal("amount_msat overflow for dustlimit");
|
|
|
|
|
if (!amount_msat_sub(min_effective_htlc_capacity,
|
|
|
|
|
*min_effective_htlc_capacity,
|
|
|
|
|
dust_limit))
|
|
|
|
|
*min_effective_htlc_capacity = AMOUNT_MSAT(0);
|
|
|
|
|
if (!amount_msat_sub(min_effective_htlc_capacity,
|
|
|
|
|
*min_effective_htlc_capacity,
|
|
|
|
|
dust_limit))
|
|
|
|
|
*min_effective_htlc_capacity = AMOUNT_MSAT(0);
|
2018-02-20 20:59:04 +00:00
|
|
|
|
|
|
|
|
/* 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
|
|
|
*/
|
2019-10-15 11:58:30 +01:00
|
|
|
ours->dust_limit = chainparams->dust_limit;
|
2019-02-21 03:45:54 +00:00
|
|
|
ours->max_htlc_value_in_flight = AMOUNT_MSAT(UINT64_MAX);
|
2018-02-20 20:59:04 +00:00
|
|
|
|
|
|
|
|
/* Don't care */
|
2019-02-21 03:45:54 +00:00
|
|
|
ours->htlc_minimum = AMOUNT_MSAT(0);
|
2018-02-20 20:59:04 +00:00
|
|
|
|
|
|
|
|
/* 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;
|
|
|
|
|
|
2019-07-27 18:45:22 +01:00
|
|
|
ours->max_accepted_htlcs = ld->config.max_concurrent_htlcs;
|
2018-02-20 20:59:04 +00:00
|
|
|
|
|
|
|
|
/* This is filled in by lightning_openingd, for consistency. */
|
2019-02-21 03:45:54 +00:00
|
|
|
ours->channel_reserve = AMOUNT_SAT(UINT64_MAX);
|
2018-07-31 05:34:42 +01:00
|
|
|
}
|
2018-02-20 20:59:04 +00:00
|
|
|
|
2019-05-20 23:45:20 +01:00
|
|
|
struct openchannel_hook_payload {
|
|
|
|
|
struct subd *openingd;
|
|
|
|
|
struct amount_sat funding_satoshis;
|
|
|
|
|
struct amount_msat push_msat;
|
|
|
|
|
struct amount_sat dust_limit_satoshis;
|
|
|
|
|
struct amount_msat max_htlc_value_in_flight_msat;
|
|
|
|
|
struct amount_sat channel_reserve_satoshis;
|
|
|
|
|
struct amount_msat htlc_minimum_msat;
|
|
|
|
|
u32 feerate_per_kw;
|
|
|
|
|
u16 to_self_delay;
|
|
|
|
|
u16 max_accepted_htlcs;
|
|
|
|
|
u8 channel_flags;
|
|
|
|
|
u8 *shutdown_scriptpubkey;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
openchannel_hook_serialize(struct openchannel_hook_payload *payload,
|
|
|
|
|
struct json_stream *stream)
|
|
|
|
|
{
|
|
|
|
|
struct uncommitted_channel *uc = payload->openingd->channel;
|
|
|
|
|
json_object_start(stream, "openchannel");
|
|
|
|
|
json_add_node_id(stream, "id", &uc->peer->id);
|
|
|
|
|
json_add_amount_sat_only(stream, "funding_satoshis",
|
|
|
|
|
payload->funding_satoshis);
|
|
|
|
|
json_add_amount_msat_only(stream, "push_msat", payload->push_msat);
|
|
|
|
|
json_add_amount_sat_only(stream, "dust_limit_satoshis",
|
|
|
|
|
payload->dust_limit_satoshis);
|
|
|
|
|
json_add_amount_msat_only(stream, "max_htlc_value_in_flight_msat",
|
|
|
|
|
payload->max_htlc_value_in_flight_msat);
|
|
|
|
|
json_add_amount_sat_only(stream, "channel_reserve_satoshis",
|
|
|
|
|
payload->channel_reserve_satoshis);
|
|
|
|
|
json_add_amount_msat_only(stream, "htlc_minimum_msat",
|
|
|
|
|
payload->htlc_minimum_msat);
|
|
|
|
|
json_add_num(stream, "feerate_per_kw", payload->feerate_per_kw);
|
|
|
|
|
json_add_num(stream, "to_self_delay", payload->to_self_delay);
|
|
|
|
|
json_add_num(stream, "max_accepted_htlcs", payload->max_accepted_htlcs);
|
|
|
|
|
json_add_num(stream, "channel_flags", payload->channel_flags);
|
|
|
|
|
if (tal_count(payload->shutdown_scriptpubkey) != 0)
|
2019-06-05 06:29:01 +01:00
|
|
|
json_add_hex_talarr(stream, "shutdown_scriptpubkey",
|
|
|
|
|
payload->shutdown_scriptpubkey);
|
2019-05-20 23:45:20 +01:00
|
|
|
json_object_end(stream); /* .openchannel */
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* openingd dies? Remove openingd ptr from payload */
|
|
|
|
|
static void openchannel_payload_remove_openingd(struct subd *openingd,
|
|
|
|
|
struct openchannel_hook_payload *payload)
|
|
|
|
|
{
|
|
|
|
|
assert(payload->openingd == openingd);
|
|
|
|
|
payload->openingd = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
2020-04-15 11:20:41 +01:00
|
|
|
static void openchannel_hook_cb(struct openchannel_hook_payload *payload STEALS,
|
2019-05-20 23:45:20 +01:00
|
|
|
const char *buffer,
|
|
|
|
|
const jsmntok_t *toks)
|
|
|
|
|
{
|
|
|
|
|
struct subd *openingd = payload->openingd;
|
2019-11-21 00:47:44 +00:00
|
|
|
const u8 *our_upfront_shutdown_script;
|
2019-05-20 23:45:20 +01:00
|
|
|
const char *errmsg = NULL;
|
|
|
|
|
|
|
|
|
|
/* We want to free this, whatever happens. */
|
|
|
|
|
tal_steal(tmpctx, payload);
|
|
|
|
|
|
|
|
|
|
/* If openingd went away, don't send it anything! */
|
|
|
|
|
if (!openingd)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
tal_del_destructor2(openingd, openchannel_payload_remove_openingd, payload);
|
|
|
|
|
|
|
|
|
|
/* If we had a hook, check what it says */
|
|
|
|
|
if (buffer) {
|
|
|
|
|
const jsmntok_t *t = json_get_member(buffer, toks, "result");
|
|
|
|
|
if (!t)
|
|
|
|
|
fatal("Plugin returned an invalid response to the"
|
|
|
|
|
" openchannel hook: %.*s",
|
|
|
|
|
toks[0].end - toks[0].start,
|
|
|
|
|
buffer + toks[0].start);
|
|
|
|
|
|
|
|
|
|
if (json_tok_streq(buffer, t, "reject")) {
|
|
|
|
|
t = json_get_member(buffer, toks, "error_message");
|
|
|
|
|
if (t)
|
|
|
|
|
errmsg = json_strdup(tmpctx, buffer, t);
|
|
|
|
|
else
|
|
|
|
|
errmsg = "";
|
|
|
|
|
log_debug(openingd->ld->log,
|
|
|
|
|
"openchannel_hook_cb says '%s'",
|
|
|
|
|
errmsg);
|
2019-11-21 00:47:44 +00:00
|
|
|
our_upfront_shutdown_script = NULL;
|
2019-05-20 23:45:20 +01:00
|
|
|
} else if (!json_tok_streq(buffer, t, "continue"))
|
|
|
|
|
fatal("Plugin returned an invalid result for the "
|
|
|
|
|
"openchannel hook: %.*s",
|
|
|
|
|
t->end - t->start, buffer + t->start);
|
2019-11-21 00:47:44 +00:00
|
|
|
|
|
|
|
|
/* Check for a 'close_to' address passed back */
|
|
|
|
|
if (!errmsg) {
|
|
|
|
|
t = json_get_member(buffer, toks, "close_to");
|
|
|
|
|
if (t) {
|
|
|
|
|
switch (json_to_address_scriptpubkey(tmpctx, chainparams,
|
|
|
|
|
buffer, t,
|
|
|
|
|
&our_upfront_shutdown_script)) {
|
|
|
|
|
case ADDRESS_PARSE_UNRECOGNIZED:
|
|
|
|
|
fatal("Plugin returned an invalid response to the"
|
|
|
|
|
" openchannel.close_to hook: %.*s",
|
|
|
|
|
t->end - t->start, buffer + t->start);
|
|
|
|
|
case ADDRESS_PARSE_WRONG_NETWORK:
|
|
|
|
|
fatal("Plugin returned invalid response to the"
|
|
|
|
|
" openchannel.close_to hook: address %s is"
|
|
|
|
|
" not on network %s",
|
|
|
|
|
tal_hex(NULL, our_upfront_shutdown_script),
|
|
|
|
|
chainparams->network_name);
|
|
|
|
|
case ADDRESS_PARSE_SUCCESS:
|
|
|
|
|
errmsg = NULL;
|
|
|
|
|
}
|
|
|
|
|
} else
|
|
|
|
|
our_upfront_shutdown_script = NULL;
|
|
|
|
|
}
|
|
|
|
|
} else
|
|
|
|
|
our_upfront_shutdown_script = NULL;
|
2019-05-20 23:45:20 +01:00
|
|
|
|
|
|
|
|
subd_send_msg(openingd,
|
2020-08-25 03:12:18 +01:00
|
|
|
take(towire_openingd_got_offer_reply(NULL, errmsg,
|
2019-11-21 00:47:44 +00:00
|
|
|
our_upfront_shutdown_script)));
|
2019-05-20 23:45:20 +01:00
|
|
|
}
|
|
|
|
|
|
2020-04-15 11:21:34 +01:00
|
|
|
REGISTER_SINGLE_PLUGIN_HOOK(openchannel,
|
|
|
|
|
openchannel_hook_cb,
|
|
|
|
|
openchannel_hook_serialize,
|
|
|
|
|
struct openchannel_hook_payload *);
|
2019-05-20 23:45:20 +01:00
|
|
|
|
2019-05-20 06:05:24 +01:00
|
|
|
static void opening_got_offer(struct subd *openingd,
|
|
|
|
|
const u8 *msg,
|
|
|
|
|
struct uncommitted_channel *uc)
|
|
|
|
|
{
|
2019-05-20 23:45:20 +01:00
|
|
|
struct openchannel_hook_payload *payload;
|
2019-05-20 06:05:24 +01:00
|
|
|
|
|
|
|
|
/* Tell them they can't open, if we already have open channel. */
|
2019-05-20 23:45:20 +01:00
|
|
|
if (peer_active_channel(uc->peer)) {
|
|
|
|
|
subd_send_msg(openingd,
|
2020-08-25 03:12:18 +01:00
|
|
|
take(towire_openingd_got_offer_reply(NULL,
|
2019-11-21 00:47:44 +00:00
|
|
|
"Already have active channel", NULL)));
|
2019-05-20 23:45:20 +01:00
|
|
|
return;
|
|
|
|
|
}
|
2019-05-20 06:05:24 +01:00
|
|
|
|
2020-04-15 11:20:41 +01:00
|
|
|
payload = tal(openingd, struct openchannel_hook_payload);
|
2019-05-20 23:45:20 +01:00
|
|
|
payload->openingd = openingd;
|
2020-08-25 03:12:18 +01:00
|
|
|
if (!fromwire_openingd_got_offer(payload, msg,
|
2019-05-20 23:45:20 +01:00
|
|
|
&payload->funding_satoshis,
|
|
|
|
|
&payload->push_msat,
|
|
|
|
|
&payload->dust_limit_satoshis,
|
|
|
|
|
&payload->max_htlc_value_in_flight_msat,
|
|
|
|
|
&payload->channel_reserve_satoshis,
|
|
|
|
|
&payload->htlc_minimum_msat,
|
|
|
|
|
&payload->feerate_per_kw,
|
|
|
|
|
&payload->to_self_delay,
|
|
|
|
|
&payload->max_accepted_htlcs,
|
|
|
|
|
&payload->channel_flags,
|
|
|
|
|
&payload->shutdown_scriptpubkey)) {
|
|
|
|
|
log_broken(openingd->log, "Malformed opening_got_offer %s",
|
|
|
|
|
tal_hex(tmpctx, msg));
|
|
|
|
|
tal_free(openingd);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
tal_add_destructor2(openingd, openchannel_payload_remove_openingd, payload);
|
2020-04-15 11:20:41 +01:00
|
|
|
plugin_hook_call_openchannel(openingd->ld, payload);
|
2019-05-20 06:05:24 +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
|
|
|
static unsigned int openingd_msg(struct subd *openingd,
|
|
|
|
|
const u8 *msg, const int *fds)
|
|
|
|
|
{
|
2020-08-25 03:12:18 +01:00
|
|
|
enum openingd_wire t = fromwire_peektype(msg);
|
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 uncommitted_channel *uc = openingd->channel;
|
|
|
|
|
|
|
|
|
|
switch (t) {
|
2020-08-25 03:12:18 +01:00
|
|
|
case WIRE_OPENINGD_FUNDER_REPLY:
|
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 (!uc->fc) {
|
|
|
|
|
log_broken(openingd->log, "Unexpected FUNDER_REPLY %s",
|
|
|
|
|
tal_hex(tmpctx, msg));
|
|
|
|
|
tal_free(openingd);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2019-05-04 06:53:13 +01:00
|
|
|
if (tal_count(fds) != 3)
|
|
|
|
|
return 3;
|
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
|
|
|
opening_funder_finished(openingd, msg, fds, uc->fc);
|
|
|
|
|
return 0;
|
2020-08-25 03:12:18 +01:00
|
|
|
case WIRE_OPENINGD_FUNDER_START_REPLY:
|
2019-05-22 00:51:52 +01:00
|
|
|
if (!uc->fc) {
|
|
|
|
|
log_broken(openingd->log, "Unexpected FUNDER_START_REPLY %s",
|
|
|
|
|
tal_hex(tmpctx, msg));
|
|
|
|
|
tal_free(openingd);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2019-05-23 00:25:22 +01:00
|
|
|
opening_funder_start_replied(openingd, msg, fds, uc->fc);
|
2019-05-22 00:51:52 +01:00
|
|
|
return 0;
|
2020-08-25 03:12:18 +01:00
|
|
|
case WIRE_OPENINGD_FUNDER_FAILED:
|
2018-08-09 01:25:29 +01:00
|
|
|
if (!uc->fc) {
|
2019-07-08 23:18:45 +01:00
|
|
|
log_unusual(openingd->log, "Unexpected FUNDER_FAILED %s",
|
2018-08-09 01:25:29 +01:00
|
|
|
tal_hex(tmpctx, msg));
|
|
|
|
|
tal_free(openingd);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
opening_funder_failed(openingd, msg, uc);
|
|
|
|
|
return 0;
|
|
|
|
|
|
2020-08-25 03:12:18 +01:00
|
|
|
case WIRE_OPENINGD_FUNDEE:
|
2019-05-04 06:53:13 +01:00
|
|
|
if (tal_count(fds) != 3)
|
|
|
|
|
return 3;
|
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
|
|
|
opening_fundee_finished(openingd, msg, fds, uc);
|
|
|
|
|
return 0;
|
|
|
|
|
|
2020-08-25 03:12:18 +01:00
|
|
|
case WIRE_OPENINGD_GOT_OFFER:
|
2019-05-20 06:05:24 +01:00
|
|
|
opening_got_offer(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
|
|
|
/* We send these! */
|
2020-08-25 03:12:18 +01:00
|
|
|
case WIRE_OPENINGD_INIT:
|
|
|
|
|
case WIRE_OPENINGD_FUNDER_START:
|
|
|
|
|
case WIRE_OPENINGD_FUNDER_COMPLETE:
|
|
|
|
|
case WIRE_OPENINGD_FUNDER_CANCEL:
|
|
|
|
|
case WIRE_OPENINGD_GOT_OFFER_REPLY:
|
|
|
|
|
case WIRE_OPENINGD_DEV_MEMLEAK:
|
2018-11-22 02:17:29 +00:00
|
|
|
/* Replies never get here */
|
2020-08-25 03:12:18 +01:00
|
|
|
case WIRE_OPENINGD_DEV_MEMLEAK_REPLY:
|
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;
|
|
|
|
|
}
|
2019-11-28 18:07:52 +00:00
|
|
|
|
|
|
|
|
switch ((enum common_wire_type)t) {
|
|
|
|
|
#if DEVELOPER
|
|
|
|
|
case WIRE_CUSTOMMSG_IN:
|
2019-12-04 23:11:28 +00:00
|
|
|
handle_custommsg_in(openingd->ld, openingd->node_id, msg);
|
2019-11-28 18:07:52 +00:00
|
|
|
return 0;
|
|
|
|
|
#else
|
|
|
|
|
case WIRE_CUSTOMMSG_IN:
|
|
|
|
|
#endif
|
|
|
|
|
/* We send these. */
|
|
|
|
|
case WIRE_CUSTOMMSG_OUT:
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
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
|
|
|
log_broken(openingd->log, "Unexpected msg %s: %s",
|
2020-08-25 03:12:18 +01:00
|
|
|
openingd_wire_name(t), tal_hex(tmpctx, msg));
|
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
|
|
|
tal_free(openingd);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void peer_start_openingd(struct peer *peer,
|
2019-06-03 19:11:25 +01:00
|
|
|
struct per_peer_state *pps,
|
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 *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;
|
2019-02-21 03:45:54 +00:00
|
|
|
struct amount_msat min_effective_htlc_capacity;
|
2018-02-20 20:59:04 +00:00
|
|
|
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",
|
2019-11-17 11:40:33 +00:00
|
|
|
uc, &peer->id, uc->log,
|
2020-08-25 03:12:18 +01:00
|
|
|
true, openingd_wire_name,
|
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_msg,
|
2018-02-20 20:59:04 +00:00
|
|
|
opening_channel_errmsg,
|
2018-02-23 05:53:47 +00:00
|
|
|
opening_channel_set_billboard,
|
2019-06-03 19:11:25 +01:00
|
|
|
take(&pps->peer_fd),
|
|
|
|
|
take(&pps->gossip_fd),
|
|
|
|
|
take(&pps->gossip_store_fd),
|
2018-07-23 03:23:03 +01:00
|
|
|
take(&hsmfd), NULL);
|
2018-02-20 20:59:04 +00:00
|
|
|
if (!uc->openingd) {
|
2020-03-25 04:26:44 +00:00
|
|
|
uncommitted_channel_disconnect(uc, LOG_BROKEN,
|
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
|
|
|
tal_fmt(tmpctx,
|
|
|
|
|
"Running lightning_openingd: %s",
|
|
|
|
|
strerror(errno)));
|
2020-03-25 04:15:16 +00:00
|
|
|
tal_free(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
|
|
|
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,
|
2019-02-21 03:45:54 +00:00
|
|
|
&min_effective_htlc_capacity);
|
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
|
|
|
/* 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
|
|
|
|
2020-08-25 03:12:18 +01:00
|
|
|
msg = towire_openingd_init(NULL,
|
2019-09-25 21:38:45 +01:00
|
|
|
chainparams,
|
2020-04-03 01:03:59 +01:00
|
|
|
peer->ld->our_features,
|
2018-02-20 20:59:04 +00:00
|
|
|
&uc->our_config,
|
|
|
|
|
max_to_self_delay,
|
2019-02-21 03:45:55 +00:00
|
|
|
min_effective_htlc_capacity,
|
2019-06-03 19:11:25 +01:00
|
|
|
pps, &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),
|
2020-04-03 01:03:59 +01:00
|
|
|
peer->their_features,
|
|
|
|
|
feature_negotiated(peer->ld->our_features,
|
|
|
|
|
peer->their_features,
|
2019-10-11 03:52:04 +01:00
|
|
|
OPT_STATIC_REMOTEKEY),
|
2020-08-14 02:30:41 +01:00
|
|
|
feature_negotiated(peer->ld->our_features,
|
|
|
|
|
peer->their_features,
|
|
|
|
|
OPT_ANCHOR_OUTPUTS),
|
2019-09-18 02:05:05 +01:00
|
|
|
send_msg,
|
2019-11-01 17:01:54 +00:00
|
|
|
IFDEV(peer->ld->dev_force_tmp_channel_id, NULL),
|
2019-09-18 02:05:05 +01:00
|
|
|
IFDEV(peer->ld->dev_fast_gossip, false));
|
2018-02-20 20:59:04 +00:00
|
|
|
subd_send_msg(uc->openingd, take(msg));
|
2018-04-23 11:08:01 +01:00
|
|
|
}
|
|
|
|
|
|
2019-06-05 01:26:39 +01:00
|
|
|
static struct command_result *json_fund_channel_complete(struct command *cmd,
|
2019-05-25 01:40:00 +01:00
|
|
|
const char *buffer,
|
|
|
|
|
const jsmntok_t *obj UNNEEDED,
|
|
|
|
|
const jsmntok_t *params)
|
|
|
|
|
{
|
|
|
|
|
u8 *msg;
|
|
|
|
|
struct node_id *id;
|
|
|
|
|
struct bitcoin_txid *funding_txid;
|
|
|
|
|
struct peer *peer;
|
|
|
|
|
struct channel *channel;
|
2019-05-31 22:37:05 +01:00
|
|
|
u32 *funding_txout_num;
|
|
|
|
|
u16 funding_txout;
|
2019-05-25 01:40:00 +01:00
|
|
|
|
|
|
|
|
if (!param(cmd, buffer, params,
|
|
|
|
|
p_req("id", param_node_id, &id),
|
|
|
|
|
p_req("txid", param_txid, &funding_txid),
|
2019-05-31 22:37:05 +01:00
|
|
|
p_req("txout", param_number, &funding_txout_num),
|
2019-05-25 01:40:00 +01:00
|
|
|
NULL))
|
|
|
|
|
return command_param_failed();
|
|
|
|
|
|
2019-05-31 22:37:05 +01:00
|
|
|
if (*funding_txout_num > UINT16_MAX)
|
|
|
|
|
return command_fail(cmd, LIGHTNINGD,
|
|
|
|
|
"Invalid parameter: funding tx vout too large %u",
|
|
|
|
|
*funding_txout_num);
|
|
|
|
|
|
|
|
|
|
funding_txout = *funding_txout_num;
|
2019-05-25 01:40:00 +01:00
|
|
|
peer = peer_by_id(cmd->ld, id);
|
|
|
|
|
if (!peer) {
|
2020-01-04 20:10:04 +00:00
|
|
|
return command_fail(cmd, FUNDING_UNKNOWN_PEER, "Unknown peer");
|
2019-05-25 01:40:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
channel = peer_active_channel(peer);
|
|
|
|
|
if (channel)
|
|
|
|
|
return command_fail(cmd, LIGHTNINGD, "Peer already %s",
|
|
|
|
|
channel_state_name(channel));
|
|
|
|
|
|
|
|
|
|
if (!peer->uncommitted_channel)
|
2020-01-04 20:10:04 +00:00
|
|
|
return command_fail(cmd, FUNDING_PEER_NOT_CONNECTED,
|
|
|
|
|
"Peer not connected");
|
2019-05-25 01:40:00 +01:00
|
|
|
|
2019-05-31 22:40:31 +01:00
|
|
|
if (!peer->uncommitted_channel->fc || !peer->uncommitted_channel->fc->inflight)
|
2019-05-25 01:40:00 +01:00
|
|
|
return command_fail(cmd, LIGHTNINGD, "No channel funding in progress.");
|
2019-06-12 07:23:24 +01:00
|
|
|
if (peer->uncommitted_channel->fc->cmd)
|
|
|
|
|
return command_fail(cmd, LIGHTNINGD, "Channel funding in progress.");
|
2019-05-25 01:40:00 +01:00
|
|
|
|
2019-06-12 07:23:24 +01:00
|
|
|
/* Set the cmd to this new cmd */
|
2019-05-31 22:46:04 +01:00
|
|
|
peer->uncommitted_channel->fc->cmd = cmd;
|
2020-08-25 03:12:18 +01:00
|
|
|
msg = towire_openingd_funder_complete(NULL,
|
2019-05-31 22:37:05 +01:00
|
|
|
funding_txid,
|
|
|
|
|
funding_txout);
|
2019-05-25 01:40:00 +01:00
|
|
|
subd_send_msg(peer->uncommitted_channel->openingd, take(msg));
|
|
|
|
|
return command_still_pending(cmd);
|
|
|
|
|
}
|
|
|
|
|
|
2019-05-31 22:57:04 +01:00
|
|
|
/**
|
2019-08-23 22:34:52 +01:00
|
|
|
* json_fund_channel_cancel - Entrypoint for cancelling a channel which funding isn't broadcast
|
2019-05-31 22:57:04 +01:00
|
|
|
*/
|
|
|
|
|
static struct command_result *json_fund_channel_cancel(struct command *cmd,
|
|
|
|
|
const char *buffer,
|
|
|
|
|
const jsmntok_t *obj UNNEEDED,
|
|
|
|
|
const jsmntok_t *params)
|
|
|
|
|
{
|
|
|
|
|
|
|
|
|
|
struct node_id *id;
|
|
|
|
|
struct peer *peer;
|
|
|
|
|
u8 *msg;
|
|
|
|
|
|
|
|
|
|
if (!param(cmd, buffer, params,
|
|
|
|
|
p_req("id", param_node_id, &id),
|
|
|
|
|
NULL))
|
|
|
|
|
return command_param_failed();
|
|
|
|
|
|
|
|
|
|
peer = peer_by_id(cmd->ld, id);
|
|
|
|
|
if (!peer) {
|
2020-01-04 20:10:04 +00:00
|
|
|
return command_fail(cmd, FUNDING_UNKNOWN_PEER, "Unknown peer");
|
2019-05-31 22:57:04 +01:00
|
|
|
}
|
|
|
|
|
|
2019-08-23 22:34:52 +01:00
|
|
|
if (peer->uncommitted_channel) {
|
2020-01-05 15:52:34 +00:00
|
|
|
if (!peer->uncommitted_channel->fc || !peer->uncommitted_channel->fc->inflight)
|
2020-06-24 05:34:26 +01:00
|
|
|
return command_fail(cmd, FUNDING_NOTHING_TO_CANCEL,
|
|
|
|
|
"No channel funding in progress.");
|
2019-05-31 22:57:04 +01:00
|
|
|
|
2019-08-23 22:34:52 +01:00
|
|
|
/* Make sure this gets notified if we succeed or cancel */
|
|
|
|
|
tal_arr_expand(&peer->uncommitted_channel->fc->cancels, cmd);
|
2020-08-25 03:12:18 +01:00
|
|
|
msg = towire_openingd_funder_cancel(NULL);
|
2019-08-23 22:34:52 +01:00
|
|
|
subd_send_msg(peer->uncommitted_channel->openingd, take(msg));
|
|
|
|
|
return command_still_pending(cmd);
|
|
|
|
|
}
|
2019-05-31 22:57:04 +01:00
|
|
|
|
2020-06-24 05:34:26 +01:00
|
|
|
/* Handle `fundchannel_cancel` after `fundchannel_complete`. */
|
|
|
|
|
return cancel_channel_before_broadcast(cmd, peer);
|
2019-05-31 22:57:04 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
2019-08-28 22:28:26 +01:00
|
|
|
* json_fund_channel_start - Entrypoint for funding a channel
|
2019-05-31 22:57:04 +01:00
|
|
|
*/
|
2019-05-22 00:51:52 +01:00
|
|
|
static struct command_result *json_fund_channel_start(struct command *cmd,
|
|
|
|
|
const char *buffer,
|
|
|
|
|
const jsmntok_t *obj UNNEEDED,
|
|
|
|
|
const jsmntok_t *params)
|
|
|
|
|
{
|
|
|
|
|
struct funding_channel * fc = tal(cmd, struct funding_channel);
|
|
|
|
|
struct node_id *id;
|
|
|
|
|
struct peer *peer;
|
|
|
|
|
struct channel *channel;
|
|
|
|
|
bool *announce_channel;
|
|
|
|
|
u32 *feerate_per_kw;
|
|
|
|
|
|
|
|
|
|
u8 *msg = NULL;
|
2019-11-23 01:45:51 +00:00
|
|
|
struct amount_sat *amount;
|
2019-12-21 05:53:12 +00:00
|
|
|
struct amount_msat *push_msat;
|
2019-05-22 00:51:52 +01:00
|
|
|
|
|
|
|
|
fc->cmd = cmd;
|
2019-06-13 05:26:51 +01:00
|
|
|
fc->cancels = tal_arr(fc, struct command *, 0);
|
2019-05-22 00:51:52 +01:00
|
|
|
fc->uc = NULL;
|
2019-05-31 22:40:31 +01:00
|
|
|
fc->inflight = false;
|
2019-09-19 19:50:58 +01:00
|
|
|
|
2020-03-25 03:39:34 +00:00
|
|
|
if (!param(fc->cmd, buffer, params,
|
|
|
|
|
p_req("id", param_node_id, &id),
|
|
|
|
|
p_req("amount", param_sat, &amount),
|
|
|
|
|
p_opt("feerate", param_feerate, &feerate_per_kw),
|
|
|
|
|
p_opt_def("announce", param_bool, &announce_channel, true),
|
|
|
|
|
p_opt("close_to", param_bitcoin_address, &fc->our_upfront_shutdown_script),
|
|
|
|
|
p_opt("push_msat", param_msat, &push_msat),
|
|
|
|
|
NULL))
|
|
|
|
|
return command_param_failed();
|
2019-05-22 00:51:52 +01:00
|
|
|
|
2019-12-21 05:53:12 +00:00
|
|
|
if (push_msat && amount_msat_greater_sat(*push_msat, *amount))
|
|
|
|
|
return command_fail(cmd, FUND_CANNOT_AFFORD,
|
|
|
|
|
"Requested to push_msat of %s is greater than "
|
|
|
|
|
"available funding amount %s",
|
|
|
|
|
type_to_string(tmpctx, struct amount_msat, push_msat),
|
|
|
|
|
type_to_string(tmpctx, struct amount_sat, amount));
|
|
|
|
|
|
2019-05-24 01:15:53 +01:00
|
|
|
fc->funding = *amount;
|
2019-05-22 00:51:52 +01:00
|
|
|
if (!feerate_per_kw) {
|
|
|
|
|
feerate_per_kw = tal(cmd, u32);
|
|
|
|
|
*feerate_per_kw = opening_feerate(cmd->ld->topology);
|
|
|
|
|
if (!*feerate_per_kw) {
|
|
|
|
|
return command_fail(cmd, LIGHTNINGD,
|
|
|
|
|
"Cannot estimate fees");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (*feerate_per_kw < feerate_floor()) {
|
|
|
|
|
return command_fail(cmd, LIGHTNINGD,
|
|
|
|
|
"Feerate below feerate floor");
|
|
|
|
|
}
|
|
|
|
|
|
2019-08-10 11:48:20 +01:00
|
|
|
if (!topology_synced(cmd->ld->topology)) {
|
|
|
|
|
return command_fail(cmd, FUNDING_STILL_SYNCING_BITCOIN,
|
|
|
|
|
"Still syncing with bitcoin network");
|
|
|
|
|
}
|
|
|
|
|
|
2019-05-22 00:51:52 +01:00
|
|
|
peer = peer_by_id(cmd->ld, id);
|
|
|
|
|
if (!peer) {
|
2020-01-04 20:10:04 +00:00
|
|
|
return command_fail(cmd, FUNDING_UNKNOWN_PEER, "Unknown peer");
|
2019-05-22 00:51:52 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
channel = peer_active_channel(peer);
|
|
|
|
|
if (channel) {
|
|
|
|
|
return command_fail(cmd, LIGHTNINGD, "Peer already %s",
|
|
|
|
|
channel_state_name(channel));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!peer->uncommitted_channel) {
|
2020-01-04 20:10:04 +00:00
|
|
|
return command_fail(cmd, FUNDING_PEER_NOT_CONNECTED,
|
|
|
|
|
"Peer not connected");
|
2019-05-22 00:51:52 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (peer->uncommitted_channel->fc) {
|
|
|
|
|
return command_fail(cmd, LIGHTNINGD, "Already funding channel");
|
|
|
|
|
}
|
|
|
|
|
|
2020-04-03 01:03:55 +01:00
|
|
|
/* BOLT #2:
|
|
|
|
|
* - if both nodes advertised `option_support_large_channel`:
|
|
|
|
|
* - MAY set `funding_satoshis` greater than or equal to 2^24 satoshi.
|
|
|
|
|
* - otherwise:
|
|
|
|
|
* - MUST set `funding_satoshis` to less than 2^24 satoshi.
|
|
|
|
|
*/
|
2020-04-03 01:03:59 +01:00
|
|
|
if (!feature_negotiated(cmd->ld->our_features,
|
|
|
|
|
peer->their_features, OPT_LARGE_CHANNELS)
|
2020-04-03 01:03:55 +01:00
|
|
|
&& amount_sat_greater(*amount, chainparams->max_funding))
|
|
|
|
|
return command_fail(cmd, FUND_MAX_EXCEEDED,
|
|
|
|
|
"Amount exceeded %s",
|
|
|
|
|
type_to_string(tmpctx, struct amount_sat,
|
|
|
|
|
&chainparams->max_funding));
|
|
|
|
|
|
2019-12-21 05:53:12 +00:00
|
|
|
fc->push = push_msat ? *push_msat : AMOUNT_MSAT(0);
|
2019-05-22 00:51:52 +01:00
|
|
|
fc->channel_flags = OUR_CHANNEL_FLAGS;
|
|
|
|
|
if (!*announce_channel) {
|
|
|
|
|
fc->channel_flags &= ~CHANNEL_FLAGS_ANNOUNCE_CHANNEL;
|
|
|
|
|
log_info(peer->ld->log, "Will open private channel with node %s",
|
|
|
|
|
type_to_string(fc, struct node_id, id));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
peer->uncommitted_channel->fc = tal_steal(peer->uncommitted_channel, fc);
|
|
|
|
|
fc->uc = peer->uncommitted_channel;
|
|
|
|
|
|
2019-10-15 02:08:33 +01:00
|
|
|
/* Needs to be stolen away from cmd */
|
|
|
|
|
if (fc->our_upfront_shutdown_script)
|
|
|
|
|
fc->our_upfront_shutdown_script
|
|
|
|
|
= tal_steal(fc, fc->our_upfront_shutdown_script);
|
|
|
|
|
|
2020-08-25 03:12:18 +01:00
|
|
|
msg = towire_openingd_funder_start(NULL,
|
2019-05-22 00:51:52 +01:00
|
|
|
*amount,
|
|
|
|
|
fc->push,
|
2019-10-15 02:08:33 +01:00
|
|
|
fc->our_upfront_shutdown_script,
|
2019-05-22 00:51:52 +01:00
|
|
|
*feerate_per_kw,
|
|
|
|
|
fc->channel_flags);
|
|
|
|
|
|
|
|
|
|
subd_send_msg(peer->uncommitted_channel->openingd, take(msg));
|
|
|
|
|
return command_still_pending(cmd);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static const struct json_command fund_channel_start_command = {
|
|
|
|
|
"fundchannel_start",
|
|
|
|
|
"channels",
|
|
|
|
|
json_fund_channel_start,
|
|
|
|
|
"Start fund channel with {id} using {amount} satoshis. "
|
|
|
|
|
"Returns a bech32 address to use as an output for a funding transaction."
|
|
|
|
|
};
|
|
|
|
|
AUTODATA(json_command, &fund_channel_start_command);
|
|
|
|
|
|
2019-05-31 22:57:04 +01:00
|
|
|
static const struct json_command fund_channel_cancel_command = {
|
|
|
|
|
"fundchannel_cancel",
|
|
|
|
|
"channels",
|
|
|
|
|
json_fund_channel_cancel,
|
|
|
|
|
"Cancel inflight channel establishment with peer {id}."
|
|
|
|
|
};
|
|
|
|
|
AUTODATA(json_command, &fund_channel_cancel_command);
|
|
|
|
|
|
2019-06-05 01:26:39 +01:00
|
|
|
static const struct json_command fund_channel_complete_command = {
|
|
|
|
|
"fundchannel_complete",
|
2019-05-25 01:40:00 +01:00
|
|
|
"channels",
|
2019-06-05 01:26:39 +01:00
|
|
|
json_fund_channel_complete,
|
2019-05-25 01:40:00 +01:00
|
|
|
"Complete channel establishment with peer {id} for funding transaction"
|
|
|
|
|
"with {txid}. Returns true on success, false otherwise."
|
|
|
|
|
};
|
2019-06-05 01:26:39 +01:00
|
|
|
AUTODATA(json_command, &fund_channel_complete_command);
|
2019-05-25 01:40:00 +01:00
|
|
|
|
2018-11-22 02:17:29 +00:00
|
|
|
#if DEVELOPER
|
|
|
|
|
/* Indented to avoid include ordering check */
|
|
|
|
|
#include <lightningd/memdump.h>
|
|
|
|
|
|
2018-11-22 02:17:29 +00:00
|
|
|
static void opening_died_forget_memleak(struct subd *openingd,
|
|
|
|
|
struct command *cmd)
|
|
|
|
|
{
|
|
|
|
|
/* FIXME: We ignore the remaining openingds in this case. */
|
|
|
|
|
opening_memleak_done(cmd, NULL);
|
|
|
|
|
}
|
|
|
|
|
|
2018-11-22 02:17:29 +00:00
|
|
|
/* Mutual recursion */
|
|
|
|
|
static void opening_memleak_req_next(struct command *cmd, struct peer *prev);
|
|
|
|
|
static void opening_memleak_req_done(struct subd *openingd,
|
|
|
|
|
const u8 *msg, const int *fds UNUSED,
|
|
|
|
|
struct command *cmd)
|
|
|
|
|
{
|
|
|
|
|
bool found_leak;
|
|
|
|
|
struct uncommitted_channel *uc = openingd->channel;
|
|
|
|
|
|
2018-11-22 02:17:29 +00:00
|
|
|
tal_del_destructor2(openingd, opening_died_forget_memleak, cmd);
|
2020-08-25 03:12:18 +01:00
|
|
|
if (!fromwire_openingd_dev_memleak_reply(msg, &found_leak)) {
|
2018-12-16 04:53:06 +00:00
|
|
|
was_pending(command_fail(cmd, LIGHTNINGD,
|
|
|
|
|
"Bad opening_dev_memleak"));
|
2018-11-22 02:17:29 +00:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (found_leak) {
|
|
|
|
|
opening_memleak_done(cmd, openingd);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
opening_memleak_req_next(cmd, uc->peer);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void opening_memleak_req_next(struct command *cmd, struct peer *prev)
|
|
|
|
|
{
|
|
|
|
|
struct peer *p;
|
|
|
|
|
|
|
|
|
|
list_for_each(&cmd->ld->peers, p, list) {
|
|
|
|
|
if (!p->uncommitted_channel)
|
|
|
|
|
continue;
|
|
|
|
|
if (p == prev) {
|
|
|
|
|
prev = NULL;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
if (prev != NULL)
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
subd_req(p,
|
|
|
|
|
p->uncommitted_channel->openingd,
|
2020-08-25 03:12:18 +01:00
|
|
|
take(towire_openingd_dev_memleak(NULL)),
|
2018-11-22 02:17:29 +00:00
|
|
|
-1, 0, opening_memleak_req_done, cmd);
|
2018-11-22 02:17:29 +00:00
|
|
|
/* Just in case it dies before replying! */
|
|
|
|
|
tal_add_destructor2(p->uncommitted_channel->openingd,
|
|
|
|
|
opening_died_forget_memleak, cmd);
|
2018-11-22 02:17:29 +00:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
opening_memleak_done(cmd, NULL);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void opening_dev_memleak(struct command *cmd)
|
|
|
|
|
{
|
|
|
|
|
opening_memleak_req_next(cmd, NULL);
|
|
|
|
|
}
|
|
|
|
|
#endif /* DEVELOPER */
|
2019-12-03 14:48:18 +00:00
|
|
|
|
|
|
|
|
struct subd *peer_get_owning_subd(struct peer *peer)
|
|
|
|
|
{
|
|
|
|
|
struct channel *channel;
|
|
|
|
|
channel = peer_active_channel(peer);
|
|
|
|
|
|
|
|
|
|
if (channel != NULL) {
|
|
|
|
|
return channel->owner;
|
|
|
|
|
} else if (peer->uncommitted_channel != NULL) {
|
|
|
|
|
return peer->uncommitted_channel->openingd;
|
|
|
|
|
}
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
