mirror of
https://github.com/ElementsProject/lightning.git
synced 2024-11-19 18:11:28 +01:00
f24bbac8d9
We need to know what the lease we're expecting is. To do this we pass around the hex encoded portion of the wire format. We can use this passed in expected lease rates to confirm that the peer is, in fact, using the same rates as what we have currently. Changelog-Added: JSON-RPC: fundchannel, multifundchannel, and openchannel_init now accept a 'compact_lease' for any requested funds
1100 lines
44 KiB
C
Generated
1100 lines
44 KiB
C
Generated
/* This file was generated by generate-wire.py */
|
|
/* Do not modify this file! Modify the .csv file it was generated from. */
|
|
/* Original template can be found at tools/gen/impl_template */
|
|
|
|
#include <openingd/dualopend_wiregen.h>
|
|
#include <assert.h>
|
|
#include <ccan/array_size/array_size.h>
|
|
#include <ccan/mem/mem.h>
|
|
#include <ccan/tal/str/str.h>
|
|
#include <common/utils.h>
|
|
#include <stdio.h>
|
|
|
|
#ifndef SUPERVERBOSE
|
|
#define SUPERVERBOSE(...)
|
|
#endif
|
|
|
|
|
|
const char *dualopend_wire_name(int e)
|
|
{
|
|
static char invalidbuf[sizeof("INVALID ") + STR_MAX_CHARS(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_GOT_RBF_OFFER: return "WIRE_DUALOPEND_GOT_RBF_OFFER";
|
|
case WIRE_DUALOPEND_GOT_RBF_OFFER_REPLY: return "WIRE_DUALOPEND_GOT_RBF_OFFER_REPLY";
|
|
case WIRE_DUALOPEND_RBF_VALIDATE: return "WIRE_DUALOPEND_RBF_VALIDATE";
|
|
case WIRE_DUALOPEND_RBF_VALID: return "WIRE_DUALOPEND_RBF_VALID";
|
|
case WIRE_DUALOPEND_RBF_INIT: return "WIRE_DUALOPEND_RBF_INIT";
|
|
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_OPENER_INIT: return "WIRE_DUALOPEND_OPENER_INIT";
|
|
case WIRE_DUALOPEND_FUNDING_SIGS: return "WIRE_DUALOPEND_FUNDING_SIGS";
|
|
case WIRE_DUALOPEND_SEND_TX_SIGS: return "WIRE_DUALOPEND_SEND_TX_SIGS";
|
|
case WIRE_DUALOPEND_TX_SIGS_SENT: return "WIRE_DUALOPEND_TX_SIGS_SENT";
|
|
case WIRE_DUALOPEND_PEER_LOCKED: return "WIRE_DUALOPEND_PEER_LOCKED";
|
|
case WIRE_DUALOPEND_CHANNEL_LOCKED: return "WIRE_DUALOPEND_CHANNEL_LOCKED";
|
|
case WIRE_DUALOPEND_DEPTH_REACHED: return "WIRE_DUALOPEND_DEPTH_REACHED";
|
|
case WIRE_DUALOPEND_SEND_SHUTDOWN: return "WIRE_DUALOPEND_SEND_SHUTDOWN";
|
|
case WIRE_DUALOPEND_GOT_SHUTDOWN: return "WIRE_DUALOPEND_GOT_SHUTDOWN";
|
|
case WIRE_DUALOPEND_FAIL_FALLEN_BEHIND: return "WIRE_DUALOPEND_FAIL_FALLEN_BEHIND";
|
|
case WIRE_DUALOPEND_SHUTDOWN_COMPLETE: return "WIRE_DUALOPEND_SHUTDOWN_COMPLETE";
|
|
case WIRE_DUALOPEND_DEV_MEMLEAK: return "WIRE_DUALOPEND_DEV_MEMLEAK";
|
|
case WIRE_DUALOPEND_DEV_MEMLEAK_REPLY: return "WIRE_DUALOPEND_DEV_MEMLEAK_REPLY";
|
|
case WIRE_DUALOPEND_DRY_RUN: return "WIRE_DUALOPEND_DRY_RUN";
|
|
case WIRE_DUALOPEND_VALIDATE_LEASE: return "WIRE_DUALOPEND_VALIDATE_LEASE";
|
|
case WIRE_DUALOPEND_VALIDATE_LEASE_REPLY: return "WIRE_DUALOPEND_VALIDATE_LEASE_REPLY";
|
|
}
|
|
|
|
snprintf(invalidbuf, sizeof(invalidbuf), "INVALID %i", e);
|
|
return invalidbuf;
|
|
}
|
|
|
|
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_GOT_RBF_OFFER:;
|
|
case WIRE_DUALOPEND_GOT_RBF_OFFER_REPLY:;
|
|
case WIRE_DUALOPEND_RBF_VALIDATE:;
|
|
case WIRE_DUALOPEND_RBF_VALID:;
|
|
case WIRE_DUALOPEND_RBF_INIT:;
|
|
case WIRE_DUALOPEND_COMMIT_RCVD:;
|
|
case WIRE_DUALOPEND_PSBT_CHANGED:;
|
|
case WIRE_DUALOPEND_PSBT_UPDATED:;
|
|
case WIRE_DUALOPEND_FAIL:;
|
|
case WIRE_DUALOPEND_OPENER_INIT:;
|
|
case WIRE_DUALOPEND_FUNDING_SIGS:;
|
|
case WIRE_DUALOPEND_SEND_TX_SIGS:;
|
|
case WIRE_DUALOPEND_TX_SIGS_SENT:;
|
|
case WIRE_DUALOPEND_PEER_LOCKED:;
|
|
case WIRE_DUALOPEND_CHANNEL_LOCKED:;
|
|
case WIRE_DUALOPEND_DEPTH_REACHED:;
|
|
case WIRE_DUALOPEND_SEND_SHUTDOWN:;
|
|
case WIRE_DUALOPEND_GOT_SHUTDOWN:;
|
|
case WIRE_DUALOPEND_FAIL_FALLEN_BEHIND:;
|
|
case WIRE_DUALOPEND_SHUTDOWN_COMPLETE:;
|
|
case WIRE_DUALOPEND_DEV_MEMLEAK:;
|
|
case WIRE_DUALOPEND_DEV_MEMLEAK_REPLY:;
|
|
case WIRE_DUALOPEND_DRY_RUN:;
|
|
case WIRE_DUALOPEND_VALIDATE_LEASE:;
|
|
case WIRE_DUALOPEND_VALIDATE_LEASE_REPLY:;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* 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)
|
|
{
|
|
u16 their_init_features_len = tal_count(their_init_features);
|
|
u8 *p = tal_arr(ctx, u8, 0);
|
|
|
|
towire_u16(&p, WIRE_DUALOPEND_INIT);
|
|
/* Which network are we configured for? */
|
|
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);
|
|
/* Base configuration we'll offer */
|
|
towire_channel_config(&p, our_config);
|
|
/* Minimum/maximum configuration values we'll accept */
|
|
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);
|
|
/* Constraints in case the other end tries to open a channel. */
|
|
towire_u32(&p, minimum_depth);
|
|
|
|
return memcheck(p, tal_count(p));
|
|
}
|
|
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)
|
|
{
|
|
u16 their_init_features_len;
|
|
|
|
const u8 *cursor = p;
|
|
size_t plen = tal_count(p);
|
|
|
|
if (fromwire_u16(&cursor, &plen) != WIRE_DUALOPEND_INIT)
|
|
return false;
|
|
/* Which network are we configured for? */
|
|
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);
|
|
/* Base configuration we'll offer */
|
|
fromwire_channel_config(&cursor, &plen, our_config);
|
|
/* Minimum/maximum configuration values we'll accept */
|
|
*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);
|
|
/* Constraints in case the other end tries to open a channel. */
|
|
*minimum_depth = fromwire_u32(&cursor, &plen);
|
|
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, const struct bitcoin_txid *funding_txid, u16 funding_txout, u32 most_recent_feerate_per_kw_funding, 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, u8 channel_flags, u32 lease_start_blockheight, u32 lease_expiry, const secp256k1_ecdsa_signature *lease_commit_sig, u32 lease_chan_max_msat, u16 lease_chan_max_ppt)
|
|
{
|
|
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);
|
|
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_bitcoin_txid(&p, funding_txid);
|
|
towire_u16(&p, funding_txout);
|
|
towire_u32(&p, most_recent_feerate_per_kw_funding);
|
|
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);
|
|
towire_u8(&p, channel_flags);
|
|
towire_u32(&p, lease_start_blockheight);
|
|
towire_u32(&p, lease_expiry);
|
|
if (!lease_commit_sig)
|
|
towire_bool(&p, false);
|
|
else {
|
|
towire_bool(&p, true);
|
|
towire_secp256k1_ecdsa_signature(&p, lease_commit_sig);
|
|
}
|
|
towire_u32(&p, lease_chan_max_msat);
|
|
towire_u16(&p, lease_chan_max_ppt);
|
|
|
|
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, struct bitcoin_txid *funding_txid, u16 *funding_txout, u32 *most_recent_feerate_per_kw_funding, 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 *channel_flags, u32 *lease_start_blockheight, u32 *lease_expiry, secp256k1_ecdsa_signature **lease_commit_sig, u32 *lease_chan_max_msat, u16 *lease_chan_max_ppt)
|
|
{
|
|
u16 their_init_features_len;
|
|
u16 local_shutdown_len;
|
|
u16 remote_shutdown_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);
|
|
fromwire_bitcoin_txid(&cursor, &plen, funding_txid);
|
|
*funding_txout = fromwire_u16(&cursor, &plen);
|
|
*most_recent_feerate_per_kw_funding = fromwire_u32(&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);
|
|
*channel_flags = fromwire_u8(&cursor, &plen);
|
|
*lease_start_blockheight = fromwire_u32(&cursor, &plen);
|
|
*lease_expiry = fromwire_u32(&cursor, &plen);
|
|
if (!fromwire_bool(&cursor, &plen))
|
|
*lease_commit_sig = NULL;
|
|
else {
|
|
*lease_commit_sig = tal(ctx, secp256k1_ecdsa_signature);
|
|
fromwire_secp256k1_ecdsa_signature(&cursor, &plen, *lease_commit_sig);
|
|
}
|
|
*lease_chan_max_msat = fromwire_u32(&cursor, &plen);
|
|
*lease_chan_max_ppt = fromwire_u16(&cursor, &plen);
|
|
return cursor != NULL;
|
|
}
|
|
|
|
/* WIRE: DUALOPEND_GOT_OFFER */
|
|
/* dualopend->master: they offered channel */
|
|
u8 *towire_dualopend_got_offer(const tal_t *ctx, const struct channel_id *channel_id, 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_per_kw_funding, u32 feerate_per_kw_commitment, u16 to_self_delay, u16 max_accepted_htlcs, u8 channel_flags, u32 locktime, const u8 *shutdown_scriptpubkey, struct amount_sat requested_amt, u32 lease_blockheight_start)
|
|
{
|
|
u16 shutdown_len = tal_count(shutdown_scriptpubkey);
|
|
u8 *p = tal_arr(ctx, u8, 0);
|
|
|
|
towire_u16(&p, WIRE_DUALOPEND_GOT_OFFER);
|
|
towire_channel_id(&p, channel_id);
|
|
towire_amount_sat(&p, opener_funding);
|
|
towire_amount_sat(&p, dust_limit_satoshis);
|
|
towire_amount_msat(&p, max_htlc_value_in_flight_msat);
|
|
towire_amount_msat(&p, htlc_minimum_msat);
|
|
towire_u32(&p, feerate_per_kw_funding);
|
|
towire_u32(&p, feerate_per_kw_commitment);
|
|
towire_u16(&p, to_self_delay);
|
|
towire_u16(&p, max_accepted_htlcs);
|
|
towire_u8(&p, channel_flags);
|
|
towire_u32(&p, locktime);
|
|
towire_u16(&p, shutdown_len);
|
|
towire_u8_array(&p, shutdown_scriptpubkey, shutdown_len);
|
|
towire_amount_sat(&p, requested_amt);
|
|
towire_u32(&p, lease_blockheight_start);
|
|
|
|
return memcheck(p, tal_count(p));
|
|
}
|
|
bool fromwire_dualopend_got_offer(const tal_t *ctx, const void *p, struct channel_id *channel_id, 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_per_kw_funding, u32 *feerate_per_kw_commitment, u16 *to_self_delay, u16 *max_accepted_htlcs, u8 *channel_flags, u32 *locktime, u8 **shutdown_scriptpubkey, struct amount_sat *requested_amt, u32 *lease_blockheight_start)
|
|
{
|
|
u16 shutdown_len;
|
|
|
|
const u8 *cursor = p;
|
|
size_t plen = tal_count(p);
|
|
|
|
if (fromwire_u16(&cursor, &plen) != WIRE_DUALOPEND_GOT_OFFER)
|
|
return false;
|
|
fromwire_channel_id(&cursor, &plen, channel_id);
|
|
*opener_funding = fromwire_amount_sat(&cursor, &plen);
|
|
*dust_limit_satoshis = fromwire_amount_sat(&cursor, &plen);
|
|
*max_htlc_value_in_flight_msat = fromwire_amount_msat(&cursor, &plen);
|
|
*htlc_minimum_msat = fromwire_amount_msat(&cursor, &plen);
|
|
*feerate_per_kw_funding = fromwire_u32(&cursor, &plen);
|
|
*feerate_per_kw_commitment = fromwire_u32(&cursor, &plen);
|
|
*to_self_delay = fromwire_u16(&cursor, &plen);
|
|
*max_accepted_htlcs = fromwire_u16(&cursor, &plen);
|
|
*channel_flags = fromwire_u8(&cursor, &plen);
|
|
*locktime = fromwire_u32(&cursor, &plen);
|
|
shutdown_len = fromwire_u16(&cursor, &plen);
|
|
// 2nd case shutdown_scriptpubkey
|
|
*shutdown_scriptpubkey = shutdown_len ? tal_arr(ctx, u8, shutdown_len) : NULL;
|
|
fromwire_u8_array(&cursor, &plen, *shutdown_scriptpubkey, shutdown_len);
|
|
*requested_amt = fromwire_amount_sat(&cursor, &plen);
|
|
*lease_blockheight_start = fromwire_u32(&cursor, &plen);
|
|
return cursor != NULL;
|
|
}
|
|
|
|
/* WIRE: DUALOPEND_GOT_OFFER_REPLY */
|
|
/* master->dualopend: reply back with our first funding info/contribs */
|
|
u8 *towire_dualopend_got_offer_reply(const tal_t *ctx, struct amount_sat accepter_funding, const struct wally_psbt *psbt, const u8 *our_shutdown_scriptpubkey, const struct lease_rates *lease_rates)
|
|
{
|
|
u16 shutdown_len = tal_count(our_shutdown_scriptpubkey);
|
|
u8 *p = tal_arr(ctx, u8, 0);
|
|
|
|
towire_u16(&p, WIRE_DUALOPEND_GOT_OFFER_REPLY);
|
|
towire_amount_sat(&p, accepter_funding);
|
|
towire_wally_psbt(&p, psbt);
|
|
towire_u16(&p, shutdown_len);
|
|
towire_u8_array(&p, our_shutdown_scriptpubkey, shutdown_len);
|
|
/* must go last because of embedded tu32 */
|
|
if (!lease_rates)
|
|
towire_bool(&p, false);
|
|
else {
|
|
towire_bool(&p, true);
|
|
towire_lease_rates(&p, lease_rates);
|
|
}
|
|
|
|
return memcheck(p, tal_count(p));
|
|
}
|
|
bool fromwire_dualopend_got_offer_reply(const tal_t *ctx, const void *p, struct amount_sat *accepter_funding, struct wally_psbt **psbt, u8 **our_shutdown_scriptpubkey, struct lease_rates **lease_rates)
|
|
{
|
|
u16 shutdown_len;
|
|
|
|
const u8 *cursor = p;
|
|
size_t plen = tal_count(p);
|
|
|
|
if (fromwire_u16(&cursor, &plen) != WIRE_DUALOPEND_GOT_OFFER_REPLY)
|
|
return false;
|
|
*accepter_funding = fromwire_amount_sat(&cursor, &plen);
|
|
*psbt = fromwire_wally_psbt(ctx, &cursor, &plen);
|
|
shutdown_len = fromwire_u16(&cursor, &plen);
|
|
// 2nd case our_shutdown_scriptpubkey
|
|
*our_shutdown_scriptpubkey = shutdown_len ? tal_arr(ctx, u8, shutdown_len) : NULL;
|
|
fromwire_u8_array(&cursor, &plen, *our_shutdown_scriptpubkey, shutdown_len);
|
|
/* must go last because of embedded tu32 */
|
|
if (!fromwire_bool(&cursor, &plen))
|
|
*lease_rates = NULL;
|
|
else {
|
|
*lease_rates = tal(ctx, struct lease_rates);
|
|
fromwire_lease_rates(&cursor, &plen, *lease_rates);
|
|
}
|
|
return cursor != NULL;
|
|
}
|
|
|
|
/* WIRE: DUALOPEND_GOT_RBF_OFFER */
|
|
/* dualopend->master: they offered a RBF */
|
|
u8 *towire_dualopend_got_rbf_offer(const tal_t *ctx, const struct channel_id *channel_id, struct amount_sat their_funding, u32 funding_feerate_per_kw, u32 locktime)
|
|
{
|
|
u8 *p = tal_arr(ctx, u8, 0);
|
|
|
|
towire_u16(&p, WIRE_DUALOPEND_GOT_RBF_OFFER);
|
|
towire_channel_id(&p, channel_id);
|
|
towire_amount_sat(&p, their_funding);
|
|
towire_u32(&p, funding_feerate_per_kw);
|
|
towire_u32(&p, locktime);
|
|
|
|
return memcheck(p, tal_count(p));
|
|
}
|
|
bool fromwire_dualopend_got_rbf_offer(const void *p, struct channel_id *channel_id, struct amount_sat *their_funding, u32 *funding_feerate_per_kw, u32 *locktime)
|
|
{
|
|
const u8 *cursor = p;
|
|
size_t plen = tal_count(p);
|
|
|
|
if (fromwire_u16(&cursor, &plen) != WIRE_DUALOPEND_GOT_RBF_OFFER)
|
|
return false;
|
|
fromwire_channel_id(&cursor, &plen, channel_id);
|
|
*their_funding = fromwire_amount_sat(&cursor, &plen);
|
|
*funding_feerate_per_kw = fromwire_u32(&cursor, &plen);
|
|
*locktime = fromwire_u32(&cursor, &plen);
|
|
return cursor != NULL;
|
|
}
|
|
|
|
/* WIRE: DUALOPEND_GOT_RBF_OFFER_REPLY */
|
|
/* master->dualopend: reply back with our funding info/contribs */
|
|
u8 *towire_dualopend_got_rbf_offer_reply(const tal_t *ctx, struct amount_sat our_funding, const struct wally_psbt *psbt)
|
|
{
|
|
u8 *p = tal_arr(ctx, u8, 0);
|
|
|
|
towire_u16(&p, WIRE_DUALOPEND_GOT_RBF_OFFER_REPLY);
|
|
towire_amount_sat(&p, our_funding);
|
|
towire_wally_psbt(&p, psbt);
|
|
|
|
return memcheck(p, tal_count(p));
|
|
}
|
|
bool fromwire_dualopend_got_rbf_offer_reply(const tal_t *ctx, const void *p, struct amount_sat *our_funding, struct wally_psbt **psbt)
|
|
{
|
|
const u8 *cursor = p;
|
|
size_t plen = tal_count(p);
|
|
|
|
if (fromwire_u16(&cursor, &plen) != WIRE_DUALOPEND_GOT_RBF_OFFER_REPLY)
|
|
return false;
|
|
*our_funding = fromwire_amount_sat(&cursor, &plen);
|
|
*psbt = fromwire_wally_psbt(ctx, &cursor, &plen);
|
|
return cursor != NULL;
|
|
}
|
|
|
|
/* WIRE: DUALOPEND_RBF_VALIDATE */
|
|
/* dualopend->master: is this a valid RBF candidate transaction? */
|
|
u8 *towire_dualopend_rbf_validate(const tal_t *ctx, const struct wally_psbt *proposed_funding_psbt)
|
|
{
|
|
u8 *p = tal_arr(ctx, u8, 0);
|
|
|
|
towire_u16(&p, WIRE_DUALOPEND_RBF_VALIDATE);
|
|
towire_wally_psbt(&p, proposed_funding_psbt);
|
|
|
|
return memcheck(p, tal_count(p));
|
|
}
|
|
bool fromwire_dualopend_rbf_validate(const tal_t *ctx, const void *p, struct wally_psbt **proposed_funding_psbt)
|
|
{
|
|
const u8 *cursor = p;
|
|
size_t plen = tal_count(p);
|
|
|
|
if (fromwire_u16(&cursor, &plen) != WIRE_DUALOPEND_RBF_VALIDATE)
|
|
return false;
|
|
*proposed_funding_psbt = fromwire_wally_psbt(ctx, &cursor, &plen);
|
|
return cursor != NULL;
|
|
}
|
|
|
|
/* WIRE: DUALOPEND_RBF_VALID */
|
|
/* master->dualopend: this is a valid RBF candidate transaction */
|
|
u8 *towire_dualopend_rbf_valid(const tal_t *ctx)
|
|
{
|
|
u8 *p = tal_arr(ctx, u8, 0);
|
|
|
|
towire_u16(&p, WIRE_DUALOPEND_RBF_VALID);
|
|
|
|
return memcheck(p, tal_count(p));
|
|
}
|
|
bool fromwire_dualopend_rbf_valid(const void *p)
|
|
{
|
|
const u8 *cursor = p;
|
|
size_t plen = tal_count(p);
|
|
|
|
if (fromwire_u16(&cursor, &plen) != WIRE_DUALOPEND_RBF_VALID)
|
|
return false;
|
|
return cursor != NULL;
|
|
}
|
|
|
|
/* WIRE: DUALOPEND_RBF_INIT */
|
|
/* master->dualopend: attempt an RBF */
|
|
u8 *towire_dualopend_rbf_init(const tal_t *ctx, struct amount_sat our_funding, u32 funding_feerate_perkw, const struct wally_psbt *psbt)
|
|
{
|
|
u8 *p = tal_arr(ctx, u8, 0);
|
|
|
|
towire_u16(&p, WIRE_DUALOPEND_RBF_INIT);
|
|
towire_amount_sat(&p, our_funding);
|
|
towire_u32(&p, funding_feerate_perkw);
|
|
towire_wally_psbt(&p, psbt);
|
|
|
|
return memcheck(p, tal_count(p));
|
|
}
|
|
bool fromwire_dualopend_rbf_init(const tal_t *ctx, const void *p, struct amount_sat *our_funding, u32 *funding_feerate_perkw, struct wally_psbt **psbt)
|
|
{
|
|
const u8 *cursor = p;
|
|
size_t plen = tal_count(p);
|
|
|
|
if (fromwire_u16(&cursor, &plen) != WIRE_DUALOPEND_RBF_INIT)
|
|
return false;
|
|
*our_funding = fromwire_amount_sat(&cursor, &plen);
|
|
*funding_feerate_perkw = fromwire_u32(&cursor, &plen);
|
|
*psbt = fromwire_wally_psbt(ctx, &cursor, &plen);
|
|
return cursor != NULL;
|
|
}
|
|
|
|
/* WIRE: DUALOPEND_COMMIT_RCVD */
|
|
/* dualopend->master: ready to commit channel open to database and */
|
|
/* get some signatures for the funding_tx. */
|
|
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 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_funding, u32 feerate_per_kw_commitment, const u8 *local_shutdown_scriptpubkey, const u8 *remote_shutdown_scriptpubkey, u32 lease_start_blockheight, u32 lease_expiry, const secp256k1_ecdsa_signature *lease_commit_sig, u32 lease_chan_max_msat, u16 lease_chan_max_ppt)
|
|
{
|
|
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_DUALOPEND_COMMIT_RCVD);
|
|
towire_channel_config(&p, their_config);
|
|
towire_bitcoin_tx(&p, remote_first_commit);
|
|
if (!pbase)
|
|
towire_bool(&p, false);
|
|
else {
|
|
towire_bool(&p, true);
|
|
towire_penalty_base(&p, pbase);
|
|
}
|
|
towire_bitcoin_signature(&p, first_commit_sig);
|
|
towire_wally_psbt(&p, psbt);
|
|
towire_pubkey(&p, revocation_basepoint);
|
|
towire_pubkey(&p, payment_basepoint);
|
|
towire_pubkey(&p, htlc_basepoint);
|
|
towire_pubkey(&p, delayed_payment_basepoint);
|
|
towire_pubkey(&p, their_per_commit_point);
|
|
towire_pubkey(&p, remote_fundingkey);
|
|
towire_bitcoin_txid(&p, funding_txid);
|
|
towire_u16(&p, funding_txout);
|
|
towire_amount_sat(&p, funding_satoshis);
|
|
towire_amount_sat(&p, our_funding_sats);
|
|
towire_u8(&p, channel_flags);
|
|
towire_u32(&p, feerate_per_kw_funding);
|
|
towire_u32(&p, feerate_per_kw_commitment);
|
|
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_u32(&p, lease_start_blockheight);
|
|
towire_u32(&p, lease_expiry);
|
|
if (!lease_commit_sig)
|
|
towire_bool(&p, false);
|
|
else {
|
|
towire_bool(&p, true);
|
|
towire_secp256k1_ecdsa_signature(&p, lease_commit_sig);
|
|
}
|
|
towire_u32(&p, lease_chan_max_msat);
|
|
towire_u16(&p, lease_chan_max_ppt);
|
|
|
|
return memcheck(p, tal_count(p));
|
|
}
|
|
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 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_funding, u32 *feerate_per_kw_commitment, u8 **local_shutdown_scriptpubkey, u8 **remote_shutdown_scriptpubkey, u32 *lease_start_blockheight, u32 *lease_expiry, secp256k1_ecdsa_signature **lease_commit_sig, u32 *lease_chan_max_msat, u16 *lease_chan_max_ppt)
|
|
{
|
|
u16 local_shutdown_len;
|
|
u16 remote_shutdown_len;
|
|
|
|
const u8 *cursor = p;
|
|
size_t plen = tal_count(p);
|
|
|
|
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);
|
|
if (!fromwire_bool(&cursor, &plen))
|
|
*pbase = NULL;
|
|
else {
|
|
*pbase = tal(ctx, struct penalty_base);
|
|
fromwire_penalty_base(&cursor, &plen, *pbase);
|
|
}
|
|
fromwire_bitcoin_signature(&cursor, &plen, first_commit_sig);
|
|
*psbt = fromwire_wally_psbt(ctx, &cursor, &plen);
|
|
fromwire_pubkey(&cursor, &plen, revocation_basepoint);
|
|
fromwire_pubkey(&cursor, &plen, payment_basepoint);
|
|
fromwire_pubkey(&cursor, &plen, htlc_basepoint);
|
|
fromwire_pubkey(&cursor, &plen, delayed_payment_basepoint);
|
|
fromwire_pubkey(&cursor, &plen, their_per_commit_point);
|
|
fromwire_pubkey(&cursor, &plen, remote_fundingkey);
|
|
fromwire_bitcoin_txid(&cursor, &plen, funding_txid);
|
|
*funding_txout = fromwire_u16(&cursor, &plen);
|
|
*funding_satoshis = fromwire_amount_sat(&cursor, &plen);
|
|
*our_funding_sats = fromwire_amount_sat(&cursor, &plen);
|
|
*channel_flags = fromwire_u8(&cursor, &plen);
|
|
*feerate_per_kw_funding = fromwire_u32(&cursor, &plen);
|
|
*feerate_per_kw_commitment = fromwire_u32(&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);
|
|
*lease_start_blockheight = fromwire_u32(&cursor, &plen);
|
|
*lease_expiry = fromwire_u32(&cursor, &plen);
|
|
if (!fromwire_bool(&cursor, &plen))
|
|
*lease_commit_sig = NULL;
|
|
else {
|
|
*lease_commit_sig = tal(ctx, secp256k1_ecdsa_signature);
|
|
fromwire_secp256k1_ecdsa_signature(&cursor, &plen, *lease_commit_sig);
|
|
}
|
|
*lease_chan_max_msat = fromwire_u32(&cursor, &plen);
|
|
*lease_chan_max_ppt = fromwire_u16(&cursor, &plen);
|
|
return cursor != NULL;
|
|
}
|
|
|
|
/* WIRE: DUALOPEND_PSBT_CHANGED */
|
|
/* dualopend->master: peer updated the 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_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_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_DUALOPEND_PSBT_CHANGED)
|
|
return false;
|
|
fromwire_channel_id(&cursor, &plen, channel_id);
|
|
*funding_serial = fromwire_u64(&cursor, &plen);
|
|
*psbt = fromwire_wally_psbt(ctx, &cursor, &plen);
|
|
return cursor != NULL;
|
|
}
|
|
|
|
/* WIRE: DUALOPEND_PSBT_UPDATED */
|
|
/* master->dualopend: we updated the 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_DUALOPEND_PSBT_UPDATED);
|
|
towire_wally_psbt(&p, psbt);
|
|
|
|
return memcheck(p, tal_count(p));
|
|
}
|
|
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_DUALOPEND_PSBT_UPDATED)
|
|
return false;
|
|
*psbt = fromwire_wally_psbt(ctx, &cursor, &plen);
|
|
return cursor != NULL;
|
|
}
|
|
|
|
/* WIRE: DUALOPEND_FAIL */
|
|
/* master->dualopend: fail this channel open */
|
|
u8 *towire_dualopend_fail(const tal_t *ctx, const wirestring *reason)
|
|
{
|
|
u8 *p = tal_arr(ctx, u8, 0);
|
|
|
|
towire_u16(&p, WIRE_DUALOPEND_FAIL);
|
|
towire_wirestring(&p, reason);
|
|
|
|
return memcheck(p, tal_count(p));
|
|
}
|
|
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_DUALOPEND_FAIL)
|
|
return false;
|
|
*reason = fromwire_wirestring(ctx, &cursor, &plen);
|
|
return cursor != NULL;
|
|
}
|
|
|
|
/* WIRE: DUALOPEND_OPENER_INIT */
|
|
/* master->dualopend: hello */
|
|
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, struct amount_sat requested_sats, u32 blockheight, bool dry_run, const struct lease_rates *expected_rates)
|
|
{
|
|
u16 local_shutdown_len = tal_count(local_shutdown_scriptpubkey);
|
|
u8 *p = tal_arr(ctx, u8, 0);
|
|
|
|
towire_u16(&p, WIRE_DUALOPEND_OPENER_INIT);
|
|
towire_wally_psbt(&p, psbt);
|
|
towire_amount_sat(&p, funding_amount);
|
|
towire_u16(&p, local_shutdown_len);
|
|
towire_u8_array(&p, local_shutdown_scriptpubkey, local_shutdown_len);
|
|
towire_u32(&p, feerate_per_kw);
|
|
towire_u32(&p, feerate_per_kw_funding);
|
|
towire_u8(&p, channel_flags);
|
|
towire_amount_sat(&p, requested_sats);
|
|
towire_u32(&p, blockheight);
|
|
towire_bool(&p, dry_run);
|
|
/* must go last because embedded tu32 */
|
|
if (!expected_rates)
|
|
towire_bool(&p, false);
|
|
else {
|
|
towire_bool(&p, true);
|
|
towire_lease_rates(&p, expected_rates);
|
|
}
|
|
|
|
return memcheck(p, tal_count(p));
|
|
}
|
|
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, struct amount_sat *requested_sats, u32 *blockheight, bool *dry_run, struct lease_rates **expected_rates)
|
|
{
|
|
u16 local_shutdown_len;
|
|
|
|
const u8 *cursor = p;
|
|
size_t plen = tal_count(p);
|
|
|
|
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);
|
|
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);
|
|
*feerate_per_kw = fromwire_u32(&cursor, &plen);
|
|
*feerate_per_kw_funding = fromwire_u32(&cursor, &plen);
|
|
*channel_flags = fromwire_u8(&cursor, &plen);
|
|
*requested_sats = fromwire_amount_sat(&cursor, &plen);
|
|
*blockheight = fromwire_u32(&cursor, &plen);
|
|
*dry_run = fromwire_bool(&cursor, &plen);
|
|
/* must go last because embedded tu32 */
|
|
if (!fromwire_bool(&cursor, &plen))
|
|
*expected_rates = NULL;
|
|
else {
|
|
*expected_rates = tal(ctx, struct lease_rates);
|
|
fromwire_lease_rates(&cursor, &plen, *expected_rates);
|
|
}
|
|
return cursor != NULL;
|
|
}
|
|
|
|
/* WIRE: DUALOPEND_FUNDING_SIGS */
|
|
/* dualopend->master received tx_sigs from peer */
|
|
u8 *towire_dualopend_funding_sigs(const tal_t *ctx, const struct wally_psbt *signed_psbt)
|
|
{
|
|
u8 *p = tal_arr(ctx, u8, 0);
|
|
|
|
towire_u16(&p, WIRE_DUALOPEND_FUNDING_SIGS);
|
|
towire_wally_psbt(&p, signed_psbt);
|
|
|
|
return memcheck(p, tal_count(p));
|
|
}
|
|
bool fromwire_dualopend_funding_sigs(const tal_t *ctx, const void *p, struct wally_psbt **signed_psbt)
|
|
{
|
|
const u8 *cursor = p;
|
|
size_t plen = tal_count(p);
|
|
|
|
if (fromwire_u16(&cursor, &plen) != WIRE_DUALOPEND_FUNDING_SIGS)
|
|
return false;
|
|
*signed_psbt = fromwire_wally_psbt(ctx, &cursor, &plen);
|
|
return cursor != NULL;
|
|
}
|
|
|
|
/* WIRE: DUALOPEND_SEND_TX_SIGS */
|
|
/* master->dualopend send our tx_sigs to peer */
|
|
u8 *towire_dualopend_send_tx_sigs(const tal_t *ctx, const struct wally_psbt *signed_psbt)
|
|
{
|
|
u8 *p = tal_arr(ctx, u8, 0);
|
|
|
|
towire_u16(&p, WIRE_DUALOPEND_SEND_TX_SIGS);
|
|
towire_wally_psbt(&p, signed_psbt);
|
|
|
|
return memcheck(p, tal_count(p));
|
|
}
|
|
bool fromwire_dualopend_send_tx_sigs(const tal_t *ctx, const void *p, struct wally_psbt **signed_psbt)
|
|
{
|
|
const u8 *cursor = p;
|
|
size_t plen = tal_count(p);
|
|
|
|
if (fromwire_u16(&cursor, &plen) != WIRE_DUALOPEND_SEND_TX_SIGS)
|
|
return false;
|
|
*signed_psbt = fromwire_wally_psbt(ctx, &cursor, &plen);
|
|
return cursor != NULL;
|
|
}
|
|
|
|
/* WIRE: DUALOPEND_TX_SIGS_SENT */
|
|
/* dualopend->master tx sigs transmitted to peer */
|
|
u8 *towire_dualopend_tx_sigs_sent(const tal_t *ctx)
|
|
{
|
|
u8 *p = tal_arr(ctx, u8, 0);
|
|
|
|
towire_u16(&p, WIRE_DUALOPEND_TX_SIGS_SENT);
|
|
|
|
return memcheck(p, tal_count(p));
|
|
}
|
|
bool fromwire_dualopend_tx_sigs_sent(const void *p)
|
|
{
|
|
const u8 *cursor = p;
|
|
size_t plen = tal_count(p);
|
|
|
|
if (fromwire_u16(&cursor, &plen) != WIRE_DUALOPEND_TX_SIGS_SENT)
|
|
return false;
|
|
return cursor != NULL;
|
|
}
|
|
|
|
/* WIRE: DUALOPEND_PEER_LOCKED */
|
|
/* dualopend->peer peer locked channel */
|
|
u8 *towire_dualopend_peer_locked(const tal_t *ctx, const struct pubkey *remote_per_commit)
|
|
{
|
|
u8 *p = tal_arr(ctx, u8, 0);
|
|
|
|
towire_u16(&p, WIRE_DUALOPEND_PEER_LOCKED);
|
|
towire_pubkey(&p, remote_per_commit);
|
|
|
|
return memcheck(p, tal_count(p));
|
|
}
|
|
bool fromwire_dualopend_peer_locked(const void *p, struct pubkey *remote_per_commit)
|
|
{
|
|
const u8 *cursor = p;
|
|
size_t plen = tal_count(p);
|
|
|
|
if (fromwire_u16(&cursor, &plen) != WIRE_DUALOPEND_PEER_LOCKED)
|
|
return false;
|
|
fromwire_pubkey(&cursor, &plen, remote_per_commit);
|
|
return cursor != NULL;
|
|
}
|
|
|
|
/* WIRE: DUALOPEND_CHANNEL_LOCKED */
|
|
/* dualopend->master this channel has been locked */
|
|
u8 *towire_dualopend_channel_locked(const tal_t *ctx, const struct per_peer_state *pps)
|
|
{
|
|
u8 *p = tal_arr(ctx, u8, 0);
|
|
|
|
towire_u16(&p, WIRE_DUALOPEND_CHANNEL_LOCKED);
|
|
towire_per_peer_state(&p, pps);
|
|
|
|
return memcheck(p, tal_count(p));
|
|
}
|
|
bool fromwire_dualopend_channel_locked(const tal_t *ctx, const void *p, struct per_peer_state **pps)
|
|
{
|
|
const u8 *cursor = p;
|
|
size_t plen = tal_count(p);
|
|
|
|
if (fromwire_u16(&cursor, &plen) != WIRE_DUALOPEND_CHANNEL_LOCKED)
|
|
return false;
|
|
*pps = fromwire_per_peer_state(ctx, &cursor, &plen);
|
|
return cursor != NULL;
|
|
}
|
|
|
|
/* WIRE: DUALOPEND_DEPTH_REACHED */
|
|
/* master->dualopend funding reached depth; tell peer */
|
|
u8 *towire_dualopend_depth_reached(const tal_t *ctx, u32 depth)
|
|
{
|
|
u8 *p = tal_arr(ctx, u8, 0);
|
|
|
|
towire_u16(&p, WIRE_DUALOPEND_DEPTH_REACHED);
|
|
towire_u32(&p, depth);
|
|
|
|
return memcheck(p, tal_count(p));
|
|
}
|
|
bool fromwire_dualopend_depth_reached(const void *p, u32 *depth)
|
|
{
|
|
const u8 *cursor = p;
|
|
size_t plen = tal_count(p);
|
|
|
|
if (fromwire_u16(&cursor, &plen) != WIRE_DUALOPEND_DEPTH_REACHED)
|
|
return false;
|
|
*depth = fromwire_u32(&cursor, &plen);
|
|
return cursor != NULL;
|
|
}
|
|
|
|
/* WIRE: DUALOPEND_SEND_SHUTDOWN */
|
|
/* Tell peer to shut down channel. */
|
|
u8 *towire_dualopend_send_shutdown(const tal_t *ctx, const u8 *shutdown_scriptpubkey)
|
|
{
|
|
u16 shutdown_scriptpubkey_len = tal_count(shutdown_scriptpubkey);
|
|
u8 *p = tal_arr(ctx, u8, 0);
|
|
|
|
towire_u16(&p, WIRE_DUALOPEND_SEND_SHUTDOWN);
|
|
towire_u16(&p, shutdown_scriptpubkey_len);
|
|
towire_u8_array(&p, shutdown_scriptpubkey, shutdown_scriptpubkey_len);
|
|
|
|
return memcheck(p, tal_count(p));
|
|
}
|
|
bool fromwire_dualopend_send_shutdown(const tal_t *ctx, const void *p, u8 **shutdown_scriptpubkey)
|
|
{
|
|
u16 shutdown_scriptpubkey_len;
|
|
|
|
const u8 *cursor = p;
|
|
size_t plen = tal_count(p);
|
|
|
|
if (fromwire_u16(&cursor, &plen) != WIRE_DUALOPEND_SEND_SHUTDOWN)
|
|
return false;
|
|
shutdown_scriptpubkey_len = fromwire_u16(&cursor, &plen);
|
|
// 2nd case shutdown_scriptpubkey
|
|
*shutdown_scriptpubkey = shutdown_scriptpubkey_len ? tal_arr(ctx, u8, shutdown_scriptpubkey_len) : NULL;
|
|
fromwire_u8_array(&cursor, &plen, *shutdown_scriptpubkey, shutdown_scriptpubkey_len);
|
|
return cursor != NULL;
|
|
}
|
|
|
|
/* WIRE: DUALOPEND_GOT_SHUTDOWN */
|
|
/* Peer told us that channel is shutting down */
|
|
u8 *towire_dualopend_got_shutdown(const tal_t *ctx, const u8 *scriptpubkey)
|
|
{
|
|
u16 scriptpubkey_len = tal_count(scriptpubkey);
|
|
u8 *p = tal_arr(ctx, u8, 0);
|
|
|
|
towire_u16(&p, WIRE_DUALOPEND_GOT_SHUTDOWN);
|
|
towire_u16(&p, scriptpubkey_len);
|
|
towire_u8_array(&p, scriptpubkey, scriptpubkey_len);
|
|
|
|
return memcheck(p, tal_count(p));
|
|
}
|
|
bool fromwire_dualopend_got_shutdown(const tal_t *ctx, const void *p, u8 **scriptpubkey)
|
|
{
|
|
u16 scriptpubkey_len;
|
|
|
|
const u8 *cursor = p;
|
|
size_t plen = tal_count(p);
|
|
|
|
if (fromwire_u16(&cursor, &plen) != WIRE_DUALOPEND_GOT_SHUTDOWN)
|
|
return false;
|
|
scriptpubkey_len = fromwire_u16(&cursor, &plen);
|
|
// 2nd case scriptpubkey
|
|
*scriptpubkey = scriptpubkey_len ? tal_arr(ctx, u8, scriptpubkey_len) : NULL;
|
|
fromwire_u8_array(&cursor, &plen, *scriptpubkey, scriptpubkey_len);
|
|
return cursor != NULL;
|
|
}
|
|
|
|
/* WIRE: DUALOPEND_FAIL_FALLEN_BEHIND */
|
|
/* Peer presented proof it was from the future. */
|
|
u8 *towire_dualopend_fail_fallen_behind(const tal_t *ctx)
|
|
{
|
|
u8 *p = tal_arr(ctx, u8, 0);
|
|
|
|
towire_u16(&p, WIRE_DUALOPEND_FAIL_FALLEN_BEHIND);
|
|
|
|
return memcheck(p, tal_count(p));
|
|
}
|
|
bool fromwire_dualopend_fail_fallen_behind(const void *p)
|
|
{
|
|
const u8 *cursor = p;
|
|
size_t plen = tal_count(p);
|
|
|
|
if (fromwire_u16(&cursor, &plen) != WIRE_DUALOPEND_FAIL_FALLEN_BEHIND)
|
|
return false;
|
|
return cursor != NULL;
|
|
}
|
|
|
|
/* WIRE: DUALOPEND_SHUTDOWN_COMPLETE */
|
|
/* Shutdown is complete */
|
|
u8 *towire_dualopend_shutdown_complete(const tal_t *ctx, const struct per_peer_state *per_peer_state)
|
|
{
|
|
u8 *p = tal_arr(ctx, u8, 0);
|
|
|
|
towire_u16(&p, WIRE_DUALOPEND_SHUTDOWN_COMPLETE);
|
|
towire_per_peer_state(&p, per_peer_state);
|
|
|
|
return memcheck(p, tal_count(p));
|
|
}
|
|
bool fromwire_dualopend_shutdown_complete(const tal_t *ctx, const void *p, struct per_peer_state **per_peer_state)
|
|
{
|
|
const u8 *cursor = p;
|
|
size_t plen = tal_count(p);
|
|
|
|
if (fromwire_u16(&cursor, &plen) != WIRE_DUALOPEND_SHUTDOWN_COMPLETE)
|
|
return false;
|
|
*per_peer_state = fromwire_per_peer_state(ctx, &cursor, &plen);
|
|
return cursor != NULL;
|
|
}
|
|
|
|
/* WIRE: DUALOPEND_DEV_MEMLEAK */
|
|
/* master -> dualopend: do you have a memleak? */
|
|
u8 *towire_dualopend_dev_memleak(const tal_t *ctx)
|
|
{
|
|
u8 *p = tal_arr(ctx, u8, 0);
|
|
|
|
towire_u16(&p, WIRE_DUALOPEND_DEV_MEMLEAK);
|
|
|
|
return memcheck(p, tal_count(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_DUALOPEND_DEV_MEMLEAK)
|
|
return false;
|
|
return cursor != NULL;
|
|
}
|
|
|
|
/* 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_DUALOPEND_DEV_MEMLEAK_REPLY);
|
|
towire_bool(&p, leak);
|
|
|
|
return memcheck(p, tal_count(p));
|
|
}
|
|
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_DUALOPEND_DEV_MEMLEAK_REPLY)
|
|
return false;
|
|
*leak = fromwire_bool(&cursor, &plen);
|
|
return cursor != NULL;
|
|
}
|
|
|
|
/* WIRE: DUALOPEND_DRY_RUN */
|
|
/* dualopend -> master: this was a dry run */
|
|
u8 *towire_dualopend_dry_run(const tal_t *ctx, const struct channel_id *channel_id, struct amount_sat our_funding, struct amount_sat their_funding, const struct lease_rates *lease_rates)
|
|
{
|
|
u8 *p = tal_arr(ctx, u8, 0);
|
|
|
|
towire_u16(&p, WIRE_DUALOPEND_DRY_RUN);
|
|
towire_channel_id(&p, channel_id);
|
|
towire_amount_sat(&p, our_funding);
|
|
towire_amount_sat(&p, their_funding);
|
|
/* must go last because of embedded tu32 */
|
|
if (!lease_rates)
|
|
towire_bool(&p, false);
|
|
else {
|
|
towire_bool(&p, true);
|
|
towire_lease_rates(&p, lease_rates);
|
|
}
|
|
|
|
return memcheck(p, tal_count(p));
|
|
}
|
|
bool fromwire_dualopend_dry_run(const tal_t *ctx, const void *p, struct channel_id *channel_id, struct amount_sat *our_funding, struct amount_sat *their_funding, struct lease_rates **lease_rates)
|
|
{
|
|
const u8 *cursor = p;
|
|
size_t plen = tal_count(p);
|
|
|
|
if (fromwire_u16(&cursor, &plen) != WIRE_DUALOPEND_DRY_RUN)
|
|
return false;
|
|
fromwire_channel_id(&cursor, &plen, channel_id);
|
|
*our_funding = fromwire_amount_sat(&cursor, &plen);
|
|
*their_funding = fromwire_amount_sat(&cursor, &plen);
|
|
/* must go last because of embedded tu32 */
|
|
if (!fromwire_bool(&cursor, &plen))
|
|
*lease_rates = NULL;
|
|
else {
|
|
*lease_rates = tal(ctx, struct lease_rates);
|
|
fromwire_lease_rates(&cursor, &plen, *lease_rates);
|
|
}
|
|
return cursor != NULL;
|
|
}
|
|
|
|
/* WIRE: DUALOPEND_VALIDATE_LEASE */
|
|
/* dualopend -> master: validate liqudity offer sig */
|
|
u8 *towire_dualopend_validate_lease(const tal_t *ctx, const secp256k1_ecdsa_signature *sig, u32 lease_expiry, u32 chan_fee_max_base_msat, u16 chan_fee_max_ppt, const struct pubkey *their_pubkey)
|
|
{
|
|
u8 *p = tal_arr(ctx, u8, 0);
|
|
|
|
towire_u16(&p, WIRE_DUALOPEND_VALIDATE_LEASE);
|
|
towire_secp256k1_ecdsa_signature(&p, sig);
|
|
towire_u32(&p, lease_expiry);
|
|
towire_u32(&p, chan_fee_max_base_msat);
|
|
towire_u16(&p, chan_fee_max_ppt);
|
|
towire_pubkey(&p, their_pubkey);
|
|
|
|
return memcheck(p, tal_count(p));
|
|
}
|
|
bool fromwire_dualopend_validate_lease(const void *p, secp256k1_ecdsa_signature *sig, u32 *lease_expiry, u32 *chan_fee_max_base_msat, u16 *chan_fee_max_ppt, struct pubkey *their_pubkey)
|
|
{
|
|
const u8 *cursor = p;
|
|
size_t plen = tal_count(p);
|
|
|
|
if (fromwire_u16(&cursor, &plen) != WIRE_DUALOPEND_VALIDATE_LEASE)
|
|
return false;
|
|
fromwire_secp256k1_ecdsa_signature(&cursor, &plen, sig);
|
|
*lease_expiry = fromwire_u32(&cursor, &plen);
|
|
*chan_fee_max_base_msat = fromwire_u32(&cursor, &plen);
|
|
*chan_fee_max_ppt = fromwire_u16(&cursor, &plen);
|
|
fromwire_pubkey(&cursor, &plen, their_pubkey);
|
|
return cursor != NULL;
|
|
}
|
|
|
|
/* WIRE: DUALOPEND_VALIDATE_LEASE_REPLY */
|
|
u8 *towire_dualopend_validate_lease_reply(const tal_t *ctx, const wirestring *err_msg)
|
|
{
|
|
u8 *p = tal_arr(ctx, u8, 0);
|
|
|
|
towire_u16(&p, WIRE_DUALOPEND_VALIDATE_LEASE_REPLY);
|
|
if (!err_msg)
|
|
towire_bool(&p, false);
|
|
else {
|
|
towire_bool(&p, true);
|
|
towire_wirestring(&p, err_msg);
|
|
}
|
|
|
|
return memcheck(p, tal_count(p));
|
|
}
|
|
bool fromwire_dualopend_validate_lease_reply(const tal_t *ctx, const void *p, wirestring **err_msg)
|
|
{
|
|
const u8 *cursor = p;
|
|
size_t plen = tal_count(p);
|
|
|
|
if (fromwire_u16(&cursor, &plen) != WIRE_DUALOPEND_VALIDATE_LEASE_REPLY)
|
|
return false;
|
|
if (!fromwire_bool(&cursor, &plen))
|
|
*err_msg = NULL;
|
|
else {
|
|
*err_msg = fromwire_wirestring(ctx, &cursor, &plen);
|
|
}
|
|
return cursor != NULL;
|
|
}
|
|
// SHA256STAMP:893f2d8e99ee42b814c293ee5fc24c6234b4198c87eaa9ec55e83c8085b5045f
|