mirror of
https://github.com/ElementsProject/lightning.git
synced 2025-01-18 21:35:11 +01:00
peer: rename closing_onchain to onchain.
The "closing" is implied. Plus, it's too long. Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
This commit is contained in:
Rusty Russell
parent
e19d5751fe
commit
ab38fd7542
205
daemon/peer.c
205
daemon/peer.c
@ -1165,20 +1165,20 @@ static void state_event(struct peer *peer,
|
||||
}
|
||||
}
|
||||
|
||||
/* Create a HTLC fulfill transaction for closing_onchain.tx[out_num]. */
|
||||
/* Create a HTLC fulfill transaction for onchain.tx[out_num]. */
|
||||
static const struct bitcoin_tx *htlc_fulfill_tx(const struct peer *peer,
|
||||
unsigned int out_num)
|
||||
{
|
||||
struct bitcoin_tx *tx = bitcoin_tx(peer, 1, 1);
|
||||
const struct htlc *htlc = peer->closing_onchain.htlcs[out_num];
|
||||
const u8 *wscript = peer->closing_onchain.wscripts[out_num];
|
||||
const struct htlc *htlc = peer->onchain.htlcs[out_num];
|
||||
const u8 *wscript = peer->onchain.wscripts[out_num];
|
||||
struct bitcoin_signature sig;
|
||||
u64 fee, satoshis;
|
||||
|
||||
assert(htlc->r);
|
||||
|
||||
tx->input[0].index = out_num;
|
||||
tx->input[0].txid = peer->closing_onchain.txid;
|
||||
tx->input[0].txid = peer->onchain.txid;
|
||||
satoshis = htlc->msatoshis / 1000;
|
||||
tx->input[0].amount = tal_dup(tx->input, u64, &satoshis);
|
||||
tx->input[0].sequence_number = bitcoin_nsequence(&peer->remote.locktime);
|
||||
@ -1253,14 +1253,14 @@ static bool fulfill_onchain(struct peer *peer, struct htlc *htlc)
|
||||
{
|
||||
size_t i;
|
||||
|
||||
for (i = 0; i < tal_count(peer->closing_onchain.htlcs); i++) {
|
||||
if (peer->closing_onchain.htlcs[i] == htlc) {
|
||||
for (i = 0; i < tal_count(peer->onchain.htlcs); i++) {
|
||||
if (peer->onchain.htlcs[i] == htlc) {
|
||||
/* Already irrevocably resolved? */
|
||||
if (peer->closing_onchain.resolved[i])
|
||||
if (peer->onchain.resolved[i])
|
||||
return false;
|
||||
peer->closing_onchain.resolved[i]
|
||||
peer->onchain.resolved[i]
|
||||
= htlc_fulfill_tx(peer, i);
|
||||
broadcast_tx(peer, peer->closing_onchain.resolved[i]);
|
||||
broadcast_tx(peer, peer->onchain.resolved[i]);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@ -1614,10 +1614,10 @@ static struct peer *new_peer(struct lightningd_state *dstate,
|
||||
peer->closing.their_sig = NULL;
|
||||
peer->closing.our_script = NULL;
|
||||
peer->closing.their_script = NULL;
|
||||
peer->closing_onchain.tx = NULL;
|
||||
peer->closing_onchain.resolved = NULL;
|
||||
peer->closing_onchain.htlcs = NULL;
|
||||
peer->closing_onchain.wscripts = NULL;
|
||||
peer->onchain.tx = NULL;
|
||||
peer->onchain.resolved = NULL;
|
||||
peer->onchain.htlcs = NULL;
|
||||
peer->onchain.wscripts = NULL;
|
||||
peer->commit_timer = NULL;
|
||||
peer->nc = NULL;
|
||||
peer->their_prev_revocation_hash = NULL;
|
||||
@ -2057,7 +2057,7 @@ static bool outputscript_eq(const struct bitcoin_tx_output *out,
|
||||
}
|
||||
|
||||
/* This tx is their commitment;
|
||||
* fill in closing_onchain.htlcs[], wscripts[], to_us_idx and to_them_idx */
|
||||
* fill in onchain.htlcs[], wscripts[], to_us_idx and to_them_idx */
|
||||
static bool map_onchain_outputs(struct peer *peer,
|
||||
const struct sha256 *rhash,
|
||||
const struct bitcoin_tx *tx,
|
||||
@ -2068,11 +2068,9 @@ static bool map_onchain_outputs(struct peer *peer,
|
||||
struct htlc_output_map *hmap;
|
||||
size_t i;
|
||||
|
||||
peer->closing_onchain.to_us_idx = peer->closing_onchain.to_them_idx = -1;
|
||||
peer->closing_onchain.htlcs
|
||||
= tal_arr(tx, struct htlc *, tx->output_count);
|
||||
peer->closing_onchain.wscripts
|
||||
= tal_arr(tx, const u8 *, tx->output_count);
|
||||
peer->onchain.to_us_idx = peer->onchain.to_them_idx = -1;
|
||||
peer->onchain.htlcs = tal_arr(tx, struct htlc *, tx->output_count);
|
||||
peer->onchain.wscripts = tal_arr(tx, const u8 *, tx->output_count);
|
||||
|
||||
to_us = commit_output_to_us(tx, peer, rhash, side, &to_us_wscript);
|
||||
to_them = commit_output_to_them(tx, peer, rhash, side,
|
||||
@ -2083,37 +2081,34 @@ static bool map_onchain_outputs(struct peer *peer,
|
||||
|
||||
for (i = 0; i < tx->output_count; i++) {
|
||||
log_debug(peer->log, "%s: output %zi", __func__, i);
|
||||
if (peer->closing_onchain.to_us_idx == -1
|
||||
if (peer->onchain.to_us_idx == -1
|
||||
&& outputscript_eq(tx->output, i, to_us)) {
|
||||
log_add(peer->log, " -> to us");
|
||||
peer->closing_onchain.htlcs[i] = NULL;
|
||||
peer->closing_onchain.wscripts[i] = to_us_wscript;
|
||||
peer->closing_onchain.to_us_idx = i;
|
||||
peer->onchain.htlcs[i] = NULL;
|
||||
peer->onchain.wscripts[i] = to_us_wscript;
|
||||
peer->onchain.to_us_idx = i;
|
||||
continue;
|
||||
}
|
||||
if (peer->closing_onchain.to_them_idx == -1
|
||||
if (peer->onchain.to_them_idx == -1
|
||||
&& outputscript_eq(tx->output, i, to_them)) {
|
||||
log_add(peer->log, " -> to them");
|
||||
peer->closing_onchain.htlcs[i] = NULL;
|
||||
peer->closing_onchain.wscripts[i] = to_them_wscript;
|
||||
peer->closing_onchain.to_them_idx = i;
|
||||
peer->onchain.htlcs[i] = NULL;
|
||||
peer->onchain.wscripts[i] = to_them_wscript;
|
||||
peer->onchain.to_them_idx = i;
|
||||
continue;
|
||||
}
|
||||
/* Must be an HTLC output */
|
||||
peer->closing_onchain.htlcs[i] = txout_get_htlc(hmap,
|
||||
peer->onchain.htlcs[i] = txout_get_htlc(hmap,
|
||||
tx->output[i].script,
|
||||
tx->output[i].script_length,
|
||||
peer->closing_onchain.wscripts+i);
|
||||
if (!peer->closing_onchain.htlcs[i]) {
|
||||
peer->onchain.wscripts+i);
|
||||
if (!peer->onchain.htlcs[i]) {
|
||||
log_add(peer->log, "no HTLC found");
|
||||
goto fail;
|
||||
}
|
||||
tal_steal(peer->closing_onchain.htlcs,
|
||||
peer->closing_onchain.htlcs[i]);
|
||||
tal_steal(peer->closing_onchain.wscripts,
|
||||
peer->closing_onchain.wscripts[i]);
|
||||
log_add(peer->log, "HTLC %"PRIu64,
|
||||
peer->closing_onchain.htlcs[i]->id);
|
||||
tal_steal(peer->onchain.htlcs, peer->onchain.htlcs[i]);
|
||||
tal_steal(peer->onchain.wscripts, peer->onchain.wscripts[i]);
|
||||
log_add(peer->log, "HTLC %"PRIu64, peer->onchain.htlcs[i]->id);
|
||||
}
|
||||
tal_free(hmap);
|
||||
return true;
|
||||
@ -2153,12 +2148,12 @@ static bool is_mutual_close(const struct peer *peer,
|
||||
return false;
|
||||
}
|
||||
|
||||
/* Create a HTLC refund collection for closing_onchain.tx output out_num. */
|
||||
/* Create a HTLC refund collection for onchain.tx output out_num. */
|
||||
static const struct bitcoin_tx *htlc_timeout_tx(const struct peer *peer,
|
||||
unsigned int out_num)
|
||||
{
|
||||
const struct htlc *htlc = peer->closing_onchain.htlcs[out_num];
|
||||
const u8 *wscript = peer->closing_onchain.wscripts[out_num];
|
||||
const struct htlc *htlc = peer->onchain.htlcs[out_num];
|
||||
const u8 *wscript = peer->onchain.wscripts[out_num];
|
||||
struct bitcoin_tx *tx = bitcoin_tx(peer, 1, 1);
|
||||
struct bitcoin_signature sig;
|
||||
u64 fee, satoshis;
|
||||
@ -2166,7 +2161,7 @@ static const struct bitcoin_tx *htlc_timeout_tx(const struct peer *peer,
|
||||
/* We must set locktime so HTLC expiry can OP_CHECKLOCKTIMEVERIFY */
|
||||
tx->lock_time = htlc->expiry.locktime;
|
||||
tx->input[0].index = out_num;
|
||||
tx->input[0].txid = peer->closing_onchain.txid;
|
||||
tx->input[0].txid = peer->onchain.txid;
|
||||
satoshis = htlc->msatoshis / 1000;
|
||||
tx->input[0].amount = tal_dup(tx->input, u64, &satoshis);
|
||||
tx->input[0].sequence_number = bitcoin_nsequence(&peer->remote.locktime);
|
||||
@ -2211,13 +2206,13 @@ static const struct bitcoin_tx *htlc_timeout_tx(const struct peer *peer,
|
||||
|
||||
static void reset_onchain_closing(struct peer *peer)
|
||||
{
|
||||
if (peer->closing_onchain.tx) {
|
||||
if (peer->onchain.tx) {
|
||||
/* FIXME: Log old txid */
|
||||
log_unusual(peer->log, "New anchor spend, forgetting old");
|
||||
peer->closing_onchain.tx = tal_free(peer->closing_onchain.tx);
|
||||
peer->closing_onchain.resolved = NULL;
|
||||
peer->closing_onchain.htlcs = NULL;
|
||||
peer->closing_onchain.wscripts = NULL;
|
||||
peer->onchain.tx = tal_free(peer->onchain.tx);
|
||||
peer->onchain.resolved = NULL;
|
||||
peer->onchain.htlcs = NULL;
|
||||
peer->onchain.wscripts = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
@ -2225,7 +2220,7 @@ static const struct bitcoin_tx *irrevocably_resolved(struct peer *peer)
|
||||
{
|
||||
/* We can't all be irrevocably resolved until the commit tx is,
|
||||
* so just mark that as resolving us. */
|
||||
return peer->closing_onchain.tx;
|
||||
return peer->onchain.tx;
|
||||
}
|
||||
|
||||
/* We've spent an HTLC output to get our funds back. There's still a
|
||||
@ -2255,7 +2250,7 @@ static enum watch_result our_htlc_depth(struct peer *peer,
|
||||
enum htlc_side whose_commit,
|
||||
unsigned int out_num)
|
||||
{
|
||||
struct htlc *h = peer->closing_onchain.htlcs[out_num];
|
||||
struct htlc *h = peer->onchain.htlcs[out_num];
|
||||
u32 height;
|
||||
|
||||
/* Must be in a block. */
|
||||
@ -2286,14 +2281,13 @@ static enum watch_result our_htlc_depth(struct peer *peer,
|
||||
* MUST *resolve* the output by spending it.
|
||||
*/
|
||||
/* FIXME: we should simply delete this watch if HTLC is fulfilled. */
|
||||
if (!peer->closing_onchain.resolved[out_num]) {
|
||||
peer->closing_onchain.resolved[out_num]
|
||||
= htlc_timeout_tx(peer, out_num);
|
||||
watch_tx(peer->closing_onchain.resolved[out_num],
|
||||
if (!peer->onchain.resolved[out_num]) {
|
||||
peer->onchain.resolved[out_num] = htlc_timeout_tx(peer, out_num);
|
||||
watch_tx(peer->onchain.resolved[out_num],
|
||||
peer,
|
||||
peer->closing_onchain.resolved[out_num],
|
||||
peer->onchain.resolved[out_num],
|
||||
our_htlc_timeout_depth, h);
|
||||
broadcast_tx(peer, peer->closing_onchain.resolved[out_num]);
|
||||
broadcast_tx(peer, peer->onchain.resolved[out_num]);
|
||||
}
|
||||
return DELETE_WATCH;
|
||||
}
|
||||
@ -2320,7 +2314,7 @@ static enum watch_result their_htlc_depth(struct peer *peer,
|
||||
ptrint_t *out_num)
|
||||
{
|
||||
u32 height;
|
||||
const struct htlc *htlc = peer->closing_onchain.htlcs[ptr2int(out_num)];
|
||||
const struct htlc *htlc = peer->onchain.htlcs[ptr2int(out_num)];
|
||||
|
||||
/* Must be in a block. */
|
||||
if (depth == 0)
|
||||
@ -2336,8 +2330,7 @@ static enum watch_result their_htlc_depth(struct peer *peer,
|
||||
if (height < abs_locktime_to_blocks(&htlc->expiry))
|
||||
return KEEP_WATCHING;
|
||||
|
||||
peer->closing_onchain.resolved[ptr2int(out_num)]
|
||||
= irrevocably_resolved(peer);
|
||||
peer->onchain.resolved[ptr2int(out_num)] = irrevocably_resolved(peer);
|
||||
return DELETE_WATCH;
|
||||
}
|
||||
|
||||
@ -2350,7 +2343,7 @@ static enum watch_result our_main_output_depth(struct peer *peer,
|
||||
if (depth < rel_locktime_to_blocks(&peer->remote.locktime))
|
||||
return KEEP_WATCHING;
|
||||
|
||||
assert(peer->closing_onchain.to_us_idx != -1);
|
||||
assert(peer->onchain.to_us_idx != -1);
|
||||
|
||||
/* BOLT #onchain:
|
||||
*
|
||||
@ -2361,9 +2354,9 @@ static enum watch_result our_main_output_depth(struct peer *peer,
|
||||
* recommended), the output is *resolved* by the spending
|
||||
* transaction
|
||||
*/
|
||||
peer->closing_onchain.resolved[peer->closing_onchain.to_us_idx]
|
||||
peer->onchain.resolved[peer->onchain.to_us_idx]
|
||||
= bitcoin_spend_ours(peer);
|
||||
broadcast_tx(peer, peer->closing_onchain.resolved[peer->closing_onchain.to_us_idx]);
|
||||
broadcast_tx(peer, peer->onchain.resolved[peer->onchain.to_us_idx]);
|
||||
return DELETE_WATCH;
|
||||
}
|
||||
|
||||
@ -2443,7 +2436,7 @@ static enum watch_result our_htlc_spent(struct peer *peer,
|
||||
* the redemption transaction itself once we've extracted the
|
||||
* preimage; the knowledge is not revocable.
|
||||
*/
|
||||
peer->closing_onchain.resolved[tx->input[input_num].index]
|
||||
peer->onchain.resolved[tx->input[input_num].index]
|
||||
= irrevocably_resolved(peer);
|
||||
return DELETE_WATCH;
|
||||
}
|
||||
@ -2462,12 +2455,10 @@ static void resolve_our_htlc(struct peer *peer,
|
||||
* (the node pays back to itself) or redemption transaction (the other
|
||||
* node provides the redemption preimage).
|
||||
*/
|
||||
watch_txo(peer->closing_onchain.tx,
|
||||
peer, &peer->closing_onchain.txid, out_num,
|
||||
our_htlc_spent,
|
||||
peer->closing_onchain.htlcs[out_num]);
|
||||
watch_txid(peer->closing_onchain.tx, peer,
|
||||
&peer->closing_onchain.txid, cb, int2ptr(out_num));
|
||||
watch_txo(peer->onchain.tx, peer, &peer->onchain.txid, out_num,
|
||||
our_htlc_spent, peer->onchain.htlcs[out_num]);
|
||||
watch_txid(peer->onchain.tx, peer,
|
||||
&peer->onchain.txid, cb, int2ptr(out_num));
|
||||
}
|
||||
|
||||
static void resolve_their_htlc(struct peer *peer, unsigned int out_num)
|
||||
@ -2478,18 +2469,16 @@ static void resolve_their_htlc(struct peer *peer, unsigned int out_num)
|
||||
* unresolved *commitment tx* output it was offered, it MUST *resolve*
|
||||
* the output by spending it using the preimage.
|
||||
*/
|
||||
if (peer->closing_onchain.htlcs[out_num]->r) {
|
||||
peer->closing_onchain.resolved[out_num]
|
||||
= htlc_fulfill_tx(peer, out_num);
|
||||
broadcast_tx(peer, peer->closing_onchain.resolved[out_num]);
|
||||
if (peer->onchain.htlcs[out_num]->r) {
|
||||
peer->onchain.resolved[out_num] = htlc_fulfill_tx(peer, out_num);
|
||||
broadcast_tx(peer, peer->onchain.resolved[out_num]);
|
||||
} else {
|
||||
/* BOLT #onchain:
|
||||
*
|
||||
* Otherwise, if the output HTLC has expired, it is considered
|
||||
* *irrevocably resolved*.
|
||||
*/
|
||||
watch_tx(peer->closing_onchain.tx, peer,
|
||||
peer->closing_onchain.tx,
|
||||
watch_tx(peer->onchain.tx, peer, peer->onchain.tx,
|
||||
their_htlc_depth, int2ptr(out_num));
|
||||
}
|
||||
}
|
||||
@ -2501,7 +2490,7 @@ static void resolve_their_htlc(struct peer *peer, unsigned int out_num)
|
||||
static void resolve_our_unilateral(struct peer *peer)
|
||||
{
|
||||
unsigned int i;
|
||||
const struct bitcoin_tx *tx = peer->closing_onchain.tx;
|
||||
const struct bitcoin_tx *tx = peer->onchain.tx;
|
||||
|
||||
/* This only works because we always watch for a long time before
|
||||
* freeing peer, by which time this has resolved. We could create
|
||||
@ -2517,7 +2506,7 @@ static void resolve_our_unilateral(struct peer *peer)
|
||||
* by the other node's `open_channel` `delay` field) before
|
||||
* spending the output.
|
||||
*/
|
||||
if (i == peer->closing_onchain.to_us_idx)
|
||||
if (i == peer->onchain.to_us_idx)
|
||||
watch_tx(tx, peer, tx, our_main_output_depth, NULL);
|
||||
|
||||
/* BOLT #onchain:
|
||||
@ -2525,15 +2514,15 @@ static void resolve_our_unilateral(struct peer *peer)
|
||||
* 2. _B's main output_: No action required, this output is
|
||||
* considered *resolved* by the *commitment tx*.
|
||||
*/
|
||||
else if (i == peer->closing_onchain.to_them_idx)
|
||||
peer->closing_onchain.resolved[i] = tx;
|
||||
else if (i == peer->onchain.to_them_idx)
|
||||
peer->onchain.resolved[i] = tx;
|
||||
|
||||
/* BOLT #onchain:
|
||||
*
|
||||
* 3. _A's offered HTLCs_: See On-chain HTLC Handling: Our
|
||||
* Offers below.
|
||||
*/
|
||||
else if (htlc_owner(peer->closing_onchain.htlcs[i]) == LOCAL)
|
||||
else if (htlc_owner(peer->onchain.htlcs[i]) == LOCAL)
|
||||
resolve_our_htlc(peer, i, our_htlc_depth_ourcommit);
|
||||
|
||||
/* BOLT #onchain:
|
||||
@ -2553,7 +2542,7 @@ static void resolve_our_unilateral(struct peer *peer)
|
||||
static void resolve_their_unilateral(struct peer *peer)
|
||||
{
|
||||
unsigned int i;
|
||||
const struct bitcoin_tx *tx = peer->closing_onchain.tx;
|
||||
const struct bitcoin_tx *tx = peer->onchain.tx;
|
||||
|
||||
for (i = 0; i < tx->output_count; i++) {
|
||||
/* BOLT #onchain:
|
||||
@ -2562,21 +2551,21 @@ static void resolve_their_unilateral(struct peer *peer)
|
||||
* simple P2WPKH output. This output is considered
|
||||
* *resolved* by the *commitment tx*.
|
||||
*/
|
||||
if (i == peer->closing_onchain.to_us_idx)
|
||||
peer->closing_onchain.resolved[i] = tx;
|
||||
if (i == peer->onchain.to_us_idx)
|
||||
peer->onchain.resolved[i] = tx;
|
||||
/* BOLT #onchain:
|
||||
*
|
||||
* 2. _B's main output_: No action required, this output is
|
||||
* considered *resolved* by the *commitment tx*.
|
||||
*/
|
||||
else if (i == peer->closing_onchain.to_them_idx)
|
||||
peer->closing_onchain.resolved[i] = tx;
|
||||
else if (i == peer->onchain.to_them_idx)
|
||||
peer->onchain.resolved[i] = tx;
|
||||
/* BOLT #onchain:
|
||||
*
|
||||
* 3. _A's offered HTLCs_: See On-chain HTLC Handling: Our
|
||||
* Offers below.
|
||||
*/
|
||||
else if (htlc_owner(peer->closing_onchain.htlcs[i]) == LOCAL)
|
||||
else if (htlc_owner(peer->onchain.htlcs[i]) == LOCAL)
|
||||
resolve_our_htlc(peer, i, our_htlc_depth_theircommit);
|
||||
/*
|
||||
* 4. _B's offered HTLCs_: See On-chain HTLC Handling: Their
|
||||
@ -2597,13 +2586,13 @@ static void resolve_mutual_close(struct peer *peer)
|
||||
* the output, which is sent to its specified scriptpubkey (see BOLT
|
||||
* #2 "4.1: Closing initiation: close_clearing").
|
||||
*/
|
||||
for (i = 0; i < peer->closing_onchain.tx->output_count; i++)
|
||||
peer->closing_onchain.resolved[i] = irrevocably_resolved(peer);
|
||||
for (i = 0; i < peer->onchain.tx->output_count; i++)
|
||||
peer->onchain.resolved[i] = irrevocably_resolved(peer);
|
||||
|
||||
/* No HTLCs. */
|
||||
peer->closing_onchain.htlcs = tal_arrz(peer->closing_onchain.tx,
|
||||
struct htlc *,
|
||||
peer->closing_onchain.tx->output_count);
|
||||
peer->onchain.htlcs = tal_arrz(peer->onchain.tx,
|
||||
struct htlc *,
|
||||
peer->onchain.tx->output_count);
|
||||
}
|
||||
|
||||
/* Called every time the tx spending the funding tx changes depth. */
|
||||
@ -2612,7 +2601,7 @@ static enum watch_result check_for_resolution(struct peer *peer,
|
||||
const struct sha256_double *txid,
|
||||
void *unused)
|
||||
{
|
||||
size_t i, n = tal_count(peer->closing_onchain.resolved);
|
||||
size_t i, n = tal_count(peer->onchain.resolved);
|
||||
size_t forever = peer->dstate->config.forever_confirms;
|
||||
|
||||
/* BOLT #onchain:
|
||||
@ -2622,7 +2611,7 @@ static enum watch_result check_for_resolution(struct peer *peer,
|
||||
* reorganizations.
|
||||
*/
|
||||
for (i = 0; i < n; i++)
|
||||
if (!peer->closing_onchain.resolved[i])
|
||||
if (!peer->onchain.resolved[i])
|
||||
return KEEP_WATCHING;
|
||||
|
||||
/* BOLT #onchain:
|
||||
@ -2637,7 +2626,7 @@ static enum watch_result check_for_resolution(struct peer *peer,
|
||||
for (i = 0; i < n; i++) {
|
||||
struct sha256_double txid;
|
||||
|
||||
bitcoin_txid(peer->closing_onchain.resolved[i], &txid);
|
||||
bitcoin_txid(peer->onchain.resolved[i], &txid);
|
||||
if (get_tx_depth(peer->dstate, &txid) < forever)
|
||||
return KEEP_WATCHING;
|
||||
}
|
||||
@ -2681,13 +2670,13 @@ static void resolve_their_steal(struct peer *peer,
|
||||
const struct sha256 *revocation_preimage)
|
||||
{
|
||||
int i, n;
|
||||
const struct bitcoin_tx *tx = peer->closing_onchain.tx;
|
||||
const struct bitcoin_tx *tx = peer->onchain.tx;
|
||||
struct bitcoin_tx *steal_tx;
|
||||
size_t wsize = 0;
|
||||
u64 input_total = 0, fee;
|
||||
|
||||
/* Create steal_tx: don't need to steal to_us output */
|
||||
if (peer->closing_onchain.to_us_idx == -1)
|
||||
if (peer->onchain.to_us_idx == -1)
|
||||
steal_tx = bitcoin_tx(tx, tx->output_count, 1);
|
||||
else
|
||||
steal_tx = bitcoin_tx(tx, tx->output_count - 1, 1);
|
||||
@ -2700,9 +2689,9 @@ static void resolve_their_steal(struct peer *peer,
|
||||
* simple P2WPKH output. This output is considered
|
||||
* *resolved* by the *commitment tx*.
|
||||
*/
|
||||
if (i == peer->closing_onchain.to_us_idx) {
|
||||
if (i == peer->onchain.to_us_idx) {
|
||||
log_debug(peer->log, "%i is to-us, ignoring", i);
|
||||
peer->closing_onchain.resolved[i] = tx;
|
||||
peer->onchain.resolved[i] = tx;
|
||||
continue;
|
||||
}
|
||||
|
||||
@ -2717,15 +2706,15 @@ static void resolve_their_steal(struct peer *peer,
|
||||
* 4. _B's offered HTLCs_: The node MUST *resolve* this by
|
||||
* spending using the revocation preimage.
|
||||
*/
|
||||
peer->closing_onchain.resolved[i] = steal_tx;
|
||||
peer->onchain.resolved[i] = steal_tx;
|
||||
|
||||
/* Connect it up. */
|
||||
steal_tx->input[n].txid = peer->closing_onchain.txid;
|
||||
steal_tx->input[n].txid = peer->onchain.txid;
|
||||
steal_tx->input[n].index = i;
|
||||
steal_tx->input[n].amount = tal_dup(steal_tx, u64,
|
||||
&tx->output[i].amount);
|
||||
/* Track witness size, for fee. */
|
||||
wsize += tal_count(peer->closing_onchain.wscripts[n]);
|
||||
wsize += tal_count(peer->onchain.wscripts[n]);
|
||||
input_total += tx->output[i].amount;
|
||||
n++;
|
||||
}
|
||||
@ -2739,8 +2728,8 @@ static void resolve_their_steal(struct peer *peer,
|
||||
log_unusual(peer->log, "Not worth stealing tiny amount %"PRIu64,
|
||||
input_total);
|
||||
/* Consider them all resolved by steal tx. */
|
||||
for (i = 0; i < tal_count(peer->closing_onchain.resolved); i++)
|
||||
peer->closing_onchain.resolved[i] = tx;
|
||||
for (i = 0; i < tal_count(peer->onchain.resolved); i++)
|
||||
peer->onchain.resolved[i] = tx;
|
||||
tal_free(steal_tx);
|
||||
return;
|
||||
}
|
||||
@ -2757,7 +2746,7 @@ static void resolve_their_steal(struct peer *peer,
|
||||
|
||||
sig.stype = SIGHASH_ALL;
|
||||
peer_sign_steal_input(peer, steal_tx, i,
|
||||
peer->closing_onchain.wscripts[i],
|
||||
peer->onchain.wscripts[i],
|
||||
&sig.sig);
|
||||
|
||||
steal_tx->input[i].witness
|
||||
@ -2766,7 +2755,7 @@ static void resolve_their_steal(struct peer *peer,
|
||||
revocation_preimage,
|
||||
sizeof(*revocation_preimage),
|
||||
&sig,
|
||||
peer->closing_onchain.wscripts[i]);
|
||||
peer->onchain.wscripts[i]);
|
||||
}
|
||||
|
||||
broadcast_tx(peer, steal_tx);
|
||||
@ -2821,8 +2810,8 @@ static enum watch_result anchor_spent(struct peer *peer,
|
||||
/* We may have been following a different spend. Forget it. */
|
||||
reset_onchain_closing(peer);
|
||||
|
||||
peer->closing_onchain.tx = tal_steal(peer, tx);
|
||||
bitcoin_txid(tx, &peer->closing_onchain.txid);
|
||||
peer->onchain.tx = tal_steal(peer, tx);
|
||||
bitcoin_txid(tx, &peer->onchain.txid);
|
||||
|
||||
/* If we have any HTLCs we're not committed to yet, fail them now. */
|
||||
for (h = htlc_map_first(&peer->htlcs, &it);
|
||||
@ -2834,7 +2823,7 @@ static enum watch_result anchor_spent(struct peer *peer,
|
||||
}
|
||||
|
||||
/* We need to resolve every output. */
|
||||
peer->closing_onchain.resolved
|
||||
peer->onchain.resolved
|
||||
= tal_arrz(tx, const struct bitcoin_tx *, tx->output_count);
|
||||
|
||||
/* A mutual close tx. */
|
||||
@ -2844,7 +2833,7 @@ static enum watch_result anchor_spent(struct peer *peer,
|
||||
resolve_mutual_close(peer);
|
||||
/* Our unilateral */
|
||||
} else if (structeq(&peer->local.commit->txid,
|
||||
&peer->closing_onchain.txid)) {
|
||||
&peer->onchain.txid)) {
|
||||
newstate = STATE_CLOSE_ONCHAIN_OUR_UNILATERAL;
|
||||
/* We're almost certainly closed to them by now. */
|
||||
err = pkt_err(peer, "Our own unilateral close tx seen");
|
||||
@ -2859,7 +2848,7 @@ static enum watch_result anchor_spent(struct peer *peer,
|
||||
}
|
||||
resolve_our_unilateral(peer);
|
||||
/* Must be their unilateral */
|
||||
} else if (find_their_old_tx(peer, &peer->closing_onchain.txid,
|
||||
} else if (find_their_old_tx(peer, &peer->onchain.txid,
|
||||
&commit_num)) {
|
||||
struct sha256 *preimage, rhash;
|
||||
|
||||
@ -2906,7 +2895,7 @@ static enum watch_result anchor_spent(struct peer *peer,
|
||||
*/
|
||||
assert(!state_can_io(peer->state));
|
||||
|
||||
assert(peer->closing_onchain.resolved != NULL);
|
||||
assert(peer->onchain.resolved != NULL);
|
||||
watch_tx(tx, peer, tx, check_for_resolution, NULL);
|
||||
|
||||
return KEEP_WATCHING;
|
||||
|
||||
@ -170,7 +170,7 @@ struct peer {
|
||||
const u8 **wscripts;
|
||||
/* The tx which resolves each txout. */
|
||||
const struct bitcoin_tx **resolved;
|
||||
} closing_onchain;
|
||||
} onchain;
|
||||
|
||||
/* All HTLCs. */
|
||||
struct htlc_map htlcs;
|
||||
|
||||
Loading…
Reference in New Issue
Block a user