aljaz/lightning
1
0
Fork 0
mirror of https://github.com/aljazceru/lightning.git synced 2025-12-19 23:24:27 +01:00
Code Issues Packages Projects Releases Wiki Activity

state: take struct peer instead of struct state_data.

Browse Source 
Just a name change for the test code, but this is what we'll be using
for the daemon.

Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
This commit is contained in:
Rusty Russell
2016-01-22 06:41:45 +10:30
parent 2c356fde55
commit 15c5fca876
3 changed files with 474 additions and 474 deletions
Download Patch File Download Diff File Expand all files Collapse all files

144
state.c
View File

@@ -31,7 +31,7 @@ static struct state_effect *next_state(const tal_t *ctx,
struct state_effect *state(const tal_t *ctx, struct state_effect *state(const tal_t *ctx,
const enum state state, const enum state state,
const struct state_data *sdata, const struct peer *peer,
const enum state_input input, const enum state_input input,
const union input *idata) const union input *idata)
{ {
@@ -49,19 +49,19 @@ struct state_effect *state(const tal_t *ctx,
case STATE_INIT_NOANCHOR: case STATE_INIT_NOANCHOR:
assert(input == INPUT_NONE); assert(input == INPUT_NONE);
add_effect(&effect, send_pkt, add_effect(&effect, send_pkt,
pkt_open(ctx, sdata, pkt_open(ctx, peer,
OPEN_CHANNEL__ANCHOR_OFFER__WONT_CREATE_ANCHOR)); OPEN_CHANNEL__ANCHOR_OFFER__WONT_CREATE_ANCHOR));
return next_state(ctx, effect, return next_state(ctx, effect,
STATE_OPEN_WAIT_FOR_OPEN_NOANCHOR); STATE_OPEN_WAIT_FOR_OPEN_NOANCHOR);
case STATE_INIT_WITHANCHOR: case STATE_INIT_WITHANCHOR:
assert(input == INPUT_NONE); assert(input == INPUT_NONE);
add_effect(&effect, send_pkt, add_effect(&effect, send_pkt,
pkt_open(ctx, sdata, pkt_open(ctx, peer,
OPEN_CHANNEL__ANCHOR_OFFER__WILL_CREATE_ANCHOR)); OPEN_CHANNEL__ANCHOR_OFFER__WILL_CREATE_ANCHOR));
return next_state(ctx, effect, STATE_OPEN_WAIT_FOR_OPEN_WITHANCHOR); return next_state(ctx, effect, STATE_OPEN_WAIT_FOR_OPEN_WITHANCHOR);
case STATE_OPEN_WAIT_FOR_OPEN_NOANCHOR: case STATE_OPEN_WAIT_FOR_OPEN_NOANCHOR:
if (input_is(input, PKT_OPEN)) { if (input_is(input, PKT_OPEN)) {
err = accept_pkt_open(ctx, sdata, idata->pkt, &effect); err = accept_pkt_open(ctx, peer, idata->pkt, &effect);
if (err) if (err)
goto err_close_nocleanup; goto err_close_nocleanup;
return next_state(ctx, effect, STATE_OPEN_WAIT_FOR_ANCHOR); return next_state(ctx, effect, STATE_OPEN_WAIT_FOR_ANCHOR);
@@ -78,10 +78,10 @@ struct state_effect *state(const tal_t *ctx,
break; break;
case STATE_OPEN_WAIT_FOR_OPEN_WITHANCHOR: case STATE_OPEN_WAIT_FOR_OPEN_WITHANCHOR:
if (input_is(input, PKT_OPEN)) { if (input_is(input, PKT_OPEN)) {
err = accept_pkt_open(ctx, sdata, idata->pkt, &effect); err = accept_pkt_open(ctx, peer, idata->pkt, &effect);
if (err) if (err)
goto err_close_nocleanup; goto err_close_nocleanup;
add_effect(&effect, send_pkt, pkt_anchor(ctx, sdata)); add_effect(&effect, send_pkt, pkt_anchor(ctx, peer));
return next_state(ctx, effect, return next_state(ctx, effect,
STATE_OPEN_WAIT_FOR_COMMIT_SIG); STATE_OPEN_WAIT_FOR_COMMIT_SIG);
} else if (input_is(input, CMD_SEND_HTLC_UPDATE)) { } else if (input_is(input, CMD_SEND_HTLC_UPDATE)) {
@@ -97,13 +97,13 @@ struct state_effect *state(const tal_t *ctx,
break; break;
case STATE_OPEN_WAIT_FOR_ANCHOR: case STATE_OPEN_WAIT_FOR_ANCHOR:
if (input_is(input, PKT_OPEN_ANCHOR)) { if (input_is(input, PKT_OPEN_ANCHOR)) {
err = accept_pkt_anchor(ctx, sdata, idata->pkt, &effect); err = accept_pkt_anchor(ctx, peer, idata->pkt, &effect);
if (err) if (err)
goto err_close_nocleanup; goto err_close_nocleanup;
add_effect(&effect, send_pkt, add_effect(&effect, send_pkt,
pkt_open_commit_sig(ctx, sdata)); pkt_open_commit_sig(ctx, peer));
add_effect(&effect, watch, add_effect(&effect, watch,
bitcoin_watch_anchor(ctx, sdata, bitcoin_watch_anchor(ctx, peer,
BITCOIN_ANCHOR_DEPTHOK, BITCOIN_ANCHOR_DEPTHOK,
BITCOIN_ANCHOR_TIMEOUT, BITCOIN_ANCHOR_TIMEOUT,
BITCOIN_ANCHOR_UNSPENT, BITCOIN_ANCHOR_UNSPENT,
@@ -125,14 +125,14 @@ struct state_effect *state(const tal_t *ctx,
break; break;
case STATE_OPEN_WAIT_FOR_COMMIT_SIG: case STATE_OPEN_WAIT_FOR_COMMIT_SIG:
if (input_is(input, PKT_OPEN_COMMIT_SIG)) { if (input_is(input, PKT_OPEN_COMMIT_SIG)) {
err = accept_pkt_open_commit_sig(ctx, sdata, idata->pkt, err = accept_pkt_open_commit_sig(ctx, peer, idata->pkt,
&effect); &effect);
if (err) if (err)
goto err_start_unilateral_close; goto err_start_unilateral_close;
add_effect(&effect, broadcast_tx, add_effect(&effect, broadcast_tx,
bitcoin_anchor(ctx, sdata)); bitcoin_anchor(ctx, peer));
add_effect(&effect, watch, add_effect(&effect, watch,
bitcoin_watch_anchor(ctx, sdata, bitcoin_watch_anchor(ctx, peer,
BITCOIN_ANCHOR_DEPTHOK, BITCOIN_ANCHOR_DEPTHOK,
INPUT_NONE, INPUT_NONE,
BITCOIN_ANCHOR_UNSPENT, BITCOIN_ANCHOR_UNSPENT,
@@ -153,7 +153,7 @@ struct state_effect *state(const tal_t *ctx,
case STATE_OPEN_WAITING_OURANCHOR: case STATE_OPEN_WAITING_OURANCHOR:
if (input_is(input, BITCOIN_ANCHOR_DEPTHOK)) { if (input_is(input, BITCOIN_ANCHOR_DEPTHOK)) {
add_effect(&effect, send_pkt, add_effect(&effect, send_pkt,
pkt_open_complete(ctx, sdata)); pkt_open_complete(ctx, peer));
return next_state(ctx, effect, return next_state(ctx, effect,
STATE_OPEN_WAIT_FOR_COMPLETE_OURANCHOR); STATE_OPEN_WAIT_FOR_COMPLETE_OURANCHOR);
} else if (input_is(input, BITCOIN_ANCHOR_UNSPENT)) { } else if (input_is(input, BITCOIN_ANCHOR_UNSPENT)) {
@@ -171,7 +171,7 @@ struct state_effect *state(const tal_t *ctx,
} else if (input_is(input, BITCOIN_ANCHOR_THEIRSPEND)) { } else if (input_is(input, BITCOIN_ANCHOR_THEIRSPEND)) {
/* We no longer care about anchor depth. */ /* We no longer care about anchor depth. */
add_effect(&effect, unwatch, add_effect(&effect, unwatch,
bitcoin_unwatch_anchor_depth(ctx, sdata, bitcoin_unwatch_anchor_depth(ctx, peer,
BITCOIN_ANCHOR_DEPTHOK, BITCOIN_ANCHOR_DEPTHOK,
INPUT_NONE)); INPUT_NONE));
goto them_unilateral; goto them_unilateral;
@@ -181,21 +181,21 @@ struct state_effect *state(const tal_t *ctx,
} else if (input_is(input, CMD_CLOSE)) { } else if (input_is(input, CMD_CLOSE)) {
/* We no longer care about anchor depth. */ /* We no longer care about anchor depth. */
add_effect(&effect, unwatch, add_effect(&effect, unwatch,
bitcoin_unwatch_anchor_depth(ctx, sdata, bitcoin_unwatch_anchor_depth(ctx, peer,
BITCOIN_ANCHOR_DEPTHOK, BITCOIN_ANCHOR_DEPTHOK,
INPUT_NONE)); INPUT_NONE));
goto start_closing; goto start_closing;
} else if (input_is(input, PKT_CLOSE)) { } else if (input_is(input, PKT_CLOSE)) {
/* We no longer care about anchor depth. */ /* We no longer care about anchor depth. */
add_effect(&effect, unwatch, add_effect(&effect, unwatch,
bitcoin_unwatch_anchor_depth(ctx, sdata, bitcoin_unwatch_anchor_depth(ctx, peer,
BITCOIN_ANCHOR_DEPTHOK, BITCOIN_ANCHOR_DEPTHOK,
INPUT_NONE)); INPUT_NONE));
goto accept_closing; goto accept_closing;
} else if (input_is_pkt(input)) { } else if (input_is_pkt(input)) {
/* We no longer care about anchor depth. */ /* We no longer care about anchor depth. */
add_effect(&effect, unwatch, add_effect(&effect, unwatch,
bitcoin_unwatch_anchor_depth(ctx, sdata, bitcoin_unwatch_anchor_depth(ctx, peer,
BITCOIN_ANCHOR_DEPTHOK, BITCOIN_ANCHOR_DEPTHOK,
INPUT_NONE)); INPUT_NONE));
goto unexpected_pkt; goto unexpected_pkt;
@@ -209,7 +209,7 @@ struct state_effect *state(const tal_t *ctx,
return next_state(ctx, effect, STATE_ERR_ANCHOR_TIMEOUT); return next_state(ctx, effect, STATE_ERR_ANCHOR_TIMEOUT);
} else if (input_is(input, BITCOIN_ANCHOR_DEPTHOK)) { } else if (input_is(input, BITCOIN_ANCHOR_DEPTHOK)) {
add_effect(&effect, send_pkt, add_effect(&effect, send_pkt,
pkt_open_complete(ctx, sdata)); pkt_open_complete(ctx, peer));
return next_state(ctx, effect, STATE_OPEN_WAIT_FOR_COMPLETE_THEIRANCHOR); return next_state(ctx, effect, STATE_OPEN_WAIT_FOR_COMPLETE_THEIRANCHOR);
} else if (input_is(input, BITCOIN_ANCHOR_UNSPENT)) { } else if (input_is(input, BITCOIN_ANCHOR_UNSPENT)) {
goto anchor_unspent; goto anchor_unspent;
@@ -219,7 +219,7 @@ struct state_effect *state(const tal_t *ctx,
} else if (input_is(input, BITCOIN_ANCHOR_THEIRSPEND)) { } else if (input_is(input, BITCOIN_ANCHOR_THEIRSPEND)) {
/* We no longer care about anchor depth. */ /* We no longer care about anchor depth. */
add_effect(&effect, unwatch, add_effect(&effect, unwatch,
bitcoin_unwatch_anchor_depth(ctx, sdata, bitcoin_unwatch_anchor_depth(ctx, peer,
BITCOIN_ANCHOR_DEPTHOK, BITCOIN_ANCHOR_DEPTHOK,
BITCOIN_ANCHOR_TIMEOUT)); BITCOIN_ANCHOR_TIMEOUT));
goto them_unilateral; goto them_unilateral;
@@ -236,21 +236,21 @@ struct state_effect *state(const tal_t *ctx,
} else if (input_is(input, CMD_CLOSE)) { } else if (input_is(input, CMD_CLOSE)) {
/* We no longer care about anchor depth. */ /* We no longer care about anchor depth. */
add_effect(&effect, unwatch, add_effect(&effect, unwatch,
bitcoin_unwatch_anchor_depth(ctx, sdata, bitcoin_unwatch_anchor_depth(ctx, peer,
BITCOIN_ANCHOR_DEPTHOK, BITCOIN_ANCHOR_DEPTHOK,
BITCOIN_ANCHOR_TIMEOUT)); BITCOIN_ANCHOR_TIMEOUT));
goto start_closing; goto start_closing;
} else if (input_is(input, PKT_CLOSE)) { } else if (input_is(input, PKT_CLOSE)) {
/* We no longer care about anchor depth. */ /* We no longer care about anchor depth. */
add_effect(&effect, unwatch, add_effect(&effect, unwatch,
bitcoin_unwatch_anchor_depth(ctx, sdata, bitcoin_unwatch_anchor_depth(ctx, peer,
BITCOIN_ANCHOR_DEPTHOK, BITCOIN_ANCHOR_DEPTHOK,
BITCOIN_ANCHOR_TIMEOUT)); BITCOIN_ANCHOR_TIMEOUT));
goto accept_closing; goto accept_closing;
} else if (input_is_pkt(input)) { } else if (input_is_pkt(input)) {
/* We no longer care about anchor depth. */ /* We no longer care about anchor depth. */
add_effect(&effect, unwatch, add_effect(&effect, unwatch,
bitcoin_unwatch_anchor_depth(ctx, sdata, bitcoin_unwatch_anchor_depth(ctx, peer,
BITCOIN_ANCHOR_DEPTHOK, BITCOIN_ANCHOR_DEPTHOK,
BITCOIN_ANCHOR_TIMEOUT)); BITCOIN_ANCHOR_TIMEOUT));
goto unexpected_pkt; goto unexpected_pkt;
@@ -297,7 +297,7 @@ struct state_effect *state(const tal_t *ctx,
if (input_is(input, CMD_SEND_HTLC_UPDATE)) { if (input_is(input, CMD_SEND_HTLC_UPDATE)) {
/* We are to send an HTLC update. */ /* We are to send an HTLC update. */
add_effect(&effect, send_pkt, add_effect(&effect, send_pkt,
pkt_htlc_update(ctx, sdata, pkt_htlc_update(ctx, peer,
idata->htlc_prog)); idata->htlc_prog));
add_effect(&effect, htlc_in_progress, idata->htlc_prog); add_effect(&effect, htlc_in_progress, idata->htlc_prog);
return next_state(ctx, effect, return next_state(ctx, effect,
@@ -306,9 +306,9 @@ struct state_effect *state(const tal_t *ctx,
/* We are to send an HTLC fulfill. */ /* We are to send an HTLC fulfill. */
/* This gives us the r value (FIXME: type!) */ /* This gives us the r value (FIXME: type!) */
add_effect(&effect, r_value, add_effect(&effect, r_value,
r_value_from_cmd(ctx, sdata, idata->htlc)); r_value_from_cmd(ctx, peer, idata->htlc));
add_effect(&effect, send_pkt, add_effect(&effect, send_pkt,
pkt_htlc_fulfill(ctx, sdata, pkt_htlc_fulfill(ctx, peer,
idata->htlc_prog)); idata->htlc_prog));
add_effect(&effect, htlc_in_progress, idata->htlc_prog); add_effect(&effect, htlc_in_progress, idata->htlc_prog);
return next_state(ctx, effect, return next_state(ctx, effect,
@@ -316,7 +316,7 @@ struct state_effect *state(const tal_t *ctx,
} else if (input_is(input, CMD_SEND_HTLC_TIMEDOUT)) { } else if (input_is(input, CMD_SEND_HTLC_TIMEDOUT)) {
/* We are to send an HTLC timedout. */ /* We are to send an HTLC timedout. */
add_effect(&effect, send_pkt, add_effect(&effect, send_pkt,
pkt_htlc_timedout(ctx, sdata, pkt_htlc_timedout(ctx, peer,
idata->htlc_prog)); idata->htlc_prog));
add_effect(&effect, htlc_in_progress, idata->htlc_prog); add_effect(&effect, htlc_in_progress, idata->htlc_prog);
return next_state(ctx, effect, return next_state(ctx, effect,
@@ -324,7 +324,7 @@ struct state_effect *state(const tal_t *ctx,
} else if (input_is(input, CMD_SEND_HTLC_ROUTEFAIL)) { } else if (input_is(input, CMD_SEND_HTLC_ROUTEFAIL)) {
/* We are to send an HTLC routefail. */ /* We are to send an HTLC routefail. */
add_effect(&effect, send_pkt, add_effect(&effect, send_pkt,
pkt_htlc_routefail(ctx, sdata, pkt_htlc_routefail(ctx, peer,
idata->htlc_prog)); idata->htlc_prog));
add_effect(&effect, htlc_in_progress, idata->htlc_prog); add_effect(&effect, htlc_in_progress, idata->htlc_prog);
return next_state(ctx, effect, return next_state(ctx, effect,
@@ -407,7 +407,7 @@ struct state_effect *state(const tal_t *ctx,
goto accept_htlc_routefail; goto accept_htlc_routefail;
} else if (input_is(input, PKT_UPDATE_ACCEPT)) { } else if (input_is(input, PKT_UPDATE_ACCEPT)) {
struct signature *sig; struct signature *sig;
err = accept_pkt_update_accept(ctx, sdata, idata->pkt, err = accept_pkt_update_accept(ctx, peer, idata->pkt,
&sig, &effect); &sig, &effect);
if (err) { if (err) {
add_effect(&effect, cmd_fail, NULL); add_effect(&effect, cmd_fail, NULL);
@@ -416,7 +416,7 @@ struct state_effect *state(const tal_t *ctx,
} }
add_effect(&effect, update_theirsig, sig); add_effect(&effect, update_theirsig, sig);
add_effect(&effect, send_pkt, add_effect(&effect, send_pkt,
pkt_update_signature(ctx, sdata)); pkt_update_signature(ctx, peer));
/* HTLC is signed (though old tx not revoked yet!) */ /* HTLC is signed (though old tx not revoked yet!) */
add_effect(&effect, htlc_fulfill, true); add_effect(&effect, htlc_fulfill, true);
return next_state(ctx, effect, return next_state(ctx, effect,
@@ -446,7 +446,7 @@ struct state_effect *state(const tal_t *ctx,
case STATE_WAIT_FOR_UPDATE_COMPLETE_LOWPRIO: case STATE_WAIT_FOR_UPDATE_COMPLETE_LOWPRIO:
case STATE_WAIT_FOR_UPDATE_COMPLETE_HIGHPRIO: case STATE_WAIT_FOR_UPDATE_COMPLETE_HIGHPRIO:
if (input_is(input, PKT_UPDATE_COMPLETE)) { if (input_is(input, PKT_UPDATE_COMPLETE)) {
err = accept_pkt_update_complete(ctx, sdata, idata->pkt, err = accept_pkt_update_complete(ctx, peer, idata->pkt,
&effect); &effect);
if (err) { if (err) {
add_effect(&effect, cmd_fail, NULL); add_effect(&effect, cmd_fail, NULL);
@@ -479,7 +479,7 @@ struct state_effect *state(const tal_t *ctx,
case STATE_WAIT_FOR_UPDATE_SIG_HIGHPRIO: case STATE_WAIT_FOR_UPDATE_SIG_HIGHPRIO:
if (input_is(input, PKT_UPDATE_SIGNATURE)) { if (input_is(input, PKT_UPDATE_SIGNATURE)) {
struct signature *sig; struct signature *sig;
err = accept_pkt_update_signature(ctx, sdata, idata->pkt, err = accept_pkt_update_signature(ctx, peer, idata->pkt,
&sig, &effect); &sig, &effect);
if (err) { if (err) {
add_effect(&effect, htlc_abandon, true); add_effect(&effect, htlc_abandon, true);
@@ -487,7 +487,7 @@ struct state_effect *state(const tal_t *ctx,
} }
add_effect(&effect, update_theirsig, sig); add_effect(&effect, update_theirsig, sig);
add_effect(&effect, send_pkt, add_effect(&effect, send_pkt,
pkt_update_complete(ctx, sdata)); pkt_update_complete(ctx, peer));
add_effect(&effect, htlc_fulfill, true); add_effect(&effect, htlc_fulfill, true);
/* Toggle between high and low priority states. */ /* Toggle between high and low priority states. */
return next_state(ctx, effect, return next_state(ctx, effect,
@@ -518,30 +518,30 @@ struct state_effect *state(const tal_t *ctx,
case STATE_WAIT_FOR_CLOSE_COMPLETE: case STATE_WAIT_FOR_CLOSE_COMPLETE:
if (input_is(input, PKT_CLOSE_COMPLETE)) { if (input_is(input, PKT_CLOSE_COMPLETE)) {
err = accept_pkt_close_complete(ctx, sdata, idata->pkt, err = accept_pkt_close_complete(ctx, peer, idata->pkt,
&effect); &effect);
if (err) if (err)
goto err_start_unilateral_close_already_closing; goto err_start_unilateral_close_already_closing;
add_effect(&effect, cmd_close_done, true); add_effect(&effect, cmd_close_done, true);
add_effect(&effect, send_pkt, add_effect(&effect, send_pkt,
pkt_close_ack(ctx, sdata)); pkt_close_ack(ctx, peer));
add_effect(&effect, broadcast_tx, add_effect(&effect, broadcast_tx,
bitcoin_close(ctx, sdata)); bitcoin_close(ctx, peer));
add_effect(&effect, stop_commands, true); add_effect(&effect, stop_commands, true);
add_effect(&effect, stop_packets, true); add_effect(&effect, stop_packets, true);
return next_state(ctx, effect, STATE_CLOSE_WAIT_CLOSE); return next_state(ctx, effect, STATE_CLOSE_WAIT_CLOSE);
} else if (input_is(input, PKT_CLOSE)) { } else if (input_is(input, PKT_CLOSE)) {
/* We can use the sig just like CLOSE_COMPLETE */ /* We can use the sig just like CLOSE_COMPLETE */
err = accept_pkt_simultaneous_close(ctx, sdata, err = accept_pkt_simultaneous_close(ctx, peer,
idata->pkt, idata->pkt,
&effect); &effect);
if (err) if (err)
goto err_start_unilateral_close_already_closing; goto err_start_unilateral_close_already_closing;
add_effect(&effect, cmd_close_done, true); add_effect(&effect, cmd_close_done, true);
add_effect(&effect, send_pkt, add_effect(&effect, send_pkt,
pkt_close_ack(ctx, sdata)); pkt_close_ack(ctx, peer));
add_effect(&effect, broadcast_tx, add_effect(&effect, broadcast_tx,
bitcoin_close(ctx, sdata)); bitcoin_close(ctx, peer));
add_effect(&effect, stop_commands, true); add_effect(&effect, stop_commands, true);
add_effect(&effect, stop_packets, true); add_effect(&effect, stop_packets, true);
return next_state(ctx, effect, STATE_CLOSE_WAIT_CLOSE); return next_state(ctx, effect, STATE_CLOSE_WAIT_CLOSE);
@@ -563,7 +563,7 @@ struct state_effect *state(const tal_t *ctx,
case STATE_WAIT_FOR_CLOSE_ACK: case STATE_WAIT_FOR_CLOSE_ACK:
if (input_is(input, PKT_CLOSE_ACK)) { if (input_is(input, PKT_CLOSE_ACK)) {
err = accept_pkt_close_ack(ctx, sdata, idata->pkt, err = accept_pkt_close_ack(ctx, peer, idata->pkt,
&effect); &effect);
if (err) if (err)
add_effect(&effect, send_pkt, err); add_effect(&effect, send_pkt, err);
@@ -648,7 +648,7 @@ struct state_effect *state(const tal_t *ctx,
* (we stole them all) */ * (we stole them all) */
if (bits & STATE_CLOSE_HTLCS_BIT) if (bits & STATE_CLOSE_HTLCS_BIT)
add_effect(&effect, unwatch_htlc, add_effect(&effect, unwatch_htlc,
htlc_unwatch_all(ctx, sdata)); htlc_unwatch_all(ctx, peer));
return next_state(ctx, effect, STATE_CLOSED); return next_state(ctx, effect, STATE_CLOSED);
} }
@@ -670,7 +670,7 @@ struct state_effect *state(const tal_t *ctx,
&& input_is(input, BITCOIN_ANCHOR_OURCOMMIT_DELAYPASSED)) { && input_is(input, BITCOIN_ANCHOR_OURCOMMIT_DELAYPASSED)) {
BUILD_ASSERT(!((STATE_CLOSE_WAIT_HTLCS - base) BUILD_ASSERT(!((STATE_CLOSE_WAIT_HTLCS - base)
& STATE_CLOSE_OURCOMMIT_BIT)); & STATE_CLOSE_OURCOMMIT_BIT));
tx = bitcoin_spend_ours(ctx, sdata); tx = bitcoin_spend_ours(ctx, peer);
/* Now we need to wait for our commit to be done. */ /* Now we need to wait for our commit to be done. */
add_effect(&effect, broadcast_tx, tx); add_effect(&effect, broadcast_tx, tx);
add_effect(&effect, watch, add_effect(&effect, watch,
@@ -708,7 +708,7 @@ struct state_effect *state(const tal_t *ctx,
return effect; return effect;
} else if (input_is(input, BITCOIN_HTLC_TOTHEM_TIMEOUT)){ } else if (input_is(input, BITCOIN_HTLC_TOTHEM_TIMEOUT)){
tx = bitcoin_htlc_timeout(ctx, tx = bitcoin_htlc_timeout(ctx,
sdata, peer,
idata->htlc); idata->htlc);
/* HTLC timed out, spend it back to us. */ /* HTLC timed out, spend it back to us. */
add_effect(&effect, broadcast_tx, tx); add_effect(&effect, broadcast_tx, tx);
@@ -723,12 +723,12 @@ struct state_effect *state(const tal_t *ctx,
BITCOIN_HTLC_RETURN_SPEND_DONE)); BITCOIN_HTLC_RETURN_SPEND_DONE));
return effect; return effect;
} else if (input_is(input, INPUT_RVALUE)) { } else if (input_is(input, INPUT_RVALUE)) {
tx = bitcoin_htlc_spend(ctx, sdata, tx = bitcoin_htlc_spend(ctx, peer,
idata->htlc); idata->htlc);
/* This gives us the r value. */ /* This gives us the r value. */
add_effect(&effect, r_value, add_effect(&effect, r_value,
r_value_from_cmd(ctx, sdata, r_value_from_cmd(ctx, peer,
idata->htlc)); idata->htlc));
/* Spend it... */ /* Spend it... */
add_effect(&effect, broadcast_tx, tx); add_effect(&effect, broadcast_tx, tx);
@@ -784,13 +784,13 @@ struct state_effect *state(const tal_t *ctx,
* (even if they already have, due to tx malleability). * (even if they already have, due to tx malleability).
*/ */
if (input_is(input, BITCOIN_ANCHOR_THEIRSPEND)) { if (input_is(input, BITCOIN_ANCHOR_THEIRSPEND)) {
tx = bitcoin_spend_theirs(ctx, sdata, idata->btc); tx = bitcoin_spend_theirs(ctx, peer, idata->btc);
add_effect(&effect, broadcast_tx, tx); add_effect(&effect, broadcast_tx, tx);
add_effect(&effect, watch, add_effect(&effect, watch,
bitcoin_watch(ctx, tx, bitcoin_watch(ctx, tx,
BITCOIN_SPEND_THEIRS_DONE)); BITCOIN_SPEND_THEIRS_DONE));
/* HTLC watches. */ /* HTLC watches. */
htlcs = htlc_outputs_their_commit(ctx, sdata, htlcs = htlc_outputs_their_commit(ctx, peer,
idata->btc, idata->btc,
BITCOIN_HTLC_TOUS_TIMEOUT, BITCOIN_HTLC_TOUS_TIMEOUT,
BITCOIN_HTLC_TOTHEM_SPENT, BITCOIN_HTLC_TOTHEM_SPENT,
@@ -803,7 +803,7 @@ struct state_effect *state(const tal_t *ctx,
return next_state(ctx, effect, base + bits); return next_state(ctx, effect, base + bits);
/* This can happen multiple times: need to steal ALL */ /* This can happen multiple times: need to steal ALL */
} else if (input_is(input, BITCOIN_ANCHOR_OTHERSPEND)) { } else if (input_is(input, BITCOIN_ANCHOR_OTHERSPEND)) {
tx = bitcoin_steal(ctx, sdata, idata->btc); tx = bitcoin_steal(ctx, peer, idata->btc);
if (!tx) if (!tx)
return next_state(ctx, effect, return next_state(ctx, effect,
STATE_ERR_INFORMATION_LEAK); STATE_ERR_INFORMATION_LEAK);
@@ -889,14 +889,14 @@ start_unilateral_close:
/* No more inputs, no more commands. */ /* No more inputs, no more commands. */
add_effect(&effect, stop_packets, true); add_effect(&effect, stop_packets, true);
add_effect(&effect, stop_commands, true); add_effect(&effect, stop_commands, true);
tx = bitcoin_commit(ctx, sdata); tx = bitcoin_commit(ctx, peer);
add_effect(&effect, broadcast_tx, tx); add_effect(&effect, broadcast_tx, tx);
add_effect(&effect, watch, add_effect(&effect, watch,
bitcoin_watch_delayed(ctx, tx, bitcoin_watch_delayed(ctx, tx,
BITCOIN_ANCHOR_OURCOMMIT_DELAYPASSED)); BITCOIN_ANCHOR_OURCOMMIT_DELAYPASSED));
/* HTLC watches. */ /* HTLC watches. */
htlcs = htlc_outputs_our_commit(ctx, sdata, tx, htlcs = htlc_outputs_our_commit(ctx, peer, tx,
BITCOIN_HTLC_TOUS_TIMEOUT, BITCOIN_HTLC_TOUS_TIMEOUT,
BITCOIN_HTLC_TOTHEM_SPENT, BITCOIN_HTLC_TOTHEM_SPENT,
BITCOIN_HTLC_TOTHEM_TIMEOUT); BITCOIN_HTLC_TOTHEM_TIMEOUT);
@@ -922,14 +922,14 @@ start_unilateral_close_already_closing:
/* No more inputs, no more commands. */ /* No more inputs, no more commands. */
add_effect(&effect, stop_packets, true); add_effect(&effect, stop_packets, true);
add_effect(&effect, stop_commands, true); add_effect(&effect, stop_commands, true);
tx = bitcoin_commit(ctx, sdata); tx = bitcoin_commit(ctx, peer);
add_effect(&effect, broadcast_tx, tx); add_effect(&effect, broadcast_tx, tx);
add_effect(&effect, watch, add_effect(&effect, watch,
bitcoin_watch_delayed(ctx, tx, bitcoin_watch_delayed(ctx, tx,
BITCOIN_ANCHOR_OURCOMMIT_DELAYPASSED)); BITCOIN_ANCHOR_OURCOMMIT_DELAYPASSED));
/* We agreed to close: shouldn't have any HTLCs */ /* We agreed to close: shouldn't have any HTLCs */
if (committed_to_htlcs(sdata)) if (committed_to_htlcs(peer))
return next_state(ctx, effect, STATE_ERR_INTERNAL); return next_state(ctx, effect, STATE_ERR_INTERNAL);
return next_state(ctx, effect, STATE_CLOSE_WAIT_CLOSE_OURCOMMIT); return next_state(ctx, effect, STATE_CLOSE_WAIT_CLOSE_OURCOMMIT);
@@ -945,7 +945,7 @@ them_unilateral:
/* No more inputs, no more commands. */ /* No more inputs, no more commands. */
add_effect(&effect, stop_packets, true); add_effect(&effect, stop_packets, true);
add_effect(&effect, stop_commands, true); add_effect(&effect, stop_commands, true);
tx = bitcoin_spend_theirs(ctx, sdata, idata->btc); tx = bitcoin_spend_theirs(ctx, peer, idata->btc);
add_effect(&effect, broadcast_tx, tx); add_effect(&effect, broadcast_tx, tx);
add_effect(&effect, watch, add_effect(&effect, watch,
bitcoin_watch(ctx, tx, bitcoin_watch(ctx, tx,
@@ -953,7 +953,7 @@ them_unilateral:
/* HTLC watches (based on what they broadcast, which *may* be out /* HTLC watches (based on what they broadcast, which *may* be out
* of step with our current state by +/- 1 htlc. */ * of step with our current state by +/- 1 htlc. */
htlcs = htlc_outputs_their_commit(ctx, sdata, idata->btc, htlcs = htlc_outputs_their_commit(ctx, peer, idata->btc,
BITCOIN_HTLC_TOUS_TIMEOUT, BITCOIN_HTLC_TOUS_TIMEOUT,
BITCOIN_HTLC_TOTHEM_SPENT, BITCOIN_HTLC_TOTHEM_SPENT,
BITCOIN_HTLC_TOTHEM_TIMEOUT); BITCOIN_HTLC_TOTHEM_TIMEOUT);
@@ -964,7 +964,7 @@ them_unilateral:
return next_state(ctx, effect, STATE_CLOSE_WAIT_SPENDTHEM); return next_state(ctx, effect, STATE_CLOSE_WAIT_SPENDTHEM);
accept_htlc_update: accept_htlc_update:
err = accept_pkt_htlc_update(ctx, sdata, idata->pkt, &decline, &htlcprog, err = accept_pkt_htlc_update(ctx, peer, idata->pkt, &decline, &htlcprog,
&effect); &effect);
if (err) if (err)
goto err_start_unilateral_close; goto err_start_unilateral_close;
@@ -974,34 +974,34 @@ accept_htlc_update:
return next_state(ctx, effect, prio(state, STATE_NORMAL)); return next_state(ctx, effect, prio(state, STATE_NORMAL));
} }
add_effect(&effect, htlc_in_progress, htlcprog); add_effect(&effect, htlc_in_progress, htlcprog);
add_effect(&effect, send_pkt, pkt_update_accept(ctx, sdata)); add_effect(&effect, send_pkt, pkt_update_accept(ctx, peer));
return next_state(ctx, effect, prio(state, STATE_WAIT_FOR_UPDATE_SIG)); return next_state(ctx, effect, prio(state, STATE_WAIT_FOR_UPDATE_SIG));
accept_htlc_routefail: accept_htlc_routefail:
err = accept_pkt_htlc_routefail(ctx, sdata, idata->pkt, &htlcprog, err = accept_pkt_htlc_routefail(ctx, peer, idata->pkt, &htlcprog,
&effect); &effect);
if (err) if (err)
goto err_start_unilateral_close; goto err_start_unilateral_close;
add_effect(&effect, htlc_in_progress, htlcprog); add_effect(&effect, htlc_in_progress, htlcprog);
add_effect(&effect, send_pkt, pkt_update_accept(ctx, sdata)); add_effect(&effect, send_pkt, pkt_update_accept(ctx, peer));
return next_state(ctx, effect, prio(state, STATE_WAIT_FOR_UPDATE_SIG)); return next_state(ctx, effect, prio(state, STATE_WAIT_FOR_UPDATE_SIG));
accept_htlc_timedout: accept_htlc_timedout:
err = accept_pkt_htlc_timedout(ctx, sdata, idata->pkt, &htlcprog, err = accept_pkt_htlc_timedout(ctx, peer, idata->pkt, &htlcprog,
&effect); &effect);
if (err) if (err)
goto err_start_unilateral_close; goto err_start_unilateral_close;
add_effect(&effect, htlc_in_progress, htlcprog); add_effect(&effect, htlc_in_progress, htlcprog);
add_effect(&effect, send_pkt, pkt_update_accept(ctx, sdata)); add_effect(&effect, send_pkt, pkt_update_accept(ctx, peer));
return next_state(ctx, effect, prio(state, STATE_WAIT_FOR_UPDATE_SIG)); return next_state(ctx, effect, prio(state, STATE_WAIT_FOR_UPDATE_SIG));
accept_htlc_fulfill: accept_htlc_fulfill:
err = accept_pkt_htlc_fulfill(ctx, sdata, idata->pkt, &htlcprog, err = accept_pkt_htlc_fulfill(ctx, peer, idata->pkt, &htlcprog,
&effect); &effect);
if (err) if (err)
goto err_start_unilateral_close; goto err_start_unilateral_close;
add_effect(&effect, htlc_in_progress, htlcprog); add_effect(&effect, htlc_in_progress, htlcprog);
add_effect(&effect, send_pkt, pkt_update_accept(ctx, sdata)); add_effect(&effect, send_pkt, pkt_update_accept(ctx, peer));
add_effect(&effect, r_value, r_value_from_pkt(ctx, idata->pkt)); add_effect(&effect, r_value, r_value_from_pkt(ctx, idata->pkt));
return next_state(ctx, effect, prio(state, STATE_WAIT_FOR_UPDATE_SIG)); return next_state(ctx, effect, prio(state, STATE_WAIT_FOR_UPDATE_SIG));
@@ -1010,7 +1010,7 @@ start_closing:
* Start a mutual close. * Start a mutual close.
*/ */
/* Protocol doesn't (currently?) allow closing with HTLCs. */ /* Protocol doesn't (currently?) allow closing with HTLCs. */
if (committed_to_htlcs(sdata)) { if (committed_to_htlcs(peer)) {
add_effect(&effect, cmd_close_done, false); add_effect(&effect, cmd_close_done, false);
err = pkt_err(ctx, "Close forced due to HTLCs"); err = pkt_err(ctx, "Close forced due to HTLCs");
goto err_start_unilateral_close; goto err_start_unilateral_close;
@@ -1018,20 +1018,20 @@ start_closing:
add_effect(&effect, close_timeout, INPUT_CLOSE_COMPLETE_TIMEOUT); add_effect(&effect, close_timeout, INPUT_CLOSE_COMPLETE_TIMEOUT);
add_effect(&effect, watch, add_effect(&effect, watch,
bitcoin_watch_close(ctx, sdata, BITCOIN_CLOSE_DONE)); bitcoin_watch_close(ctx, peer, BITCOIN_CLOSE_DONE));
/* As soon as we send packet, they could close. */ /* As soon as we send packet, they could close. */
add_effect(&effect, send_pkt, pkt_close(ctx, sdata)); add_effect(&effect, send_pkt, pkt_close(ctx, peer));
return next_state(ctx, effect, STATE_WAIT_FOR_CLOSE_COMPLETE); return next_state(ctx, effect, STATE_WAIT_FOR_CLOSE_COMPLETE);
accept_closing: accept_closing:
err = accept_pkt_close(ctx, sdata, idata->pkt, &effect); err = accept_pkt_close(ctx, peer, idata->pkt, &effect);
if (err) if (err)
goto err_start_unilateral_close; goto err_start_unilateral_close;
/* As soon as we send packet, they could close. */ /* As soon as we send packet, they could close. */
add_effect(&effect, watch, add_effect(&effect, watch,
bitcoin_watch_close(ctx, sdata, BITCOIN_CLOSE_DONE)); bitcoin_watch_close(ctx, peer, BITCOIN_CLOSE_DONE));
add_effect(&effect, send_pkt, pkt_close_complete(ctx, sdata)); add_effect(&effect, send_pkt, pkt_close_complete(ctx, peer));
/* No more commands, we're already closing. */ /* No more commands, we're already closing. */
add_effect(&effect, stop_commands, true); add_effect(&effect, stop_commands, true);
return next_state(ctx, effect, STATE_WAIT_FOR_CLOSE_ACK); return next_state(ctx, effect, STATE_WAIT_FOR_CLOSE_ACK);
@@ -1047,7 +1047,7 @@ instant_close:
add_effect(&effect, stop_commands, true); add_effect(&effect, stop_commands, true);
/* We can't have any HTLCs, since we haven't started. */ /* We can't have any HTLCs, since we haven't started. */
if (committed_to_htlcs(sdata)) if (committed_to_htlcs(peer))
return next_state(ctx, effect, STATE_ERR_INTERNAL); return next_state(ctx, effect, STATE_ERR_INTERNAL);
return next_state(ctx, effect, STATE_CLOSED); return next_state(ctx, effect, STATE_CLOSED);
@@ -1063,12 +1063,12 @@ fail_during_close:
return next_state(ctx, effect, STATE_CLOSED); return next_state(ctx, effect, STATE_CLOSED);
} else if (input_is(input, BITCOIN_ANCHOR_THEIRSPEND)) { } else if (input_is(input, BITCOIN_ANCHOR_THEIRSPEND)) {
/* A reorganization could make this happen. */ /* A reorganization could make this happen. */
tx = bitcoin_spend_theirs(ctx, sdata, idata->btc); tx = bitcoin_spend_theirs(ctx, peer, idata->btc);
add_effect(&effect, broadcast_tx, tx); add_effect(&effect, broadcast_tx, tx);
add_effect(&effect, watch, add_effect(&effect, watch,
bitcoin_watch(ctx, tx, bitcoin_watch(ctx, tx,
BITCOIN_SPEND_THEIRS_DONE)); BITCOIN_SPEND_THEIRS_DONE));
htlcs = htlc_outputs_their_commit(ctx, sdata, idata->btc, htlcs = htlc_outputs_their_commit(ctx, peer, idata->btc,
BITCOIN_HTLC_TOUS_TIMEOUT, BITCOIN_HTLC_TOUS_TIMEOUT,
BITCOIN_HTLC_TOTHEM_SPENT, BITCOIN_HTLC_TOTHEM_SPENT,
BITCOIN_HTLC_TOTHEM_TIMEOUT); BITCOIN_HTLC_TOTHEM_TIMEOUT);
@@ -1081,7 +1081,7 @@ fail_during_close:
} }
return next_state(ctx, effect, STATE_CLOSE_WAIT_SPENDTHEM_CLOSE); return next_state(ctx, effect, STATE_CLOSE_WAIT_SPENDTHEM_CLOSE);
} else if (input_is(input, BITCOIN_ANCHOR_OTHERSPEND)) { } else if (input_is(input, BITCOIN_ANCHOR_OTHERSPEND)) {
tx = bitcoin_steal(ctx, sdata, idata->btc); tx = bitcoin_steal(ctx, peer, idata->btc);
if (!tx) if (!tx)
return next_state(ctx, effect, return next_state(ctx, effect,
STATE_ERR_INFORMATION_LEAK); STATE_ERR_INFORMATION_LEAK);
@@ -1106,7 +1106,7 @@ old_commit_spotted:
add_effect(&effect, stop_commands, true); add_effect(&effect, stop_commands, true);
/* If we can't find it, we're lost. */ /* If we can't find it, we're lost. */
tx = bitcoin_steal(ctx, sdata, idata->btc); tx = bitcoin_steal(ctx, peer, idata->btc);
if (!tx) if (!tx)
return next_state(ctx, effect, STATE_ERR_INFORMATION_LEAK); return next_state(ctx, effect, STATE_ERR_INFORMATION_LEAK);
add_effect(&effect, broadcast_tx, tx); add_effect(&effect, broadcast_tx, tx);

106
state.h
View File

@@ -115,7 +115,7 @@ static inline bool state_is_error(enum state s)
return s >= STATE_ERR_ANCHOR_TIMEOUT && s <= STATE_ERR_INTERNAL; return s >= STATE_ERR_ANCHOR_TIMEOUT && s <= STATE_ERR_INTERNAL;
} }
struct state_data; struct peer;
static bool input_is_pkt(enum state_input input) static bool input_is_pkt(enum state_input input)
{ {
@@ -132,7 +132,7 @@ union input {
struct state_effect *state(const tal_t *ctx, struct state_effect *state(const tal_t *ctx,
const enum state state, const enum state state,
const struct state_data *sdata, const struct peer *peer,
const enum state_input input, const enum state_input input,
const union input *idata); const union input *idata);
@@ -160,108 +160,108 @@ static inline bool input_is(enum state_input a, enum state_input b)
struct signature; struct signature;
/* Create various kinds of packets, allocated off @ctx */ /* Create various kinds of packets, allocated off @ctx */
Pkt *pkt_open(const tal_t *ctx, const struct state_data *sdata, Pkt *pkt_open(const tal_t *ctx, const struct peer *peer,
OpenChannel__AnchorOffer anchor); OpenChannel__AnchorOffer anchor);
Pkt *pkt_anchor(const tal_t *ctx, const struct state_data *sdata); Pkt *pkt_anchor(const tal_t *ctx, const struct peer *peer);
Pkt *pkt_open_commit_sig(const tal_t *ctx, const struct state_data *sdata); Pkt *pkt_open_commit_sig(const tal_t *ctx, const struct peer *peer);
Pkt *pkt_open_complete(const tal_t *ctx, const struct state_data *sdata); Pkt *pkt_open_complete(const tal_t *ctx, const struct peer *peer);
Pkt *pkt_htlc_update(const tal_t *ctx, const struct state_data *sdata, Pkt *pkt_htlc_update(const tal_t *ctx, const struct peer *peer,
const struct htlc_progress *htlc_prog); const struct htlc_progress *htlc_prog);
Pkt *pkt_htlc_fulfill(const tal_t *ctx, const struct state_data *sdata, Pkt *pkt_htlc_fulfill(const tal_t *ctx, const struct peer *peer,
const struct htlc_progress *htlc_prog); const struct htlc_progress *htlc_prog);
Pkt *pkt_htlc_timedout(const tal_t *ctx, const struct state_data *sdata, Pkt *pkt_htlc_timedout(const tal_t *ctx, const struct peer *peer,
const struct htlc_progress *htlc_prog); const struct htlc_progress *htlc_prog);
Pkt *pkt_htlc_routefail(const tal_t *ctx, const struct state_data *sdata, Pkt *pkt_htlc_routefail(const tal_t *ctx, const struct peer *peer,
const struct htlc_progress *htlc_prog); const struct htlc_progress *htlc_prog);
Pkt *pkt_update_accept(const tal_t *ctx, const struct state_data *sdata); Pkt *pkt_update_accept(const tal_t *ctx, const struct peer *peer);
Pkt *pkt_update_signature(const tal_t *ctx, const struct state_data *sdata); Pkt *pkt_update_signature(const tal_t *ctx, const struct peer *peer);
Pkt *pkt_update_complete(const tal_t *ctx, const struct state_data *sdata); Pkt *pkt_update_complete(const tal_t *ctx, const struct peer *peer);
Pkt *pkt_err(const tal_t *ctx, const char *msg); Pkt *pkt_err(const tal_t *ctx, const char *msg);
Pkt *pkt_close(const tal_t *ctx, const struct state_data *sdata); Pkt *pkt_close(const tal_t *ctx, const struct peer *peer);
Pkt *pkt_close_complete(const tal_t *ctx, const struct state_data *sdata); Pkt *pkt_close_complete(const tal_t *ctx, const struct peer *peer);
Pkt *pkt_close_ack(const tal_t *ctx, const struct state_data *sdata); Pkt *pkt_close_ack(const tal_t *ctx, const struct peer *peer);
Pkt *unexpected_pkt(const tal_t *ctx, enum state_input input); Pkt *unexpected_pkt(const tal_t *ctx, enum state_input input);
/* Process various packets: return an error packet on failure. */ /* Process various packets: return an error packet on failure. */
Pkt *accept_pkt_open(const tal_t *ctx, Pkt *accept_pkt_open(const tal_t *ctx,
const struct state_data *sdata, const struct peer *peer,
const Pkt *pkt, const Pkt *pkt,
struct state_effect **effect); struct state_effect **effect);
Pkt *accept_pkt_anchor(const tal_t *ctx, Pkt *accept_pkt_anchor(const tal_t *ctx,
const struct state_data *sdata, const struct peer *peer,
const Pkt *pkt, const Pkt *pkt,
struct state_effect **effect); struct state_effect **effect);
Pkt *accept_pkt_open_commit_sig(const tal_t *ctx, Pkt *accept_pkt_open_commit_sig(const tal_t *ctx,
const struct state_data *sdata, const Pkt *pkt, const struct peer *peer, const Pkt *pkt,
struct state_effect **effect); struct state_effect **effect);
Pkt *accept_pkt_htlc_update(const tal_t *ctx, Pkt *accept_pkt_htlc_update(const tal_t *ctx,
const struct state_data *sdata, const Pkt *pkt, const struct peer *peer, const Pkt *pkt,
Pkt **decline, Pkt **decline,
struct htlc_progress **htlcprog, struct htlc_progress **htlcprog,
struct state_effect **effect); struct state_effect **effect);
Pkt *accept_pkt_htlc_routefail(const tal_t *ctx, Pkt *accept_pkt_htlc_routefail(const tal_t *ctx,
const struct state_data *sdata, const Pkt *pkt, const struct peer *peer, const Pkt *pkt,
struct htlc_progress **htlcprog, struct htlc_progress **htlcprog,
struct state_effect **effect); struct state_effect **effect);
Pkt *accept_pkt_htlc_timedout(const tal_t *ctx, Pkt *accept_pkt_htlc_timedout(const tal_t *ctx,
const struct state_data *sdata, const Pkt *pkt, const struct peer *peer, const Pkt *pkt,
struct htlc_progress **htlcprog, struct htlc_progress **htlcprog,
struct state_effect **effect); struct state_effect **effect);
Pkt *accept_pkt_htlc_fulfill(const tal_t *ctx, Pkt *accept_pkt_htlc_fulfill(const tal_t *ctx,
const struct state_data *sdata, const Pkt *pkt, const struct peer *peer, const Pkt *pkt,
struct htlc_progress **htlcprog, struct htlc_progress **htlcprog,
struct state_effect **effect); struct state_effect **effect);
Pkt *accept_pkt_update_accept(const tal_t *ctx, Pkt *accept_pkt_update_accept(const tal_t *ctx,
const struct state_data *sdata, const Pkt *pkt, const struct peer *peer, const Pkt *pkt,
struct signature **sig, struct signature **sig,
struct state_effect **effect); struct state_effect **effect);
Pkt *accept_pkt_update_complete(const tal_t *ctx, Pkt *accept_pkt_update_complete(const tal_t *ctx,
const struct state_data *sdata, const Pkt *pkt, const struct peer *peer, const Pkt *pkt,
struct state_effect **effect); struct state_effect **effect);
Pkt *accept_pkt_update_signature(const tal_t *ctx, Pkt *accept_pkt_update_signature(const tal_t *ctx,
const struct state_data *sdata, const struct peer *peer,
const Pkt *pkt, const Pkt *pkt,
struct signature **sig, struct signature **sig,
struct state_effect **effect); struct state_effect **effect);
Pkt *accept_pkt_close(const tal_t *ctx, Pkt *accept_pkt_close(const tal_t *ctx,
const struct state_data *sdata, const Pkt *pkt, const struct peer *peer, const Pkt *pkt,
struct state_effect **effect); struct state_effect **effect);
Pkt *accept_pkt_close_complete(const tal_t *ctx, Pkt *accept_pkt_close_complete(const tal_t *ctx,
const struct state_data *sdata, const Pkt *pkt, const struct peer *peer, const Pkt *pkt,
struct state_effect **effect); struct state_effect **effect);
Pkt *accept_pkt_simultaneous_close(const tal_t *ctx, Pkt *accept_pkt_simultaneous_close(const tal_t *ctx,
const struct state_data *sdata, const struct peer *peer,
const Pkt *pkt, const Pkt *pkt,
struct state_effect **effect); struct state_effect **effect);
Pkt *accept_pkt_close_ack(const tal_t *ctx, Pkt *accept_pkt_close_ack(const tal_t *ctx,
const struct state_data *sdata, const Pkt *pkt, const struct peer *peer, const Pkt *pkt,
struct state_effect **effect); struct state_effect **effect);
/** /**
* committed_to_htlcs: do we have any locked-in HTLCs? * committed_to_htlcs: do we have any locked-in HTLCs?
* @sdata: the state data for this peer. * @peer: the state data for this peer.
* *
* If we were to generate a commit tx now, would it have HTLCs in it? * If we were to generate a commit tx now, would it have HTLCs in it?
*/ */
bool committed_to_htlcs(const struct state_data *sdata); bool committed_to_htlcs(const struct peer *peer);
/** /**
* bitcoin_watch_anchor: create a watch for the anchor. * bitcoin_watch_anchor: create a watch for the anchor.
* @ctx: context to tal the watch struct off. * @ctx: context to tal the watch struct off.
* @sdata: the state data for this peer. * @peer: the state data for this peer.
* @depthok: the input to give when anchor reaches expected depth. * @depthok: the input to give when anchor reaches expected depth.
* @timeout: the input to give if anchor doesn't reach depth in time. * @timeout: the input to give if anchor doesn't reach depth in time.
* @unspent: the input to give if anchor is unspent after @depthok. * @unspent: the input to give if anchor is unspent after @depthok.
@@ -272,7 +272,7 @@ bool committed_to_htlcs(const struct state_data *sdata);
* ourselves out). * ourselves out).
*/ */
struct watch *bitcoin_watch_anchor(const tal_t *ctx, struct watch *bitcoin_watch_anchor(const tal_t *ctx,
const struct state_data *sdata, const struct peer *peer,
enum state_input depthok, enum state_input depthok,
enum state_input timeout, enum state_input timeout,
enum state_input unspent, enum state_input unspent,
@@ -282,14 +282,14 @@ struct watch *bitcoin_watch_anchor(const tal_t *ctx,
/** /**
* bitcoin_unwatch_anchor_depth: remove depth watch for the anchor. * bitcoin_unwatch_anchor_depth: remove depth watch for the anchor.
* @ctx: context to tal the watch struct off. * @ctx: context to tal the watch struct off.
* @sdata: the state data for this peer. * @peer: the state data for this peer.
* @depthok: the input to give when anchor reaches expected depth. * @depthok: the input to give when anchor reaches expected depth.
* @timeout: the input to give if anchor doesn't reach depth in time. * @timeout: the input to give if anchor doesn't reach depth in time.
* *
* @depthok and @timeout must match bitcoin_watch_anchor() call. * @depthok and @timeout must match bitcoin_watch_anchor() call.
*/ */
struct watch *bitcoin_unwatch_anchor_depth(const tal_t *ctx, struct watch *bitcoin_unwatch_anchor_depth(const tal_t *ctx,
const struct state_data *sdata, const struct peer *peer,
enum state_input depthok, enum state_input depthok,
enum state_input timeout); enum state_input timeout);
@@ -321,26 +321,26 @@ struct watch *bitcoin_watch(const tal_t *ctx,
/** /**
* bitcoin_watch_close: watch close tx until it's "irreversible" * bitcoin_watch_close: watch close tx until it's "irreversible"
* @ctx: context to tal the watch struct off. * @ctx: context to tal the watch struct off.
* @sdata: the state data for this peer. * @peer: the state data for this peer.
* @done: the input to give when tx is completely buried. * @done: the input to give when tx is completely buried.
* *
* This tx *is* malleable, since the other side can transmit theirs. * This tx *is* malleable, since the other side can transmit theirs.
*/ */
struct watch *bitcoin_watch_close(const tal_t *ctx, struct watch *bitcoin_watch_close(const tal_t *ctx,
const struct state_data *sdata, const struct peer *peer,
enum state_input done); enum state_input done);
/** /**
* htlc_outputs_our_commit: HTLC outputs from our commit tx to watch. * htlc_outputs_our_commit: HTLC outputs from our commit tx to watch.
* @ctx: context to tal the watch struct off. * @ctx: context to tal the watch struct off.
* @sdata: the state data for this peer. * @peer: the state data for this peer.
* @tx: the commitment tx * @tx: the commitment tx
* @tous_timeout: input to give when a HTLC output to us times out. * @tous_timeout: input to give when a HTLC output to us times out.
* @tothem_spent: input to give when a HTLC output to them is spent. * @tothem_spent: input to give when a HTLC output to them is spent.
* @tothem_timeout: input to give when a HTLC output to them times out. * @tothem_timeout: input to give when a HTLC output to them times out.
*/ */
struct htlc_watch *htlc_outputs_our_commit(const tal_t *ctx, struct htlc_watch *htlc_outputs_our_commit(const tal_t *ctx,
const struct state_data *sdata, const struct peer *peer,
const struct bitcoin_tx *tx, const struct bitcoin_tx *tx,
enum state_input tous_timeout, enum state_input tous_timeout,
enum state_input tothem_spent, enum state_input tothem_spent,
@@ -349,14 +349,14 @@ struct htlc_watch *htlc_outputs_our_commit(const tal_t *ctx,
/** /**
* htlc_outputs_their_commit: HTLC outputs from their commit tx to watch. * htlc_outputs_their_commit: HTLC outputs from their commit tx to watch.
* @ctx: context to tal the watch struct off. * @ctx: context to tal the watch struct off.
* @sdata: the state data for this peer. * @peer: the state data for this peer.
* @tx: the commitment tx * @tx: the commitment tx
* @tous_timeout: input to give when a HTLC output to us times out. * @tous_timeout: input to give when a HTLC output to us times out.
* @tothem_spent: input to give when a HTLC output to them is spent. * @tothem_spent: input to give when a HTLC output to them is spent.
* @tothem_timeout: input to give when a HTLC output to them times out. * @tothem_timeout: input to give when a HTLC output to them times out.
*/ */
struct htlc_watch *htlc_outputs_their_commit(const tal_t *ctx, struct htlc_watch *htlc_outputs_their_commit(const tal_t *ctx,
const struct state_data *sdata, const struct peer *peer,
const struct bitcoin_event *tx, const struct bitcoin_event *tx,
enum state_input tous_timeout, enum state_input tous_timeout,
enum state_input tothem_spent, enum state_input tothem_spent,
@@ -375,10 +375,10 @@ struct htlc_unwatch *htlc_unwatch(const tal_t *ctx,
/** /**
* htlc_unwatch_all: stop watching all HTLCs * htlc_unwatch_all: stop watching all HTLCs
* @ctx: context to tal the watch struct off. * @ctx: context to tal the watch struct off.
* @sdata: the state data for this peer. * @peer: the state data for this peer.
*/ */
struct htlc_unwatch *htlc_unwatch_all(const tal_t *ctx, struct htlc_unwatch *htlc_unwatch_all(const tal_t *ctx,
const struct state_data *sdata); const struct peer *peer);
/** /**
* htlc_spend_watch: watch our spend of an HTLC * htlc_spend_watch: watch our spend of an HTLC
@@ -403,42 +403,42 @@ struct htlc_spend_watch *htlc_spend_unwatch(const tal_t *ctx,
enum state_input all_done); enum state_input all_done);
/* Create a bitcoin anchor tx. */ /* Create a bitcoin anchor tx. */
struct bitcoin_tx *bitcoin_anchor(const tal_t *ctx, struct bitcoin_tx *bitcoin_anchor(const tal_t *ctx,
const struct state_data *sdata); const struct peer *peer);
/* Create a bitcoin close tx. */ /* Create a bitcoin close tx. */
struct bitcoin_tx *bitcoin_close(const tal_t *ctx, struct bitcoin_tx *bitcoin_close(const tal_t *ctx,
const struct state_data *sdata); const struct peer *peer);
/* Create a bitcoin spend tx (to spend our commit's outputs) */ /* Create a bitcoin spend tx (to spend our commit's outputs) */
struct bitcoin_tx *bitcoin_spend_ours(const tal_t *ctx, struct bitcoin_tx *bitcoin_spend_ours(const tal_t *ctx,
const struct state_data *sdata); const struct peer *peer);
/* Create a bitcoin spend tx (to spend their commit's outputs) */ /* Create a bitcoin spend tx (to spend their commit's outputs) */
struct bitcoin_tx *bitcoin_spend_theirs(const tal_t *ctx, struct bitcoin_tx *bitcoin_spend_theirs(const tal_t *ctx,
const struct state_data *sdata, const struct peer *peer,
const struct bitcoin_event *btc); const struct bitcoin_event *btc);
/* Create a bitcoin steal tx (to steal all their commit's outputs) */ /* Create a bitcoin steal tx (to steal all their commit's outputs) */
struct bitcoin_tx *bitcoin_steal(const tal_t *ctx, struct bitcoin_tx *bitcoin_steal(const tal_t *ctx,
const struct state_data *sdata, const struct peer *peer,
struct bitcoin_event *btc); struct bitcoin_event *btc);
/* Create our commit tx */ /* Create our commit tx */
struct bitcoin_tx *bitcoin_commit(const tal_t *ctx, struct bitcoin_tx *bitcoin_commit(const tal_t *ctx,
const struct state_data *sdata); const struct peer *peer);
/* Create a HTLC refund collection */ /* Create a HTLC refund collection */
struct bitcoin_tx *bitcoin_htlc_timeout(const tal_t *ctx, struct bitcoin_tx *bitcoin_htlc_timeout(const tal_t *ctx,
const struct state_data *sdata, const struct peer *peer,
const struct htlc *htlc); const struct htlc *htlc);
/* Create a HTLC collection */ /* Create a HTLC collection */
struct bitcoin_tx *bitcoin_htlc_spend(const tal_t *ctx, struct bitcoin_tx *bitcoin_htlc_spend(const tal_t *ctx,
const struct state_data *sdata, const struct peer *peer,
const struct htlc *htlc); const struct htlc *htlc);
struct htlc_rval *r_value_from_cmd(const tal_t *ctx, struct htlc_rval *r_value_from_cmd(const tal_t *ctx,
const struct state_data *sdata, const struct peer *peer,
const struct htlc *htlc); const struct htlc *htlc);
struct htlc_rval *bitcoin_r_value(const tal_t *ctx, const struct htlc *htlc); struct htlc_rval *bitcoin_r_value(const tal_t *ctx, const struct htlc *htlc);
struct htlc_rval *r_value_from_pkt(const tal_t *ctx, const Pkt *pkt); struct htlc_rval *r_value_from_pkt(const tal_t *ctx, const Pkt *pkt);

698
test/test_state_coverage.c
View File

File diff suppressed because it is too large Load Diff