rustyrussell · Sep 15, 2014 · Sep 15, 2014 · Sep 15, 2014 · Sep 15, 2014 · Sep 15, 2014
diff --git a/Makefile.in b/Makefile.in
@@ -7,8 +7,8 @@
 #   blackbox-check: run the blackbox tests
 #   update-mocks: regenerate the mocks for the unit tests.
 
-PETTYCOIN_OBJS := block.o check_block.o check_tx.o difficulty.o shadouble.o timestamp.o gateways.o hash_tx.o pettycoin.o merkle_txs.o merkle_recurse.o tx_cmp.o genesis.o marshal.o hash_block.o prev_txhashes.o state.o tal_packet.o dns.o netaddr.o peer.o peer_cache.o pseudorand.o welcome.o log.o generating.o blockfile.o pending.o log_helper.o txhash.o signature.o proof.o chain.o features.o todo.o base58.o sync.o create_refs.o shard.o packet_io.o tx.o complain.o block_shard.o recv_block.o input_refs.o peer_wants.o inputhash.o tx_in_hashes.o merkle_hashes.o recv_tx.o reward.o recv_complain.o json.o jsonrpc.o getinfo.o ecode_names.o sendrawtransaction.c pettycoin_dir.o pkt_names.o hex.o listtransactions.o json_add_tx.o gettransaction.o
-PETTYCOIN_GENERATE_OBJS := pettycoin-generate.o merkle_hashes.o merkle_recurse.o hash_tx.o tx_cmp.o shadouble.o marshal.o minimal_log.o timestamp.o tal_packet.o hex.o
+PETTYCOIN_OBJS := block.o check_block.o check_tx.o difficulty.o shadouble.o timestamp.o gateways.o hash_tx.o pettycoin.o merkle_txs.o merkle_recurse.o tx_cmp.o genesis.o marshal.o hash_block.o prev_txhashes.o state.o tal_packet.o dns.o netaddr.o peer.o peer_cache.o pseudorand.o welcome.o log.o generating.o blockfile.o pending.o log_helper.o txhash.o signature.o proof.o chain.o features.o todo.o base58.o sync.o create_refs.o shard.o packet_io.o tx.o complain.o block_shard.o recv_block.o input_refs.o peer_wants.o inputhash.o tx_in_hashes.o merkle_hashes.o recv_tx.o reward.o recv_complain.o json.o jsonrpc.o getinfo.o ecode_names.o sendrawtransaction.c pettycoin_dir.o pkt_names.o hex.o listtransactions.o json_add_tx.o gettransaction.o prev_blocks.o detached_block.o
+PETTYCOIN_GENERATE_OBJS := pettycoin-generate.o merkle_hashes.o merkle_recurse.o hash_tx.o tx_cmp.o shadouble.o marshal.o minimal_log.o tal_packet.o hex.o
 MKGENESIS_OBJS := mkgenesis.o shadouble.o hash_block.o merkle_hashes.o merkle_recurse.o minimal_log.o
 SIZES_OBJS := sizes.o
 MKPRIV_OBJS := mkpriv.o

diff --git a/TODO.md b/TODO.md
@@ -54,16 +54,16 @@ Before Alpha02:
 
 * Include power of 2 previous blocks in prev
     * Would allow SPV-style block skips which would enable foldover reward on ancient blocks.
+* Multiple gateways
+    * Requires a mechanism to create new gateways.
+* Simplify welcome message to have 64k bits always.
+    * 8k simply isn't that much, and it's simpler.
 * Complaint for tx in wrong shard.
     * If someone managed to sneak this into the network presently, there'd
 	  be no way for nodes to report it.
 * Fix fee calculation
     * It's currently 3/1024 of the total, it should be 0.3% of the non-change
 	  amount.
-* Multiple gateways
-    * Requires a mechanism to create new gateways.
-* Simplify welcome message to have 64k bits always.
-    * 8k simply isn't that much, and it's simpler.
 * Merge mining
     * Means larger blocks, but we'll want this eventually.
 * Network time consensus

