lukechilds
/
lightning
mirror of https://github.com/lukechilds/lightning.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

watch: express everything in terms of watch_tx and watch_txo. 

With segregated witness, we can (in advance!) specify the txid or tx
output we want to watch, so convert to that now.  For the moment it's
done by pretending we have normalized txids; that goes away after the
conversion.

Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
ppa-0.6.1
Rusty Russell 9 years ago
parent
14d722d48d
commit
3d9cb81215
4 changed files with 222 additions and 193 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 36
      daemon/peer.c
  2. 2
      daemon/test/test.sh
  3. 246
      daemon/watch.c
  4. 55
      daemon/watch.h

36
daemon/peer.c
View File

@ -644,8 +644,10 @@ struct anchor_watch {
static void anchor_depthchange(struct peer *peer, int depth, static void anchor_depthchange(struct peer *peer, int depth,
const struct sha256_double *blkhash, const struct sha256_double *blkhash,
struct anchor_watch *w) const struct sha256_double *txid,
void *unused)
{ {
struct anchor_watch *w = peer->anchor.watches;
/* Still waiting for it to reach depth? */ /* Still waiting for it to reach depth? */
if (w->depthok != INPUT_NONE) { if (w->depthok != INPUT_NONE) {
/* Beware sign! */ /* Beware sign! */
@ -737,7 +739,10 @@ static bool is_mutual_close(const struct peer *peer,
return matches; return matches;
} }
static void close_depth_cb(struct peer *peer, int depth) static void close_depth_cb(struct peer *peer, int depth,
const struct sha256_double *txid,
const struct sha256_double *blkhash,
void *unused)
{ {
if (depth >= peer->dstate->config.forever_confirms) { if (depth >= peer->dstate->config.forever_confirms) {
state_event(peer, BITCOIN_CLOSE_DONE, NULL); state_event(peer, BITCOIN_CLOSE_DONE, NULL);
@ -748,8 +753,9 @@ static void close_depth_cb(struct peer *peer, int depth)
* invalid transactions! */ * invalid transactions! */
static void anchor_spent(struct peer *peer, static void anchor_spent(struct peer *peer,
const struct bitcoin_tx *tx, const struct bitcoin_tx *tx,
struct anchor_watch *w) void *unused)
{ {
struct anchor_watch *w = peer->anchor.watches;
union input idata; union input idata;
/* FIXME: change type in idata? */ /* FIXME: change type in idata? */
@ -757,7 +763,7 @@ static void anchor_spent(struct peer *peer,
if (is_unrevoked_commit(peer->them.commit, tx)) if (is_unrevoked_commit(peer->them.commit, tx))
state_event(peer, w->theyspent, &idata); state_event(peer, w->theyspent, &idata);
else if (is_mutual_close(peer, tx)) else if (is_mutual_close(peer, tx))
add_close_tx_watch(peer, peer, tx, close_depth_cb); watch_tx(peer, peer, tx, close_depth_cb, NULL);
else else
state_event(peer, w->otherspent, &idata); state_event(peer, w->otherspent, &idata);
} }
@ -789,10 +795,9 @@ void peer_watch_anchor(struct peer *peer,
w->theyspent = theyspent; w->theyspent = theyspent;
w->otherspent = otherspent; w->otherspent = otherspent;
add_anchor_watch(w, peer, &peer->anchor.txid, peer->anchor.index, peer_watch_setup(peer);
anchor_depthchange, watch_txid(w, peer, &peer->anchor.txid, anchor_depthchange, NULL);
anchor_spent, watch_txo(w, peer, &peer->anchor.txid, 0, anchor_spent, NULL);
w);
/* For anchor timeout, expect 20 minutes per block, +2 hours. /* For anchor timeout, expect 20 minutes per block, +2 hours.
* *
@ -833,6 +838,7 @@ void peer_unwatch_anchor_depth(struct peer *peer,
static void commit_tx_depth(struct peer *peer, int depth, static void commit_tx_depth(struct peer *peer, int depth,
const struct sha256_double *blkhash, const struct sha256_double *blkhash,
const struct sha256_double *txid,
ptrint_t *canspend) ptrint_t *canspend)
{ {
log_debug(peer->log, "Commit tx reached depth %i", depth); log_debug(peer->log, "Commit tx reached depth %i", depth);
@ -899,7 +905,7 @@ void peer_watch_delayed(struct peer *peer,
memset(&peer->cur_commit.blockid, 0xFF, memset(&peer->cur_commit.blockid, 0xFF,
sizeof(peer->cur_commit.blockid)); sizeof(peer->cur_commit.blockid));
peer->cur_commit.watch peer->cur_commit.watch
= add_commit_tx_watch(tx, peer, &txid, commit_tx_depth, = watch_txid(tx, peer, &txid, commit_tx_depth,
int2ptr(canspend)); int2ptr(canspend));
watch_tx_outputs(peer, tx); watch_tx_outputs(peer, tx);
@ -907,6 +913,7 @@ void peer_watch_delayed(struct peer *peer,
static void spend_tx_done(struct peer *peer, int depth, static void spend_tx_done(struct peer *peer, int depth,
const struct sha256_double *blkhash, const struct sha256_double *blkhash,
const struct sha256_double *txid,
ptrint_t *done) ptrint_t *done)
{ {
log_debug(peer->log, "tx reached depth %i", depth); log_debug(peer->log, "tx reached depth %i", depth);
@ -930,16 +937,7 @@ void peer_watch_tx(struct peer *peer,
const struct bitcoin_tx *tx, const struct bitcoin_tx *tx,
enum state_input done) enum state_input done)
{ {
struct sha256_double txid; watch_tx(tx, peer, tx, spend_tx_done, int2ptr(done));
bitcoin_txid(tx, &txid);
log_debug(peer->log, "Watching tx %02x%02x%02x%02x...",
txid.sha.u.u8[0],
txid.sha.u.u8[1],
txid.sha.u.u8[2],
txid.sha.u.u8[3]);
add_commit_tx_watch(tx, peer, &txid, spend_tx_done, int2ptr(done));
} }
struct bitcoin_tx *peer_create_close_tx(struct peer *peer, u64 fee) struct bitcoin_tx *peer_create_close_tx(struct peer *peer, u64 fee)

2
daemon/test/test.sh
View File

@ -408,7 +408,7 @@ $CLI generate 1
TIME=$(($EXPIRY + 33)) TIME=$(($EXPIRY + 33))
lcli1 dev-mocktime $TIME lcli1 dev-mocktime $TIME
lcli2 dev-mocktime $TIME lcli2 dev-mocktime $TIME
sleep 1 sleep 2
check_no_peers lcli1 check_no_peers lcli1
check_no_peers lcli2 check_no_peers lcli2

246
daemon/watch.c
View File

@ -58,28 +58,6 @@ static void destroy_txowatch(struct txowatch *w)
txowatch_hash_del(&w->peer->dstate->txowatches, w); txowatch_hash_del(&w->peer->dstate->txowatches, w);
} }
/* Watch a txo. */
static void insert_txo_watch(const tal_t *ctx,
struct peer *peer,
const struct sha256_double *txid,
unsigned int txout,
void (*cb)(struct peer *peer,
const struct bitcoin_tx *tx,
void *cbdata),
void *cbdata)
{
struct txowatch *w = tal(ctx, struct txowatch);
w->out.txid = *txid;
w->out.index = txout;
w->peer = peer;
w->cb = cb;
w->cbdata = cbdata;
txowatch_hash_add(&w->peer->dstate->txowatches, w);
tal_add_destructor(w, destroy_txowatch);
}
const struct sha256_double *txwatch_keyof(const struct txwatch *w) const struct sha256_double *txwatch_keyof(const struct txwatch *w)
{ {
return &w->txid; return &w->txid;
@ -100,30 +78,42 @@ static void destroy_txwatch(struct txwatch *w)
txwatch_hash_del(&w->dstate->txwatches, w); txwatch_hash_del(&w->dstate->txwatches, w);
} }
static struct txwatch *insert_txwatch(const tal_t *ctx, /* FIXME: This is a hack! */
void peer_watch_setup(struct peer *peer)
{
struct sha256 h;
struct ripemd160 redeemhash;
/* Telling bitcoind to watch the redeemhash address means
* it'll tell is about the anchor itself (spend to that
* address), and any commit txs (spend from that address).*/
sha256(&h, peer->anchor.redeemscript,
tal_count(peer->anchor.redeemscript));
ripemd160(&redeemhash, h.u.u8, sizeof(h));
bitcoind_watch_addr(peer->dstate, &redeemhash);
}
struct txwatch *watch_txid_(const tal_t *ctx,
struct peer *peer, struct peer *peer,
const struct sha256_double *txid, const struct sha256_double *txid,
void (*cb)(struct peer *, int, void (*cb)(struct peer *peer, int depth,
const struct sha256_double *, const struct sha256_double *blkhash,
void *), const struct sha256_double *txid,
void *cbdata) void *arg),
void *cb_arg)
{ {
struct txwatch *w; struct txwatch *w;
/* We could have a null-watch on it because we saw it spend a TXO */ assert(!txwatch_hash_get(&peer->dstate->txwatches, txid));
w = txwatch_hash_get(&peer->dstate->txwatches, txid);
if (w) {
assert(!w->cb);
tal_free(w);
}
w = tal(ctx, struct txwatch); w = tal(ctx, struct txwatch);
w->depth = 0; w->depth = -1;
w->txid = *txid; w->txid = *txid;
w->dstate = peer->dstate; w->dstate = peer->dstate;
w->peer = peer; w->peer = peer;
w->cb = cb; w->cb = cb;
w->cbdata = cbdata; w->cbdata = cb_arg;
txwatch_hash_add(&w->dstate->txwatches, w); txwatch_hash_add(&w->dstate->txwatches, w);
tal_add_destructor(w, destroy_txwatch); tal_add_destructor(w, destroy_txwatch);
@ -131,106 +121,128 @@ static struct txwatch *insert_txwatch(const tal_t *ctx,
return w; return w;
} }
/* This just serves to avoid us doing bitcoind_txid_lookup repeatedly struct txwatch *watch_tx_(const tal_t *ctx,
* on unknown txs. */ struct peer *peer,
static void insert_null_txwatch(struct lightningd_state *dstate, const struct bitcoin_tx *tx,
const struct sha256_double *txid) void (*cb)(struct peer *peer, int depth,
const struct sha256_double *blkhash,
const struct sha256_double *txid,
void *arg),
void *cb_arg)
{ {
struct txwatch *w = tal(dstate, struct txwatch); struct sha256_double txid;
w->depth = 0;
w->txid = *txid;
w->dstate = dstate;
w->peer = NULL;
w->cb = NULL;
w->cbdata = NULL;
txwatch_hash_add(&w->dstate->txwatches, w); normalized_txid(tx, &txid);
tal_add_destructor(w, destroy_txwatch); return watch_txid(ctx, peer, &txid, cb, cb_arg);
} }
void add_anchor_watch_(const tal_t *ctx, struct txowatch *watch_txo_(const tal_t *ctx,
struct peer *peer, struct peer *peer,
const struct sha256_double *txid, const struct sha256_double *txid,
unsigned int out, unsigned int output,
void (*anchor_cb)(struct peer *peer, int depth, void (*cb)(struct peer *peer,
const struct sha256_double *blkhash, const struct bitcoin_tx *tx,
void *), void *),
void (*spend_cb)(struct peer *peer,
const struct bitcoin_tx *, void *),
void *cbdata) void *cbdata)
{ {
struct sha256 h; struct txowatch *w = tal(ctx, struct txowatch);
struct ripemd160 redeemhash;
u8 *redeemscript;
insert_txwatch(ctx, peer, txid, anchor_cb, cbdata); w->out.txid = *txid;
insert_txo_watch(ctx, peer, txid, out, spend_cb, cbdata); w->out.index = output;
w->peer = peer;
w->cb = cb;
w->cbdata = cbdata;
redeemscript = bitcoin_redeem_2of2(ctx, &peer->them.commitkey, txowatch_hash_add(&w->peer->dstate->txowatches, w);
&peer->us.commitkey); tal_add_destructor(w, destroy_txowatch);
sha256(&h, redeemscript, tal_count(redeemscript));
ripemd160(&redeemhash, h.u.u8, sizeof(h));
tal_free(redeemscript);
/* Telling bitcoind to watch the redeemhash address means return w;
* it'll tell is about the anchor itself (spend to that
* address), and any commit txs (spend from that address).*/
bitcoind_watch_addr(peer->dstate, &redeemhash);
} }
struct txwatch *add_commit_tx_watch_(const tal_t *ctx, struct tx_info {
struct peer *peer, struct sha256_double blkhash;
const struct sha256_double *txid, int conf;
void (*cb)(struct peer *peer, int depth, };
const struct sha256_double *blkhash,
void *),
void *cbdata)
{
return insert_txwatch(ctx, peer, txid, cb, cbdata);
/* We are already watching the anchor txo, so we don't need to
* watch anything else. */
}
static void cb_no_arg(struct peer *peer, int depth, static void insert_null_txwatch(struct lightningd_state *dstate,
const struct sha256_double *blkhash, void *vcb) const struct sha256_double *txid)
{ {
void (*cb)(struct peer *peer, int depth) = vcb; struct txwatch *w = tal(dstate, struct txwatch);
cb(peer, depth); w->depth = 0;
w->txid = *txid;
w->dstate = dstate;
w->peer = NULL;
w->cb = NULL;
w->cbdata = NULL;
txwatch_hash_add(&w->dstate->txwatches, w);
tal_add_destructor(w, destroy_txwatch);
} }
void add_close_tx_watch(const tal_t *ctx, static void watched_normalized_txid(struct lightningd_state *dstate,
struct peer *peer,
const struct bitcoin_tx *tx, const struct bitcoin_tx *tx,
void (*cb)(struct peer *peer, int depth)) struct tx_info *txinfo)
{ {
struct txwatch *txw;
struct sha256_double txid; struct sha256_double txid;
size_t i;
normalized_txid(tx, &txid);
txw = txwatch_hash_get(&dstate->txwatches, &txid);
/* Reset to real txid for logging. */
bitcoin_txid(tx, &txid); bitcoin_txid(tx, &txid);
insert_txwatch(ctx, peer, &txid, cb_no_arg, cb);
/* We are already watching the anchor txo, so we don't need to if (txw) {
* watch anything else. */ if (txinfo->conf != txw->depth) {
log_debug(txw->peer->log,
"Got depth change %u for %02x%02x%02x...\n",
txinfo->conf,
txid.sha.u.u8[0],
txid.sha.u.u8[1],
txid.sha.u.u8[2]);
txw->depth = txinfo->conf;
txw->cb(txw->peer, txw->depth, &txinfo->blkhash, &txid,
txw->cbdata);
}
return;
} }
static void tx_watched_inputs(struct lightningd_state *dstate, /* Hmm, otherwise it may be new */
const struct bitcoin_tx *tx, void *unused) for (i = 0; i < tx->input_count; i++) {
{ struct txowatch *txo;
size_t in;
for (in = 0; in < tx->input_count; in++) {
struct txwatch_output out; struct txwatch_output out;
struct txowatch *txow;
out.txid = tx->input[in].txid;
out.index = tx->input[in].index;
txow = txowatch_hash_get(&dstate->txowatches, &out); out.txid = tx->input[i].txid;
if (txow) out.index = tx->input[i].index;
txow->cb(txow->peer, tx, txow->cbdata); txo = txowatch_hash_get(&dstate->txowatches, &out);
/* Presumably, this sets a watch on it. */
if (txo) {
log_debug(txo->peer->log,
"New tx spending %02x%02x%02x output %u:"
" %02x%02x%02x...\n",
out.txid.sha.u.u8[0],
out.txid.sha.u.u8[1],
out.txid.sha.u.u8[2],
out.index,
txid.sha.u.u8[0],
txid.sha.u.u8[1],
txid.sha.u.u8[2]);
txo->cb(txo->peer, tx, txo->cbdata);
return;
} }
} }
static void watched_transaction(struct lightningd_state *dstate, /* OK, not interesting. Put in fake (on original txid). */
log_debug(dstate->base_log, "Ignoring tx %02x%02x%02x...\n",
txid.sha.u.u8[0],
txid.sha.u.u8[1],
txid.sha.u.u8[2]);
insert_null_txwatch(dstate, &txid);
}
static void watched_txid(struct lightningd_state *dstate,
const struct sha256_double *txid, const struct sha256_double *txid,
int confirmations, int confirmations,
bool is_coinbase, bool is_coinbase,
@ -238,25 +250,29 @@ static void watched_transaction(struct lightningd_state *dstate,
{ {
struct txwatch *txw; struct txwatch *txw;
struct tx_info *txinfo;
/* Maybe it spent an output we're watching? */
if (is_coinbase)
return;
/* Are we watching this txid directly (or already reported)? */ /* Are we watching this txid directly (or already reported)? */
txw = txwatch_hash_get(&dstate->txwatches, txid); txw = txwatch_hash_get(&dstate->txwatches, txid);
if (txw) { if (txw) {
if (confirmations != txw->depth) { if (txw->cb && confirmations != txw->depth) {
txw->depth = confirmations; txw->depth = confirmations;
if (txw->cb) txw->cb(txw->peer, txw->depth, blkhash, txid,
txw->cb(txw->peer, txw->depth, blkhash,
txw->cbdata); txw->cbdata);
} }
return; return;
} }
/* Don't report about this txid twice. */ txinfo = tal(dstate, struct tx_info);
insert_null_txwatch(dstate, txid); txinfo->conf = confirmations;
if (blkhash)
/* Maybe it spent an output we're watching? */ txinfo->blkhash = *blkhash;
if (!is_coinbase) /* FIXME: Since we don't use segwit, we need to normalize txids. */
bitcoind_txid_lookup(dstate, txid, tx_watched_inputs, NULL); bitcoind_txid_lookup(dstate, txid, watched_normalized_txid, txinfo);
} }
static struct timeout watch_timeout; static struct timeout watch_timeout;
@ -267,7 +283,7 @@ static void start_poll_transactions(struct lightningd_state *dstate)
log_unusual(dstate->base_log, log_unusual(dstate->base_log,
"Delaying start poll: commands in progress"); "Delaying start poll: commands in progress");
} else } else
bitcoind_poll_transactions(dstate, watched_transaction); bitcoind_poll_transactions(dstate, watched_txid);
refresh_timeout(dstate, &watch_timeout); refresh_timeout(dstate, &watch_timeout);
} }

55
daemon/watch.h
View File

@ -52,6 +52,7 @@ struct txwatch {
/* A new depth (-1 if conflicted), blkhash valid if > 0 */ /* A new depth (-1 if conflicted), blkhash valid if > 0 */
void (*cb)(struct peer *peer, int depth, void (*cb)(struct peer *peer, int depth,
const struct sha256_double *blkhash, const struct sha256_double *blkhash,
const struct sha256_double *txid,
void *cbdata); void *cbdata);
void *cbdata; void *cbdata;
}; };
@ -63,51 +64,65 @@ HTABLE_DEFINE_TYPE(struct txwatch, txwatch_keyof, txid_hash, txwatch_eq,
txwatch_hash); txwatch_hash);
void add_anchor_watch_(const tal_t *ctx, struct txwatch *watch_txid_(const tal_t *ctx,
struct peer *peer, struct peer *peer,
const struct sha256_double *txid, const struct sha256_double *txid,
unsigned int out, void (*cb)(struct peer *peer, int depth,
void (*anchor_cb)(struct peer *peer, int depth,
const struct sha256_double *blkhash, const struct sha256_double *blkhash,
const struct sha256_double *txidx,
void *), void *),
void (*spend_cb)(struct peer *peer,
const struct bitcoin_tx *, void *),
void *cbdata); void *cbdata);
#define add_anchor_watch(ctx, peer, txid, out, anchor_cb, spend_cb, cbdata) \ #define watch_txid(ctx, peer, txid, cb, cbdata) \
add_anchor_watch_((ctx), (peer), (txid), (out), \ watch_txid_((ctx), (peer), (txid), \
typesafe_cb_preargs(void, void *, \ typesafe_cb_preargs(void, void *, \
(anchor_cb), (cbdata), \ (cb), (cbdata), \
struct peer *, \ struct peer *, \
int depth, \ int depth, \
const struct sha256_double *), \ const struct sha256_double *, \
typesafe_cb_preargs(void, void *, \ const struct sha256_double *txidx), \
(spend_cb), (cbdata), \
struct peer *, \
const struct bitcoin_tx *), \
(cbdata)) (cbdata))
struct txwatch *add_commit_tx_watch_(const tal_t *ctx, struct txwatch *watch_tx_(const tal_t *ctx,
struct peer *peer, struct peer *peer,
const struct sha256_double *txid, const struct bitcoin_tx *tx,
void (*cb)(struct peer *peer, int depth, void (*cb)(struct peer *peer, int depth,
const struct sha256_double *blkhash, const struct sha256_double *blkhash,
const struct sha256_double *txidx,
void *), void *),
void *cbdata); void *cbdata);
#define add_commit_tx_watch(ctx, peer, txid, cb, cbdata) \ #define watch_tx(ctx, peer, tx, cb, cbdata) \
add_commit_tx_watch_((ctx), (peer), (txid), \ watch_tx_((ctx), (peer), (tx), \
typesafe_cb_preargs(void, void *, \ typesafe_cb_preargs(void, void *, \
(cb), (cbdata), \ (cb), (cbdata), \
struct peer *, \ struct peer *, \
int, \ int depth, \
const struct sha256_double *, \
const struct sha256_double *), \ const struct sha256_double *), \
(cbdata)) (cbdata))
void add_close_tx_watch(const tal_t *ctx, struct txowatch *watch_txo_(const tal_t *ctx,
struct peer *peer, struct peer *peer,
const struct sha256_double *txid,
unsigned int output,
void (*cb)(struct peer *peer,
const struct bitcoin_tx *tx, const struct bitcoin_tx *tx,
void (*cb)(struct peer *peer, int depth)); void *),
void *cbdata);
#define watch_txo(ctx, peer, txid, outnum, cb, cbdata) \
watch_txo_((ctx), (peer), (txid), (outnum), \
typesafe_cb_preargs(void, void *, \
(cb), (cbdata), \
struct peer *, \
const struct bitcoin_tx *), \
(cbdata))
void peer_watch_setup(struct peer *peer);
/* FIXME: Seg witness removes need for this! */
void normalized_txid(const struct bitcoin_tx *tx, struct sha256_double *txid);
void setup_watch_timer(struct lightningd_state *dstate); void setup_watch_timer(struct lightningd_state *dstate);
#endif /* LIGHTNING_DAEMON_WATCH_H */ #endif /* LIGHTNING_DAEMON_WATCH_H */

Write Preview
Loading…
Cancel
Save