mirrors/core-lightning
1
0
Fork 0
mirror of https://github.com/ElementsProject/lightning.git synced 2025-01-18 05:12:45 +01:00
Code Issues Projects Releases Wiki Activity

daemon: use "local" and "remote" instead of "us" and "them".

Browse Source 
This is the language used in BOLT#2; be consistent.

Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
This commit is contained in:
Rusty Russell 2016-05-26 15:25:24 +09:30
parent b66d3e263a
commit 84f5a82eea
4 changed files with 230 additions and 230 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

212
daemon/packets.c
View File

@ -97,29 +97,29 @@ void queue_pkt_open(struct peer *peer, OpenChannel__AnchorOffer anchor)
/* Set up out commit info now: rest gets done in setup_first_commit
* once anchor is established. */
peer->us.commit = talz(peer, struct commit_info);
peer->us.commit->revocation_hash = peer->us.next_revocation_hash;
peer_get_revocation_hash(peer, 1, &peer->us.next_revocation_hash);
peer->local.commit = talz(peer, struct commit_info);
peer->local.commit->revocation_hash = peer->local.next_revocation_hash;
peer_get_revocation_hash(peer, 1, &peer->local.next_revocation_hash);
open_channel__init(o);
o->revocation_hash = sha256_to_proto(o, &peer->us.commit->revocation_hash);
o->next_revocation_hash = sha256_to_proto(o, &peer->us.next_revocation_hash);
o->commit_key = pubkey_to_proto(o, &peer->us.commitkey);
o->final_key = pubkey_to_proto(o, &peer->us.finalkey);
o->revocation_hash = sha256_to_proto(o, &peer->local.commit->revocation_hash);
o->next_revocation_hash = sha256_to_proto(o, &peer->local.next_revocation_hash);
o->commit_key = pubkey_to_proto(o, &peer->local.commitkey);
o->final_key = pubkey_to_proto(o, &peer->local.finalkey);
o->delay = tal(o, Locktime);
locktime__init(o->delay);
o->delay->locktime_case = LOCKTIME__LOCKTIME_SECONDS;
o->delay->seconds = rel_locktime_to_seconds(&peer->us.locktime);
o->initial_fee_rate = peer->us.commit_fee_rate;
o->delay->seconds = rel_locktime_to_seconds(&peer->local.locktime);
o->initial_fee_rate = peer->local.commit_fee_rate;
if (anchor == OPEN_CHANNEL__ANCHOR_OFFER__WILL_CREATE_ANCHOR)
assert(peer->us.offer_anchor == CMD_OPEN_WITH_ANCHOR);
assert(peer->local.offer_anchor == CMD_OPEN_WITH_ANCHOR);
else {
assert(anchor == OPEN_CHANNEL__ANCHOR_OFFER__WONT_CREATE_ANCHOR);
assert(peer->us.offer_anchor == CMD_OPEN_WITHOUT_ANCHOR);
assert(peer->local.offer_anchor == CMD_OPEN_WITHOUT_ANCHOR);
}
o->anch = anchor;
o->min_depth = peer->us.mindepth;
o->min_depth = peer->local.mindepth;
queue_pkt(peer, PKT__PKT_OPEN, o);
}
@ -141,12 +141,12 @@ void queue_pkt_anchor(struct peer *peer)
}
/* Sign their commit sig */
peer->them.commit->sig = tal(peer->them.commit,
peer->remote.commit->sig = tal(peer->remote.commit,
struct bitcoin_signature);
peer->them.commit->sig->stype = SIGHASH_ALL;
peer_sign_theircommit(peer, peer->them.commit->tx,
&peer->them.commit->sig->sig);
a->commit_sig = signature_to_proto(a, &peer->them.commit->sig->sig);
peer->remote.commit->sig->stype = SIGHASH_ALL;
peer_sign_theircommit(peer, peer->remote.commit->tx,
&peer->remote.commit->sig->sig);
a->commit_sig = signature_to_proto(a, &peer->remote.commit->sig->sig);
queue_pkt(peer, PKT__PKT_OPEN_ANCHOR, a);
}
@ -157,15 +157,15 @@ void queue_pkt_open_commit_sig(struct peer *peer)
open_commit_sig__init(s);
dump_tx("Creating sig for:", peer->them.commit->tx);
dump_key("Using key:", &peer->us.commitkey);
dump_tx("Creating sig for:", peer->remote.commit->tx);
dump_key("Using key:", &peer->local.commitkey);
peer->them.commit->sig = tal(peer->them.commit,
peer->remote.commit->sig = tal(peer->remote.commit,
struct bitcoin_signature);
peer->them.commit->sig->stype = SIGHASH_ALL;
peer_sign_theircommit(peer, peer->them.commit->tx,
&peer->them.commit->sig->sig);
s->sig = signature_to_proto(s, &peer->them.commit->sig->sig);
peer->remote.commit->sig->stype = SIGHASH_ALL;
peer_sign_theircommit(peer, peer->remote.commit->tx,
&peer->remote.commit->sig->sig);
s->sig = signature_to_proto(s, &peer->remote.commit->sig->sig);
queue_pkt(peer, PKT__PKT_OPEN_COMMIT_SIG, s);
}
@ -184,7 +184,7 @@ static void add_our_htlc_ourside(struct peer *peer, void *arg)
struct channel_htlc *htlc = arg;
/* FIXME: must add even if can't pay fee any more! */
if (!funding_a_add_htlc(peer->us.staging_cstate,
if (!funding_a_add_htlc(peer->local.staging_cstate,
htlc->msatoshis, &htlc->expiry,
&htlc->rhash, htlc->id))
fatal("FIXME: Failed to add htlc %"PRIu64" to self on ack",
@ -209,7 +209,7 @@ void queue_pkt_htlc_add(struct peer *peer,
routing__init(u->route);
/* We're about to send this, so their side will have it from now on. */
if (!funding_b_add_htlc(peer->them.staging_cstate,
if (!funding_b_add_htlc(peer->remote.staging_cstate,
htlc_prog->stage.add.htlc.msatoshis,
&htlc_prog->stage.add.htlc.expiry,
&htlc_prog->stage.add.htlc.rhash,
@ -230,8 +230,8 @@ static void fulfill_their_htlc_ourside(struct peer *peer, void *arg)
{
size_t n;
n = funding_htlc_by_id(&peer->us.staging_cstate->b, ptr2int(arg));
funding_b_fulfill_htlc(peer->us.staging_cstate, n);
n = funding_htlc_by_id(&peer->local.staging_cstate->b, ptr2int(arg));
funding_b_fulfill_htlc(peer->local.staging_cstate, n);
}
void queue_pkt_htlc_fulfill(struct peer *peer,
@ -247,8 +247,8 @@ void queue_pkt_htlc_fulfill(struct peer *peer,
f->r = sha256_to_proto(f, &htlc_prog->stage.fulfill.r);
/* We're about to send this, so their side will have it from now on. */
n = funding_htlc_by_id(&peer->them.staging_cstate->a, f->id);
funding_a_fulfill_htlc(peer->them.staging_cstate, n);
n = funding_htlc_by_id(&peer->remote.staging_cstate->a, f->id);
funding_a_fulfill_htlc(peer->remote.staging_cstate, n);
their_commit_changed(peer);
queue_pkt_with_ack(peer, PKT__PKT_UPDATE_FULFILL_HTLC, f,
@ -260,8 +260,8 @@ static void fail_their_htlc_ourside(struct peer *peer, void *arg)
{
size_t n;
n = funding_htlc_by_id(&peer->us.staging_cstate->b, ptr2int(arg));
funding_b_fail_htlc(peer->us.staging_cstate, n);
n = funding_htlc_by_id(&peer->local.staging_cstate->b, ptr2int(arg));
funding_b_fail_htlc(peer->local.staging_cstate, n);
}
void queue_pkt_htlc_fail(struct peer *peer,
@ -279,8 +279,8 @@ void queue_pkt_htlc_fail(struct peer *peer,
fail_reason__init(f->reason);
/* We're about to send this, so their side will have it from now on. */
n = funding_htlc_by_id(&peer->them.staging_cstate->a, f->id);
funding_a_fail_htlc(peer->them.staging_cstate, n);
n = funding_htlc_by_id(&peer->remote.staging_cstate->a, f->id);
funding_a_fail_htlc(peer->remote.staging_cstate, n);
their_commit_changed(peer);
queue_pkt_with_ack(peer, PKT__PKT_UPDATE_FAIL_HTLC, f,
@ -294,13 +294,13 @@ void queue_pkt_commit(struct peer *peer)
struct commit_info *ci = talz(peer, struct commit_info);
/* Create new commit info for this commit tx. */
ci->prev = peer->them.commit;
ci->revocation_hash = peer->them.next_revocation_hash;
ci->cstate = copy_funding(ci, peer->them.staging_cstate);
ci->prev = peer->remote.commit;
ci->revocation_hash = peer->remote.next_revocation_hash;
ci->cstate = copy_funding(ci, peer->remote.staging_cstate);
ci->tx = create_commit_tx(ci,
&peer->them.finalkey,
&peer->us.finalkey,
&peer->us.locktime,
&peer->remote.finalkey,
&peer->local.finalkey,
&peer->local.locktime,
&peer->anchor.txid,
peer->anchor.index,
peer->anchor.satoshis,
@ -326,7 +326,7 @@ void queue_pkt_commit(struct peer *peer)
peer_sign_theircommit(peer, ci->tx, &ci->sig->sig);
/* Switch to the new commitment. */
peer->them.commit = ci;
peer->remote.commit = ci;
peer_check_if_cleared(peer);
@ -339,7 +339,7 @@ void queue_pkt_commit(struct peer *peer)
}
/* Send a preimage for the old commit tx. The one we've just committed to is
* in peer->us.commit. */
* in peer->local.commit. */
void queue_pkt_revocation(struct peer *peer)
{
UpdateRevocation *u = tal(peer, UpdateRevocation);
@ -347,23 +347,23 @@ void queue_pkt_revocation(struct peer *peer)
update_revocation__init(u);
assert(peer->commit_tx_counter > 0);
assert(peer->us.commit);
assert(peer->us.commit->prev);
assert(!peer->us.commit->prev->revocation_preimage);
assert(peer->local.commit);
assert(peer->local.commit->prev);
assert(!peer->local.commit->prev->revocation_preimage);
/* We have their signature on the current one, right? */
assert(peer->us.commit->sig);
assert(peer->local.commit->sig);
peer->us.commit->prev->revocation_preimage
= tal(peer->us.commit->prev, struct sha256);
peer->local.commit->prev->revocation_preimage
= tal(peer->local.commit->prev, struct sha256);
peer_get_revocation_preimage(peer, peer->commit_tx_counter-1,
peer->us.commit->prev->revocation_preimage);
peer->local.commit->prev->revocation_preimage);
peer_check_if_cleared(peer);
u->revocation_preimage
= sha256_to_proto(u, peer->us.commit->prev->revocation_preimage);
= sha256_to_proto(u, peer->local.commit->prev->revocation_preimage);
u->next_revocation_hash = sha256_to_proto(u,
&peer->us.next_revocation_hash);
&peer->local.next_revocation_hash);
u->ack = peer_outgoing_ack(peer);
queue_pkt(peer, PKT__PKT_UPDATE_REVOCATION, u);
@ -393,7 +393,7 @@ void queue_pkt_close_clearing(struct peer *peer)
CloseClearing *c = tal(peer, CloseClearing);
close_clearing__init(c);
redeemscript = bitcoin_redeem_single(c, &peer->us.finalkey);
redeemscript = bitcoin_redeem_single(c, &peer->local.finalkey);
peer->closing.our_script = scriptpubkey_p2sh(peer, redeemscript);
c->scriptpubkey.data = tal_dup_arr(c, u8,
@ -446,37 +446,37 @@ Pkt *accept_pkt_open(struct peer *peer, const Pkt *pkt)
if (o->initial_fee_rate < peer->dstate->config.commitment_fee_rate_min)
return pkt_err(peer, "Commitment fee rate too low");
if (o->anch == OPEN_CHANNEL__ANCHOR_OFFER__WILL_CREATE_ANCHOR)
peer->them.offer_anchor = CMD_OPEN_WITH_ANCHOR;
peer->remote.offer_anchor = CMD_OPEN_WITH_ANCHOR;
else if (o->anch == OPEN_CHANNEL__ANCHOR_OFFER__WONT_CREATE_ANCHOR)
peer->them.offer_anchor = CMD_OPEN_WITHOUT_ANCHOR;
peer->remote.offer_anchor = CMD_OPEN_WITHOUT_ANCHOR;
else
return pkt_err(peer, "Unknown offer anchor value");
if (peer->them.offer_anchor == peer->us.offer_anchor)
if (peer->remote.offer_anchor == peer->local.offer_anchor)
return pkt_err(peer, "Only one side can offer anchor");
if (!proto_to_rel_locktime(o->delay, &peer->them.locktime))
if (!proto_to_rel_locktime(o->delay, &peer->remote.locktime))
return pkt_err(peer, "Malformed locktime");
peer->them.mindepth = o->min_depth;
peer->them.commit_fee_rate = o->initial_fee_rate;
peer->remote.mindepth = o->min_depth;
peer->remote.commit_fee_rate = o->initial_fee_rate;
if (!proto_to_pubkey(peer->dstate->secpctx,
o->commit_key, &peer->them.commitkey))
o->commit_key, &peer->remote.commitkey))
return pkt_err(peer, "Bad commitkey");
if (!proto_to_pubkey(peer->dstate->secpctx,
o->final_key, &peer->them.finalkey))
o->final_key, &peer->remote.finalkey))
return pkt_err(peer, "Bad finalkey");
/* Set up their commit info now: rest gets done in setup_first_commit
* once anchor is established. */
peer->them.commit = talz(peer, struct commit_info);
proto_to_sha256(o->revocation_hash, &peer->them.commit->revocation_hash);
peer->remote.commit = talz(peer, struct commit_info);
proto_to_sha256(o->revocation_hash, &peer->remote.commit->revocation_hash);
proto_to_sha256(o->next_revocation_hash,
&peer->them.next_revocation_hash);
&peer->remote.next_revocation_hash);
/* Witness script for anchor. */
peer->anchor.witnessscript
= bitcoin_redeem_2of2(peer, &peer->us.commitkey,
&peer->them.commitkey);
= bitcoin_redeem_2of2(peer, &peer->local.commitkey,
&peer->remote.commitkey);
return NULL;
}
@ -496,7 +496,7 @@ static Pkt *check_and_save_commit_sig(struct peer *peer,
ci->tx, 0,
NULL, 0,
peer->anchor.witnessscript,
&peer->them.commitkey,
&peer->remote.commitkey,
ci->sig))
return pkt_err(peer, "Bad signature");
@ -508,8 +508,8 @@ Pkt *accept_pkt_anchor(struct peer *peer, const Pkt *pkt)
const OpenAnchor *a = pkt->open_anchor;
/* They must be offering anchor for us to try accepting */
assert(peer->us.offer_anchor == CMD_OPEN_WITHOUT_ANCHOR);
assert(peer->them.offer_anchor == CMD_OPEN_WITH_ANCHOR);
assert(peer->local.offer_anchor == CMD_OPEN_WITHOUT_ANCHOR);
assert(peer->remote.offer_anchor == CMD_OPEN_WITH_ANCHOR);
proto_to_sha256(a->txid, &peer->anchor.txid.sha);
peer->anchor.index = a->output_index;
@ -518,14 +518,14 @@ Pkt *accept_pkt_anchor(struct peer *peer, const Pkt *pkt)
if (!setup_first_commit(peer))
return pkt_err(peer, "Insufficient funds for fee");
return check_and_save_commit_sig(peer, peer->us.commit, a->commit_sig);
return check_and_save_commit_sig(peer, peer->local.commit, a->commit_sig);
}
Pkt *accept_pkt_open_commit_sig(struct peer *peer, const Pkt *pkt)
{
const OpenCommitSig *s = pkt->open_commit_sig;
return check_and_save_commit_sig(peer, peer->us.commit, s->sig);
return check_and_save_commit_sig(peer, peer->local.commit, s->sig);
}
Pkt *accept_pkt_open_complete(struct peer *peer, const Pkt *pkt)
@ -563,8 +563,8 @@ Pkt *accept_pkt_htlc_add(struct peer *peer, const Pkt *pkt)
* A node MUST NOT add a HTLC if it would result in it
* offering more than 300 HTLCs in either commitment transaction.
*/
if (tal_count(peer->them.staging_cstate->a.htlcs) == 300
|| tal_count(peer->us.staging_cstate->b.htlcs) == 300)
if (tal_count(peer->remote.staging_cstate->a.htlcs) == 300
|| tal_count(peer->local.staging_cstate->b.htlcs) == 300)
return pkt_err(peer, "Too many HTLCs");
/* BOLT #2:
@ -572,14 +572,14 @@ Pkt *accept_pkt_htlc_add(struct peer *peer, const Pkt *pkt)
* A node MUST NOT set `id` equal to another HTLC which is in
* the current staged commitment transaction.
*/
if (funding_htlc_by_id(&peer->them.staging_cstate->a, u->id)
< tal_count(peer->them.staging_cstate->a.htlcs))
if (funding_htlc_by_id(&peer->remote.staging_cstate->a, u->id)
< tal_count(peer->remote.staging_cstate->a.htlcs))
return pkt_err(peer, "HTLC id %"PRIu64" clashes for you", u->id);
/* FIXME: Assert this... */
/* Note: these should be in sync, so this should be redundant! */
if (funding_htlc_by_id(&peer->us.staging_cstate->b, u->id)
< tal_count(peer->us.staging_cstate->b.htlcs))
if (funding_htlc_by_id(&peer->local.staging_cstate->b, u->id)
< tal_count(peer->local.staging_cstate->b.htlcs))
return pkt_err(peer, "HTLC id %"PRIu64" clashes for us", u->id);
/* BOLT #2:
@ -593,7 +593,7 @@ Pkt *accept_pkt_htlc_add(struct peer *peer, const Pkt *pkt)
/* FIXME: This is wrong! We may have already added more txs to
* them.staging_cstate, driving that fee up.
* We should check against the last version they acknowledged. */
if (!funding_a_add_htlc(peer->them.staging_cstate,
if (!funding_a_add_htlc(peer->remote.staging_cstate,
u->amount_msat, &expiry, &rhash, u->id))
return pkt_err(peer, "Cannot afford %"PRIu64" milli-satoshis"
" in your commitment tx",
@ -601,7 +601,7 @@ Pkt *accept_pkt_htlc_add(struct peer *peer, const Pkt *pkt)
/* If we fail here, we've already changed them.staging_cstate, so
* MUST terminate. */
if (!funding_b_add_htlc(peer->us.staging_cstate,
if (!funding_b_add_htlc(peer->local.staging_cstate,
u->amount_msat, &expiry, &rhash, u->id))
return pkt_err(peer, "Cannot afford %"PRIu64" milli-satoshis"
" in our commitment tx",
@ -623,19 +623,19 @@ static Pkt *find_commited_htlc(struct peer *peer, uint64_t id,
* current commitment transaction, and MUST fail the
* connection if it does not.
*/
*n_us = funding_htlc_by_id(&peer->us.commit->cstate->a, id);
if (*n_us == tal_count(peer->us.commit->cstate->a.htlcs))
*n_us = funding_htlc_by_id(&peer->local.commit->cstate->a, id);
if (*n_us == tal_count(peer->local.commit->cstate->a.htlcs))
return pkt_err(peer, "Did not find HTLC %"PRIu64, id);
/* They must not fail/fulfill twice, so it should be in staging, too. */
*n_us = funding_htlc_by_id(&peer->us.staging_cstate->a, id);
if (*n_us == tal_count(peer->us.staging_cstate->a.htlcs))
*n_us = funding_htlc_by_id(&peer->local.staging_cstate->a, id);
if (*n_us == tal_count(peer->local.staging_cstate->a.htlcs))
return pkt_err(peer, "Already removed HTLC %"PRIu64, id);
/* FIXME: Assert this... */
/* Note: these should match. */
*n_them = funding_htlc_by_id(&peer->them.staging_cstate->b, id);
if (*n_them == tal_count(peer->them.staging_cstate->b.htlcs))
*n_them = funding_htlc_by_id(&peer->remote.staging_cstate->b, id);
if (*n_them == tal_count(peer->remote.staging_cstate->b.htlcs))
return pkt_err(peer, "Did not find your HTLC %"PRIu64, id);
return NULL;
@ -653,8 +653,8 @@ Pkt *accept_pkt_htlc_fail(struct peer *peer, const Pkt *pkt)
/* FIXME: Save reason. */
funding_a_fail_htlc(peer->us.staging_cstate, n_us);
funding_b_fail_htlc(peer->them.staging_cstate, n_them);
funding_a_fail_htlc(peer->local.staging_cstate, n_us);
funding_b_fail_htlc(peer->remote.staging_cstate, n_them);
their_commit_changed(peer);
return NULL;
}
@ -674,14 +674,14 @@ Pkt *accept_pkt_htlc_fulfill(struct peer *peer, const Pkt *pkt)
proto_to_sha256(f->r, &r);
sha256(&rhash, &r, sizeof(r));
if (!structeq(&rhash, &peer->us.staging_cstate->a.htlcs[n_us].rhash))
if (!structeq(&rhash, &peer->local.staging_cstate->a.htlcs[n_us].rhash))
return pkt_err(peer, "Invalid r for %"PRIu64, f->id);
/* Same ID must have same rhash */
assert(structeq(&rhash, &peer->them.staging_cstate->b.htlcs[n_them].rhash));
assert(structeq(&rhash, &peer->remote.staging_cstate->b.htlcs[n_them].rhash));
funding_a_fulfill_htlc(peer->us.staging_cstate, n_us);
funding_b_fulfill_htlc(peer->them.staging_cstate, n_them);
funding_a_fulfill_htlc(peer->local.staging_cstate, n_us);
funding_b_fulfill_htlc(peer->remote.staging_cstate, n_them);
their_commit_changed(peer);
return NULL;
}
@ -693,13 +693,13 @@ Pkt *accept_pkt_commit(struct peer *peer, const Pkt *pkt)
struct commit_info *ci = talz(peer, struct commit_info);
/* Create new commit info for this commit tx. */
ci->prev = peer->us.commit;
ci->revocation_hash = peer->us.next_revocation_hash;
ci->cstate = copy_funding(ci, peer->us.staging_cstate);
ci->prev = peer->local.commit;
ci->revocation_hash = peer->local.next_revocation_hash;
ci->cstate = copy_funding(ci, peer->local.staging_cstate);
ci->tx = create_commit_tx(ci,
&peer->us.finalkey,
&peer->them.finalkey,
&peer->them.locktime,
&peer->local.finalkey,
&peer->remote.finalkey,
&peer->remote.locktime,
&peer->anchor.txid,
peer->anchor.index,
peer->anchor.satoshis,
@ -720,10 +720,10 @@ Pkt *accept_pkt_commit(struct peer *peer, const Pkt *pkt)
return err;
/* Switch to the new commitment. */
peer->us.commit = ci;
peer->local.commit = ci;
peer->commit_tx_counter++;
peer_get_revocation_hash(peer, peer->commit_tx_counter + 1,
&peer->us.next_revocation_hash);
&peer->local.next_revocation_hash);
peer_check_if_cleared(peer);
return NULL;
@ -744,21 +744,21 @@ Pkt *accept_pkt_revocation(struct peer *peer, const Pkt *pkt)
/* FIXME: Save preimage in shachain too. */
if (!check_preimage(r->revocation_preimage,
&peer->them.commit->prev->revocation_hash))
&peer->remote.commit->prev->revocation_hash))
return pkt_err(peer, "complete preimage incorrect");
/* They're revoking the previous one. */
assert(!peer->them.commit->prev->revocation_preimage);
peer->them.commit->prev->revocation_preimage
= tal(peer->them.commit->prev, struct sha256);
assert(!peer->remote.commit->prev->revocation_preimage);
peer->remote.commit->prev->revocation_preimage
= tal(peer->remote.commit->prev, struct sha256);
proto_to_sha256(r->revocation_preimage,
peer->them.commit->prev->revocation_preimage);
peer->remote.commit->prev->revocation_preimage);
peer_check_if_cleared(peer);
/* Save next revocation hash. */
proto_to_sha256(r->next_revocation_hash,
&peer->them.next_revocation_hash);
&peer->remote.next_revocation_hash);
return NULL;
}
@ -793,7 +793,7 @@ Pkt *accept_pkt_close_sig(struct peer *peer, const Pkt *pkt, bool *acked,
* number of satoshis.
*/
if ((c->close_fee & 1)
|| c->close_fee > commit_tx_fee(peer->them.commit->tx,
|| c->close_fee > commit_tx_fee(peer->remote.commit->tx,
peer->anchor.satoshis)) {
return pkt_err(peer, "Invalid close fee");
}
@ -829,7 +829,7 @@ Pkt *accept_pkt_close_sig(struct peer *peer, const Pkt *pkt, bool *acked,
if (!check_tx_sig(peer->dstate->secpctx, close_tx, 0,
NULL, 0,
peer->anchor.witnessscript,
&peer->them.commitkey, &theirsig))
&peer->remote.commitkey, &theirsig))
return pkt_err(peer, "Invalid signature");
tal_free(peer->closing.their_sig);

228
daemon/peer.c
View File

@ -138,7 +138,7 @@ static void peer_breakdown(struct peer *peer)
broadcast_tx(peer, bitcoin_close(peer));
/* If we have a signed commit tx (maybe not if we just offered
* anchor), use it. */
} else if (peer->us.commit->sig) {
} else if (peer->local.commit->sig) {
log_unusual(peer->log, "Peer breakdown: sending commit tx");
broadcast_tx(peer, bitcoin_commit(peer));
} else
@ -258,10 +258,10 @@ static bool committed_to_htlcs(const struct peer *peer)
const struct commit_info *i;
/* Before anchor exchange, we don't even have cstate. */
if (!peer->us.commit || !peer->us.commit->cstate)
if (!peer->local.commit || !peer->local.commit->cstate)
return false;
i = peer->us.commit;
i = peer->local.commit;
while (i && !i->revocation_preimage) {
if (tal_count(i->cstate->a.htlcs))
return true;
@ -270,7 +270,7 @@ static bool committed_to_htlcs(const struct peer *peer)
i = i->prev;
}
i = peer->them.commit;
i = peer->remote.commit;
while (i && !i->revocation_preimage) {
if (tal_count(i->cstate->a.htlcs))
return true;
@ -361,7 +361,7 @@ static struct io_plan *pkt_in(struct io_conn *conn, struct peer *peer)
static void do_anchor_offer(struct peer *peer, void *unused)
{
set_current_command(peer, peer->us.offer_anchor, NULL, NULL);
set_current_command(peer, peer->local.offer_anchor, NULL, NULL);
}
/* Crypto is on, we are live. */
@ -369,7 +369,7 @@ static struct io_plan *peer_crypto_on(struct io_conn *conn, struct peer *peer)
{
peer_secrets_init(peer);
peer_get_revocation_hash(peer, 0, &peer->us.next_revocation_hash);
peer_get_revocation_hash(peer, 0, &peer->local.next_revocation_hash);
assert(peer->state == STATE_INIT);
@ -421,11 +421,11 @@ static void peer_disconnect(struct io_conn *conn, struct peer *peer)
static void do_commit(struct peer *peer, struct command *jsoncmd)
{
/* We can have changes we suggested, or changes they suggested. */
if (peer->them.staging_cstate
&& peer->them.commit
&& peer->them.commit->cstate
&& peer->them.staging_cstate->changes
!= peer->them.commit->cstate->changes) {
if (peer->remote.staging_cstate
&& peer->remote.commit
&& peer->remote.commit->cstate
&& peer->remote.staging_cstate->changes
!= peer->remote.commit->cstate->changes) {
log_debug(peer->log, "do_commit: sending commit command");
set_current_command(peer, CMD_SEND_COMMIT, NULL, jsoncmd);
return;
@ -447,7 +447,7 @@ static void try_commit(struct peer *peer)
void their_commit_changed(struct peer *peer)
{
log_debug(peer->log, "their_commit_changed: changes=%u",
peer->them.staging_cstate->changes);
peer->remote.staging_cstate->changes);
if (!peer->commit_timer) {
log_debug(peer->log, "their_commit_changed: adding timer");
peer->commit_timer = new_reltimer(peer->dstate, peer,
@ -506,16 +506,16 @@ static struct peer *new_peer(struct lightningd_state *dstate,
peer->fake_close = false;
io_set_finish(conn, peer_disconnect, peer);
peer->us.offer_anchor = offer_anchor;
peer->local.offer_anchor = offer_anchor;
if (!seconds_to_rel_locktime(dstate->config.rel_locktime,
&peer->us.locktime))
&peer->local.locktime))
fatal("Invalid locktime configuration %u",
dstate->config.rel_locktime);
peer->us.mindepth = dstate->config.anchor_confirms;
peer->us.commit_fee_rate = dstate->config.commitment_fee_rate;
peer->local.mindepth = dstate->config.anchor_confirms;
peer->local.commit_fee_rate = dstate->config.commitment_fee_rate;
peer->us.commit = peer->them.commit = NULL;
peer->us.staging_cstate = peer->them.staging_cstate = NULL;
peer->local.commit = peer->remote.commit = NULL;
peer->local.staging_cstate = peer->remote.staging_cstate = NULL;
/* FIXME: Attach IO logging for this peer. */
tal_add_destructor(peer, destroy_peer);
@ -746,7 +746,7 @@ static void anchor_depthchange(struct peer *peer, unsigned int depth,
/* Still waiting for it to reach depth? */
if (w->depthok != INPUT_NONE) {
if (depth >= peer->us.mindepth) {
if (depth >= peer->local.mindepth) {
enum state_input in = w->depthok;
w->depthok = INPUT_NONE;
/* We don't need the timeout timer any more. */
@ -850,10 +850,10 @@ static const struct bitcoin_tx *htlc_timeout_tx(const struct peer *peer,
htlc = htlc_by_index(ci, i);
wscript = bitcoin_redeem_htlc_send(peer,
&peer->us.finalkey,
&peer->them.finalkey,
&peer->local.finalkey,
&peer->remote.finalkey,
&htlc->expiry,
&peer->them.locktime,
&peer->remote.locktime,
&ci->revocation_hash,
&htlc->rhash);
@ -863,12 +863,12 @@ static const struct bitcoin_tx *htlc_timeout_tx(const struct peer *peer,
bitcoin_txid(ci->tx, &tx->input[0].txid);
satoshis = htlc->msatoshis / 1000;
tx->input[0].amount = tal_dup(tx->input, u64, &satoshis);
tx->input[0].sequence_number = bitcoin_nsequence(&peer->them.locktime);
tx->input[0].sequence_number = bitcoin_nsequence(&peer->remote.locktime);
/* Using a new output address here would be useless: they can tell
* it's our HTLC, and that we collected it via timeout. */
tx->output[0].script = scriptpubkey_p2sh(tx,
bitcoin_redeem_single(tx, &peer->us.finalkey));
bitcoin_redeem_single(tx, &peer->local.finalkey));
tx->output[0].script_length = tal_count(tx->output[0].script);
log_unusual(peer->log, "Pre-witness txlen = %zu\n",
@ -995,9 +995,9 @@ static void resolve_cheating(struct peer *peer)
peer->closing_onchain.resolved[0] = steal_tx;
wscripts[n++]
= bitcoin_redeem_secret_or_delay(wscripts,
&peer->them.finalkey,
&peer->us.locktime,
&peer->us.finalkey,
&peer->remote.finalkey,
&peer->local.locktime,
&peer->local.finalkey,
&ci->revocation_hash);
}
@ -1015,19 +1015,19 @@ static void resolve_cheating(struct peer *peer)
if (htlc_a_offered(ci, i)) {
wscripts[n]
= bitcoin_redeem_htlc_send(wscripts,
&peer->them.finalkey,
&peer->us.finalkey,
&peer->remote.finalkey,
&peer->local.finalkey,
&h->expiry,
&peer->us.locktime,
&peer->local.locktime,
&ci->revocation_hash,
&h->rhash);
} else {
wscripts[n]
= bitcoin_redeem_htlc_recv(wscripts,
&peer->them.finalkey,
&peer->us.finalkey,
&peer->remote.finalkey,
&peer->local.finalkey,
&h->expiry,
&peer->us.locktime,
&peer->local.locktime,
&ci->revocation_hash,
&h->rhash);
}
@ -1144,7 +1144,7 @@ static void our_htlc_depth(struct peer *peer,
/* FIXME: Handle CSV in blocks. */
csv_timeout = get_tx_mediantime(peer->dstate, txid)
+ rel_locktime_to_seconds(&peer->them.locktime);
+ rel_locktime_to_seconds(&peer->remote.locktime);
if (mediantime <= csv_timeout)
return;
@ -1289,7 +1289,7 @@ static void our_main_output_depth(struct peer *peer,
/* FIXME: Handle CSV in blocks. */
csv_timeout = get_tx_mediantime(peer->dstate, txid)
+ rel_locktime_to_seconds(&peer->them.locktime);
+ rel_locktime_to_seconds(&peer->remote.locktime);
if (mediantime <= csv_timeout)
return;
@ -1509,7 +1509,7 @@ static void anchor_spent(struct peer *peer,
peer->closing_onchain.tx = tal_steal(peer, tx);
bitcoin_txid(tx, &txid);
peer->closing_onchain.ci = find_commit(peer->them.commit, &txid);
peer->closing_onchain.ci = find_commit(peer->remote.commit, &txid);
if (peer->closing_onchain.ci) {
if (peer->closing_onchain.ci->revocation_preimage) {
set_peer_state(peer, STATE_CLOSE_ONCHAIN_CHEATED,
@ -1521,11 +1521,11 @@ static void anchor_spent(struct peer *peer,
"anchor_spent");
resolve_their_unilateral(peer);
}
} else if (txidmatch(peer->us.commit->tx, &txid)) {
} else if (txidmatch(peer->local.commit->tx, &txid)) {
set_peer_state(peer,
STATE_CLOSE_ONCHAIN_OUR_UNILATERAL,
"anchor_spent");
peer->closing_onchain.ci = peer->us.commit;
peer->closing_onchain.ci = peer->local.commit;
resolve_our_unilateral(peer);
} else if (is_mutual_close(peer, tx)) {
set_peer_state(peer,
@ -1606,7 +1606,7 @@ void peer_watch_anchor(struct peer *peer,
if (w->timeout != INPUT_NONE) {
w->timer = new_reltimer(peer->dstate, w,
time_from_sec(7200
+ 20*peer->us.mindepth),
+ 20*peer->local.mindepth),
anchor_timeout, w);
} else
w->timer = NULL;
@ -1636,7 +1636,7 @@ struct bitcoin_tx *peer_create_close_tx(struct peer *peer, u64 fee)
struct channel_state cstate;
/* We don't need a deep copy here, just fee levels. */
cstate = *peer->us.staging_cstate;
cstate = *peer->local.staging_cstate;
if (!force_fee(&cstate, fee)) {
log_unusual(peer->log,
"peer_create_close_tx: can't afford fee %"PRIu64,
@ -1647,10 +1647,10 @@ struct bitcoin_tx *peer_create_close_tx(struct peer *peer, u64 fee)
log_debug(peer->log,
"creating close-tx with fee %"PRIu64": to %02x%02x%02x%02x/%02x%02x%02x%02x, amounts %u/%u",
fee,
peer->us.finalkey.der[0], peer->us.finalkey.der[1],
peer->us.finalkey.der[2], peer->us.finalkey.der[3],
peer->them.finalkey.der[0], peer->them.finalkey.der[1],
peer->them.finalkey.der[2], peer->them.finalkey.der[3],
peer->local.finalkey.der[0], peer->local.finalkey.der[1],
peer->local.finalkey.der[2], peer->local.finalkey.der[3],
peer->remote.finalkey.der[0], peer->remote.finalkey.der[1],
peer->remote.finalkey.der[2], peer->remote.finalkey.der[3],
cstate.a.pay_msat / 1000,
cstate.b.pay_msat / 1000);
@ -1680,7 +1680,7 @@ void peer_calculate_close_fee(struct peer *peer)
* fee of the final commitment transaction, and MUST set
* `close_fee` to an even number of satoshis.
*/
maxfee = commit_tx_fee(peer->us.commit->tx, peer->anchor.satoshis);
maxfee = commit_tx_fee(peer->local.commit->tx, peer->anchor.satoshis);
if (peer->closing.our_fee > maxfee) {
/* This shouldn't happen: we never accept a commit fee
* less than the min_rate, which is greater than the
@ -1741,8 +1741,8 @@ const struct bitcoin_tx *bitcoin_close(struct peer *peer)
= bitcoin_witness_2of2(close_tx->input,
peer->closing.their_sig,
&our_close_sig,
&peer->them.commitkey,
&peer->us.commitkey);
&peer->remote.commitkey,
&peer->local.commitkey);
return close_tx;
}
@ -1751,7 +1751,7 @@ const struct bitcoin_tx *bitcoin_close(struct peer *peer)
const struct bitcoin_tx *bitcoin_spend_ours(struct peer *peer)
{
u8 *witnessscript;
const struct bitcoin_tx *commit = peer->us.commit->tx;
const struct bitcoin_tx *commit = peer->local.commit->tx;
struct bitcoin_signature sig;
struct bitcoin_tx *tx;
unsigned int p2wsh_out;
@ -1759,22 +1759,22 @@ const struct bitcoin_tx *bitcoin_spend_ours(struct peer *peer)
/* The redeemscript for a commit tx is fairly complex. */
witnessscript = bitcoin_redeem_secret_or_delay(peer,
&peer->us.finalkey,
&peer->them.locktime,
&peer->them.finalkey,
&peer->us.commit->revocation_hash);
&peer->local.finalkey,
&peer->remote.locktime,
&peer->remote.finalkey,
&peer->local.commit->revocation_hash);
/* Now, create transaction to spend it. */
tx = bitcoin_tx(peer, 1, 1);
bitcoin_txid(commit, &tx->input[0].txid);
p2wsh_out = find_p2wsh_out(commit, witnessscript);
tx->input[0].index = p2wsh_out;
tx->input[0].sequence_number = bitcoin_nsequence(&peer->them.locktime);
tx->input[0].sequence_number = bitcoin_nsequence(&peer->remote.locktime);
tx->input[0].amount = tal_dup(tx->input, u64,
&commit->output[p2wsh_out].amount);
tx->output[0].script = scriptpubkey_p2sh(tx,
bitcoin_redeem_single(tx, &peer->us.finalkey));
bitcoin_redeem_single(tx, &peer->local.finalkey));
tx->output[0].script_length = tal_count(tx->output[0].script);
/* Witness length can vary, due to DER encoding of sigs, but we
@ -1808,20 +1808,20 @@ const struct bitcoin_tx *bitcoin_commit(struct peer *peer)
struct bitcoin_signature sig;
/* Can't be signed already, and can't have scriptsig! */
assert(peer->us.commit->tx->input[0].script_length == 0);
assert(!peer->us.commit->tx->input[0].witness);
assert(peer->local.commit->tx->input[0].script_length == 0);
assert(!peer->local.commit->tx->input[0].witness);
sig.stype = SIGHASH_ALL;
peer_sign_ourcommit(peer, peer->us.commit->tx, &sig.sig);
peer_sign_ourcommit(peer, peer->local.commit->tx, &sig.sig);
peer->us.commit->tx->input[0].witness
= bitcoin_witness_2of2(peer->us.commit->tx->input,
peer->us.commit->sig,
peer->local.commit->tx->input[0].witness
= bitcoin_witness_2of2(peer->local.commit->tx->input,
peer->local.commit->sig,
&sig,
&peer->them.commitkey,
&peer->us.commitkey);
&peer->remote.commitkey,
&peer->local.commitkey);
return peer->us.commit->tx;
return peer->local.commit->tx;
}
/* Now we can create anchor tx. */
@ -1871,7 +1871,7 @@ static void got_feerate(struct lightningd_state *dstate,
void bitcoin_create_anchor(struct peer *peer, enum state_input done)
{
/* We must be offering anchor for us to try creating it */
assert(peer->us.offer_anchor);
assert(peer->local.offer_anchor);
assert(done == BITCOIN_ANCHOR_CREATED);
bitcoind_estimate_fee(peer->dstate, got_feerate, peer);
@ -1896,50 +1896,50 @@ const struct bitcoin_tx *bitcoin_anchor(struct peer *peer)
* insufficient funds. */
bool setup_first_commit(struct peer *peer)
{
assert(!peer->us.commit->tx);
assert(!peer->them.commit->tx);
assert(!peer->local.commit->tx);
assert(!peer->remote.commit->tx);
/* Revocation hashes already filled in, from pkt_open */
peer->us.commit->cstate = initial_funding(peer,
peer->us.offer_anchor
peer->local.commit->cstate = initial_funding(peer,
peer->local.offer_anchor
== CMD_OPEN_WITH_ANCHOR,
peer->anchor.satoshis,
peer->us.commit_fee_rate);
if (!peer->us.commit->cstate)
peer->local.commit_fee_rate);
if (!peer->local.commit->cstate)
return false;
peer->them.commit->cstate = initial_funding(peer,
peer->them.offer_anchor
peer->remote.commit->cstate = initial_funding(peer,
peer->remote.offer_anchor
== CMD_OPEN_WITH_ANCHOR,
peer->anchor.satoshis,
peer->them.commit_fee_rate);
if (!peer->them.commit->cstate)
peer->remote.commit_fee_rate);
if (!peer->remote.commit->cstate)
return false;
peer->us.commit->tx = create_commit_tx(peer->us.commit,
&peer->us.finalkey,
&peer->them.finalkey,
&peer->them.locktime,
peer->local.commit->tx = create_commit_tx(peer->local.commit,
&peer->local.finalkey,
&peer->remote.finalkey,
&peer->remote.locktime,
&peer->anchor.txid,
peer->anchor.index,
peer->anchor.satoshis,
&peer->us.commit->revocation_hash,
peer->us.commit->cstate,
&peer->us.commit->map);
&peer->local.commit->revocation_hash,
peer->local.commit->cstate,
&peer->local.commit->map);
peer->them.commit->tx = create_commit_tx(peer->them.commit,
&peer->them.finalkey,
&peer->us.finalkey,
&peer->us.locktime,
peer->remote.commit->tx = create_commit_tx(peer->remote.commit,
&peer->remote.finalkey,
&peer->local.finalkey,
&peer->local.locktime,
&peer->anchor.txid,
peer->anchor.index,
peer->anchor.satoshis,
&peer->them.commit->revocation_hash,
peer->them.commit->cstate,
&peer->them.commit->map);
&peer->remote.commit->revocation_hash,
peer->remote.commit->cstate,
&peer->remote.commit->map);
peer->us.staging_cstate = copy_funding(peer, peer->us.commit->cstate);
peer->them.staging_cstate = copy_funding(peer, peer->them.commit->cstate);
peer->local.staging_cstate = copy_funding(peer, peer->local.commit->cstate);
peer->remote.staging_cstate = copy_funding(peer, peer->remote.commit->cstate);
return true;
}
@ -2003,11 +2003,11 @@ static void json_getpeers(struct command *cmd,
/* FIXME: Report anchor. */
if (!p->us.commit || !p->us.commit->cstate) {
if (!p->local.commit || !p->local.commit->cstate) {
json_object_end(response);
continue;
}
last = p->us.commit->cstate;
last = p->local.commit->cstate;
json_add_num(response, "our_amount", last->a.pay_msat);
json_add_num(response, "our_fee", last->a.fee_msat);
@ -2017,9 +2017,9 @@ static void json_getpeers(struct command *cmd,
json_add_htlcs(response, "their_htlcs", &last->b);
/* Any changes since then? */
if (p->us.staging_cstate->changes != last->changes)
if (p->local.staging_cstate->changes != last->changes)
json_add_num(response, "staged_changes",
p->us.staging_cstate->changes
p->local.staging_cstate->changes
- last->changes);
json_object_end(response);
}
@ -2061,8 +2061,8 @@ static void check_htlc_expiry(struct peer *peer, void *unused)
/* Check their currently still-existing htlcs for expiry:
* We eliminate them from staging as we go. */
for (i = 0; i < tal_count(peer->them.staging_cstate->a.htlcs); i++) {
struct channel_htlc *htlc = &peer->them.staging_cstate->a.htlcs[i];
for (i = 0; i < tal_count(peer->remote.staging_cstate->a.htlcs); i++) {
struct channel_htlc *htlc = &peer->remote.staging_cstate->a.htlcs[i];
/* Not a seconds-based expiry? */
if (!abs_locktime_is_seconds(&htlc->expiry))
@ -2119,8 +2119,8 @@ static void do_newhtlc(struct peer *peer, struct newhtlc *newhtlc)
* A node MUST NOT add a HTLC if it would result in it
* offering more than 300 HTLCs in either commitment transaction.
*/
if (tal_count(peer->us.staging_cstate->a.htlcs) == 300
|| tal_count(peer->them.staging_cstate->b.htlcs) == 300) {
if (tal_count(peer->local.staging_cstate->a.htlcs) == 300
|| tal_count(peer->remote.staging_cstate->b.htlcs) == 300) {
command_fail(newhtlc->jsoncmd, "Too many HTLCs");
}
@ -2130,7 +2130,7 @@ static void do_newhtlc(struct peer *peer, struct newhtlc *newhtlc)
* A node MUST NOT offer `amount_msat` it cannot pay for in
* both commitment transactions at the current `fee_rate`
*/
cstate = copy_funding(newhtlc, peer->them.staging_cstate);
cstate = copy_funding(newhtlc, peer->remote.staging_cstate);
if (!funding_b_add_htlc(cstate, newhtlc->htlc.msatoshis,
&newhtlc->htlc.expiry, &newhtlc->htlc.rhash,
newhtlc->htlc.id)) {
@ -2141,7 +2141,7 @@ static void do_newhtlc(struct peer *peer, struct newhtlc *newhtlc)
return;
}
cstate = copy_funding(newhtlc, peer->us.staging_cstate);
cstate = copy_funding(newhtlc, peer->local.staging_cstate);
if (!funding_a_add_htlc(cstate, newhtlc->htlc.msatoshis,
&newhtlc->htlc.expiry, &newhtlc->htlc.rhash,
newhtlc->htlc.id)) {
@ -2183,7 +2183,7 @@ static void json_newhtlc(struct command *cmd,
return;
}
if (!peer->them.commit || !peer->them.commit->cstate) {
if (!peer->remote.commit || !peer->remote.commit->cstate) {
command_fail(cmd, "peer not fully established");
return;
}
@ -2251,11 +2251,11 @@ static size_t find_their_committed_htlc(struct peer *peer,
const struct sha256 *rhash)
{
/* Must be in last committed cstate. */
if (funding_find_htlc(&peer->them.commit->cstate->a, rhash)
== tal_count(peer->them.commit->cstate->a.htlcs))
return tal_count(peer->them.staging_cstate->a.htlcs);
if (funding_find_htlc(&peer->remote.commit->cstate->a, rhash)
== tal_count(peer->remote.commit->cstate->a.htlcs))
return tal_count(peer->remote.staging_cstate->a.htlcs);
return funding_find_htlc(&peer->them.staging_cstate->a, rhash);
return funding_find_htlc(&peer->remote.staging_cstate->a, rhash);
}
struct fulfillhtlc {
@ -2276,11 +2276,11 @@ static void do_fullfill(struct peer *peer,
sha256(&rhash, &fulfillhtlc->r, sizeof(fulfillhtlc->r));
i = find_their_committed_htlc(peer, &rhash);
if (i == tal_count(peer->them.staging_cstate->a.htlcs)) {
if (i == tal_count(peer->remote.staging_cstate->a.htlcs)) {
command_fail(fulfillhtlc->jsoncmd, "preimage htlc not found");
return;
}
stage.fulfill.id = peer->them.staging_cstate->a.htlcs[i].id;
stage.fulfill.id = peer->remote.staging_cstate->a.htlcs[i].id;
set_htlc_command(peer, fulfillhtlc->jsoncmd,
CMD_SEND_HTLC_FULFILL, &stage);
}
@ -2306,7 +2306,7 @@ static void json_fulfillhtlc(struct command *cmd,
return;
}
if (!peer->them.commit || !peer->them.commit->cstate) {
if (!peer->remote.commit || !peer->remote.commit->cstate) {
command_fail(cmd, "peer not fully established");
return;
}
@ -2347,14 +2347,14 @@ static void do_failhtlc(struct peer *peer,
stage.fail.fail = HTLC_FAIL;
/* Look in peer->them.staging_cstate->a, as that's where we'll
/* Look in peer->remote.staging_cstate->a, as that's where we'll
* immediately remove it from: avoids double-handling. */
i = find_their_committed_htlc(peer, &failhtlc->rhash);
if (i == tal_count(peer->them.staging_cstate->a.htlcs)) {
if (i == tal_count(peer->remote.staging_cstate->a.htlcs)) {
command_fail(failhtlc->jsoncmd, "htlc not found");
return;
}
stage.fail.id = peer->them.staging_cstate->a.htlcs[i].id;
stage.fail.id = peer->remote.staging_cstate->a.htlcs[i].id;
set_htlc_command(peer, failhtlc->jsoncmd, CMD_SEND_HTLC_FAIL, &stage);
}
@ -2380,7 +2380,7 @@ static void json_failhtlc(struct command *cmd,
return;
}
if (!peer->them.commit || !peer->them.commit->cstate) {
if (!peer->remote.commit || !peer->remote.commit->cstate) {
command_fail(cmd, "peer not fully established");
return;
}
@ -2427,7 +2427,7 @@ static void json_commit(struct command *cmd,
return;
}
if (!peer->them.commit || !peer->them.commit->cstate) {
if (!peer->remote.commit || !peer->remote.commit->cstate) {
command_fail(cmd, "peer not fully established");
return;
}
@ -2535,7 +2535,7 @@ static void json_signcommit(struct command *cmd,
return;
}
if (!peer->us.commit->sig) {
if (!peer->local.commit->sig) {
command_fail(cmd, "Peer has not given us a signature");
return;
}

4
daemon/peer.h
View File

@ -223,12 +223,12 @@ struct peer {
bool fake_close;
/* Stuff we have in common. */
struct peer_visible_state us, them;
struct peer_visible_state local, remote;
};
void setup_listeners(struct lightningd_state *dstate, unsigned int portnum);
/* Populates very first peer->{us,them}.commit->{tx,cstate} */
/* Populates very first peer->{local,remote}.commit->{tx,cstate} */
bool setup_first_commit(struct peer *peer);
void set_peer_state(struct peer *peer, enum state newstate, const char *why);

16
daemon/secrets.c
View File

@ -51,7 +51,7 @@ void peer_sign_theircommit(const struct peer *peer,
NULL, 0,
peer->anchor.witnessscript,
&peer->secrets->commit,
&peer->us.commitkey,
&peer->local.commitkey,
sig);
}
@ -65,7 +65,7 @@ void peer_sign_ourcommit(const struct peer *peer,
NULL, 0,
peer->anchor.witnessscript,
&peer->secrets->commit,
&peer->us.commitkey,
&peer->local.commitkey,
sig);
}
@ -80,7 +80,7 @@ void peer_sign_spend(const struct peer *peer,
NULL, 0,
commit_witnessscript,
&peer->secrets->final,
&peer->us.finalkey,
&peer->local.finalkey,
sig);
}
@ -95,7 +95,7 @@ void peer_sign_htlc_refund(const struct peer *peer,
NULL, 0,
htlc_witnessscript,
&peer->secrets->final,
&peer->us.finalkey,
&peer->local.finalkey,
sig);
}
@ -108,7 +108,7 @@ void peer_sign_mutual_close(const struct peer *peer,
NULL, 0,
peer->anchor.witnessscript,
&peer->secrets->commit,
&peer->us.commitkey,
&peer->local.commitkey,
sig);
}
@ -124,7 +124,7 @@ void peer_sign_steal_input(const struct peer *peer,
NULL, 0,
witnessscript,
&peer->secrets->final,
&peer->us.finalkey,
&peer->local.finalkey,
sig);
}
@ -142,8 +142,8 @@ void peer_secrets_init(struct peer *peer)
{
peer->secrets = tal(peer, struct peer_secrets);
new_keypair(peer->dstate, &peer->secrets->commit, &peer->us.commitkey);
new_keypair(peer->dstate, &peer->secrets->final, &peer->us.finalkey);
new_keypair(peer->dstate, &peer->secrets->commit, &peer->local.commitkey);
new_keypair(peer->dstate, &peer->secrets->final, &peer->local.finalkey);
if (RAND_bytes(peer->secrets->revocation_seed.u.u8,
sizeof(peer->secrets->revocation_seed.u.u8)) != 1)
fatal("Could not get random bytes for revocation seed");