diff --git a/lightningd/dual_open_control.c b/lightningd/dual_open_control.c index f5296e4c6..83a1f651c 100644 --- a/lightningd/dual_open_control.c +++ b/lightningd/dual_open_control.c @@ -1803,6 +1803,7 @@ static unsigned int dual_opend_msg(struct subd *dualopend, /* Messages we send */ case WIRE_DUALOPEND_INIT: + case WIRE_DUALOPEND_REINIT: case WIRE_DUALOPEND_OPENER_INIT: case WIRE_DUALOPEND_GOT_OFFER_REPLY: case WIRE_DUALOPEND_FAIL: @@ -1863,6 +1864,85 @@ AUTODATA(json_command, &openchannel_update_command); AUTODATA(json_command, &openchannel_signed_command); #endif /* EXPERIMENTAL_FEATURES */ +void peer_restart_dualopend(struct peer *peer, + struct per_peer_state *pps, + struct channel *channel, + const u8 *send_msg) +{ + u32 max_to_self_delay; + struct amount_msat min_effective_htlc_capacity; + struct channel_config unused_config; + int hsmfd; + u8 *msg; + + hsmfd = hsm_get_client_fd(peer->ld, &peer->id, channel->dbid, + HSM_CAP_COMMITMENT_POINT + | HSM_CAP_SIGN_REMOTE_TX); + + channel_set_owner(channel, + new_channel_subd(peer->ld, "lightning_dualopend", + channel, CHANNEL, + &peer->id, + channel->log, true, + dualopend_wire_name, + dual_opend_msg, + channel_errmsg, + channel_set_billboard, + take(&pps->peer_fd), + take(&pps->gossip_fd), + take(&pps->gossip_store_fd), + take(&hsmfd), NULL)); + if (!channel->owner) { + log_broken(channel->log, "Could not subdaemon channel: %s", + strerror(errno)); + channel_fail_reconnect_later(channel, + "Failed to subdaemon channel"); + return; + } + + /* Find the max self delay and min htlc capacity */ + channel_config(peer->ld, &unused_config, + &max_to_self_delay, + &min_effective_htlc_capacity); + + msg = towire_dualopend_reinit(NULL, + chainparams, + peer->ld->our_features, + peer->their_features, + &channel->our_config, + &channel->channel_info.their_config, + &channel->cid, + max_to_self_delay, + min_effective_htlc_capacity, + pps, + &channel->local_basepoints, + &channel->local_funding_pubkey, + &channel->channel_info.remote_fundingkey, + channel->minimum_depth, + feerate_min(peer->ld, NULL), + feerate_max(peer->ld, NULL), + &channel->funding_txid, + channel->funding_outnum, + channel->funding, + channel->our_msat, + &channel->channel_info.theirbase, + &channel->channel_info.remote_per_commit, + channel->psbt, + channel->opener, + channel->scid != NULL, + channel->remote_funding_locked, + channel->state == CHANNELD_SHUTTING_DOWN, + channel->shutdown_scriptpubkey[REMOTE] != NULL, + channel->shutdown_scriptpubkey[LOCAL], + channel->remote_upfront_shutdown_script, + channel->remote_tx_sigs, + channel->fee_states, + send_msg); + + + subd_send_msg(channel->owner, take(msg)); +} + void peer_start_dualopend(struct peer *peer, struct per_peer_state *pps, const u8 *send_msg) diff --git a/lightningd/dual_open_control.h b/lightningd/dual_open_control.h index 32e4d65cc..a1335381d 100644 --- a/lightningd/dual_open_control.h +++ b/lightningd/dual_open_control.h @@ -10,6 +10,11 @@ void peer_start_dualopend(struct peer *peer, struct per_peer_state *pps, const u8 *send_msg); +void peer_restart_dualopend(struct peer *peer, + struct per_peer_state *pps, + struct channel *channel, + const u8 *send_msg); + void dualopen_tell_depth(struct subd *dualopend, struct channel *channel, u32 depth); diff --git a/lightningd/peer_control.c b/lightningd/peer_control.c index 3be18e533..bc3c0bc9f 100644 --- a/lightningd/peer_control.c +++ b/lightningd/peer_control.c @@ -1024,9 +1024,18 @@ peer_connected_hook_cb(struct peer_connected_hook_payload *payload STEALS, } case DUALOPEND_OPEN_INIT: case DUALOPEND_AWAITING_LOCKIN: - /* FIXME: open dualopend */ - abort(); +#if EXPERIMENTAL_FEATURES + assert(!channel->owner); + channel->peer->addr = addr; + peer_restart_dualopend(peer, payload->pps, + channel, NULL); + + tal_free(payload); + return; +#else + abort(); +#endif /* EXPERIMENTAL_FEATURES */ case CHANNELD_AWAITING_LOCKIN: case CHANNELD_NORMAL: case CHANNELD_SHUTTING_DOWN: @@ -1060,7 +1069,18 @@ send_error: if (feature_negotiated(ld->our_features, peer->their_features, OPT_DUAL_FUND)) { - peer_start_dualopend(peer, payload->pps, error); + /* if we have a channel, we're actually restarting + * dualopend. we only get here if there's an error */ + if (channel) { + assert(!channel->owner); + + assert(channel->state == DUALOPEND_OPEN_INIT + || channel->state == DUALOPEND_AWAITING_LOCKIN); + channel->peer->addr = addr; + peer_restart_dualopend(peer, payload->pps, + channel, error); + } else + peer_start_dualopend(peer, payload->pps, error); } else #endif /* EXPERIMENTAL_FEATURES */ peer_start_openingd(peer, payload->pps, error); diff --git a/lightningd/test/run-invoice-select-inchan.c b/lightningd/test/run-invoice-select-inchan.c index 1e15b9f7d..5a21e7d4f 100644 --- a/lightningd/test/run-invoice-select-inchan.c +++ b/lightningd/test/run-invoice-select-inchan.c @@ -501,6 +501,12 @@ void peer_memleak_done(struct command *cmd UNNEEDED, struct subd *leaker UNNEEDE /* Generated stub for peer_normal_channel */ struct channel *peer_normal_channel(struct peer *peer UNNEEDED) { fprintf(stderr, "peer_normal_channel called!\n"); abort(); } +/* Generated stub for peer_restart_dualopend */ +void peer_restart_dualopend(struct peer *peer UNNEEDED, + struct per_peer_state *pps UNNEEDED, + struct channel *channel UNNEEDED, + const u8 *send_msg UNNEEDED) +{ fprintf(stderr, "peer_restart_dualopend called!\n"); abort(); } /* Generated stub for peer_start_channeld */ void peer_start_channeld(struct channel *channel UNNEEDED, struct per_peer_state *pps UNNEEDED, diff --git a/openingd/dualopend.c b/openingd/dualopend.c index 569c94408..ff3463a39 100644 --- a/openingd/dualopend.c +++ b/openingd/dualopend.c @@ -148,6 +148,9 @@ struct state { /* Tally of which sides are locked, or not */ bool funding_locked[NUM_SIDES]; + /* Have we gotten the peer's tx-sigs yet? */ + bool remote_funding_sigs_rcvd; + /* PSBT of the funding tx */ struct wally_psbt *psbt; @@ -156,6 +159,9 @@ struct state { /* Are we shutting down? */ bool shutdown_sent[NUM_SIDES]; + + /* Were we reconnected at start ? */ + bool reconnected; }; /* psbt_changeset_get_next - Get next message to send @@ -766,7 +772,7 @@ static void handle_tx_sigs(struct state *state, const u8 *msg) tal_hex(msg, msg)); /* Maybe they didn't get our funding_locked message ? */ - if (state->funding_locked[LOCAL]) { + if (state->funding_locked[LOCAL] && !state->reconnected) { status_broken("Got WIRE_TX_SIGNATURES after funding locked " "for channel %s, ignoring: %s", type_to_string(tmpctx, struct channel_id, @@ -2381,6 +2387,7 @@ static u8 *handle_master_in(struct state *state) /* Handled inline */ case WIRE_DUALOPEND_INIT: + case WIRE_DUALOPEND_REINIT: case WIRE_DUALOPEND_DEV_MEMLEAK_REPLY: case WIRE_DUALOPEND_FAIL: case WIRE_DUALOPEND_PSBT_UPDATED: @@ -2427,6 +2434,11 @@ static u8 *handle_peer_in(struct state *state) struct channel_id channel_id; if (t == WIRE_OPEN_CHANNEL2) { + if (state->channel) { + status_broken("Unexpected message %s", + peer_wire_name(t)); + peer_failed_connection_lost(); + } accepter_start(state, msg); return NULL; } else if (t == WIRE_TX_SIGNATURES) { @@ -2485,7 +2497,11 @@ int main(int argc, char *argv[]) struct pollfd pollfd[3]; struct state *state = tal(NULL, struct state); struct secret *none; + struct fee_states *fee_states; + enum side opener; u8 *msg, *inner; + struct amount_sat total_funding; + struct amount_msat our_msat; subdaemon_setup(argc, argv); @@ -2495,20 +2511,99 @@ int main(int argc, char *argv[]) /*~ The very first thing we read from lightningd is our init msg */ msg = wire_sync_read(tmpctx, REQ_FD); - if (!fromwire_dualopend_init(state, msg, - &chainparams, - &state->our_features, - &state->their_features, - &state->localconf, - &state->max_to_self_delay, - &state->min_effective_htlc_capacity, - &state->pps, - &state->our_points, - &state->our_funding_pubkey, - &state->minimum_depth, - &state->min_feerate, &state->max_feerate, - &inner)) - master_badmsg(WIRE_DUALOPEND_INIT, msg); + if (fromwire_dualopend_init(state, msg, + &chainparams, + &state->our_features, + &state->their_features, + &state->localconf, + &state->max_to_self_delay, + &state->min_effective_htlc_capacity, + &state->pps, + &state->our_points, + &state->our_funding_pubkey, + &state->minimum_depth, + &state->min_feerate, + &state->max_feerate, + &inner)) { + /*~ Initially we're not associated with a channel, but + * handle_peer_gossip_or_error compares this. */ + memset(&state->channel_id, 0, sizeof(state->channel_id)); + state->channel = NULL; + state->remote_funding_sigs_rcvd = false; + + /*~ We set these to NULL, meaning no requirements on shutdown */ + state->upfront_shutdown_script[LOCAL] + = state->upfront_shutdown_script[REMOTE] + = NULL; + + /*~ We're not locked or shutting down quite yet */ + state->funding_locked[LOCAL] + = state->funding_locked[REMOTE] + = false; + state->shutdown_sent[LOCAL] + = state->shutdown_sent[REMOTE] + = false; + + } else if (fromwire_dualopend_reinit(state, msg, + &chainparams, + &state->our_features, + &state->their_features, + &state->localconf, + &state->remoteconf, + &state->channel_id, + &state->max_to_self_delay, + &state->min_effective_htlc_capacity, + &state->pps, + &state->our_points, + &state->our_funding_pubkey, + &state->their_funding_pubkey, + &state->minimum_depth, + &state->min_feerate, + &state->max_feerate, + &state->funding_txid, + &state->funding_txout, + &total_funding, + &our_msat, + &state->their_points, + &state->first_per_commitment_point[REMOTE], + &state->psbt, + &opener, + &state->funding_locked[LOCAL], + &state->funding_locked[REMOTE], + &state->shutdown_sent[LOCAL], + &state->shutdown_sent[REMOTE], + &state->upfront_shutdown_script[LOCAL], + &state->upfront_shutdown_script[REMOTE], + &state->remote_funding_sigs_rcvd, + &fee_states, + &inner)) { + + /*~ We only reconnect on channels that the + * saved the the database (exchanged commitment sigs) */ + state->channel = new_initial_channel(state, + &state->channel_id, + &state->funding_txid, + state->funding_txout, + state->minimum_depth, + total_funding, + our_msat, + fee_states, + &state->localconf, + &state->remoteconf, + &state->our_points, + &state->their_points, + &state->our_funding_pubkey, + &state->their_funding_pubkey, + true, true, opener); + + if (opener == LOCAL) + state->our_role = TX_INITIATOR; + else + state->our_role = TX_ACCEPTER; + } else + master_badmsg(fromwire_peektype(msg), msg); + + /* 3 == peer, 4 == gossipd, 5 = gossip_store, 6 = hsmd */ per_peer_state_set_fds(state->pps, 3, 4, 5); @@ -2521,21 +2616,9 @@ int main(int argc, char *argv[]) tal_free(inner); } - /*~ Initially we're not associated with a channel, but - * handle_peer_gossip_or_error compares this. */ - memset(&state->channel_id, 0, sizeof(state->channel_id)); - state->channel = NULL; - state->funding_locked[LOCAL] = state->funding_locked[REMOTE] = false; - state->shutdown_sent[LOCAL]= state->shutdown_sent[REMOTE] = false; - for (size_t i = 0; i < NUM_TX_MSGS; i++) state->tx_msg_count[i] = 0; - /*~ We set these to NULL, meaning no requirements on shutdown */ - state->upfront_shutdown_script[LOCAL] - = state->upfront_shutdown_script[REMOTE] - = NULL; - /*~ We need an initial per-commitment point whether we're funding or * they are, and lightningd has reserved a unique dbid for us already, * so we might as well get the hsm daemon to generate it now. */ diff --git a/openingd/dualopend_wire.csv b/openingd/dualopend_wire.csv index 6b7be6992..757ec0053 100644 --- a/openingd/dualopend_wire.csv +++ b/openingd/dualopend_wire.csv @@ -5,6 +5,8 @@ #include #include #include +#include +#include #include #include @@ -30,6 +32,46 @@ msgdata,dualopend_init,max_feerate,u32, msgdata,dualopend_init,len,u16, msgdata,dualopend_init,msg,u8,len +# master-dualopend: peer has reconnected +msgtype,dualopend_reinit,7001 +msgdata,dualopend_reinit,chainparams,chainparams, +msgdata,dualopend_reinit,our_feature_set,feature_set, +msgdata,dualopend_reinit,their_init_features_len,u16, +msgdata,dualopend_reinit,their_init_features,u8,their_init_features_len +msgdata,dualopend_reinit,our_config,channel_config, +msgdata,dualopend_reinit,their_config,channel_config, +msgdata,dualopend_reinit,channel_id,channel_id, +msgdata,dualopend_reinit,max_to_self_delay,u32, +msgdata,dualopend_reinit,min_effective_htlc_capacity_msat,amount_msat, +msgdata,dualopend_reinit,pps,per_peer_state, +msgdata,dualopend_reinit,our_basepoints,basepoints, +msgdata,dualopend_reinit,our_funding_pubkey,pubkey, +msgdata,dualopend_reinit,their_funding_pubkey,pubkey, +msgdata,dualopend_reinit,minimum_depth,u32, +msgdata,dualopend_reinit,min_feerate,u32, +msgdata,dualopend_reinit,max_feerate,u32, +msgdata,dualopend_reinit,funding_txid,bitcoin_txid, +msgdata,dualopend_reinit,funding_txout,u16, +msgdata,dualopend_reinit,funding_satoshi,amount_sat, +msgdata,dualopend_reinit,our_funding,amount_msat, +msgdata,dualopend_reinit,their_basepoints,basepoints, +msgdata,dualopend_reinit,remote_per_commit,pubkey, +msgdata,dualopend_reinit,funding_psbt,wally_psbt, +msgdata,dualopend_reinit,opener,enum side, +msgdata,dualopend_reinit,local_funding_locked,bool, +msgdata,dualopend_reinit,remote_funding_locked,bool, +msgdata,dualopend_reinit,send_shutdown,bool, +msgdata,dualopend_reinit,remote_shutdown_received,bool, +msgdata,dualopend_reinit,local_shutdown_len,u16, +msgdata,dualopend_reinit,local_shutdown_scriptpubkey,u8,local_shutdown_len +msgdata,dualopend_reinit,remote_shutdown_len,u16, +msgdata,dualopend_reinit,remote_shutdown_scriptpubkey,u8,remote_shutdown_len +msgdata,dualopend_reinit,remote_funding_sigs_received,bool, +msgdata,dualopend_reinit,fee_states,fee_states, +# Optional msg to send. +msgdata,dualopend_reinit,len,u16, +msgdata,dualopend_reinit,msg,u8,len + # dualopend->master: they offered channel, should we continue? msgtype,dualopend_got_offer,7005 msgdata,dualopend_got_offer,opener_funding,amount_sat, diff --git a/openingd/dualopend_wiregen.c b/openingd/dualopend_wiregen.c index 75bbbc11f..72a51bf81 100644 --- a/openingd/dualopend_wiregen.c +++ b/openingd/dualopend_wiregen.c @@ -21,6 +21,7 @@ const char *dualopend_wire_name(int e) switch ((enum dualopend_wire)e) { case WIRE_DUALOPEND_INIT: return "WIRE_DUALOPEND_INIT"; + case WIRE_DUALOPEND_REINIT: return "WIRE_DUALOPEND_REINIT"; case WIRE_DUALOPEND_GOT_OFFER: return "WIRE_DUALOPEND_GOT_OFFER"; case WIRE_DUALOPEND_GOT_OFFER_REPLY: return "WIRE_DUALOPEND_GOT_OFFER_REPLY"; case WIRE_DUALOPEND_COMMIT_RCVD: return "WIRE_DUALOPEND_COMMIT_RCVD"; @@ -49,6 +50,7 @@ bool dualopend_wire_is_defined(u16 type) { switch ((enum dualopend_wire)type) { case WIRE_DUALOPEND_INIT:; + case WIRE_DUALOPEND_REINIT:; case WIRE_DUALOPEND_GOT_OFFER:; case WIRE_DUALOPEND_GOT_OFFER_REPLY:; case WIRE_DUALOPEND_COMMIT_RCVD:; @@ -144,6 +146,117 @@ bool fromwire_dualopend_init(const tal_t *ctx, const void *p, const struct chain return cursor != NULL; } +/* WIRE: DUALOPEND_REINIT */ +/* master-dualopend: peer has reconnected */ +u8 *towire_dualopend_reinit(const tal_t *ctx, const struct chainparams *chainparams, const struct feature_set *our_feature_set, const u8 *their_init_features, const struct channel_config *our_config, const struct channel_config *their_config, const struct channel_id *channel_id, u32 max_to_self_delay, struct amount_msat min_effective_htlc_capacity_msat, const struct per_peer_state *pps, const struct basepoints *our_basepoints, const struct pubkey *our_funding_pubkey, const struct pubkey *their_funding_pubkey, u32 minimum_depth, u32 min_feerate, u32 max_feerate, const struct bitcoin_txid *funding_txid, u16 funding_txout, struct amount_sat funding_satoshi, struct amount_msat our_funding, const struct basepoints *their_basepoints, const struct pubkey *remote_per_commit, const struct wally_psbt *funding_psbt, enum side opener, bool local_funding_locked, bool remote_funding_locked, bool send_shutdown, bool remote_shutdown_received, const u8 *local_shutdown_scriptpubkey, const u8 *remote_shutdown_scriptpubkey, bool remote_funding_sigs_received, const struct fee_states *fee_states, const u8 *msg) +{ + u16 their_init_features_len = tal_count(their_init_features); + u16 local_shutdown_len = tal_count(local_shutdown_scriptpubkey); + u16 remote_shutdown_len = tal_count(remote_shutdown_scriptpubkey); + u16 len = tal_count(msg); + u8 *p = tal_arr(ctx, u8, 0); + + towire_u16(&p, WIRE_DUALOPEND_REINIT); + towire_chainparams(&p, chainparams); + towire_feature_set(&p, our_feature_set); + towire_u16(&p, their_init_features_len); + towire_u8_array(&p, their_init_features, their_init_features_len); + towire_channel_config(&p, our_config); + towire_channel_config(&p, their_config); + towire_channel_id(&p, channel_id); + towire_u32(&p, max_to_self_delay); + towire_amount_msat(&p, min_effective_htlc_capacity_msat); + towire_per_peer_state(&p, pps); + towire_basepoints(&p, our_basepoints); + towire_pubkey(&p, our_funding_pubkey); + towire_pubkey(&p, their_funding_pubkey); + towire_u32(&p, minimum_depth); + towire_u32(&p, min_feerate); + towire_u32(&p, max_feerate); + towire_bitcoin_txid(&p, funding_txid); + towire_u16(&p, funding_txout); + towire_amount_sat(&p, funding_satoshi); + towire_amount_msat(&p, our_funding); + towire_basepoints(&p, their_basepoints); + towire_pubkey(&p, remote_per_commit); + towire_wally_psbt(&p, funding_psbt); + towire_side(&p, opener); + towire_bool(&p, local_funding_locked); + towire_bool(&p, remote_funding_locked); + towire_bool(&p, send_shutdown); + towire_bool(&p, remote_shutdown_received); + towire_u16(&p, local_shutdown_len); + towire_u8_array(&p, local_shutdown_scriptpubkey, local_shutdown_len); + towire_u16(&p, remote_shutdown_len); + towire_u8_array(&p, remote_shutdown_scriptpubkey, remote_shutdown_len); + towire_bool(&p, remote_funding_sigs_received); + towire_fee_states(&p, fee_states); + /* Optional msg to send. */ + towire_u16(&p, len); + towire_u8_array(&p, msg, len); + + return memcheck(p, tal_count(p)); +} +bool fromwire_dualopend_reinit(const tal_t *ctx, const void *p, const struct chainparams **chainparams, struct feature_set **our_feature_set, u8 **their_init_features, struct channel_config *our_config, struct channel_config *their_config, struct channel_id *channel_id, u32 *max_to_self_delay, struct amount_msat *min_effective_htlc_capacity_msat, struct per_peer_state **pps, struct basepoints *our_basepoints, struct pubkey *our_funding_pubkey, struct pubkey *their_funding_pubkey, u32 *minimum_depth, u32 *min_feerate, u32 *max_feerate, struct bitcoin_txid *funding_txid, u16 *funding_txout, struct amount_sat *funding_satoshi, struct amount_msat *our_funding, struct basepoints *their_basepoints, struct pubkey *remote_per_commit, struct wally_psbt **funding_psbt, enum side *opener, bool *local_funding_locked, bool *remote_funding_locked, bool *send_shutdown, bool *remote_shutdown_received, u8 **local_shutdown_scriptpubkey, u8 **remote_shutdown_scriptpubkey, bool *remote_funding_sigs_received, struct fee_states **fee_states, u8 **msg) +{ + u16 their_init_features_len; + u16 local_shutdown_len; + u16 remote_shutdown_len; + u16 len; + + const u8 *cursor = p; + size_t plen = tal_count(p); + + if (fromwire_u16(&cursor, &plen) != WIRE_DUALOPEND_REINIT) + return false; + fromwire_chainparams(&cursor, &plen, chainparams); + *our_feature_set = fromwire_feature_set(ctx, &cursor, &plen); + their_init_features_len = fromwire_u16(&cursor, &plen); + // 2nd case their_init_features + *their_init_features = their_init_features_len ? tal_arr(ctx, u8, their_init_features_len) : NULL; + fromwire_u8_array(&cursor, &plen, *their_init_features, their_init_features_len); + fromwire_channel_config(&cursor, &plen, our_config); + fromwire_channel_config(&cursor, &plen, their_config); + fromwire_channel_id(&cursor, &plen, channel_id); + *max_to_self_delay = fromwire_u32(&cursor, &plen); + *min_effective_htlc_capacity_msat = fromwire_amount_msat(&cursor, &plen); + *pps = fromwire_per_peer_state(ctx, &cursor, &plen); + fromwire_basepoints(&cursor, &plen, our_basepoints); + fromwire_pubkey(&cursor, &plen, our_funding_pubkey); + fromwire_pubkey(&cursor, &plen, their_funding_pubkey); + *minimum_depth = fromwire_u32(&cursor, &plen); + *min_feerate = fromwire_u32(&cursor, &plen); + *max_feerate = fromwire_u32(&cursor, &plen); + fromwire_bitcoin_txid(&cursor, &plen, funding_txid); + *funding_txout = fromwire_u16(&cursor, &plen); + *funding_satoshi = fromwire_amount_sat(&cursor, &plen); + *our_funding = fromwire_amount_msat(&cursor, &plen); + fromwire_basepoints(&cursor, &plen, their_basepoints); + fromwire_pubkey(&cursor, &plen, remote_per_commit); + *funding_psbt = fromwire_wally_psbt(ctx, &cursor, &plen); + *opener = fromwire_side(&cursor, &plen); + *local_funding_locked = fromwire_bool(&cursor, &plen); + *remote_funding_locked = fromwire_bool(&cursor, &plen); + *send_shutdown = fromwire_bool(&cursor, &plen); + *remote_shutdown_received = fromwire_bool(&cursor, &plen); + local_shutdown_len = fromwire_u16(&cursor, &plen); + // 2nd case local_shutdown_scriptpubkey + *local_shutdown_scriptpubkey = local_shutdown_len ? tal_arr(ctx, u8, local_shutdown_len) : NULL; + fromwire_u8_array(&cursor, &plen, *local_shutdown_scriptpubkey, local_shutdown_len); + remote_shutdown_len = fromwire_u16(&cursor, &plen); + // 2nd case remote_shutdown_scriptpubkey + *remote_shutdown_scriptpubkey = remote_shutdown_len ? tal_arr(ctx, u8, remote_shutdown_len) : NULL; + fromwire_u8_array(&cursor, &plen, *remote_shutdown_scriptpubkey, remote_shutdown_len); + *remote_funding_sigs_received = fromwire_bool(&cursor, &plen); + *fee_states = fromwire_fee_states(ctx, &cursor, &plen); + /* Optional msg to send. */ + len = fromwire_u16(&cursor, &plen); + // 2nd case msg + *msg = len ? tal_arr(ctx, u8, len) : NULL; + fromwire_u8_array(&cursor, &plen, *msg, len); + return cursor != NULL; +} + /* WIRE: DUALOPEND_GOT_OFFER */ /* dualopend->master: they offered channel */ u8 *towire_dualopend_got_offer(const tal_t *ctx, struct amount_sat opener_funding, struct amount_sat dust_limit_satoshis, struct amount_msat max_htlc_value_in_flight_msat, struct amount_msat htlc_minimum_msat, u32 feerate_funding_max, u32 feerate_funding_min, u32 feerate_funding_best, u32 feerate_per_kw, u16 to_self_delay, u16 max_accepted_htlcs, u8 channel_flags, u32 locktime, const u8 *shutdown_scriptpubkey) @@ -679,4 +792,4 @@ bool fromwire_dualopend_dev_memleak_reply(const void *p, bool *leak) *leak = fromwire_bool(&cursor, &plen); return cursor != NULL; } -// SHA256STAMP:5b6ccfff2f6cc43eee53e4aed8767fc7ae539d548277bda1c628c51f3191dfe4 +// SHA256STAMP:02f28abef3ab5503d52f776543a85f6d5682637a8e9f8494beae16ff44896442 diff --git a/openingd/dualopend_wiregen.h b/openingd/dualopend_wiregen.h index bed58c052..d1c3227fe 100644 --- a/openingd/dualopend_wiregen.h +++ b/openingd/dualopend_wiregen.h @@ -14,11 +14,15 @@ #include #include #include +#include +#include #include #include enum dualopend_wire { WIRE_DUALOPEND_INIT = 7000, + /* master-dualopend: peer has reconnected */ + WIRE_DUALOPEND_REINIT = 7001, /* dualopend->master: they offered channel */ WIRE_DUALOPEND_GOT_OFFER = 7005, /* master->dualopend: reply back with our first funding info/contribs */ @@ -73,6 +77,11 @@ bool dualopend_wire_is_defined(u16 type); u8 *towire_dualopend_init(const tal_t *ctx, const struct chainparams *chainparams, const struct feature_set *our_feature_set, const u8 *their_init_features, const struct channel_config *our_config, u32 max_to_self_delay, struct amount_msat min_effective_htlc_capacity_msat, const struct per_peer_state *pps, const struct basepoints *our_basepoints, const struct pubkey *our_funding_pubkey, u32 minimum_depth, u32 min_feerate, u32 max_feerate, const u8 *msg); bool fromwire_dualopend_init(const tal_t *ctx, const void *p, const struct chainparams **chainparams, struct feature_set **our_feature_set, u8 **their_init_features, struct channel_config *our_config, u32 *max_to_self_delay, struct amount_msat *min_effective_htlc_capacity_msat, struct per_peer_state **pps, struct basepoints *our_basepoints, struct pubkey *our_funding_pubkey, u32 *minimum_depth, u32 *min_feerate, u32 *max_feerate, u8 **msg); +/* WIRE: DUALOPEND_REINIT */ +/* master-dualopend: peer has reconnected */ +u8 *towire_dualopend_reinit(const tal_t *ctx, const struct chainparams *chainparams, const struct feature_set *our_feature_set, const u8 *their_init_features, const struct channel_config *our_config, const struct channel_config *their_config, const struct channel_id *channel_id, u32 max_to_self_delay, struct amount_msat min_effective_htlc_capacity_msat, const struct per_peer_state *pps, const struct basepoints *our_basepoints, const struct pubkey *our_funding_pubkey, const struct pubkey *their_funding_pubkey, u32 minimum_depth, u32 min_feerate, u32 max_feerate, const struct bitcoin_txid *funding_txid, u16 funding_txout, struct amount_sat funding_satoshi, struct amount_msat our_funding, const struct basepoints *their_basepoints, const struct pubkey *remote_per_commit, const struct wally_psbt *funding_psbt, enum side opener, bool local_funding_locked, bool remote_funding_locked, bool send_shutdown, bool remote_shutdown_received, const u8 *local_shutdown_scriptpubkey, const u8 *remote_shutdown_scriptpubkey, bool remote_funding_sigs_received, const struct fee_states *fee_states, const u8 *msg); +bool fromwire_dualopend_reinit(const tal_t *ctx, const void *p, const struct chainparams **chainparams, struct feature_set **our_feature_set, u8 **their_init_features, struct channel_config *our_config, struct channel_config *their_config, struct channel_id *channel_id, u32 *max_to_self_delay, struct amount_msat *min_effective_htlc_capacity_msat, struct per_peer_state **pps, struct basepoints *our_basepoints, struct pubkey *our_funding_pubkey, struct pubkey *their_funding_pubkey, u32 *minimum_depth, u32 *min_feerate, u32 *max_feerate, struct bitcoin_txid *funding_txid, u16 *funding_txout, struct amount_sat *funding_satoshi, struct amount_msat *our_funding, struct basepoints *their_basepoints, struct pubkey *remote_per_commit, struct wally_psbt **funding_psbt, enum side *opener, bool *local_funding_locked, bool *remote_funding_locked, bool *send_shutdown, bool *remote_shutdown_received, u8 **local_shutdown_scriptpubkey, u8 **remote_shutdown_scriptpubkey, bool *remote_funding_sigs_received, struct fee_states **fee_states, u8 **msg); + /* WIRE: DUALOPEND_GOT_OFFER */ /* dualopend->master: they offered channel */ u8 *towire_dualopend_got_offer(const tal_t *ctx, struct amount_sat opener_funding, struct amount_sat dust_limit_satoshis, struct amount_msat max_htlc_value_in_flight_msat, struct amount_msat htlc_minimum_msat, u32 feerate_funding_max, u32 feerate_funding_min, u32 feerate_funding_best, u32 feerate_per_kw, u16 to_self_delay, u16 max_accepted_htlcs, u8 channel_flags, u32 locktime, const u8 *shutdown_scriptpubkey); @@ -165,4 +174,4 @@ bool fromwire_dualopend_dev_memleak_reply(const void *p, bool *leak); #endif /* LIGHTNING_OPENINGD_DUALOPEND_WIREGEN_H */ -// SHA256STAMP:5b6ccfff2f6cc43eee53e4aed8767fc7ae539d548277bda1c628c51f3191dfe4 +// SHA256STAMP:02f28abef3ab5503d52f776543a85f6d5682637a8e9f8494beae16ff44896442 diff --git a/wallet/db_postgres_sqlgen.c b/wallet/db_postgres_sqlgen.c index f10220a98..c074647a8 100644 --- a/wallet/db_postgres_sqlgen.c +++ b/wallet/db_postgres_sqlgen.c @@ -1780,4 +1780,4 @@ struct db_query db_postgres_queries[] = { #endif /* LIGHTNINGD_WALLET_GEN_DB_POSTGRES */ -// SHA256STAMP:6ab0acf78761f626e452b9d6b83206d2546872001c93779eeb2f15ff8accd62f +// SHA256STAMP:ca47a99b5c64139f4556f3bf77a6d984cb9ab6b38bcd2851bc551c75c5cc240a diff --git a/wallet/db_sqlite3_sqlgen.c b/wallet/db_sqlite3_sqlgen.c index 36f559106..b7d0dc785 100644 --- a/wallet/db_sqlite3_sqlgen.c +++ b/wallet/db_sqlite3_sqlgen.c @@ -1780,4 +1780,4 @@ struct db_query db_sqlite3_queries[] = { #endif /* LIGHTNINGD_WALLET_GEN_DB_SQLITE3 */ -// SHA256STAMP:6ab0acf78761f626e452b9d6b83206d2546872001c93779eeb2f15ff8accd62f +// SHA256STAMP:ca47a99b5c64139f4556f3bf77a6d984cb9ab6b38bcd2851bc551c75c5cc240a diff --git a/wallet/statements_gettextgen.po b/wallet/statements_gettextgen.po index 466a06d8f..242fae063 100644 --- a/wallet/statements_gettextgen.po +++ b/wallet/statements_gettextgen.po @@ -1170,7 +1170,7 @@ msgstr "" msgid "not a valid SQL statement" msgstr "" -#: wallet/test/run-wallet.c:1384 +#: wallet/test/run-wallet.c:1390 msgid "INSERT INTO channels (id) VALUES (1);" msgstr "" -# SHA256STAMP:21482a898c9a9a83ab6cd873e120306701f76f8559a2e8cb93f062a532aec3b6 +# SHA256STAMP:e9a62e2d71753f9067c6853326ba6d9e486cd85947d46a228dfcc58b8de5004a diff --git a/wallet/test/run-wallet.c b/wallet/test/run-wallet.c index 070c40189..147eb5ef0 100644 --- a/wallet/test/run-wallet.c +++ b/wallet/test/run-wallet.c @@ -596,6 +596,12 @@ struct subd *peer_get_owning_subd(struct peer *peer UNNEEDED) /* Generated stub for peer_memleak_done */ void peer_memleak_done(struct command *cmd UNNEEDED, struct subd *leaker UNNEEDED) { fprintf(stderr, "peer_memleak_done called!\n"); abort(); } +/* Generated stub for peer_restart_dualopend */ +void peer_restart_dualopend(struct peer *peer UNNEEDED, + struct per_peer_state *pps UNNEEDED, + struct channel *channel UNNEEDED, + const u8 *send_msg UNNEEDED) +{ fprintf(stderr, "peer_restart_dualopend called!\n"); abort(); } /* Generated stub for peer_start_channeld */ void peer_start_channeld(struct channel *channel UNNEEDED, struct per_peer_state *pps UNNEEDED,