From 9f74dd9fb36e8aa8b0d353c4943ceb28d8446884 Mon Sep 17 00:00:00 2001 From: niftynei Date: Tue, 3 Nov 2020 10:50:52 -0600 Subject: [PATCH] df: rename the dual_open wires to match other daemon wires --- lightningd/dual_open_control.c | 58 +++++------ lightningd/opening_common.c | 4 +- openingd/dualopend.c | 58 +++++------ openingd/dualopend_wire.csv | 170 ++++++++++++++++----------------- openingd/dualopend_wiregen.c | 156 +++++++++++++++--------------- openingd/dualopend_wiregen.h | 90 ++++++++--------- 6 files changed, 268 insertions(+), 268 deletions(-) diff --git a/lightningd/dual_open_control.c b/lightningd/dual_open_control.c index a584196b7..e78636a05 100644 --- a/lightningd/dual_open_control.c +++ b/lightningd/dual_open_control.c @@ -183,7 +183,7 @@ static const u8 *hook_extract_shutdown_script(struct subd* dualopend, if (!json_tok_streq(buffer, t, "continue")) { char *errmsg = "Client error. Unable to continue"; subd_send_msg(dualopend, - take(towire_dual_open_fail(NULL, errmsg))); + take(towire_dualopend_fail(NULL, errmsg))); return NULL; } @@ -234,7 +234,7 @@ hook_extract_psbt(const tal_t *ctx, struct subd *dualopend, const char *buffer, if (dualopend) { char *errmsg = "Client error. Unable to continue"; subd_send_msg(dualopend, - take(towire_dual_open_fail(NULL, errmsg))); + take(towire_dualopend_fail(NULL, errmsg))); } return false; } @@ -285,7 +285,7 @@ hook_extract_amount(struct subd *dualopend, if (!json_tok_streq(buffer, t, "continue")) { char *errmsg = "Client error. Unable to continue"; subd_send_msg(dualopend, - take(towire_dual_open_fail(NULL, errmsg))); + take(towire_dualopend_fail(NULL, errmsg))); return false; } @@ -440,7 +440,7 @@ openchannel2_hook_cb(struct openchannel2_payload *payload STEALS) /* If there's no plugin, the psbt will be NULL. We should pass an empty * PSBT over, in this case */ - msg = towire_dual_open_got_offer_reply(NULL, payload->accepter_funding, + msg = towire_dualopend_got_offer_reply(NULL, payload->accepter_funding, payload->funding_feerate_per_kw, payload->psbt, payload->our_shutdown_scriptpubkey); @@ -498,7 +498,7 @@ openchannel2_changed_hook_cb(struct openchannel2_psbt_payload *payload STEALS) payload); subd_send_msg(dualopend, - take(towire_dual_open_psbt_updated(NULL, + take(towire_dualopend_psbt_updated(NULL, payload->psbt))); } @@ -685,7 +685,7 @@ static void opener_psbt_changed(struct subd *dualopend, struct json_stream *response; struct command *cmd = uc->fc->cmd; - if (!fromwire_dual_open_psbt_changed(cmd, msg, + if (!fromwire_dualopend_psbt_changed(cmd, msg, &cid, &funding_serial, &psbt)) { log_broken(dualopend->log, @@ -736,7 +736,7 @@ static void accepter_commit_received(struct subd *dualopend, /* This is a new channel_info.their_config so set its ID to 0 */ channel_info.their_config.id = 0; - if (!fromwire_dual_open_commit_rcvd(tmpctx, msg, + if (!fromwire_dualopend_commit_rcvd(tmpctx, msg, &channel_info.their_config, &remote_commit, &pbase, @@ -760,9 +760,9 @@ static void accepter_commit_received(struct subd *dualopend, &uc->our_config.channel_reserve, &local_upfront_shutdown_script, &remote_upfront_shutdown_script)) { - log_broken(uc->log, "bad WIRE_DUAL_OPEN_COMMIT_RCVD %s", + log_broken(uc->log, "bad WIRE_DUALOPEND_COMMIT_RCVD %s", tal_hex(msg, msg)); - uncommitted_channel_disconnect(uc, LOG_BROKEN, "bad WIRE_DUAL_OPEN_COMMIT_RCVD"); + uncommitted_channel_disconnect(uc, LOG_BROKEN, "bad WIRE_DUALOPEND_COMMIT_RCVD"); close(fds[0]); close(fds[1]); close(fds[3]); @@ -853,7 +853,7 @@ static void opener_commit_received(struct subd *dualopend, /* This is a new channel_info.their_config so set its ID to 0 */ channel_info.their_config.id = 0; - if (!fromwire_dual_open_commit_rcvd(tmpctx, msg, + if (!fromwire_dualopend_commit_rcvd(tmpctx, msg, &channel_info.their_config, &remote_commit, &pbase, @@ -877,9 +877,9 @@ static void opener_commit_received(struct subd *dualopend, &uc->our_config.channel_reserve, &local_upfront_shutdown_script, &remote_upfront_shutdown_script)) { - log_broken(uc->log, "bad WIRE_DUAL_OPEN_COMMIT_RCVD %s", + log_broken(uc->log, "bad WIRE_DUALOPEND_COMMIT_RCVD %s", tal_hex(msg, msg)); - err_reason = "bad WIRE_DUAL_OPEN_COMMIT_RCVD"; + err_reason = "bad WIRE_DUALOPEND_COMMIT_RCVD"; uncommitted_channel_disconnect(uc, LOG_BROKEN, err_reason); close(fds[0]); close(fds[1]); @@ -965,7 +965,7 @@ static void accepter_psbt_changed(struct subd *dualopend, payload->psbt = NULL; payload->rcvd = tal(payload, struct commit_rcvd); - if (!fromwire_dual_open_psbt_changed(payload, msg, + if (!fromwire_dualopend_psbt_changed(payload, msg, &payload->rcvd->cid, &unused, &payload->psbt)) { @@ -987,7 +987,7 @@ static void accepter_got_offer(struct subd *dualopend, if (peer_active_channel(uc->peer)) { subd_send_msg(dualopend, - take(towire_dual_open_fail(NULL, "Already have active channel"))); + take(towire_dualopend_fail(NULL, "Already have active channel"))); return; } @@ -998,7 +998,7 @@ static void accepter_got_offer(struct subd *dualopend, payload->our_shutdown_scriptpubkey = NULL; payload->peer_id = uc->peer->id; - if (!fromwire_dual_open_got_offer(payload, msg, + if (!fromwire_dualopend_got_offer(payload, msg, &payload->their_funding, &payload->dust_limit_satoshis, &payload->max_htlc_value_in_flight_msat, @@ -1081,7 +1081,7 @@ static struct command_result *json_open_channel_update(struct command *cmd, uc->fc->cmd = cmd; - msg = towire_dual_open_psbt_updated(NULL, psbt); + msg = towire_dualopend_psbt_updated(NULL, psbt); subd_send_msg(uc->open_daemon, take(msg)); return command_still_pending(cmd); } @@ -1224,7 +1224,7 @@ static struct command_result *json_open_channel_init(struct command *cmd, fc->our_upfront_shutdown_script = tal_steal(fc, fc->our_upfront_shutdown_script); - msg = towire_dual_open_opener_init(NULL, + msg = towire_dualopend_opener_init(NULL, psbt, *amount, fc->our_upfront_shutdown_script, *feerate_per_kw, @@ -1242,10 +1242,10 @@ static unsigned int dual_opend_msg(struct subd *dualopend, struct uncommitted_channel *uc = dualopend->channel; switch (t) { - case WIRE_DUAL_OPEN_GOT_OFFER: + case WIRE_DUALOPEND_GOT_OFFER: accepter_got_offer(dualopend, uc, msg); return 0; - case WIRE_DUAL_OPEN_PSBT_CHANGED: + case WIRE_DUALOPEND_PSBT_CHANGED: if (uc->fc) { if (!uc->fc->cmd) { log_unusual(dualopend->log, @@ -1258,7 +1258,7 @@ static unsigned int dual_opend_msg(struct subd *dualopend, } else accepter_psbt_changed(dualopend, msg); return 0; - case WIRE_DUAL_OPEN_COMMIT_RCVD: + case WIRE_DUALOPEND_COMMIT_RCVD: if (tal_count(fds) != 3) return 3; if (uc->fc) { @@ -1275,16 +1275,16 @@ static unsigned int dual_opend_msg(struct subd *dualopend, accepter_commit_received(dualopend, uc, fds, msg); return 0; - case WIRE_DUAL_OPEN_FAILED: - case WIRE_DUAL_OPEN_DEV_MEMLEAK_REPLY: + case WIRE_DUALOPEND_FAILED: + case WIRE_DUALOPEND_DEV_MEMLEAK_REPLY: /* Messages we send */ - case WIRE_DUAL_OPEN_INIT: - case WIRE_DUAL_OPEN_OPENER_INIT: - case WIRE_DUAL_OPEN_GOT_OFFER_REPLY: - case WIRE_DUAL_OPEN_FAIL: - case WIRE_DUAL_OPEN_PSBT_UPDATED: - case WIRE_DUAL_OPEN_DEV_MEMLEAK: + case WIRE_DUALOPEND_INIT: + case WIRE_DUALOPEND_OPENER_INIT: + case WIRE_DUALOPEND_GOT_OFFER_REPLY: + case WIRE_DUALOPEND_FAIL: + case WIRE_DUALOPEND_PSBT_UPDATED: + case WIRE_DUALOPEND_DEV_MEMLEAK: break; } @@ -1380,7 +1380,7 @@ void peer_start_dualopend(struct peer *peer, */ uc->minimum_depth = peer->ld->config.anchor_confirms; - msg = towire_dual_open_init(NULL, + msg = towire_dualopend_init(NULL, chainparams, peer->ld->our_features, peer->their_features, diff --git a/lightningd/opening_common.c b/lightningd/opening_common.c index 78dd693ed..5648e608f 100644 --- a/lightningd/opening_common.c +++ b/lightningd/opening_common.c @@ -173,7 +173,7 @@ static void opening_memleak_req_done(struct subd *open_daemon, tal_del_destructor2(open_daemon, opening_died_forget_memleak, cmd); if (!fromwire_openingd_dev_memleak_reply(msg, &found_leak) && - !fromwire_dual_open_dev_memleak_reply(msg, + !fromwire_dualopend_dev_memleak_reply(msg, &found_leak)) { was_pending(command_fail(cmd, LIGHTNINGD, "Bad opening_dev_memleak")); @@ -210,7 +210,7 @@ static void opening_memleak_req_next(struct command *cmd, struct peer *prev) continue; if (streq(open_daemon->name, "dualopend")) - msg = towire_dual_open_dev_memleak(NULL); + msg = towire_dualopend_dev_memleak(NULL); else msg = towire_openingd_dev_memleak(NULL); diff --git a/openingd/dualopend.c b/openingd/dualopend.c index 3a733eb4b..6d958ceba 100644 --- a/openingd/dualopend.c +++ b/openingd/dualopend.c @@ -250,7 +250,7 @@ static void negotiation_aborted(struct state *state, bool am_opener, /* If necessary, tell master that funding failed. */ if (am_opener) { - u8 *msg = towire_dual_open_failed(NULL, why); + u8 *msg = towire_dualopend_failed(NULL, why); wire_sync_write(REQ_FD, take(msg)); } @@ -635,7 +635,7 @@ static void handle_dev_memleak(struct state *state, const u8 *msg) /* If there's anything left, dump it to logs, and return true. */ found_leak = dump_memleak(memtable); wire_sync_write(REQ_FD, - take(towire_dual_open_dev_memleak_reply(NULL, + take(towire_dualopend_dev_memleak_reply(NULL, found_leak))); } @@ -657,19 +657,19 @@ fetch_psbt_changes(struct state *state, const struct wally_psbt *psbt) struct wally_psbt *updated_psbt; /* Go ask lightningd what other changes we've got */ - msg = towire_dual_open_psbt_changed(NULL, &state->channel_id, + msg = towire_dualopend_psbt_changed(NULL, &state->channel_id, state->funding_serial, psbt); wire_sync_write(REQ_FD, take(msg)); msg = wire_sync_read(tmpctx, REQ_FD); - if (fromwire_dual_open_fail(msg, msg, &err)) + if (fromwire_dualopend_fail(msg, msg, &err)) status_failed(STATUS_FAIL_MASTER_IO, "%s", err); - else if (fromwire_dual_open_psbt_updated(state, msg, &updated_psbt)) { + else if (fromwire_dualopend_psbt_updated(state, msg, &updated_psbt)) { return updated_psbt; #if DEVELOPER - } else if (fromwire_dual_open_dev_memleak(msg)) { + } else if (fromwire_dualopend_dev_memleak(msg)) { handle_dev_memleak(state, msg); #endif /* DEVELOPER */ } else @@ -795,7 +795,7 @@ static u8 *opening_negotiate_msg(const tal_t *ctx, struct state *state, /* Close connection on all_channels error. */ if (all_channels) { if (am_opener) { - msg = towire_dual_open_failed(NULL, err); + msg = towire_dualopend_failed(NULL, err); wire_sync_write(REQ_FD, take(msg)); } peer_failed_received_errmsg(state->pps, err, @@ -1268,7 +1268,7 @@ static u8 *accepter_start(struct state *state, const u8 *oc2_msg) &state->their_points.revocation); /* FIXME: pass the podle back also */ - msg = towire_dual_open_got_offer(NULL, + msg = towire_dualopend_got_offer(NULL, state->opener_funding, state->remoteconf.dust_limit, state->remoteconf.max_htlc_value_in_flight, @@ -1286,8 +1286,8 @@ static u8 *accepter_start(struct state *state, const u8 *oc2_msg) wire_sync_write(REQ_FD, take(msg)); msg = wire_sync_read(tmpctx, REQ_FD); - if ((msg_type = fromwire_peektype(msg)) == WIRE_DUAL_OPEN_FAIL) { - if (!fromwire_dual_open_fail(msg, msg, &err_reason)) + if ((msg_type = fromwire_peektype(msg)) == WIRE_DUALOPEND_FAIL) { + if (!fromwire_dualopend_fail(msg, msg, &err_reason)) master_badmsg(msg_type, msg); u8 *errmsg = towire_errorfmt(tmpctx, &state->channel_id, @@ -1295,12 +1295,12 @@ static u8 *accepter_start(struct state *state, const u8 *oc2_msg) sync_crypto_write(state->pps, take(errmsg)); return NULL; } - if (!fromwire_dual_open_got_offer_reply(state, msg, + if (!fromwire_dualopend_got_offer_reply(state, msg, &state->accepter_funding, &state->feerate_per_kw_funding, &psbt, &state->upfront_shutdown_script[LOCAL])) - master_badmsg(WIRE_DUAL_OPEN_GOT_OFFER_REPLY, msg); + master_badmsg(WIRE_DUALOPEND_GOT_OFFER_REPLY, msg); if (!psbt) psbt = create_psbt(state, 0, 0, state->tx_locktime); @@ -1547,7 +1547,7 @@ static u8 *accepter_start(struct state *state, const u8 *oc2_msg) /* Send the commitment_signed controller; will save to db * and pass messages along to channeld to send along! */ - return towire_dual_open_commit_rcvd(state, + return towire_dualopend_commit_rcvd(state, &state->remoteconf, remote_commit, pbase, @@ -1594,14 +1594,14 @@ static u8 *opener_start(struct state *state, u8 *msg) secp256k1_ecdsa_signature *htlc_sigs; u32 feerate_min, feerate_max, feerate_best; - if (!fromwire_dual_open_opener_init(state, msg, + if (!fromwire_dualopend_opener_init(state, msg, &psbt, &state->opener_funding, &state->upfront_shutdown_script[LOCAL], &state->feerate_per_kw_commitment, &state->feerate_per_kw_funding, &channel_flags)) - master_badmsg(WIRE_DUAL_OPEN_OPENER_INIT, msg); + master_badmsg(WIRE_DUALOPEND_OPENER_INIT, msg); state->our_role = TX_INITIATOR; state->tx_locktime = psbt->tx->locktime; @@ -1972,7 +1972,7 @@ static u8 *opener_start(struct state *state, u8 *msg) peer_billboard(false, "channel open: commitment received, " "sending to lightningd to save"); - return towire_dual_open_commit_rcvd(state, + return towire_dualopend_commit_rcvd(state, &state->remoteconf, remote_commit, pbase, @@ -2046,23 +2046,23 @@ static u8 *handle_master_in(struct state *state) enum dualopend_wire t = fromwire_peektype(msg); switch (t) { - case WIRE_DUAL_OPEN_DEV_MEMLEAK: + case WIRE_DUALOPEND_DEV_MEMLEAK: #if DEVELOPER handle_dev_memleak(state, msg); #endif return NULL; - case WIRE_DUAL_OPEN_OPENER_INIT: + case WIRE_DUALOPEND_OPENER_INIT: return opener_start(state, msg); /* mostly handled inline */ - case WIRE_DUAL_OPEN_INIT: - case WIRE_DUAL_OPEN_DEV_MEMLEAK_REPLY: - case WIRE_DUAL_OPEN_FAILED: - case WIRE_DUAL_OPEN_FAIL: - case WIRE_DUAL_OPEN_GOT_OFFER: - case WIRE_DUAL_OPEN_GOT_OFFER_REPLY: - case WIRE_DUAL_OPEN_COMMIT_RCVD: - case WIRE_DUAL_OPEN_PSBT_CHANGED: - case WIRE_DUAL_OPEN_PSBT_UPDATED: + case WIRE_DUALOPEND_INIT: + case WIRE_DUALOPEND_DEV_MEMLEAK_REPLY: + case WIRE_DUALOPEND_FAILED: + case WIRE_DUALOPEND_FAIL: + case WIRE_DUALOPEND_GOT_OFFER: + case WIRE_DUALOPEND_GOT_OFFER_REPLY: + case WIRE_DUALOPEND_COMMIT_RCVD: + case WIRE_DUALOPEND_PSBT_CHANGED: + case WIRE_DUALOPEND_PSBT_UPDATED: break; } @@ -2148,7 +2148,7 @@ 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_dual_open_init(state, msg, + if (!fromwire_dualopend_init(state, msg, &chainparams, &state->our_features, &state->their_features, @@ -2161,7 +2161,7 @@ int main(int argc, char *argv[]) &state->minimum_depth, &state->min_feerate, &state->max_feerate, &inner)) - master_badmsg(WIRE_DUAL_OPEN_INIT, msg); + master_badmsg(WIRE_DUALOPEND_INIT, msg); /* 3 == peer, 4 == gossipd, 5 = gossip_store, 6 = hsmd */ per_peer_state_set_fds(state->pps, 3, 4, 5); diff --git a/openingd/dualopend_wire.csv b/openingd/dualopend_wire.csv index 85a8fd30c..cd517f1a1 100644 --- a/openingd/dualopend_wire.csv +++ b/openingd/dualopend_wire.csv @@ -8,114 +8,114 @@ #include #include -msgtype,dual_open_init,7000 +msgtype,dualopend_init,7000 # Which network are we configured for? -msgdata,dual_open_init,chainparams,chainparams, -msgdata,dual_open_init,our_feature_set,feature_set, -msgdata,dual_open_init,their_init_features_len,u16, -msgdata,dual_open_init,their_init_features,u8,their_init_features_len +msgdata,dualopend_init,chainparams,chainparams, +msgdata,dualopend_init,our_feature_set,feature_set, +msgdata,dualopend_init,their_init_features_len,u16, +msgdata,dualopend_init,their_init_features,u8,their_init_features_len # Base configuration we'll offer -msgdata,dual_open_init,our_config,channel_config, +msgdata,dualopend_init,our_config,channel_config, # Minimum/maximum configuration values we'll accept -msgdata,dual_open_init,max_to_self_delay,u32, -msgdata,dual_open_init,min_effective_htlc_capacity_msat,amount_msat, -msgdata,dual_open_init,pps,per_peer_state, -msgdata,dual_open_init,our_basepoints,basepoints, -msgdata,dual_open_init,our_funding_pubkey,pubkey, +msgdata,dualopend_init,max_to_self_delay,u32, +msgdata,dualopend_init,min_effective_htlc_capacity_msat,amount_msat, +msgdata,dualopend_init,pps,per_peer_state, +msgdata,dualopend_init,our_basepoints,basepoints, +msgdata,dualopend_init,our_funding_pubkey,pubkey, # Constraints in case the other end tries to open a channel. -msgdata,dual_open_init,minimum_depth,u32, -msgdata,dual_open_init,min_feerate,u32, -msgdata,dual_open_init,max_feerate,u32, +msgdata,dualopend_init,minimum_depth,u32, +msgdata,dualopend_init,min_feerate,u32, +msgdata,dualopend_init,max_feerate,u32, # Optional msg to send. -msgdata,dual_open_init,len,u16, -msgdata,dual_open_init,msg,u8,len +msgdata,dualopend_init,len,u16, +msgdata,dualopend_init,msg,u8,len # dualopend->master: they offered channel, should we continue? -msgtype,dual_open_got_offer,7005 -msgdata,dual_open_got_offer,opener_funding,amount_sat, -msgdata,dual_open_got_offer,dust_limit_satoshis,amount_sat, -msgdata,dual_open_got_offer,max_htlc_value_in_flight_msat,amount_msat, -msgdata,dual_open_got_offer,htlc_minimum_msat,amount_msat, -msgdata,dual_open_got_offer,feerate_funding_max,u32, -msgdata,dual_open_got_offer,feerate_funding_min,u32, -msgdata,dual_open_got_offer,feerate_funding_best,u32, -msgdata,dual_open_got_offer,feerate_per_kw,u32, -msgdata,dual_open_got_offer,to_self_delay,u16, -msgdata,dual_open_got_offer,max_accepted_htlcs,u16, -msgdata,dual_open_got_offer,channel_flags,u8, -msgdata,dual_open_got_offer,locktime,u32, -msgdata,dual_open_got_offer,shutdown_len,u16, -msgdata,dual_open_got_offer,shutdown_scriptpubkey,u8,shutdown_len +msgtype,dualopend_got_offer,7005 +msgdata,dualopend_got_offer,opener_funding,amount_sat, +msgdata,dualopend_got_offer,dust_limit_satoshis,amount_sat, +msgdata,dualopend_got_offer,max_htlc_value_in_flight_msat,amount_msat, +msgdata,dualopend_got_offer,htlc_minimum_msat,amount_msat, +msgdata,dualopend_got_offer,feerate_funding_max,u32, +msgdata,dualopend_got_offer,feerate_funding_min,u32, +msgdata,dualopend_got_offer,feerate_funding_best,u32, +msgdata,dualopend_got_offer,feerate_per_kw,u32, +msgdata,dualopend_got_offer,to_self_delay,u16, +msgdata,dualopend_got_offer,max_accepted_htlcs,u16, +msgdata,dualopend_got_offer,channel_flags,u8, +msgdata,dualopend_got_offer,locktime,u32, +msgdata,dualopend_got_offer,shutdown_len,u16, +msgdata,dualopend_got_offer,shutdown_scriptpubkey,u8,shutdown_len # master->dualopend: reply back with our first funding info/contribs -msgtype,dual_open_got_offer_reply,7105 -msgdata,dual_open_got_offer_reply,accepter_funding,amount_sat, -msgdata,dual_open_got_offer_reply,feerate_funding,u32, -msgdata,dual_open_got_offer_reply,psbt,wally_psbt, -msgdata,dual_open_got_offer_reply,shutdown_len,u16, -msgdata,dual_open_got_offer_reply,our_shutdown_scriptpubkey,?u8,shutdown_len +msgtype,dualopend_got_offer_reply,7105 +msgdata,dualopend_got_offer_reply,accepter_funding,amount_sat, +msgdata,dualopend_got_offer_reply,feerate_funding,u32, +msgdata,dualopend_got_offer_reply,psbt,wally_psbt, +msgdata,dualopend_got_offer_reply,shutdown_len,u16, +msgdata,dualopend_got_offer_reply,our_shutdown_scriptpubkey,?u8,shutdown_len # dualopend->master: ready to commit channel open to database and # get some signatures for the funding_tx. -msgtype,dual_open_commit_rcvd,7007 -msgdata,dual_open_commit_rcvd,their_config,channel_config, -msgdata,dual_open_commit_rcvd,remote_first_commit,bitcoin_tx, -msgdata,dual_open_commit_rcvd,pbase,?penalty_base, -msgdata,dual_open_commit_rcvd,first_commit_sig,bitcoin_signature, -msgdata,dual_open_commit_rcvd,psbt,wally_psbt, -msgdata,dual_open_commit_rcvd,channel_id,channel_id, -msgdata,dual_open_commit_rcvd,pps,per_peer_state, -msgdata,dual_open_commit_rcvd,revocation_basepoint,pubkey, -msgdata,dual_open_commit_rcvd,payment_basepoint,pubkey, -msgdata,dual_open_commit_rcvd,htlc_basepoint,pubkey, -msgdata,dual_open_commit_rcvd,delayed_payment_basepoint,pubkey, -msgdata,dual_open_commit_rcvd,their_per_commit_point,pubkey, -msgdata,dual_open_commit_rcvd,remote_fundingkey,pubkey, -msgdata,dual_open_commit_rcvd,funding_txid,bitcoin_txid, -msgdata,dual_open_commit_rcvd,funding_txout,u16, -msgdata,dual_open_commit_rcvd,funding_satoshis,amount_sat, -msgdata,dual_open_commit_rcvd,our_funding_sats,amount_sat, -msgdata,dual_open_commit_rcvd,channel_flags,u8, -msgdata,dual_open_commit_rcvd,feerate_per_kw,u32, +msgtype,dualopend_commit_rcvd,7007 +msgdata,dualopend_commit_rcvd,their_config,channel_config, +msgdata,dualopend_commit_rcvd,remote_first_commit,bitcoin_tx, +msgdata,dualopend_commit_rcvd,pbase,?penalty_base, +msgdata,dualopend_commit_rcvd,first_commit_sig,bitcoin_signature, +msgdata,dualopend_commit_rcvd,psbt,wally_psbt, +msgdata,dualopend_commit_rcvd,channel_id,channel_id, +msgdata,dualopend_commit_rcvd,pps,per_peer_state, +msgdata,dualopend_commit_rcvd,revocation_basepoint,pubkey, +msgdata,dualopend_commit_rcvd,payment_basepoint,pubkey, +msgdata,dualopend_commit_rcvd,htlc_basepoint,pubkey, +msgdata,dualopend_commit_rcvd,delayed_payment_basepoint,pubkey, +msgdata,dualopend_commit_rcvd,their_per_commit_point,pubkey, +msgdata,dualopend_commit_rcvd,remote_fundingkey,pubkey, +msgdata,dualopend_commit_rcvd,funding_txid,bitcoin_txid, +msgdata,dualopend_commit_rcvd,funding_txout,u16, +msgdata,dualopend_commit_rcvd,funding_satoshis,amount_sat, +msgdata,dualopend_commit_rcvd,our_funding_sats,amount_sat, +msgdata,dualopend_commit_rcvd,channel_flags,u8, +msgdata,dualopend_commit_rcvd,feerate_per_kw,u32, # our commitment signatures, for the peer -msgdata,dual_open_commit_rcvd,msglen,u16, -msgdata,dual_open_commit_rcvd,commitment_msg,u8,msglen -msgdata,dual_open_commit_rcvd,our_channel_reserve_satoshis,amount_sat, -msgdata,dual_open_commit_rcvd,local_shutdown_len,u16, -msgdata,dual_open_commit_rcvd,local_shutdown_scriptpubkey,u8,local_shutdown_len -msgdata,dual_open_commit_rcvd,remote_shutdown_len,u16, -msgdata,dual_open_commit_rcvd,remote_shutdown_scriptpubkey,u8,remote_shutdown_len +msgdata,dualopend_commit_rcvd,msglen,u16, +msgdata,dualopend_commit_rcvd,commitment_msg,u8,msglen +msgdata,dualopend_commit_rcvd,our_channel_reserve_satoshis,amount_sat, +msgdata,dualopend_commit_rcvd,local_shutdown_len,u16, +msgdata,dualopend_commit_rcvd,local_shutdown_scriptpubkey,u8,local_shutdown_len +msgdata,dualopend_commit_rcvd,remote_shutdown_len,u16, +msgdata,dualopend_commit_rcvd,remote_shutdown_scriptpubkey,u8,remote_shutdown_len # dualopend->master: peer updated the psbt -msgtype,dual_open_psbt_changed,7107 -msgdata,dual_open_psbt_changed,channel_id,channel_id, -msgdata,dual_open_psbt_changed,funding_serial,u64, -msgdata,dual_open_psbt_changed,psbt,wally_psbt, +msgtype,dualopend_psbt_changed,7107 +msgdata,dualopend_psbt_changed,channel_id,channel_id, +msgdata,dualopend_psbt_changed,funding_serial,u64, +msgdata,dualopend_psbt_changed,psbt,wally_psbt, # master->dualopend: we updated the psbt -msgtype,dual_open_psbt_updated,7108 -msgdata,dual_open_psbt_updated,psbt,wally_psbt, +msgtype,dualopend_psbt_updated,7108 +msgdata,dualopend_psbt_updated,psbt,wally_psbt, # master->dualopend: fail this channel open -msgtype,dual_open_fail,7003 -msgdata,dual_open_fail,reason,wirestring, +msgtype,dualopend_fail,7003 +msgdata,dualopend_fail,reason,wirestring, # dualopend->master: we failed to negotiate channel -msgtype,dual_open_failed,7004 -msgdata,dual_open_failed,reason,wirestring, +msgtype,dualopend_failed,7004 +msgdata,dualopend_failed,reason,wirestring, # master->dualopend: hello, I'd like to start a channel open -msgtype,dual_open_opener_init,7200 -msgdata,dual_open_opener_init,psbt,wally_psbt, -msgdata,dual_open_opener_init,funding_amount,amount_sat, -msgdata,dual_open_opener_init,local_shutdown_len,u16, -msgdata,dual_open_opener_init,local_shutdown_scriptpubkey,u8,local_shutdown_len -msgdata,dual_open_opener_init,feerate_per_kw,u32, -msgdata,dual_open_opener_init,feerate_per_kw_funding,u32, -msgdata,dual_open_opener_init,channel_flags,u8, +msgtype,dualopend_opener_init,7200 +msgdata,dualopend_opener_init,psbt,wally_psbt, +msgdata,dualopend_opener_init,funding_amount,amount_sat, +msgdata,dualopend_opener_init,local_shutdown_len,u16, +msgdata,dualopend_opener_init,local_shutdown_scriptpubkey,u8,local_shutdown_len +msgdata,dualopend_opener_init,feerate_per_kw,u32, +msgdata,dualopend_opener_init,feerate_per_kw_funding,u32, +msgdata,dualopend_opener_init,channel_flags,u8, # master -> dualopend: do you have a memleak? -msgtype,dual_open_dev_memleak,7033 +msgtype,dualopend_dev_memleak,7033 -msgtype,dual_open_dev_memleak_reply,7133 -msgdata,dual_open_dev_memleak_reply,leak,bool, +msgtype,dualopend_dev_memleak_reply,7133 +msgdata,dualopend_dev_memleak_reply,leak,bool, diff --git a/openingd/dualopend_wiregen.c b/openingd/dualopend_wiregen.c index 96c00dc8b..c7be40bc6 100644 --- a/openingd/dualopend_wiregen.c +++ b/openingd/dualopend_wiregen.c @@ -20,17 +20,17 @@ const char *dualopend_wire_name(int e) static char invalidbuf[sizeof("INVALID ") + STR_MAX_CHARS(e)]; switch ((enum dualopend_wire)e) { - case WIRE_DUAL_OPEN_INIT: return "WIRE_DUAL_OPEN_INIT"; - case WIRE_DUAL_OPEN_GOT_OFFER: return "WIRE_DUAL_OPEN_GOT_OFFER"; - case WIRE_DUAL_OPEN_GOT_OFFER_REPLY: return "WIRE_DUAL_OPEN_GOT_OFFER_REPLY"; - case WIRE_DUAL_OPEN_COMMIT_RCVD: return "WIRE_DUAL_OPEN_COMMIT_RCVD"; - case WIRE_DUAL_OPEN_PSBT_CHANGED: return "WIRE_DUAL_OPEN_PSBT_CHANGED"; - case WIRE_DUAL_OPEN_PSBT_UPDATED: return "WIRE_DUAL_OPEN_PSBT_UPDATED"; - case WIRE_DUAL_OPEN_FAIL: return "WIRE_DUAL_OPEN_FAIL"; - case WIRE_DUAL_OPEN_FAILED: return "WIRE_DUAL_OPEN_FAILED"; - case WIRE_DUAL_OPEN_OPENER_INIT: return "WIRE_DUAL_OPEN_OPENER_INIT"; - case WIRE_DUAL_OPEN_DEV_MEMLEAK: return "WIRE_DUAL_OPEN_DEV_MEMLEAK"; - case WIRE_DUAL_OPEN_DEV_MEMLEAK_REPLY: return "WIRE_DUAL_OPEN_DEV_MEMLEAK_REPLY"; + case WIRE_DUALOPEND_INIT: return "WIRE_DUALOPEND_INIT"; + 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"; + case WIRE_DUALOPEND_PSBT_CHANGED: return "WIRE_DUALOPEND_PSBT_CHANGED"; + case WIRE_DUALOPEND_PSBT_UPDATED: return "WIRE_DUALOPEND_PSBT_UPDATED"; + case WIRE_DUALOPEND_FAIL: return "WIRE_DUALOPEND_FAIL"; + case WIRE_DUALOPEND_FAILED: return "WIRE_DUALOPEND_FAILED"; + case WIRE_DUALOPEND_OPENER_INIT: return "WIRE_DUALOPEND_OPENER_INIT"; + case WIRE_DUALOPEND_DEV_MEMLEAK: return "WIRE_DUALOPEND_DEV_MEMLEAK"; + case WIRE_DUALOPEND_DEV_MEMLEAK_REPLY: return "WIRE_DUALOPEND_DEV_MEMLEAK_REPLY"; } snprintf(invalidbuf, sizeof(invalidbuf), "INVALID %i", e); @@ -40,17 +40,17 @@ const char *dualopend_wire_name(int e) bool dualopend_wire_is_defined(u16 type) { switch ((enum dualopend_wire)type) { - case WIRE_DUAL_OPEN_INIT:; - case WIRE_DUAL_OPEN_GOT_OFFER:; - case WIRE_DUAL_OPEN_GOT_OFFER_REPLY:; - case WIRE_DUAL_OPEN_COMMIT_RCVD:; - case WIRE_DUAL_OPEN_PSBT_CHANGED:; - case WIRE_DUAL_OPEN_PSBT_UPDATED:; - case WIRE_DUAL_OPEN_FAIL:; - case WIRE_DUAL_OPEN_FAILED:; - case WIRE_DUAL_OPEN_OPENER_INIT:; - case WIRE_DUAL_OPEN_DEV_MEMLEAK:; - case WIRE_DUAL_OPEN_DEV_MEMLEAK_REPLY:; + case WIRE_DUALOPEND_INIT:; + case WIRE_DUALOPEND_GOT_OFFER:; + case WIRE_DUALOPEND_GOT_OFFER_REPLY:; + case WIRE_DUALOPEND_COMMIT_RCVD:; + case WIRE_DUALOPEND_PSBT_CHANGED:; + case WIRE_DUALOPEND_PSBT_UPDATED:; + case WIRE_DUALOPEND_FAIL:; + case WIRE_DUALOPEND_FAILED:; + case WIRE_DUALOPEND_OPENER_INIT:; + case WIRE_DUALOPEND_DEV_MEMLEAK:; + case WIRE_DUALOPEND_DEV_MEMLEAK_REPLY:; return true; } return false; @@ -60,14 +60,14 @@ bool dualopend_wire_is_defined(u16 type) -/* WIRE: DUAL_OPEN_INIT */ -u8 *towire_dual_open_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) +/* WIRE: DUALOPEND_INIT */ +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) { u16 their_init_features_len = tal_count(their_init_features); u16 len = tal_count(msg); u8 *p = tal_arr(ctx, u8, 0); - towire_u16(&p, WIRE_DUAL_OPEN_INIT); + towire_u16(&p, WIRE_DUALOPEND_INIT); /* Which network are we configured for? */ towire_chainparams(&p, chainparams); towire_feature_set(&p, our_feature_set); @@ -91,7 +91,7 @@ u8 *towire_dual_open_init(const tal_t *ctx, const struct chainparams *chainparam return memcheck(p, tal_count(p)); } -bool fromwire_dual_open_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) +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) { u16 their_init_features_len; u16 len; @@ -99,7 +99,7 @@ bool fromwire_dual_open_init(const tal_t *ctx, const void *p, const struct chain const u8 *cursor = p; size_t plen = tal_count(p); - if (fromwire_u16(&cursor, &plen) != WIRE_DUAL_OPEN_INIT) + if (fromwire_u16(&cursor, &plen) != WIRE_DUALOPEND_INIT) return false; /* Which network are we configured for? */ fromwire_chainparams(&cursor, &plen, chainparams); @@ -128,14 +128,14 @@ bool fromwire_dual_open_init(const tal_t *ctx, const void *p, const struct chain return cursor != NULL; } -/* WIRE: DUAL_OPEN_GOT_OFFER */ +/* WIRE: DUALOPEND_GOT_OFFER */ /* dualopend->master: they offered channel */ -u8 *towire_dual_open_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) +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) { u16 shutdown_len = tal_count(shutdown_scriptpubkey); u8 *p = tal_arr(ctx, u8, 0); - towire_u16(&p, WIRE_DUAL_OPEN_GOT_OFFER); + towire_u16(&p, WIRE_DUALOPEND_GOT_OFFER); towire_amount_sat(&p, opener_funding); towire_amount_sat(&p, dust_limit_satoshis); towire_amount_msat(&p, max_htlc_value_in_flight_msat); @@ -153,14 +153,14 @@ u8 *towire_dual_open_got_offer(const tal_t *ctx, struct amount_sat opener_fundin return memcheck(p, tal_count(p)); } -bool fromwire_dual_open_got_offer(const tal_t *ctx, const void *p, 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, u8 **shutdown_scriptpubkey) +bool fromwire_dualopend_got_offer(const tal_t *ctx, const void *p, 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, u8 **shutdown_scriptpubkey) { u16 shutdown_len; const u8 *cursor = p; size_t plen = tal_count(p); - if (fromwire_u16(&cursor, &plen) != WIRE_DUAL_OPEN_GOT_OFFER) + if (fromwire_u16(&cursor, &plen) != WIRE_DUALOPEND_GOT_OFFER) return false; *opener_funding = fromwire_amount_sat(&cursor, &plen); *dust_limit_satoshis = fromwire_amount_sat(&cursor, &plen); @@ -181,14 +181,14 @@ bool fromwire_dual_open_got_offer(const tal_t *ctx, const void *p, struct amount return cursor != NULL; } -/* WIRE: DUAL_OPEN_GOT_OFFER_REPLY */ +/* WIRE: DUALOPEND_GOT_OFFER_REPLY */ /* master->dualopend: reply back with our first funding info/contribs */ -u8 *towire_dual_open_got_offer_reply(const tal_t *ctx, struct amount_sat accepter_funding, u32 feerate_funding, const struct wally_psbt *psbt, const u8 *our_shutdown_scriptpubkey) +u8 *towire_dualopend_got_offer_reply(const tal_t *ctx, struct amount_sat accepter_funding, u32 feerate_funding, const struct wally_psbt *psbt, const u8 *our_shutdown_scriptpubkey) { u16 shutdown_len = tal_count(our_shutdown_scriptpubkey); u8 *p = tal_arr(ctx, u8, 0); - towire_u16(&p, WIRE_DUAL_OPEN_GOT_OFFER_REPLY); + towire_u16(&p, WIRE_DUALOPEND_GOT_OFFER_REPLY); towire_amount_sat(&p, accepter_funding); towire_u32(&p, feerate_funding); towire_wally_psbt(&p, psbt); @@ -197,14 +197,14 @@ u8 *towire_dual_open_got_offer_reply(const tal_t *ctx, struct amount_sat accepte return memcheck(p, tal_count(p)); } -bool fromwire_dual_open_got_offer_reply(const tal_t *ctx, const void *p, struct amount_sat *accepter_funding, u32 *feerate_funding, struct wally_psbt **psbt, u8 **our_shutdown_scriptpubkey) +bool fromwire_dualopend_got_offer_reply(const tal_t *ctx, const void *p, struct amount_sat *accepter_funding, u32 *feerate_funding, struct wally_psbt **psbt, u8 **our_shutdown_scriptpubkey) { u16 shutdown_len; const u8 *cursor = p; size_t plen = tal_count(p); - if (fromwire_u16(&cursor, &plen) != WIRE_DUAL_OPEN_GOT_OFFER_REPLY) + if (fromwire_u16(&cursor, &plen) != WIRE_DUALOPEND_GOT_OFFER_REPLY) return false; *accepter_funding = fromwire_amount_sat(&cursor, &plen); *feerate_funding = fromwire_u32(&cursor, &plen); @@ -216,17 +216,17 @@ bool fromwire_dual_open_got_offer_reply(const tal_t *ctx, const void *p, struct return cursor != NULL; } -/* WIRE: DUAL_OPEN_COMMIT_RCVD */ +/* WIRE: DUALOPEND_COMMIT_RCVD */ /* dualopend->master: ready to commit channel open to database and */ /* get some signatures for the funding_tx. */ -u8 *towire_dual_open_commit_rcvd(const tal_t *ctx, const struct channel_config *their_config, const struct bitcoin_tx *remote_first_commit, const struct penalty_base *pbase, const struct bitcoin_signature *first_commit_sig, const struct wally_psbt *psbt, const struct channel_id *channel_id, const struct per_peer_state *pps, const struct pubkey *revocation_basepoint, const struct pubkey *payment_basepoint, const struct pubkey *htlc_basepoint, const struct pubkey *delayed_payment_basepoint, const struct pubkey *their_per_commit_point, const struct pubkey *remote_fundingkey, const struct bitcoin_txid *funding_txid, u16 funding_txout, struct amount_sat funding_satoshis, struct amount_sat our_funding_sats, u8 channel_flags, u32 feerate_per_kw, const u8 *commitment_msg, struct amount_sat our_channel_reserve_satoshis, const u8 *local_shutdown_scriptpubkey, const u8 *remote_shutdown_scriptpubkey) +u8 *towire_dualopend_commit_rcvd(const tal_t *ctx, const struct channel_config *their_config, const struct bitcoin_tx *remote_first_commit, const struct penalty_base *pbase, const struct bitcoin_signature *first_commit_sig, const struct wally_psbt *psbt, const struct channel_id *channel_id, const struct per_peer_state *pps, const struct pubkey *revocation_basepoint, const struct pubkey *payment_basepoint, const struct pubkey *htlc_basepoint, const struct pubkey *delayed_payment_basepoint, const struct pubkey *their_per_commit_point, const struct pubkey *remote_fundingkey, const struct bitcoin_txid *funding_txid, u16 funding_txout, struct amount_sat funding_satoshis, struct amount_sat our_funding_sats, u8 channel_flags, u32 feerate_per_kw, const u8 *commitment_msg, struct amount_sat our_channel_reserve_satoshis, const u8 *local_shutdown_scriptpubkey, const u8 *remote_shutdown_scriptpubkey) { u16 msglen = tal_count(commitment_msg); u16 local_shutdown_len = tal_count(local_shutdown_scriptpubkey); u16 remote_shutdown_len = tal_count(remote_shutdown_scriptpubkey); u8 *p = tal_arr(ctx, u8, 0); - towire_u16(&p, WIRE_DUAL_OPEN_COMMIT_RCVD); + towire_u16(&p, WIRE_DUALOPEND_COMMIT_RCVD); towire_channel_config(&p, their_config); towire_bitcoin_tx(&p, remote_first_commit); if (!pbase) @@ -262,7 +262,7 @@ u8 *towire_dual_open_commit_rcvd(const tal_t *ctx, const struct channel_config * return memcheck(p, tal_count(p)); } -bool fromwire_dual_open_commit_rcvd(const tal_t *ctx, const void *p, struct channel_config *their_config, struct bitcoin_tx **remote_first_commit, struct penalty_base **pbase, struct bitcoin_signature *first_commit_sig, struct wally_psbt **psbt, struct channel_id *channel_id, struct per_peer_state **pps, struct pubkey *revocation_basepoint, struct pubkey *payment_basepoint, struct pubkey *htlc_basepoint, struct pubkey *delayed_payment_basepoint, struct pubkey *their_per_commit_point, struct pubkey *remote_fundingkey, struct bitcoin_txid *funding_txid, u16 *funding_txout, struct amount_sat *funding_satoshis, struct amount_sat *our_funding_sats, u8 *channel_flags, u32 *feerate_per_kw, u8 **commitment_msg, struct amount_sat *our_channel_reserve_satoshis, u8 **local_shutdown_scriptpubkey, u8 **remote_shutdown_scriptpubkey) +bool fromwire_dualopend_commit_rcvd(const tal_t *ctx, const void *p, struct channel_config *their_config, struct bitcoin_tx **remote_first_commit, struct penalty_base **pbase, struct bitcoin_signature *first_commit_sig, struct wally_psbt **psbt, struct channel_id *channel_id, struct per_peer_state **pps, struct pubkey *revocation_basepoint, struct pubkey *payment_basepoint, struct pubkey *htlc_basepoint, struct pubkey *delayed_payment_basepoint, struct pubkey *their_per_commit_point, struct pubkey *remote_fundingkey, struct bitcoin_txid *funding_txid, u16 *funding_txout, struct amount_sat *funding_satoshis, struct amount_sat *our_funding_sats, u8 *channel_flags, u32 *feerate_per_kw, u8 **commitment_msg, struct amount_sat *our_channel_reserve_satoshis, u8 **local_shutdown_scriptpubkey, u8 **remote_shutdown_scriptpubkey) { u16 msglen; u16 local_shutdown_len; @@ -271,7 +271,7 @@ bool fromwire_dual_open_commit_rcvd(const tal_t *ctx, const void *p, struct chan const u8 *cursor = p; size_t plen = tal_count(p); - if (fromwire_u16(&cursor, &plen) != WIRE_DUAL_OPEN_COMMIT_RCVD) + if (fromwire_u16(&cursor, &plen) != WIRE_DUALOPEND_COMMIT_RCVD) return false; fromwire_channel_config(&cursor, &plen, their_config); *remote_first_commit = fromwire_bitcoin_tx(ctx, &cursor, &plen); @@ -314,25 +314,25 @@ bool fromwire_dual_open_commit_rcvd(const tal_t *ctx, const void *p, struct chan return cursor != NULL; } -/* WIRE: DUAL_OPEN_PSBT_CHANGED */ +/* WIRE: DUALOPEND_PSBT_CHANGED */ /* dualopend->master: peer updated the psbt */ -u8 *towire_dual_open_psbt_changed(const tal_t *ctx, const struct channel_id *channel_id, u64 funding_serial, const struct wally_psbt *psbt) +u8 *towire_dualopend_psbt_changed(const tal_t *ctx, const struct channel_id *channel_id, u64 funding_serial, const struct wally_psbt *psbt) { u8 *p = tal_arr(ctx, u8, 0); - towire_u16(&p, WIRE_DUAL_OPEN_PSBT_CHANGED); + towire_u16(&p, WIRE_DUALOPEND_PSBT_CHANGED); towire_channel_id(&p, channel_id); towire_u64(&p, funding_serial); towire_wally_psbt(&p, psbt); return memcheck(p, tal_count(p)); } -bool fromwire_dual_open_psbt_changed(const tal_t *ctx, const void *p, struct channel_id *channel_id, u64 *funding_serial, struct wally_psbt **psbt) +bool fromwire_dualopend_psbt_changed(const tal_t *ctx, const void *p, struct channel_id *channel_id, u64 *funding_serial, struct wally_psbt **psbt) { const u8 *cursor = p; size_t plen = tal_count(p); - if (fromwire_u16(&cursor, &plen) != WIRE_DUAL_OPEN_PSBT_CHANGED) + if (fromwire_u16(&cursor, &plen) != WIRE_DUALOPEND_PSBT_CHANGED) return false; fromwire_channel_id(&cursor, &plen, channel_id); *funding_serial = fromwire_u64(&cursor, &plen); @@ -340,80 +340,80 @@ bool fromwire_dual_open_psbt_changed(const tal_t *ctx, const void *p, struct cha return cursor != NULL; } -/* WIRE: DUAL_OPEN_PSBT_UPDATED */ +/* WIRE: DUALOPEND_PSBT_UPDATED */ /* master->dualopend: we updated the psbt */ -u8 *towire_dual_open_psbt_updated(const tal_t *ctx, const struct wally_psbt *psbt) +u8 *towire_dualopend_psbt_updated(const tal_t *ctx, const struct wally_psbt *psbt) { u8 *p = tal_arr(ctx, u8, 0); - towire_u16(&p, WIRE_DUAL_OPEN_PSBT_UPDATED); + towire_u16(&p, WIRE_DUALOPEND_PSBT_UPDATED); towire_wally_psbt(&p, psbt); return memcheck(p, tal_count(p)); } -bool fromwire_dual_open_psbt_updated(const tal_t *ctx, const void *p, struct wally_psbt **psbt) +bool fromwire_dualopend_psbt_updated(const tal_t *ctx, const void *p, struct wally_psbt **psbt) { const u8 *cursor = p; size_t plen = tal_count(p); - if (fromwire_u16(&cursor, &plen) != WIRE_DUAL_OPEN_PSBT_UPDATED) + if (fromwire_u16(&cursor, &plen) != WIRE_DUALOPEND_PSBT_UPDATED) return false; *psbt = fromwire_wally_psbt(ctx, &cursor, &plen); return cursor != NULL; } -/* WIRE: DUAL_OPEN_FAIL */ +/* WIRE: DUALOPEND_FAIL */ /* master->dualopend: fail this channel open */ -u8 *towire_dual_open_fail(const tal_t *ctx, const wirestring *reason) +u8 *towire_dualopend_fail(const tal_t *ctx, const wirestring *reason) { u8 *p = tal_arr(ctx, u8, 0); - towire_u16(&p, WIRE_DUAL_OPEN_FAIL); + towire_u16(&p, WIRE_DUALOPEND_FAIL); towire_wirestring(&p, reason); return memcheck(p, tal_count(p)); } -bool fromwire_dual_open_fail(const tal_t *ctx, const void *p, wirestring **reason) +bool fromwire_dualopend_fail(const tal_t *ctx, const void *p, wirestring **reason) { const u8 *cursor = p; size_t plen = tal_count(p); - if (fromwire_u16(&cursor, &plen) != WIRE_DUAL_OPEN_FAIL) + if (fromwire_u16(&cursor, &plen) != WIRE_DUALOPEND_FAIL) return false; *reason = fromwire_wirestring(ctx, &cursor, &plen); return cursor != NULL; } -/* WIRE: DUAL_OPEN_FAILED */ +/* WIRE: DUALOPEND_FAILED */ /* dualopend->master: we failed to negotiate channel */ -u8 *towire_dual_open_failed(const tal_t *ctx, const wirestring *reason) +u8 *towire_dualopend_failed(const tal_t *ctx, const wirestring *reason) { u8 *p = tal_arr(ctx, u8, 0); - towire_u16(&p, WIRE_DUAL_OPEN_FAILED); + towire_u16(&p, WIRE_DUALOPEND_FAILED); towire_wirestring(&p, reason); return memcheck(p, tal_count(p)); } -bool fromwire_dual_open_failed(const tal_t *ctx, const void *p, wirestring **reason) +bool fromwire_dualopend_failed(const tal_t *ctx, const void *p, wirestring **reason) { const u8 *cursor = p; size_t plen = tal_count(p); - if (fromwire_u16(&cursor, &plen) != WIRE_DUAL_OPEN_FAILED) + if (fromwire_u16(&cursor, &plen) != WIRE_DUALOPEND_FAILED) return false; *reason = fromwire_wirestring(ctx, &cursor, &plen); return cursor != NULL; } -/* WIRE: DUAL_OPEN_OPENER_INIT */ +/* WIRE: DUALOPEND_OPENER_INIT */ /* master->dualopend: hello */ -u8 *towire_dual_open_opener_init(const tal_t *ctx, const struct wally_psbt *psbt, struct amount_sat funding_amount, const u8 *local_shutdown_scriptpubkey, u32 feerate_per_kw, u32 feerate_per_kw_funding, u8 channel_flags) +u8 *towire_dualopend_opener_init(const tal_t *ctx, const struct wally_psbt *psbt, struct amount_sat funding_amount, const u8 *local_shutdown_scriptpubkey, u32 feerate_per_kw, u32 feerate_per_kw_funding, u8 channel_flags) { u16 local_shutdown_len = tal_count(local_shutdown_scriptpubkey); u8 *p = tal_arr(ctx, u8, 0); - towire_u16(&p, WIRE_DUAL_OPEN_OPENER_INIT); + towire_u16(&p, WIRE_DUALOPEND_OPENER_INIT); towire_wally_psbt(&p, psbt); towire_amount_sat(&p, funding_amount); towire_u16(&p, local_shutdown_len); @@ -424,14 +424,14 @@ u8 *towire_dual_open_opener_init(const tal_t *ctx, const struct wally_psbt *psbt return memcheck(p, tal_count(p)); } -bool fromwire_dual_open_opener_init(const tal_t *ctx, const void *p, struct wally_psbt **psbt, struct amount_sat *funding_amount, u8 **local_shutdown_scriptpubkey, u32 *feerate_per_kw, u32 *feerate_per_kw_funding, u8 *channel_flags) +bool fromwire_dualopend_opener_init(const tal_t *ctx, const void *p, struct wally_psbt **psbt, struct amount_sat *funding_amount, u8 **local_shutdown_scriptpubkey, u32 *feerate_per_kw, u32 *feerate_per_kw_funding, u8 *channel_flags) { u16 local_shutdown_len; const u8 *cursor = p; size_t plen = tal_count(p); - if (fromwire_u16(&cursor, &plen) != WIRE_DUAL_OPEN_OPENER_INIT) + if (fromwire_u16(&cursor, &plen) != WIRE_DUALOPEND_OPENER_INIT) return false; *psbt = fromwire_wally_psbt(ctx, &cursor, &plen); *funding_amount = fromwire_amount_sat(&cursor, &plen); @@ -445,44 +445,44 @@ bool fromwire_dual_open_opener_init(const tal_t *ctx, const void *p, struct wall return cursor != NULL; } -/* WIRE: DUAL_OPEN_DEV_MEMLEAK */ +/* WIRE: DUALOPEND_DEV_MEMLEAK */ /* master -> dualopend: do you have a memleak? */ -u8 *towire_dual_open_dev_memleak(const tal_t *ctx) +u8 *towire_dualopend_dev_memleak(const tal_t *ctx) { u8 *p = tal_arr(ctx, u8, 0); - towire_u16(&p, WIRE_DUAL_OPEN_DEV_MEMLEAK); + towire_u16(&p, WIRE_DUALOPEND_DEV_MEMLEAK); return memcheck(p, tal_count(p)); } -bool fromwire_dual_open_dev_memleak(const void *p) +bool fromwire_dualopend_dev_memleak(const void *p) { const u8 *cursor = p; size_t plen = tal_count(p); - if (fromwire_u16(&cursor, &plen) != WIRE_DUAL_OPEN_DEV_MEMLEAK) + if (fromwire_u16(&cursor, &plen) != WIRE_DUALOPEND_DEV_MEMLEAK) return false; return cursor != NULL; } -/* WIRE: DUAL_OPEN_DEV_MEMLEAK_REPLY */ -u8 *towire_dual_open_dev_memleak_reply(const tal_t *ctx, bool leak) +/* WIRE: DUALOPEND_DEV_MEMLEAK_REPLY */ +u8 *towire_dualopend_dev_memleak_reply(const tal_t *ctx, bool leak) { u8 *p = tal_arr(ctx, u8, 0); - towire_u16(&p, WIRE_DUAL_OPEN_DEV_MEMLEAK_REPLY); + towire_u16(&p, WIRE_DUALOPEND_DEV_MEMLEAK_REPLY); towire_bool(&p, leak); return memcheck(p, tal_count(p)); } -bool fromwire_dual_open_dev_memleak_reply(const void *p, bool *leak) +bool fromwire_dualopend_dev_memleak_reply(const void *p, bool *leak) { const u8 *cursor = p; size_t plen = tal_count(p); - if (fromwire_u16(&cursor, &plen) != WIRE_DUAL_OPEN_DEV_MEMLEAK_REPLY) + if (fromwire_u16(&cursor, &plen) != WIRE_DUALOPEND_DEV_MEMLEAK_REPLY) return false; *leak = fromwire_bool(&cursor, &plen); return cursor != NULL; } -// SHA256STAMP:f08f0c25f359d5c8f843d78c94eca9b0543b39e62a34983f6572adf92ff02aaa +// SHA256STAMP:c00536896059d3bd16cd8e1512674abcda83fd680e171dfc016a796f7b4be522 diff --git a/openingd/dualopend_wiregen.h b/openingd/dualopend_wiregen.h index 9ee1fa2fe..c29f86a8f 100644 --- a/openingd/dualopend_wiregen.h +++ b/openingd/dualopend_wiregen.h @@ -18,27 +18,27 @@ #include enum dualopend_wire { - WIRE_DUAL_OPEN_INIT = 7000, + WIRE_DUALOPEND_INIT = 7000, /* dualopend->master: they offered channel */ - WIRE_DUAL_OPEN_GOT_OFFER = 7005, + WIRE_DUALOPEND_GOT_OFFER = 7005, /* master->dualopend: reply back with our first funding info/contribs */ - WIRE_DUAL_OPEN_GOT_OFFER_REPLY = 7105, + WIRE_DUALOPEND_GOT_OFFER_REPLY = 7105, /* dualopend->master: ready to commit channel open to database and */ /* get some signatures for the funding_tx. */ - WIRE_DUAL_OPEN_COMMIT_RCVD = 7007, + WIRE_DUALOPEND_COMMIT_RCVD = 7007, /* dualopend->master: peer updated the psbt */ - WIRE_DUAL_OPEN_PSBT_CHANGED = 7107, + WIRE_DUALOPEND_PSBT_CHANGED = 7107, /* master->dualopend: we updated the psbt */ - WIRE_DUAL_OPEN_PSBT_UPDATED = 7108, + WIRE_DUALOPEND_PSBT_UPDATED = 7108, /* master->dualopend: fail this channel open */ - WIRE_DUAL_OPEN_FAIL = 7003, + WIRE_DUALOPEND_FAIL = 7003, /* dualopend->master: we failed to negotiate channel */ - WIRE_DUAL_OPEN_FAILED = 7004, + WIRE_DUALOPEND_FAILED = 7004, /* master->dualopend: hello */ - WIRE_DUAL_OPEN_OPENER_INIT = 7200, + WIRE_DUALOPEND_OPENER_INIT = 7200, /* master -> dualopend: do you have a memleak? */ - WIRE_DUAL_OPEN_DEV_MEMLEAK = 7033, - WIRE_DUAL_OPEN_DEV_MEMLEAK_REPLY = 7133, + WIRE_DUALOPEND_DEV_MEMLEAK = 7033, + WIRE_DUALOPEND_DEV_MEMLEAK_REPLY = 7133, }; const char *dualopend_wire_name(int e); @@ -53,60 +53,60 @@ const char *dualopend_wire_name(int e); bool dualopend_wire_is_defined(u16 type); -/* WIRE: DUAL_OPEN_INIT */ -u8 *towire_dual_open_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_dual_open_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_INIT */ +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: DUAL_OPEN_GOT_OFFER */ +/* WIRE: DUALOPEND_GOT_OFFER */ /* dualopend->master: they offered channel */ -u8 *towire_dual_open_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); -bool fromwire_dual_open_got_offer(const tal_t *ctx, const void *p, 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, u8 **shutdown_scriptpubkey); +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); +bool fromwire_dualopend_got_offer(const tal_t *ctx, const void *p, 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, u8 **shutdown_scriptpubkey); -/* WIRE: DUAL_OPEN_GOT_OFFER_REPLY */ +/* WIRE: DUALOPEND_GOT_OFFER_REPLY */ /* master->dualopend: reply back with our first funding info/contribs */ -u8 *towire_dual_open_got_offer_reply(const tal_t *ctx, struct amount_sat accepter_funding, u32 feerate_funding, const struct wally_psbt *psbt, const u8 *our_shutdown_scriptpubkey); -bool fromwire_dual_open_got_offer_reply(const tal_t *ctx, const void *p, struct amount_sat *accepter_funding, u32 *feerate_funding, struct wally_psbt **psbt, u8 **our_shutdown_scriptpubkey); +u8 *towire_dualopend_got_offer_reply(const tal_t *ctx, struct amount_sat accepter_funding, u32 feerate_funding, const struct wally_psbt *psbt, const u8 *our_shutdown_scriptpubkey); +bool fromwire_dualopend_got_offer_reply(const tal_t *ctx, const void *p, struct amount_sat *accepter_funding, u32 *feerate_funding, struct wally_psbt **psbt, u8 **our_shutdown_scriptpubkey); -/* WIRE: DUAL_OPEN_COMMIT_RCVD */ +/* WIRE: DUALOPEND_COMMIT_RCVD */ /* dualopend->master: ready to commit channel open to database and */ /* get some signatures for the funding_tx. */ -u8 *towire_dual_open_commit_rcvd(const tal_t *ctx, const struct channel_config *their_config, const struct bitcoin_tx *remote_first_commit, const struct penalty_base *pbase, const struct bitcoin_signature *first_commit_sig, const struct wally_psbt *psbt, const struct channel_id *channel_id, const struct per_peer_state *pps, const struct pubkey *revocation_basepoint, const struct pubkey *payment_basepoint, const struct pubkey *htlc_basepoint, const struct pubkey *delayed_payment_basepoint, const struct pubkey *their_per_commit_point, const struct pubkey *remote_fundingkey, const struct bitcoin_txid *funding_txid, u16 funding_txout, struct amount_sat funding_satoshis, struct amount_sat our_funding_sats, u8 channel_flags, u32 feerate_per_kw, const u8 *commitment_msg, struct amount_sat our_channel_reserve_satoshis, const u8 *local_shutdown_scriptpubkey, const u8 *remote_shutdown_scriptpubkey); -bool fromwire_dual_open_commit_rcvd(const tal_t *ctx, const void *p, struct channel_config *their_config, struct bitcoin_tx **remote_first_commit, struct penalty_base **pbase, struct bitcoin_signature *first_commit_sig, struct wally_psbt **psbt, struct channel_id *channel_id, struct per_peer_state **pps, struct pubkey *revocation_basepoint, struct pubkey *payment_basepoint, struct pubkey *htlc_basepoint, struct pubkey *delayed_payment_basepoint, struct pubkey *their_per_commit_point, struct pubkey *remote_fundingkey, struct bitcoin_txid *funding_txid, u16 *funding_txout, struct amount_sat *funding_satoshis, struct amount_sat *our_funding_sats, u8 *channel_flags, u32 *feerate_per_kw, u8 **commitment_msg, struct amount_sat *our_channel_reserve_satoshis, u8 **local_shutdown_scriptpubkey, u8 **remote_shutdown_scriptpubkey); +u8 *towire_dualopend_commit_rcvd(const tal_t *ctx, const struct channel_config *their_config, const struct bitcoin_tx *remote_first_commit, const struct penalty_base *pbase, const struct bitcoin_signature *first_commit_sig, const struct wally_psbt *psbt, const struct channel_id *channel_id, const struct per_peer_state *pps, const struct pubkey *revocation_basepoint, const struct pubkey *payment_basepoint, const struct pubkey *htlc_basepoint, const struct pubkey *delayed_payment_basepoint, const struct pubkey *their_per_commit_point, const struct pubkey *remote_fundingkey, const struct bitcoin_txid *funding_txid, u16 funding_txout, struct amount_sat funding_satoshis, struct amount_sat our_funding_sats, u8 channel_flags, u32 feerate_per_kw, const u8 *commitment_msg, struct amount_sat our_channel_reserve_satoshis, const u8 *local_shutdown_scriptpubkey, const u8 *remote_shutdown_scriptpubkey); +bool fromwire_dualopend_commit_rcvd(const tal_t *ctx, const void *p, struct channel_config *their_config, struct bitcoin_tx **remote_first_commit, struct penalty_base **pbase, struct bitcoin_signature *first_commit_sig, struct wally_psbt **psbt, struct channel_id *channel_id, struct per_peer_state **pps, struct pubkey *revocation_basepoint, struct pubkey *payment_basepoint, struct pubkey *htlc_basepoint, struct pubkey *delayed_payment_basepoint, struct pubkey *their_per_commit_point, struct pubkey *remote_fundingkey, struct bitcoin_txid *funding_txid, u16 *funding_txout, struct amount_sat *funding_satoshis, struct amount_sat *our_funding_sats, u8 *channel_flags, u32 *feerate_per_kw, u8 **commitment_msg, struct amount_sat *our_channel_reserve_satoshis, u8 **local_shutdown_scriptpubkey, u8 **remote_shutdown_scriptpubkey); -/* WIRE: DUAL_OPEN_PSBT_CHANGED */ +/* WIRE: DUALOPEND_PSBT_CHANGED */ /* dualopend->master: peer updated the psbt */ -u8 *towire_dual_open_psbt_changed(const tal_t *ctx, const struct channel_id *channel_id, u64 funding_serial, const struct wally_psbt *psbt); -bool fromwire_dual_open_psbt_changed(const tal_t *ctx, const void *p, struct channel_id *channel_id, u64 *funding_serial, struct wally_psbt **psbt); +u8 *towire_dualopend_psbt_changed(const tal_t *ctx, const struct channel_id *channel_id, u64 funding_serial, const struct wally_psbt *psbt); +bool fromwire_dualopend_psbt_changed(const tal_t *ctx, const void *p, struct channel_id *channel_id, u64 *funding_serial, struct wally_psbt **psbt); -/* WIRE: DUAL_OPEN_PSBT_UPDATED */ +/* WIRE: DUALOPEND_PSBT_UPDATED */ /* master->dualopend: we updated the psbt */ -u8 *towire_dual_open_psbt_updated(const tal_t *ctx, const struct wally_psbt *psbt); -bool fromwire_dual_open_psbt_updated(const tal_t *ctx, const void *p, struct wally_psbt **psbt); +u8 *towire_dualopend_psbt_updated(const tal_t *ctx, const struct wally_psbt *psbt); +bool fromwire_dualopend_psbt_updated(const tal_t *ctx, const void *p, struct wally_psbt **psbt); -/* WIRE: DUAL_OPEN_FAIL */ +/* WIRE: DUALOPEND_FAIL */ /* master->dualopend: fail this channel open */ -u8 *towire_dual_open_fail(const tal_t *ctx, const wirestring *reason); -bool fromwire_dual_open_fail(const tal_t *ctx, const void *p, wirestring **reason); +u8 *towire_dualopend_fail(const tal_t *ctx, const wirestring *reason); +bool fromwire_dualopend_fail(const tal_t *ctx, const void *p, wirestring **reason); -/* WIRE: DUAL_OPEN_FAILED */ +/* WIRE: DUALOPEND_FAILED */ /* dualopend->master: we failed to negotiate channel */ -u8 *towire_dual_open_failed(const tal_t *ctx, const wirestring *reason); -bool fromwire_dual_open_failed(const tal_t *ctx, const void *p, wirestring **reason); +u8 *towire_dualopend_failed(const tal_t *ctx, const wirestring *reason); +bool fromwire_dualopend_failed(const tal_t *ctx, const void *p, wirestring **reason); -/* WIRE: DUAL_OPEN_OPENER_INIT */ +/* WIRE: DUALOPEND_OPENER_INIT */ /* master->dualopend: hello */ -u8 *towire_dual_open_opener_init(const tal_t *ctx, const struct wally_psbt *psbt, struct amount_sat funding_amount, const u8 *local_shutdown_scriptpubkey, u32 feerate_per_kw, u32 feerate_per_kw_funding, u8 channel_flags); -bool fromwire_dual_open_opener_init(const tal_t *ctx, const void *p, struct wally_psbt **psbt, struct amount_sat *funding_amount, u8 **local_shutdown_scriptpubkey, u32 *feerate_per_kw, u32 *feerate_per_kw_funding, u8 *channel_flags); +u8 *towire_dualopend_opener_init(const tal_t *ctx, const struct wally_psbt *psbt, struct amount_sat funding_amount, const u8 *local_shutdown_scriptpubkey, u32 feerate_per_kw, u32 feerate_per_kw_funding, u8 channel_flags); +bool fromwire_dualopend_opener_init(const tal_t *ctx, const void *p, struct wally_psbt **psbt, struct amount_sat *funding_amount, u8 **local_shutdown_scriptpubkey, u32 *feerate_per_kw, u32 *feerate_per_kw_funding, u8 *channel_flags); -/* WIRE: DUAL_OPEN_DEV_MEMLEAK */ +/* WIRE: DUALOPEND_DEV_MEMLEAK */ /* master -> dualopend: do you have a memleak? */ -u8 *towire_dual_open_dev_memleak(const tal_t *ctx); -bool fromwire_dual_open_dev_memleak(const void *p); +u8 *towire_dualopend_dev_memleak(const tal_t *ctx); +bool fromwire_dualopend_dev_memleak(const void *p); -/* WIRE: DUAL_OPEN_DEV_MEMLEAK_REPLY */ -u8 *towire_dual_open_dev_memleak_reply(const tal_t *ctx, bool leak); -bool fromwire_dual_open_dev_memleak_reply(const void *p, bool *leak); +/* WIRE: DUALOPEND_DEV_MEMLEAK_REPLY */ +u8 *towire_dualopend_dev_memleak_reply(const tal_t *ctx, bool leak); +bool fromwire_dualopend_dev_memleak_reply(const void *p, bool *leak); #endif /* LIGHTNING_OPENINGD_DUALOPEND_WIREGEN_H */ -// SHA256STAMP:f08f0c25f359d5c8f843d78c94eca9b0543b39e62a34983f6572adf92ff02aaa +// SHA256STAMP:c00536896059d3bd16cd8e1512674abcda83fd680e171dfc016a796f7b4be522