diff --git a/block.c b/block.c
@@ -32,30 +32,23 @@ static void destroy_block(struct block *b)
 static struct block *new_block(const tal_t *ctx,
 			       BIGNUM *prev_work,
 			       const struct protocol_block_id *sha,
-			       const struct protocol_block_header *hdr,
-			       const u8 *shard_nums,
-			       const struct protocol_double_sha *merkles,
-			       const u8 *prev_txhashes,
-			       const struct protocol_block_tailer *tailer)
+			       const struct block_info *bi)
 {
 	struct block *block = tal(ctx, struct block);
 	unsigned int i;
 
-	total_work_done(le32_to_cpu(tailer->difficulty),
+	total_work_done(le32_to_cpu(bi->tailer->difficulty),
 			prev_work, &block->total_work);
 
-	block->hdr = hdr;
-	block->shard_nums = shard_nums;
-	block->merkles = merkles;
-	block->prev_txhashes = prev_txhashes;
-	block->tailer = tailer;
+	block->bi = *bi;
 	block->all_known = false;
 	list_head_init(&block->children);
 	block->sha = *sha;
-	block->shard = tal_arr(block, struct block_shard *, num_shards(hdr));
-	for (i = 0; i < num_shards(hdr); i++)
+	block->shard = tal_arr(block, struct block_shard *,
+			       num_shards(bi->hdr));
+	for (i = 0; i < num_shards(bi->hdr); i++)
 		block->shard[i] = new_block_shard(block->shard, i,
-						  shard_nums[i]);
+						  bi->num_txs[i]);
 
 	/* In case we destroy before block_add(), eg. testing. */
 	block->prev = NULL;
@@ -67,20 +60,15 @@ static struct block *new_block(const tal_t *ctx,
 struct block *block_add(struct state *state,
 			struct block *prev,
 			const struct protocol_block_id *sha,
-			const struct protocol_block_header *hdr,
-			const u8 *shard_nums,
-			const struct protocol_double_sha *merkles,
-			const u8 *prev_txhashes,
-			const struct protocol_block_tailer *tailer)
+			const struct block_info *bi)
 {
-	u32 height = le32_to_cpu(hdr->height);
+	u32 height = le32_to_cpu(bi->hdr->height);
 	struct block *block;
 
 	log_debug(state->log, "Adding block %u ", height);
 	log_add_struct(state->log, struct protocol_block_id, sha);
 
-	block = new_block(state, &prev->total_work, sha, hdr, shard_nums,
-			  merkles, prev_txhashes, tailer);
+	block = new_block(state, &prev->total_work, sha, bi);
 	block->prev = prev;
 
 	/* Add to list for that generation. */
@@ -149,7 +137,7 @@ bool block_all_known(const struct block *block)
 {
 	unsigned int i;
 
-	for (i = 0; i < num_shards(block->hdr); i++) {
+	for (i = 0; i < num_shards(block->bi.hdr); i++) {
 		if (!shard_all_known(block->shard[i]))
 			return false;
 	}
@@ -161,7 +149,7 @@ struct protocol_input_ref *block_get_refs(const struct block *block,
 {
 	const struct block_shard *s = block->shard[shardnum];
 
-	assert(shardnum < num_shards(block->hdr));
+	assert(shardnum < num_shards(block->bi.hdr));
 	assert(txoff < s->size);
 
 	if (!shard_is_tx(s, txoff))
@@ -176,7 +164,7 @@ union protocol_tx *block_get_tx(const struct block *block,
 {
 	const struct block_shard *s = block->shard[shardnum];
 
-	assert(shardnum < num_shards(block->hdr));
+	assert(shardnum < num_shards(block->bi.hdr));
 	assert(txoff < s->size);
 
 	if (!shard_is_tx(s, txoff))
@@ -189,8 +177,8 @@ bool block_empty(const struct block *block)
 {
 	unsigned int i;
 
-	for (i = 0; i < num_shards(block->hdr); i++) {
-		if (block->shard_nums[i] != 0)
+	for (i = 0; i < num_shards(block->bi.hdr); i++) {
+		if (block->bi.num_txs[i] != 0)
 			return false;
 	}
 	return true;

diff --git a/block.h b/block.h
@@ -1,6 +1,7 @@
 #ifndef PETTYCOIN_BLOCK_H
 #define PETTYCOIN_BLOCK_H
 #include "config.h"
+#include "block_info.h"
 #include "block_shard.h"
 #include "protocol.h"
 #include "protocol_net.h"
@@ -34,11 +35,7 @@ struct block {
 	struct block *prev;
 
 	/* The block itself: */
-	const struct protocol_block_header *hdr;
-	const u8 *shard_nums;
-	const struct protocol_double_sha *merkles;
-	const u8 *prev_txhashes;
-	const struct protocol_block_tailer *tailer;
+	struct block_info bi;
 
 	/* This is set if there's a problem with the block (or ancestor). */
 	const void *complaint;
@@ -70,11 +67,7 @@ static inline const struct block *genesis_block(const struct state *state)
 struct block *block_add(struct state *state,
 			struct block *prev,
 			const struct protocol_block_id *sha,
-			const struct protocol_block_header *hdr,
-			const u8 *shard_nums,
-			const struct protocol_double_sha *merkles,
-			const u8 *prev_txhashes,
-			const struct protocol_block_tailer *tailer);
+			const struct block_info *bi);
 
 /* Get tx_idx'th tx inside shard shardnum inside block. */
 union protocol_tx *block_get_tx(const struct block *block, u16 shardnum,

diff --git a/block_shard.c b/block_shard.c
@@ -75,7 +75,7 @@ void check_block_shard(struct state *state,
 {
 	unsigned int i, txcount = 0, hashcount = 0;
 
-	assert(shard->size == block->shard_nums[shard->shardnum]);
+	assert(shard->size == block_num_txs(&block->bi, shard->shardnum));
 
 	if (shard_all_hashes(shard))
 		assert(!shard->proof);
@@ -123,7 +123,8 @@ void check_block_shard(struct state *state,
 	if (txcount + hashcount == shard->size) {
 		struct protocol_double_sha sha;
 		merkle_txs(shard, &sha);
-		assert(structeq(&sha, &block->merkles[shard->shardnum]));
+		assert(structeq(&sha, block_merkle(&block->bi,
+						   shard->shardnum)));
 	}
 }
 

diff --git a/block_shard.h b/block_shard.h
@@ -30,7 +30,7 @@ struct block_shard {
 	/* How many transaction hashes do we have? */
 	u8 hashcount;
 
-	/* What's our max (== block->shard_nums[shard->shardnum]) */
+	/* What's our max (== block->num_txs[shard->shardnum]) */
 	u8 size;
 
 	/* If we don't know all hashes, we store array of proofs here. */

diff --git a/blockfile.c b/blockfile.c
@@ -24,26 +24,18 @@ static bool load_block(struct state *state, struct protocol_net_hdr *pkt)
 {
 	struct block *prev, *block;
 	enum protocol_ecode e;
-	const u8 *shard_nums;
-	const struct protocol_double_sha *merkles;
-	const u8 *prev_txhashes;
-	const struct protocol_block_tailer *tailer;
-	const struct protocol_block_header *hdr;
+	struct block_info bi;
 	struct protocol_block_id sha;
 
-	e = unmarshal_block(state->log, (void *)pkt,
-			    &hdr, &shard_nums, &merkles, &prev_txhashes,
-			    &tailer);
+	e = unmarshal_block(state->log, (void *)pkt, &bi);
 	if (e != PROTOCOL_ECODE_NONE)
 		return false;
 
-	e = check_block_header(state, hdr, shard_nums, merkles, prev_txhashes,
-			       tailer, &prev, &sha.sha);
+	e = check_block_header(state, &bi, &prev, &sha.sha);
 	if (e != PROTOCOL_ECODE_NONE)
 		return false;
 
-	block = block_add(state, prev, &sha,
-			  hdr, shard_nums, merkles, prev_txhashes, tailer);
+	block = block_add(state, prev, &sha, &bi);
 
 	/* Now new block owns the packet. */
 	tal_steal(block, pkt);
@@ -170,9 +162,7 @@ void save_block(struct state *state, struct block *new)
 	if (state->blockfd == -1)
 		return;
 
-	blk = marshal_block(state,
-			    new->hdr, new->shard_nums, new->merkles,
-			    new->prev_txhashes, new->tailer);
+	blk = marshal_block(state, &new->bi);
 	len = le32_to_cpu(blk->len);
 
 	if (!write_all(state->blockfd, blk, len))

diff --git a/chain.c b/chain.c
@@ -7,6 +7,7 @@
 #include "jsonrpc.h"
 #include "peer.h"
 #include "pending.h"
+#include "prev_blocks.h"
 #include "shard.h"
 #include "tal_arr.h"
 #include "todo.h"
@@ -28,15 +29,15 @@ struct block *step_towards(const struct block *curr, const struct block *target)
 	const struct block *prev_target;
 
 	/* Move back towards target. */
-	while (le32_to_cpu(curr->hdr->height) > le32_to_cpu(target->hdr->height))
+	while (block_height(&curr->bi) > block_height(&target->bi))
 		curr = curr->prev;
 
 	/* Already past it, or equal to it */
 	if (curr == target)
 		return NULL;
 
 	/* Move target back towards curr. */
-	while (le32_to_cpu(target->hdr->height) > le32_to_cpu(curr->hdr->height)) {
+	while (block_height(&target->bi) > block_height(&curr->bi)) {
 		prev_target = target;
 		target = target->prev;
 	}
@@ -129,14 +130,17 @@ void check_chains(struct state *state, bool all)
 		num_next_level = 0;
 		list_for_each(state->block_height[n], i, list) {
 			const struct block *b;
-			assert(le32_to_cpu(i->hdr->height) == n);
+			assert(block_height(&i->bi) == n);
 			assert(num_this_level);
 			num_this_level--;
 			if (n == 0)
 				assert(i == genesis_block(state));
 			else {
-				assert(structeq(&i->hdr->prev_block,
-						&i->prev->sha));
+				struct protocol_block_id prevs
+					[PROTOCOL_NUM_PREV_IDS];
+				make_prev_blocks(b->prev, prevs);
+				assert(memcmp(block_prev(&i->bi, 0), prevs,
+					      sizeof(prevs) == 0));
 				if (i->prev->complaint)
 					assert(i->complaint);
 			}
@@ -332,7 +336,7 @@ static void new_longest(struct state *state, const struct block *block)
 {
 	if (block->pending_features && !state->upcoming_features) {
 		/* Be conservative, halve estimate of time to confirm feature */
-		time_t impact = le32_to_cpu(block->tailer->timestamp)
+		time_t impact = block_timestamp(&block->bi)
 			+ (PROTOCOL_FEATURE_CONFIRM_DELAY
 			   * PROTOCOL_BLOCK_TARGET_TIME(state->test_net) / 2);
 		struct tm *when;
@@ -407,8 +411,8 @@ void update_block_ptrs_new_block(struct state *state, struct block *block)
 	 * update_block_ptrs_new_shard() directly, since that would
 	 * call update_known multiple times if block completely
 	 * known, which breaks the longest_known[] calc.  */
-	for (i = 0; i < num_shards(block->hdr); i++) {
-		if (block->shard_nums[i] == 0)
+	for (i = 0; i < num_shards(block->bi.hdr); i++) {
+		if (block->bi.num_txs[i] == 0)
 			update_block_ptrs_new_shard_or_empty(state, block, i);
 	}
 	if (block_all_known(block)) {
@@ -526,32 +530,33 @@ static char *json_getblock(struct json_connection *jcon,
 
 	json_object_start(response, NULL);
 	json_add_block_id(response, "hash", &b->sha);
-	json_add_num(response, "version", b->hdr->version);
-	json_add_num(response, "features_vote", b->hdr->features_vote);
-	json_add_num(response, "shard_order", b->hdr->shard_order);
-	json_add_num(response, "nonce1", le32_to_cpu(b->tailer->nonce1));
-	json_add_hex(response, "nonce2", b->hdr->nonce2,
-		     sizeof(b->hdr->nonce2));
-	json_add_num(response, "height", le32_to_cpu(b->hdr->height));
+	json_add_num(response, "version", b->bi.hdr->version);
+	json_add_num(response, "features_vote", b->bi.hdr->features_vote);
+	json_add_num(response, "shard_order", b->bi.hdr->shard_order);
+	json_add_num(response, "nonce1", le32_to_cpu(b->bi.tailer->nonce1));
+	json_add_hex(response, "nonce2", b->bi.hdr->nonce2,
+		     sizeof(b->bi.hdr->nonce2));
+	json_add_num(response, "height", block_height(&b->bi));
 	json_add_address(response, "fees_to",
-			 jcon->state->test_net, &b->hdr->fees_to);
-	json_add_num(response, "timestamp",
-		     le32_to_cpu(b->tailer->timestamp));
-	json_add_num(response, "difficulty",
-		     le32_to_cpu(b->tailer->difficulty));
-	json_add_block_id(response, "prev", &b->hdr->prev_block);
+			 jcon->state->test_net, &b->bi.hdr->fees_to);
+	json_add_num(response, "timestamp", block_timestamp(&b->bi));
+	json_add_num(response, "difficulty", block_difficulty(&b->bi));
+	json_array_start(response, "prevs");
+	for (i = 0; i < PROTOCOL_NUM_PREV_IDS; i++)
+		json_add_block_id(response, NULL, block_prev(&b->bi, i));
+	json_array_end(response);
 	json_array_start(response, "next");
 	list_for_each(&b->children, b2, sibling)
 		json_add_block_id(response, NULL, &b2->sha);
 	json_array_end(response);
 
 	json_array_start(response, "merkles");
-	for (shardnum = 0; shardnum < num_shards(b->hdr); shardnum++)
-		json_add_double_sha(response, NULL, &b->merkles[shardnum]);
+	for (shardnum = 0; shardnum < num_shards(b->bi.hdr); shardnum++)
+		json_add_double_sha(response, NULL, &b->bi.merkles[shardnum]);
 	json_array_end(response);
 
 	json_array_start(response, "shards");
-	for (shardnum = 0; shardnum < num_shards(b->hdr); shardnum++) {
+	for (shardnum = 0; shardnum < num_shards(b->bi.hdr); shardnum++) {
 		struct block_shard *s = b->shard[shardnum];
 
 		json_array_start(response, NULL);

diff --git a/chain.h b/chain.h
@@ -15,7 +15,8 @@ static inline bool block_preceeds(const struct block *a, const struct block *b)
 	if (a == b)
 		return true;
 
-	if (le32_to_cpu(a->hdr->height) >= le32_to_cpu(b->hdr->height))
+	if (le32_to_cpu(a->bi.hdr->height)
+	    >= le32_to_cpu(b->bi.hdr->height))
 		return false;
 
 	return block_preceeds(a, b->prev);