From 4a6fd8fad1209bc7eb1bb90abea66f6ba4ab28a9 Mon Sep 17 00:00:00 2001
From: Ori Newman <orinewman1@gmail.com>
Date: Thu, 27 Dec 2018 17:43:25 +0200
Subject: [PATCH] [DEV-320] add decoupling related fields to wire tx (#134)

* [DEV-320] Add decoupling-related fields to wire.Tx

* [DEV-320] Fix SerializeSize for MsgTx

* [DEV-320] Fix indexers test

* [DEV-320] Fix utils test

* [DEV-320] Fix ffldb tests

* [DEV-320] Fix mining tests

* [DEV-320] fix txsort tests

* [DEV-320] change default subnetwork id to 1 and remove payload for default subnetwork id

* [DEV-320] Add msgtx serialization tests

* [DEV-320] get rid of temp prints, and change error messages
---
 blockdag/dag_test.go              |   6 +-
 blockdag/example_test.go          |   2 +-
 blockdag/fullblocktests/params.go |   3 +-
 blockdag/indexers/txindex_test.go | 210 ++++++++++++++++--------------
 blockdag/testdata/blk_0_to_4.dat  | Bin 1657 -> 1721 bytes
 blockdag/testdata/blk_3A.dat      | Bin 394 -> 410 bytes
 blockdag/testdata/blk_3B.dat      | Bin 195 -> 203 bytes
 blockdag/testdata/blk_3C.dat      | Bin 227 -> 235 bytes
 blockdag/testdata/blk_3D.dat      | Bin 439 -> 456 bytes
 blockdag/validate_test.go         |  25 ++--
 dagconfig/genesis.go              |  75 +++++------
 dagconfig/genesis_test.go         | 128 +++++++++---------
 database/example_test.go          |   2 +-
 database/testdata/blocks1-256.bz2 | Bin 9944 -> 9966 bytes
 database/testdata/generator.go    |   5 +-
 mining/policy_test.go             |   8 +-
 util/block_test.go                |  28 ++--
 util/bloom/filter_test.go         |  32 +++--
 util/bloom/merkleblock_test.go    |  30 +++--
 util/coinset/coins_test.go        |  26 ++--
 util/tx_test.go                   |   2 +-
 util/txsort/testdata/bip69-1.hex  |   2 +-
 util/txsort/testdata/bip69-2.hex  |   2 +-
 util/txsort/testdata/bip69-3.hex  |   2 +-
 util/txsort/testdata/bip69-4.hex  |   2 +-
 util/txsort/testdata/bip69-5.hex  |   2 +-
 util/txsort/txsort_test.go        |  20 +--
 wire/blockheader_test.go          |  16 +--
 wire/common_test.go               |   8 +-
 wire/message_test.go              |   4 +-
 wire/msgblock_test.go             |  18 +--
 wire/msgheaders_test.go           |   8 +-
 wire/msgtx.go                     | 141 +++++++++++++++++---
 wire/msgtx_test.go                | 151 ++++++++++++++++++++-
 34 files changed, 629 insertions(+), 329 deletions(-)

diff --git a/blockdag/dag_test.go b/blockdag/dag_test.go
index 90d125fed..d36d8b301 100644
--- a/blockdag/dag_test.go
+++ b/blockdag/dag_test.go
@@ -94,7 +94,7 @@ func TestHaveBlock(t *testing.T) {
 		DAGParams: &dagconfig.SimNetParams,
 	})
 	if err != nil {
-		t.Fatalf("Failed to setup chain instance: %v", err)
+		t.Fatalf("Failed to setup DAG instance: %v", err)
 	}
 	defer teardownFunc()
 
@@ -185,10 +185,10 @@ func TestHaveBlock(t *testing.T) {
 		{hash: dagconfig.SimNetParams.GenesisHash.String(), want: true},
 
 		// Block 3b should be present (as a second child of Block 2).
-		{hash: "2b31fe171eeadcaec5978add980ebb8108fd5d9082e870ff71744842e0dd01bb", want: true},
+		{hash: "74e325a48f84020f3d36c07edf9cda95d93cff866ff8e8df5d2825d2ced6d28f", want: true},
 
 		// Block 100000 should be present (as an orphan).
-		{hash: "64f3da4fe61edb33ad6dd5e857ebcfe296182a0c4aaef01e30b4032b94ec1620", want: true},
+		{hash: "566ca0e828951be69df4b45b82b4eb9b593b712a0018a382cb75790f85810be3", want: true},
 
 		// Random hashes should not be available.
 		{hash: "123", want: false},
diff --git a/blockdag/example_test.go b/blockdag/example_test.go
index 87490cf98..99708e324 100644
--- a/blockdag/example_test.go
+++ b/blockdag/example_test.go
@@ -68,7 +68,7 @@ func ExampleBlockDAG_ProcessBlock() {
 	fmt.Printf("Block accepted. Is it an orphan?: %v", isOrphan)
 
 	// Output:
-	// Failed to process block: already have block 000000f9fa27ce9258baefc92e485fc5744eae341554fd03f25e1e10baa8c9c3
+	// Failed to process block: already have block 47c205482e0a2aa1f5503ec73ea0ffe5226f9d9357f037dcde79f75d85171634
 }
 
 // This example demonstrates how to convert the compact "bits" in a block header
diff --git a/blockdag/fullblocktests/params.go b/blockdag/fullblocktests/params.go
index a9528b2d4..fe8e110ec 100644
--- a/blockdag/fullblocktests/params.go
+++ b/blockdag/fullblocktests/params.go
@@ -83,7 +83,8 @@ var (
 					"c4f35504e51ec112de5c384df7ba0b8d578a" +
 					"4c702b6bf11d5fac"),
 			}},
-			LockTime: 0,
+			LockTime:     0,
+			SubNetworkID: wire.SubNetworkDAGCoin,
 		}},
 	}
 )
diff --git a/blockdag/indexers/txindex_test.go b/blockdag/indexers/txindex_test.go
index 067356fdb..3d7c767d0 100644
--- a/blockdag/indexers/txindex_test.go
+++ b/blockdag/indexers/txindex_test.go
@@ -107,21 +107,21 @@ var block1 = wire.MsgBlock{
 		Version: 1,
 		ParentHashes: []daghash.Hash{
 			[32]byte{ // Make go vet happy.
-				0x4a, 0xc1, 0x82, 0x2e, 0x43, 0x05, 0xea, 0x0c,
-				0x4f, 0xcc, 0x77, 0x87, 0xae, 0x26, 0x48, 0x87,
-				0x50, 0x13, 0xee, 0x2f, 0x55, 0xa7, 0x18, 0xa7,
-				0x1e, 0xf2, 0xd8, 0x7c, 0xc1, 0x13, 0xac, 0x22,
+				0x34, 0x16, 0x17, 0x85, 0x5d, 0xf7, 0x79, 0xde,
+				0xdc, 0x37, 0xf0, 0x57, 0x93, 0x9d, 0x6f, 0x22,
+				0xe5, 0xff, 0xa0, 0x3e, 0xc7, 0x3e, 0x50, 0xf5,
+				0xa1, 0x2a, 0x0a, 0x2e, 0x48, 0x05, 0xc2, 0x47,
 			},
 		},
 		MerkleRoot: daghash.Hash([32]byte{ // Make go vet happy.
-			0xec, 0x37, 0x81, 0x75, 0x51, 0x79, 0x41, 0x34,
-			0x3a, 0xae, 0x05, 0x48, 0x67, 0xfa, 0xdf, 0x84,
-			0xef, 0x06, 0x5b, 0x93, 0x07, 0xa8, 0xc2, 0xb7,
-			0x2a, 0x94, 0x07, 0x3b, 0x5f, 0xee, 0xb8, 0x6a,
+			0x6c, 0x56, 0xa7, 0x7d, 0xfa, 0x18, 0x89, 0xdc,
+			0x20, 0x60, 0x3f, 0x51, 0x32, 0xa8, 0xdc, 0x47,
+			0x5f, 0x43, 0xb7, 0xe8, 0xae, 0x24, 0x22, 0x34,
+			0x64, 0x91, 0xe7, 0xd5, 0xac, 0xc0, 0xed, 0x88,
 		}),
-		Timestamp: time.Unix(0x5bd58c4a, 0),
+		Timestamp: time.Unix(0x5c238b71, 0),
 		Bits:      0x207fffff,
-		Nonce:     0xdffffffffffffffa,
+		Nonce:     0x00000000,
 	},
 	Transactions: []*wire.MsgTx{
 		{
@@ -150,7 +150,8 @@ var block1 = wire.MsgBlock{
 					},
 				},
 			},
-			LockTime: 0,
+			LockTime:     0,
+			SubNetworkID: wire.SubNetworkDAGCoin,
 		},
 	},
 }
@@ -160,21 +161,21 @@ var block2 = wire.MsgBlock{
 		Version: 1,
 		ParentHashes: []daghash.Hash{
 			[32]byte{ // Make go vet happy.
-				0x42, 0xb9, 0x2c, 0xee, 0x3e, 0x3e, 0x35, 0x02,
-				0xf5, 0x8d, 0xd2, 0xc8, 0xff, 0x61, 0xe3, 0x44,
-				0x59, 0xb2, 0x5d, 0x72, 0x10, 0x29, 0x62, 0x58,
-				0x3f, 0xc9, 0x41, 0xe2, 0xcd, 0xa9, 0x05, 0x11,
+				0x69, 0xe9, 0xd1, 0xa2, 0xd0, 0x5f, 0x35, 0x39,
+				0x6b, 0xa7, 0x1d, 0xeb, 0x97, 0x33, 0x7f, 0xcf,
+				0xa1, 0xa8, 0xc5, 0x1f, 0x31, 0x82, 0x09, 0x62,
+				0x79, 0xb3, 0xf9, 0xd6, 0x66, 0x3f, 0xd7, 0x45,
 			},
 		},
 		MerkleRoot: daghash.Hash([32]byte{ // Make go vet happy.
-			0x3e, 0x89, 0x5f, 0xb4, 0xa8, 0x2f, 0x64, 0xb9,
-			0xe7, 0x1d, 0x5d, 0xce, 0x41, 0x4a, 0xb0, 0x36,
-			0x4e, 0xd0, 0x4b, 0xfc, 0x0c, 0xe1, 0x82, 0xfc,
-			0x51, 0x0d, 0x03, 0x7b, 0x8c, 0xdd, 0x3e, 0x49,
+			0x29, 0xdc, 0xa7, 0x2b, 0x14, 0xfb, 0x5b, 0xe4,
+			0x3c, 0x7c, 0x91, 0x3c, 0x54, 0x7c, 0xbe, 0x20,
+			0x98, 0xe8, 0xc6, 0x01, 0x65, 0x59, 0x02, 0xa5,
+			0xa2, 0xf5, 0xf1, 0x9f, 0x3b, 0x3f, 0x28, 0x3c,
 		}),
-		Timestamp: time.Unix(0x5bd58c4b, 0),
+		Timestamp: time.Unix(0x5c238b72, 0),
 		Bits:      0x207fffff,
-		Nonce:     0x9ffffffffffffffb,
+		Nonce:     0x2000000000000001,
 	},
 	Transactions: []*wire.MsgTx{
 		{
@@ -203,7 +204,8 @@ var block2 = wire.MsgBlock{
 					},
 				},
 			},
-			LockTime: 0,
+			LockTime:     0,
+			SubNetworkID: wire.SubNetworkDAGCoin,
 		},
 		{
 			Version: 1,
@@ -211,28 +213,28 @@ var block2 = wire.MsgBlock{
 				{
 					PreviousOutPoint: wire.OutPoint{
 						Hash: daghash.Hash{
-							0xec, 0x37, 0x81, 0x75, 0x51, 0x79, 0x41, 0x34,
-							0x3a, 0xae, 0x05, 0x48, 0x67, 0xfa, 0xdf, 0x84,
-							0xef, 0x06, 0x5b, 0x93, 0x07, 0xa8, 0xc2, 0xb7,
-							0x2a, 0x94, 0x07, 0x3b, 0x5f, 0xee, 0xb8, 0x6a,
+							0x6c, 0x56, 0xa7, 0x7d, 0xfa, 0x18, 0x89, 0xdc,
+							0x20, 0x60, 0x3f, 0x51, 0x32, 0xa8, 0xdc, 0x47,
+							0x5f, 0x43, 0xb7, 0xe8, 0xae, 0x24, 0x22, 0x34,
+							0x64, 0x91, 0xe7, 0xd5, 0xac, 0xc0, 0xed, 0x88,
 						},
 						Index: 0,
 					},
 					SignatureScript: []byte{
-						0x47, 0x30, 0x44, 0x02, 0x20, 0x5d, 0xca, 0x41,
-						0xb0, 0x73, 0x9e, 0xba, 0x0c, 0xba, 0x59, 0xdd,
-						0xb5, 0x6a, 0x6e, 0xd2, 0xd2, 0x36, 0x61, 0xa5,
-						0xa0, 0x5c, 0xb5, 0x2b, 0xee, 0x5f, 0x30, 0x62,
-						0x72, 0xb3, 0x26, 0xa2, 0xdb, 0x02, 0x20, 0x0d,
-						0xc5, 0x22, 0xd8, 0x88, 0x5a, 0xf7, 0xef, 0x60,
-						0xa6, 0xd9, 0x5c, 0x7a, 0x44, 0x96, 0xfc, 0x14,
-						0x66, 0x74, 0xda, 0x2b, 0x6c, 0x99, 0x2c, 0x56,
-						0x34, 0x3d, 0x64, 0xdf, 0xc2, 0x36, 0xe8, 0x01,
-						0x21, 0x02, 0xa6, 0x73, 0x63, 0x8c, 0xb9, 0x58,
-						0x7c, 0xb6, 0x8e, 0xa0, 0x8d, 0xbe, 0xf6, 0x85,
-						0xc6, 0xf2, 0xd2, 0xa7, 0x51, 0xa8, 0xb3, 0xc6,
-						0xf2, 0xa7, 0xe9, 0xa4, 0x99, 0x9e, 0x6e, 0x4b,
-						0xfa, 0xf5,
+						0x46, 0x30, 0x43, 0x02, 0x1f, 0x56, 0x0a, 0xfa,
+						0x84, 0xc7, 0x80, 0xe1, 0x56, 0xe0, 0xec, 0x18,
+						0xe7, 0xd7, 0x02, 0x87, 0x1f, 0x22, 0x62, 0xda,
+						0xfa, 0x33, 0x82, 0xfc, 0x1d, 0x01, 0x7a, 0x0e,
+						0xa5, 0x5f, 0x4e, 0xce, 0x02, 0x20, 0x6d, 0x1f,
+						0xaf, 0xca, 0x91, 0x33, 0x8d, 0xfb, 0xb7, 0xa2,
+						0x40, 0xf9, 0x4f, 0x3c, 0x04, 0xc9, 0x47, 0x29,
+						0x6a, 0x7f, 0x45, 0x62, 0x0a, 0x2a, 0x7d, 0x93,
+						0x7b, 0xe2, 0xc9, 0xba, 0x15, 0xb3, 0x01, 0x21,
+						0x02, 0xa6, 0x73, 0x63, 0x8c, 0xb9, 0x58, 0x7c,
+						0xb6, 0x8e, 0xa0, 0x8d, 0xbe, 0xf6, 0x85, 0xc6,
+						0xf2, 0xd2, 0xa7, 0x51, 0xa8, 0xb3, 0xc6, 0xf2,
+						0xa7, 0xe9, 0xa4, 0x99, 0x9e, 0x6e, 0x4b, 0xfa,
+						0xf5,
 					},
 					Sequence: math.MaxUint64,
 				},
@@ -248,34 +250,35 @@ var block2 = wire.MsgBlock{
 					},
 				},
 			},
-			LockTime: 0,
+			LockTime:     0,
+			SubNetworkID: wire.SubNetworkDAGCoin,
 		},
 	},
 }
 
-var block3Tx *wire.MsgTx = &wire.MsgTx{
+var block3Tx = &wire.MsgTx{
 	Version: 1,
 	TxIn: []*wire.TxIn{
 		{
 			PreviousOutPoint: wire.OutPoint{
 				Hash: daghash.Hash{
-					0x69, 0x11, 0xbd, 0x7e, 0x46, 0x5e, 0xe8, 0xf7,
-					0xbe, 0x80, 0xb0, 0x21, 0x6a, 0xc8, 0xb4, 0xea,
-					0xef, 0xfa, 0x6a, 0x34, 0x75, 0x6e, 0xb5, 0x96,
-					0xd9, 0x3b, 0xe2, 0x6a, 0xd6, 0x49, 0xac, 0x6e,
+					0x99, 0x30, 0x0c, 0x6e, 0xad, 0x5c, 0x9c, 0xcf,
+					0xfc, 0xcb, 0x62, 0xfd, 0x39, 0xe3, 0xc1, 0x7e,
+					0x87, 0x17, 0xec, 0x9e, 0x7b, 0xc7, 0x81, 0xe0,
+					0x8f, 0x15, 0x85, 0xcb, 0x6d, 0x54, 0x74, 0x3e,
 				},
 				Index: 0,
 			},
 			SignatureScript: []byte{
-				0x48, 0x30, 0x45, 0x02, 0x21, 0x00, 0xea, 0xa8,
-				0xa5, 0x8b, 0x2d, 0xeb, 0x15, 0xc1, 0x18, 0x79,
-				0xa4, 0xad, 0xc3, 0xde, 0x57, 0x09, 0xac, 0xdb,
-				0x16, 0x16, 0x9f, 0x07, 0xe8, 0x7d, 0xbe, 0xf1,
-				0x4b, 0xaa, 0xd3, 0x76, 0xb4, 0x87, 0x02, 0x20,
-				0x03, 0xb3, 0xee, 0xc8, 0x9f, 0x87, 0x18, 0xee,
-				0xf3, 0xc3, 0x29, 0x29, 0x57, 0xb9, 0x93, 0x95,
-				0x4a, 0xe9, 0x49, 0x74, 0x90, 0xa1, 0x5b, 0xae,
-				0x49, 0x16, 0xa9, 0x3e, 0xb8, 0xf0, 0xf9, 0x6b,
+				0x48, 0x30, 0x45, 0x02, 0x21, 0x00, 0x91, 0xa3,
+				0xb4, 0x99, 0x57, 0xb2, 0x53, 0x2f, 0x7f, 0xaf,
+				0xb6, 0x4d, 0x9d, 0x7b, 0x1b, 0xa2, 0x41, 0x03,
+				0x1a, 0xe5, 0xfd, 0x4d, 0xe1, 0x5a, 0x7e, 0x9f,
+				0xe3, 0xdd, 0x44, 0xb8, 0x62, 0x13, 0x02, 0x20,
+				0x7a, 0xba, 0x9a, 0xe6, 0xa5, 0x81, 0x43, 0xb9,
+				0x05, 0x66, 0xc1, 0xa3, 0x79, 0xad, 0xf0, 0xf4,
+				0xb9, 0xfe, 0x28, 0x13, 0x35, 0xd6, 0x84, 0x95,
+				0x08, 0xd0, 0xaa, 0x1d, 0xb7, 0x5b, 0x88, 0x4c,
 				0x01, 0x21, 0x02, 0xa6, 0x73, 0x63, 0x8c, 0xb9,
 				0x58, 0x7c, 0xb6, 0x8e, 0xa0, 0x8d, 0xbe, 0xf6,
 				0x85, 0xc6, 0xf2, 0xd2, 0xa7, 0x51, 0xa8, 0xb3,
@@ -296,7 +299,8 @@ var block3Tx *wire.MsgTx = &wire.MsgTx{
 			},
 		},
 	},
-	LockTime: 0,
+	LockTime:     0,
+	SubNetworkID: wire.SubNetworkDAGCoin,
 }
 
 var block3 = wire.MsgBlock{
@@ -304,21 +308,21 @@ var block3 = wire.MsgBlock{
 		Version: 1,
 		ParentHashes: []daghash.Hash{
 			[32]byte{ // Make go vet happy.
-				0x8b, 0xdf, 0xd1, 0x48, 0xef, 0xf5, 0x2b, 0x5e,
-				0xfe, 0x26, 0xba, 0x37, 0xcb, 0x23, 0x0d, 0x41,
-				0x24, 0x80, 0xfe, 0x9a, 0x38, 0x90, 0xb9, 0xd3,
-				0x07, 0x30, 0xcc, 0xa0, 0x4f, 0x4e, 0xf1, 0x02,
+				0x96, 0x2d, 0x1d, 0x2b, 0xc2, 0xf9, 0x30, 0x43,
+				0x88, 0x23, 0xdb, 0x75, 0x73, 0x43, 0xb8, 0xb6,
+				0x76, 0x34, 0x42, 0x55, 0x8f, 0x44, 0x2a, 0x6f,
+				0xb1, 0xac, 0x7e, 0x9b, 0x1f, 0x9f, 0x00, 0x19,
 			},
 		},
 		MerkleRoot: daghash.Hash([32]byte{ // Make go vet happy.
-			0x24, 0x0f, 0x21, 0x89, 0x94, 0xd1, 0x77, 0x32,
-			0xff, 0x5d, 0xb4, 0xe9, 0x11, 0xd2, 0x74, 0xc9,
-			0x0f, 0x0c, 0xb7, 0xe5, 0x16, 0xf6, 0xca, 0x63,
-			0xac, 0xaa, 0x6c, 0x23, 0x42, 0xe9, 0xd5, 0x58,
+			0x58, 0xbd, 0x06, 0x58, 0x0a, 0xab, 0x32, 0x10,
+			0x97, 0x5c, 0xc6, 0x97, 0xb0, 0xde, 0xb9, 0xe2,
+			0xa6, 0x21, 0x67, 0xe5, 0x2f, 0xa3, 0xc5, 0xb2,
+			0xba, 0x8f, 0xd3, 0xc7, 0x4c, 0x18, 0x87, 0xc5,
 		}),
-		Timestamp: time.Unix(0x5bd58c4c, 0),
+		Timestamp: time.Unix(0x5c238b73, 0),
 		Bits:      0x207fffff,
-		Nonce:     0x7ffffffffffffffc,
+		Nonce:     0xdffffffffffffff9,
 	},
 	Transactions: []*wire.MsgTx{
 		{
@@ -347,7 +351,8 @@ var block3 = wire.MsgBlock{
 					},
 				},
 			},
-			LockTime: 0,
+			LockTime:     0,
+			SubNetworkID: wire.SubNetworkDAGCoin,
 		},
 		block3Tx,
 	},
@@ -358,19 +363,19 @@ var block3A = wire.MsgBlock{
 		Version: 1,
 		ParentHashes: []daghash.Hash{
 			[32]byte{ // Make go vet happy.
-				0x8b, 0xdf, 0xd1, 0x48, 0xef, 0xf5, 0x2b, 0x5e,
-				0xfe, 0x26, 0xba, 0x37, 0xcb, 0x23, 0x0d, 0x41,
-				0x24, 0x80, 0xfe, 0x9a, 0x38, 0x90, 0xb9, 0xd3,
-				0x07, 0x30, 0xcc, 0xa0, 0x4f, 0x4e, 0xf1, 0x02,
+				0x96, 0x2d, 0x1d, 0x2b, 0xc2, 0xf9, 0x30, 0x43,
+				0x88, 0x23, 0xdb, 0x75, 0x73, 0x43, 0xb8, 0xb6,
+				0x76, 0x34, 0x42, 0x55, 0x8f, 0x44, 0x2a, 0x6f,
+				0xb1, 0xac, 0x7e, 0x9b, 0x1f, 0x9f, 0x00, 0x19,
 			},
 		},
 		MerkleRoot: daghash.Hash([32]byte{ // Make go vet happy.
-			0x4b, 0xd6, 0xbf, 0x21, 0xa0, 0x62, 0x77, 0xb5,
-			0xc0, 0xd3, 0x3b, 0x31, 0x9d, 0x30, 0x9b, 0x89,
-			0x93, 0x75, 0x50, 0xdb, 0x3b, 0x87, 0x23, 0x67,
-			0x2f, 0xeb, 0xf9, 0xf2, 0x1b, 0x63, 0x5f, 0x1c,
+			0xd3, 0x95, 0x8a, 0x56, 0xfe, 0x89, 0x86, 0x9f,
+			0x47, 0x80, 0x9b, 0xea, 0x51, 0xec, 0x2b, 0x7d,
+			0x76, 0xd5, 0x15, 0xde, 0x98, 0xad, 0x5d, 0x6e,
+			0x79, 0xf5, 0xa4, 0x9b, 0x1b, 0x0c, 0xfa, 0x9b,
 		}),
-		Timestamp: time.Unix(0x5bd58c4c, 0),
+		Timestamp: time.Unix(0x5c238b73, 0),
 		Bits:      0x207fffff,
 		Nonce:     0xdffffffffffffff9,
 	},
@@ -401,7 +406,8 @@ var block3A = wire.MsgBlock{
 					},
 				},
 			},
-			LockTime: 0,
+			LockTime:     0,
+			SubNetworkID: wire.SubNetworkDAGCoin,
 		},
 		block3Tx,
 	},
@@ -412,21 +418,21 @@ var block4 = wire.MsgBlock{
 		Version: 1,
 		ParentHashes: []daghash.Hash{
 			[32]byte{ // Make go vet happy.
-				0xde, 0xe3, 0x62, 0x5f, 0x0c, 0x98, 0x26, 0x5f,
-				0x9b, 0x3e, 0xb1, 0xd9, 0x32, 0x0a, 0x84, 0xb3,
-				0xe1, 0xbe, 0xe2, 0xb7, 0x8e, 0x4a, 0xfb, 0x97,
-				0x7a, 0x53, 0x32, 0xff, 0x32, 0x17, 0xfc, 0x57,
+				0x4c, 0xfb, 0xcd, 0x2b, 0x0f, 0x3c, 0xa3, 0x61,
+				0x82, 0xce, 0x34, 0x39, 0x79, 0x0d, 0x22, 0x3b,
+				0x94, 0xdc, 0x7b, 0x66, 0xf8, 0x62, 0xc7, 0xb2,
+				0xd0, 0xfc, 0xb4, 0xf3, 0xc0, 0x7c, 0xa3, 0x63,
 			},
 		},
 		MerkleRoot: daghash.Hash([32]byte{ // Make go vet happy.
-			0xe1, 0x13, 0x4a, 0xd8, 0xd5, 0x43, 0x33, 0x95,
-			0x55, 0x19, 0x00, 0xaf, 0x13, 0x3f, 0xd6, 0x3a,
-			0x63, 0x98, 0x50, 0x61, 0xfc, 0x02, 0x2c, 0x44,
-			0x1b, 0x0e, 0x74, 0x7d, 0x5c, 0x19, 0x58, 0xb4,
+			0xe0, 0x32, 0x30, 0x4d, 0x53, 0x1d, 0xd4, 0xe0,
+			0xe1, 0xc7, 0x20, 0xf8, 0x28, 0x86, 0x45, 0x9f,
+			0x5d, 0x42, 0x1f, 0x2a, 0xb5, 0xcc, 0x62, 0x7f,
+			0xe7, 0xf2, 0xdd, 0x22, 0x64, 0x7c, 0xc4, 0x66,
 		}),
-		Timestamp: time.Unix(0x5bd58c4d, 0),
+		Timestamp: time.Unix(0x5c238b74, 0),
 		Bits:      0x207fffff,
-		Nonce:     0xdffffffffffffffa,
+		Nonce:     0xdffffffffffffffb,
 	},
 	Transactions: []*wire.MsgTx{
 		{
@@ -455,7 +461,8 @@ var block4 = wire.MsgBlock{
 					},
 				},
 			},
-			LockTime: 0,
+			LockTime:     0,
+			SubNetworkID: wire.SubNetworkDAGCoin,
 		},
 	},
 }
@@ -465,19 +472,27 @@ var block5 = wire.MsgBlock{
 		Version: 1,
 		ParentHashes: []daghash.Hash{
 			[32]byte{ // Make go vet happy.
-				0xfd, 0x96, 0x3c, 0xfb, 0xed, 0x5a, 0xeb, 0xdb, 0x3d, 0x8e, 0xe9, 0x53, 0xf1, 0xe6, 0xad, 0x12, 0x21, 0x02, 0x55, 0x62, 0xbc, 0x2e, 0x52, 0xee, 0xb9, 0xd0, 0x60, 0xda, 0xd6, 0x4a, 0x20, 0x5a},
+				0x03, 0x28, 0xad, 0x11, 0xe6, 0x8f, 0x48, 0x33,
+				0x5c, 0xa8, 0xbb, 0x8c, 0x29, 0xde, 0x43, 0xd5,
+				0x70, 0x8b, 0xbd, 0x1e, 0x61, 0x9d, 0xc8, 0x7d,
+				0xc5, 0x52, 0x86, 0x26, 0x6b, 0x68, 0xec, 0x1f,
+			},
 			[32]byte{ // Make go vet happy.
-				0xec, 0x42, 0x2c, 0x0c, 0x8c, 0x94, 0x50, 0x17, 0x85, 0xbb, 0x8c, 0xaf, 0x72, 0xd9, 0x39, 0x28, 0x26, 0xaa, 0x42, 0x8d, 0xd5, 0x09, 0xa2, 0xb6, 0xa6, 0x8c, 0x4e, 0x85, 0x72, 0x44, 0xd5, 0x70},
+				0xcf, 0xfd, 0x63, 0x11, 0x72, 0xb7, 0xdc, 0x80,
+				0x59, 0xd0, 0x35, 0x31, 0xed, 0x03, 0x89, 0x3a,
+				0xe9, 0x9b, 0x74, 0xee, 0x86, 0xad, 0x3c, 0x4e,
+				0x0b, 0x08, 0x46, 0xaa, 0x39, 0x30, 0xfa, 0x63,
+			},
 		},
 		MerkleRoot: daghash.Hash([32]byte{ // Make go vet happy.
-			0x77, 0xc7, 0x09, 0x46, 0x0f, 0x81, 0x37, 0xca,
-			0xf5, 0xec, 0xa5, 0xae, 0x4c, 0xad, 0x65, 0xc5,
-			0xdd, 0x73, 0x4f, 0xb5, 0xcf, 0x04, 0x20, 0x38,
-			0x29, 0x10, 0x5b, 0x66, 0xfe, 0x15, 0x8a, 0xfb,
+			0x8e, 0xb2, 0xf8, 0x31, 0xec, 0x11, 0xc2, 0x22,
+			0xd1, 0x31, 0x47, 0xf0, 0xbb, 0x48, 0x74, 0xce,
+			0x4a, 0x39, 0x25, 0x99, 0xa7, 0x1c, 0x8c, 0x83,
+			0x98, 0x8d, 0x66, 0xc5, 0x94, 0xa9, 0xf1, 0x50,
 		}),
-		Timestamp: time.Unix(0x5bd58c4e, 0),
+		Timestamp: time.Unix(0x5c238b75, 0),
 		Bits:      0x207fffff,
-		Nonce:     4,
+		Nonce:     0xdffffffffffffffa,
 	},
 	Transactions: []*wire.MsgTx{
 		{
@@ -506,7 +521,8 @@ var block5 = wire.MsgBlock{
 					},
 				},
 			},
-			LockTime: 0,
+			LockTime:     0,
+			SubNetworkID: wire.SubNetworkDAGCoin,
 		},
 	},
 }
diff --git a/blockdag/testdata/blk_0_to_4.dat b/blockdag/testdata/blk_0_to_4.dat
index 9e90b879e145beff6e6b9be637ea9299ffcfab40..50287849050c0d5d35095c12e150bd9b5571f7b2 100644
GIT binary patch
delta 877
zcmey#vy+$g=e{jB#U`?9h-|J=j$r_T|NrY1e*Xu9`4b(lW-@{VfdHiNFpviE8BN5*
zTVuah-n(P|A$;=Oe5I%V7uX%Q3;4QFi%ZXg^^kj}iR|)ClenHl7-{}^;dy>qfy>lc
z*R@X+Z)!9t=#<G+Sk{WL3}V-R`H7BNlNT~tL?T-_8OQ-!_+fch%Ktz9)=wusRxCPE
zmF--ouu){Y;hH<k5AAxH-Xv?ZWqO69>T8Ff`mMIgla7@)Ptkc7ePw@XY2CGAPV;LY
zmIE!EY|m;vIhDz}9^@Ucsf3&fQkd;w;L4=Pa6Dj1=Sk*Fi${(|{B!QSeSXFB`se=z
z?tx)<+!je#E$w1b;6G$8ntFcqihkjS^@`umdOqh9u)lY4e*N_0UayjOb;~m<GA%1k
z?%5eJS)ADyC0HlHe93K?_ld1FbH)kI9{~$Ct!|I`x_irJ-(O22KUx>hJT|4|cuy1O
z*#?uz?PbDi_&-~n7f|8+YqxBtU*p~AK7QAy(JPRG^$#Rm>nHoOYES;ajO6R5lTLD%
z7hL!%@kK&y@_7Tr0E5FKLfli<gdP{v>%O{?9pvjQcLNtD1%(iO!J@xErJ`5dE||#C
z({pMg#|`DWr48A>Ve0SaC#NzgxK2yfW(?mXcJZ4<$mVU@q3c;scirD}<=(=xd)mL|
zDN4XST{BsN*$2hf@VMQQoSF2n<V%+Qg&fP>*&m+WT&NIO_9JA~iI*=nZ2rC~QA^Q0
zUg7NNwFh2voJm|5)Mm2fn&rm}7o<4%moG|?$aPwY<m+D$U+)L{It>xe=7+dUBkiBA
zmniwd6Ty1n<dLiEnyyS)u<&okR?jVqXX+uv^W^!HoO<VQo?m<8OQLASh1bzfH+OL+
zoO6uX^p;<%-rJc;K|4~WP$cf4nVhfj&y%NE>*QuEb`AT>T)1!}bK=!GZV%vI2E{W6
ID4l@-05(>1&Hw-a

delta 773
zcmdnV`;&+D=e{jB`6jYzi2P&N7tH_!|Nqx3{P_<C_a{1DO#~^}4HRbtVXuQtdd{q`
zc>K?lx35$4Xb%v6rysgpV!7O>8#M=o*C<VTUAkt`x&xZ~uPvTAqhWPgR`+(Zy4^oE
zUY;(&zjXVRoP$gVOMb&G(VD!H(IN?CQ8UmMutigsJ8<08xLLPaBT9sQOKahT_{KGd
z@+VxZRQP8kd3h(-Dq*kLdxLN6m^IhZ*<g2Ee?<v*`t<WN_h+%5S{^O`XZ|597BNk3
zVAPsi%4D6#NXVU_fXMbRaAi_txT-w+1M{S*+4EMV=;(%(UW?J3)${eh!ELR31HL~y
z(qG1;U>Yc;#ktu_+9@cQJ$BlMOOu&GZx-IUUMBpR<IW4~heDGNu!IGIeAfi?U3LnC
zxxCP%aDE;?*Hdz@l(lVtGV<E(5Z+qMK5gz)k(})g_jd0Ja5#Tz`|_}tPLlg|rX4)g
z#3vw-ahAhv#q9%vhk?GEY{g_fS%Aelm+|}kS(7fCOqPH1uHk(DBX^y>uF0uus@;$E
zm9$z|O_N>&@=TVyfeVv@8z*CkesVwn=l-)r!Y^-YzUzD9y+Wo!bMgKSd&DkX@MTiq
zI`yM^_kNG$r{|t=iAbxsuVB9Y*g51~;IZ!)(yv)2{)YPn9#f%alM`Rx_jtdf)w(yt
z@r|-Vkd^Sv!`|&ziXT=o$u1KO@vaRQx0!wKb;-XA>X$Du$##jjM`!!q)M4QGzjD(Q
z^CK|7tYQU549}Ly>5&m7RvY?77+OErzTf`4`HP;#)nl!T&BZTRT3RDT%)5S%_4PS_
zF086ulFXv>sB-^at)<)LOf7;FdU(FZ%9JuGxZ5Y|c>6!Uut(+nUGFEK^qe)9{<>~)
QQR0xRgUzWF6(*2p0Kwc|GXMYp

diff --git a/blockdag/testdata/blk_3A.dat b/blockdag/testdata/blk_3A.dat
index eca91042d87da3d2edcf63349fee0d36858a159f..1af686a13499fc7aa2cb4cd8fac3afbc7e5e808f 100644
GIT binary patch
delta 239
zcmeBTp2ZyXbKjPmlNcEofQW&S+c57FTWjWw6P!N+7HnGG9`kkgmd(DumPCHEE}nU8
zN=eucHd!W)mvd_7F0FO@d9P{zrJp}jpU!W-6{K<ZkRc!AidN+qpg9cx|JN)0o*0!|
z58{ALemdzScX`2uuM%G*)Fz)dPz*3QEF#1`WliXDLA~y)8`(h$v)m0_m=qL3^aYFl
z{*;Pdal2q5M^DeGjT|?W>y|cT`-Z8%pP!t{q~JO&S(`C@li0;?79pFrX@{<7J>7MG
j&y{-%&+cjenx`nisK~UeIJswMM9pM7MjsB4{U87UYsX@y

delta 230
zcmV<C02%+91BwG$`M$K-f&l;k0RR910c&IcHy;v`R}TzMMamxPBP%`m0S!L56SZ>(
zmYtOpY&`4KSojVgw3zyck}+T#xxO8Tu&V>zn}u4VKq@oBkHZ4KTL1t60RR7gAo`J7
zZGQpx-<p!sG?O3f?tssa;zumKMPp^Gdq>8ObcHxNmK&@90001LM=(SJAVvuRR4-#t
zPzk@yauey>DejKsOQ;-pDWkuzycW{XO#&ba%J_S`zer={&gKdf8ze`l1KZ<6RPIs6
g_t0n7Ibr(&Ap)jzV~n|2e726DjlTAU#*<C~L{!XV4gdfE

diff --git a/blockdag/testdata/blk_3B.dat b/blockdag/testdata/blk_3B.dat
index 4315140f2bcab0371d8d71811b1943e757927000..95ab49d81abc4d5b80422960990032c3f7890aa9 100644
GIT binary patch
delta 114
zcmX@ic$zWs=e{jB4>K?@FoH0*VcsXU*320vIDZ5z*tEJm=Iib)n|*&RiTr3?JoDI;
zlB6BV-HgFgnIDPEX{7A_8@!s~;l-(IW$rdkJv-Osr_J*ft;#V#a~S^ruUGi<9}MPC
LOibbc84dyf*LgIO

delta 105
zcmX@jc$hKq=e{jBcQY_BFoJM)3WK@4(4=sF9zWMpa<7!NZGSTI+U*eDTFgFe?o^SS
zo#Dq))?^>Z{Ike!>PMY*WjXiP`L-F=D9lsp5#GAKTkJ5?zG$F14FCVvEByTr2JsUU
FlK@{xE(8Do

diff --git a/blockdag/testdata/blk_3C.dat b/blockdag/testdata/blk_3C.dat
index fe95c743bf63751017ec92ddae2199841eacea80..53e790c5505de523d0f3f5732516140e910dd755 100644
GIT binary patch
delta 147
zcmaFN_?of)=e{jBA2Tp8Faj|Xw_)BVw${uUCpdouEZDTVJ?87~Et`FREs6YST|D#H
zl#&n2yHfuD@wa|D@v&mjiK=YpI)#lQ+YQ&;S$=5O%k(B$^Fv&wk@ip5OO$-!iD12O
x^2pV7O;@HYSopVNtLK)*Gxb)qD#rlrVfg>QUg7tD5McVhe_~@22gr610022TNIU=l

delta 138
zcmaFO_?WT&=e{jBZ!<73Faj}Cb_#>JywId@ejY#9Q*y7AwQYYg^4jeX-dfB)ZSGW&
zoT<wlIBsg(tXr)SCBnX?wQxdw<C;VH6E0RN{4<igypxM(%jERPh!U#}{UQvlA8g-m
q|K0pW&*JK_*2U)H7c4EU4>RqH2HL~$|9`#0&;KC6^#A_E#v}mPnLPyn

diff --git a/blockdag/testdata/blk_3D.dat b/blockdag/testdata/blk_3D.dat
index 5a9453f015d8e14749cdef13a2a73744b9444a31..ced8f5580af4523ee9b3173f2ca1c08b03eaa5aa 100644
GIT binary patch
delta 283
zcmdnae1bXg=e{jB4=^$?01*Qtw_)BVw${uUCpdouEZDTVJ?87~Et`FREs6YST|D#H
zl#&t=ty;7HvUlRcLk`qUnId@2d3xCu{tY*+1UBmCHX1OkXjP5@n#1t_f4#z=|6nkG
zVq#i7NDO2F)6+>OxyuVKe3kejp*H!vfntEcVG$wjDQiNH3+i=W-N+77nC)TU%B0A!
zrgM5$$m3W4en&)HS>EN`wCj(x+ma94)|*Z(KFILqnHrM<$KHu~3#E58xknt|KKpC`
wN$V%;e;wCsWc`0}UDY?c*h7qpOv{Rsdv-=lwq;aOAY}FAdPWNlkRw3=0DFIXVE_OC

delta 278
zcmX@Xyq!7m=e{jB*E2FO01*RYb_#>JywId@ejY#9Q*y7AwQYYg^4jeX-dfB)ZSGW&
zoQG$!40(1<`Zsr(+XUSp)|i`5%r89^KIZV5sV*n>IFt8brhU;sa~S^ruUGi_9}MnK
zOiZh1`hI`bq{}9g<=?z(IN$%sU1zUra_X9D_hWq}trk|(q}PBnWw{%;Fe&72pDw9!
z!hDVW;W;ZpmikYAI*s9{_}LXYkB+1)^=J8H#-!l=X>W(*TSJAiPX_h(G6J)5E-hR!
w<KQ*H+p8y-o6J}j#Hh%$tT?%6XGG1mz6HJezO^2k?9V8vN{ka2CQdL000A|AjsO4v

diff --git a/blockdag/validate_test.go b/blockdag/validate_test.go
index a5264c155..df0eccb9f 100644
--- a/blockdag/validate_test.go
+++ b/blockdag/validate_test.go
@@ -625,14 +625,14 @@ var Block100000 = wire.MsgBlock{
 			},
 		},
 		MerkleRoot: daghash.Hash([32]byte{ // Make go vet happy.
-			0xc0, 0x92, 0x53, 0x8f, 0x6f, 0xf7, 0xf5, 0x24,
-			0xd5, 0x33, 0xd4, 0x8b, 0xf3, 0xc0, 0xf8, 0xf9,
-			0x6f, 0xff, 0xfb, 0xb7, 0xdc, 0x39, 0x9d, 0x76,
-			0x8d, 0xb0, 0xe1, 0x9c, 0x2e, 0x6d, 0x22, 0xd9,
-		}), // f3e94742aca4b5ef85488dc37c06c3282295ffec960994b2c0d5ac2a25a95766
-		Timestamp: time.Unix(0x5bbc7588, 0), // 2018-10-09 07:49:35 +0000 UTC
-		Bits:      0x207fffff,               // 503382015
-		Nonce:     0xdffffff9,
+			0x0b, 0x79, 0xf5, 0x29, 0x6d, 0x1c, 0xaa, 0x90,
+			0x2f, 0x01, 0xd4, 0x83, 0x9b, 0x2a, 0x04, 0x5e,
+			0xa0, 0x69, 0x2d, 0x16, 0xb5, 0xd7, 0xe4, 0xf3,
+			0xcd, 0xc7, 0xc9, 0xaf, 0xfb, 0xd2, 0x1b, 0x85,
+		}),
+		Timestamp: time.Unix(0x5c22330f, 0),
+		Bits:      0x207fffff,
+		Nonce:     0xdffffffffffffffc,
 	},
 	Transactions: []*wire.MsgTx{
 		{
@@ -736,7 +736,8 @@ var Block100000 = wire.MsgBlock{
 					},
 				},
 			},
-			LockTime: 0,
+			LockTime:     0,
+			SubNetworkID: wire.SubNetworkDAGCoin,
 		},
 		{
 			Version: 1,
@@ -804,7 +805,8 @@ var Block100000 = wire.MsgBlock{
 					},
 				},
 			},
-			LockTime: 0,
+			LockTime:     0,
+			SubNetworkID: wire.SubNetworkDAGCoin,
 		},
 		{
 			Version: 1,
@@ -860,7 +862,8 @@ var Block100000 = wire.MsgBlock{
 					},
 				},
 			},
-			LockTime: 0,
+			LockTime:     0,
+			SubNetworkID: wire.SubNetworkDAGCoin,
 		},
 	},
 }
diff --git a/dagconfig/genesis.go b/dagconfig/genesis.go
index 5e3c871be..97a6b077a 100644
--- a/dagconfig/genesis.go
+++ b/dagconfig/genesis.go
@@ -53,25 +53,26 @@ var genesisCoinbaseTx = wire.MsgTx{
 			},
 		},
 	},
-	LockTime: 0,
+	LockTime:     0,
+	SubNetworkID: wire.SubNetworkDAGCoin,
 }
 
 // genesisHash is the hash of the first block in the block chain for the main
 // network (genesis block).
 var genesisHash = daghash.Hash([daghash.HashSize]byte{ // Make go vet happy.
-	0xc3, 0xc9, 0xa8, 0xba, 0x10, 0x1e, 0x5e, 0xf2,
-	0x03, 0xfd, 0x54, 0x15, 0x34, 0xae, 0x4e, 0x74,
-	0xc5, 0x5f, 0x48, 0x2e, 0xc9, 0xef, 0xba, 0x58,
-	0x92, 0xce, 0x27, 0xfa, 0xf9, 0x00, 0x00, 0x00,
+	0x34, 0x16, 0x17, 0x85, 0x5d, 0xf7, 0x79, 0xde,
+	0xdc, 0x37, 0xf0, 0x57, 0x93, 0x9d, 0x6f, 0x22,
+	0xe5, 0xff, 0xa0, 0x3e, 0xc7, 0x3e, 0x50, 0xf5,
+	0xa1, 0x2a, 0x0a, 0x2e, 0x48, 0x05, 0xc2, 0x47,
 })
 
 // genesisMerkleRoot is the hash of the first transaction in the genesis block
 // for the main network.
 var genesisMerkleRoot = daghash.Hash([daghash.HashSize]byte{ // Make go vet happy.
-	0x69, 0x1f, 0x2e, 0x9c, 0x49, 0x12, 0x54, 0xc5,
-	0xde, 0x1d, 0x8f, 0xd0, 0x95, 0x40, 0x07, 0xf0,
-	0xda, 0x1b, 0x4c, 0x84, 0x3c, 0x07, 0x94, 0x87,
-	0x6a, 0xd3, 0x0e, 0xca, 0x87, 0xcc, 0x4b, 0xb9,
+	0x79, 0x6e, 0xd7, 0x12, 0x58, 0xea, 0x3f, 0x88,
+	0xa1, 0xfa, 0x7a, 0x67, 0x2b, 0x68, 0x76, 0x6b,
+	0x39, 0x6b, 0x7d, 0x15, 0x6b, 0x1a, 0xb1, 0x96,
+	0xe2, 0x17, 0x2c, 0x4a, 0x6a, 0xad, 0x72, 0x96,
 })
 
 // genesisBlock defines the genesis block of the block chain which serves as the
@@ -80,10 +81,10 @@ var genesisBlock = wire.MsgBlock{
 	Header: wire.BlockHeader{
 		Version:      1,
 		ParentHashes: []daghash.Hash{},
-		MerkleRoot:   genesisMerkleRoot,        // 4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b
-		Timestamp:    time.Unix(0x5bbe076c, 0), // 2018-10-10 14:06:36 +0000 UTC
-		Bits:         0x1e00ffff,               // 503382015 [000000ffff000000000000000000000000000000000000000000000000000000]
-		Nonce:        0x80000000000d8796,       // 9223372036855662486
+		MerkleRoot:   genesisMerkleRoot,
+		Timestamp:    time.Unix(0x5c238413, 0),
+		Bits:         0x207fffff,
+		Nonce:        0x00000001,
 	},
 	Transactions: []*wire.MsgTx{&genesisCoinbaseTx},
 }
@@ -91,10 +92,10 @@ var genesisBlock = wire.MsgBlock{
 // regTestGenesisHash is the hash of the first block in the block chain for the
 // regression test network (genesis block).
 var regTestGenesisHash = daghash.Hash([daghash.HashSize]byte{ // Make go vet happy.
-	0xe7, 0xbe, 0x90, 0x9a, 0x85, 0xf4, 0xea, 0x42,
-	0xe0, 0xd6, 0x68, 0x09, 0xc5, 0xa9, 0xd6, 0x94,
-	0xa2, 0x34, 0x52, 0x4c, 0x5f, 0x1a, 0x77, 0xb1,
-	0xcf, 0x26, 0x12, 0x0a, 0x1b, 0x26, 0x92, 0x13,
+	0x34, 0x16, 0x17, 0x85, 0x5d, 0xf7, 0x79, 0xde,
+	0xdc, 0x37, 0xf0, 0x57, 0x93, 0x9d, 0x6f, 0x22,
+	0xe5, 0xff, 0xa0, 0x3e, 0xc7, 0x3e, 0x50, 0xf5,
+	0xa1, 0x2a, 0x0a, 0x2e, 0x48, 0x05, 0xc2, 0x47,
 })
 
 // regTestGenesisMerkleRoot is the hash of the first transaction in the genesis
@@ -108,10 +109,10 @@ var regTestGenesisBlock = wire.MsgBlock{
 	Header: wire.BlockHeader{
 		Version:      1,
 		ParentHashes: []daghash.Hash{},
-		MerkleRoot:   regTestGenesisMerkleRoot, // 4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b
-		Timestamp:    time.Unix(0x5bbe0d4b, 0), // 2018-06-19 09:00:38 +0000 UTC
-		Bits:         0x207fffff,               // 545259519 [7fffff0000000000000000000000000000000000000000000000000000000000]
-		Nonce:        0x00000000,
+		MerkleRoot:   genesisMerkleRoot,
+		Timestamp:    time.Unix(0x5c238413, 0),
+		Bits:         0x207fffff,
+		Nonce:        0x00000001,
 	},
 	Transactions: []*wire.MsgTx{&genesisCoinbaseTx},
 }
@@ -119,10 +120,10 @@ var regTestGenesisBlock = wire.MsgBlock{
 // testNet3GenesisHash is the hash of the first block in the block chain for the
 // test network (version 3).
 var testNet3GenesisHash = daghash.Hash([daghash.HashSize]byte{ // Make go vet happy.
-	0xcb, 0xcb, 0x39, 0xdb, 0xc7, 0x18, 0xe3, 0xd3,
-	0x59, 0xb2, 0xf4, 0xe3, 0x9c, 0x05, 0xa3, 0x1d,
-	0x60, 0xc6, 0xf7, 0x06, 0xb5, 0x93, 0xdf, 0x11,
-	0x71, 0x1b, 0x82, 0xb1, 0xa3, 0x00, 0x00, 0x00,
+	0x34, 0x16, 0x17, 0x85, 0x5d, 0xf7, 0x79, 0xde,
+	0xdc, 0x37, 0xf0, 0x57, 0x93, 0x9d, 0x6f, 0x22,
+	0xe5, 0xff, 0xa0, 0x3e, 0xc7, 0x3e, 0x50, 0xf5,
+	0xa1, 0x2a, 0x0a, 0x2e, 0x48, 0x05, 0xc2, 0x47,
 })
 
 // testNet3GenesisMerkleRoot is the hash of the first transaction in the genesis
@@ -136,10 +137,10 @@ var testNet3GenesisBlock = wire.MsgBlock{
 	Header: wire.BlockHeader{
 		Version:      1,
 		ParentHashes: []daghash.Hash{},
-		MerkleRoot:   testNet3GenesisMerkleRoot, // 4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b
-		Timestamp:    time.Unix(0x5bbe0e49, 0),  // 2018-06-19 09:04:06 +0000 UTC
-		Bits:         0x1e00ffff,                // 503382015 [000000ffff000000000000000000000000000000000000000000000000000000]
-		Nonce:        0xc00000000032560b,        // 2150570811
+		MerkleRoot:   genesisMerkleRoot,
+		Timestamp:    time.Unix(0x5c238413, 0),
+		Bits:         0x207fffff,
+		Nonce:        0x00000001,
 	},
 	Transactions: []*wire.MsgTx{&genesisCoinbaseTx},
 }
@@ -147,10 +148,10 @@ var testNet3GenesisBlock = wire.MsgBlock{
 // simNetGenesisHash is the hash of the first block in the block chain for the
 // simulation test network.
 var simNetGenesisHash = daghash.Hash([daghash.HashSize]byte{ // Make go vet happy.
-	0x4a, 0xc1, 0x82, 0x2e, 0x43, 0x05, 0xea, 0x0c,
-	0x4f, 0xcc, 0x77, 0x87, 0xae, 0x26, 0x48, 0x87,
-	0x50, 0x13, 0xee, 0x2f, 0x55, 0xa7, 0x18, 0xa7,
-	0x1e, 0xf2, 0xd8, 0x7c, 0xc1, 0x13, 0xac, 0x22,
+	0x34, 0x16, 0x17, 0x85, 0x5d, 0xf7, 0x79, 0xde,
+	0xdc, 0x37, 0xf0, 0x57, 0x93, 0x9d, 0x6f, 0x22,
+	0xe5, 0xff, 0xa0, 0x3e, 0xc7, 0x3e, 0x50, 0xf5,
+	0xa1, 0x2a, 0x0a, 0x2e, 0x48, 0x05, 0xc2, 0x47,
 })
 
 // simNetGenesisMerkleRoot is the hash of the first transaction in the genesis
@@ -164,10 +165,10 @@ var simNetGenesisBlock = wire.MsgBlock{
 	Header: wire.BlockHeader{
 		Version:      1,
 		ParentHashes: []daghash.Hash{},
-		MerkleRoot:   simNetGenesisMerkleRoot,  // 4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b
-		Timestamp:    time.Unix(0x5bbe00fe, 0), // 2018-10-10 13:39:10 +0000 UTC
-		Bits:         0x207fffff,               // 545259519 [7fffff0000000000000000000000000000000000000000000000000000000000]
-		Nonce:        0xdffffffffffffffc,       // 1610612733
+		MerkleRoot:   genesisMerkleRoot,
+		Timestamp:    time.Unix(0x5c238413, 0),
+		Bits:         0x207fffff,
+		Nonce:        0x00000001,
 	},
 	Transactions: []*wire.MsgTx{&genesisCoinbaseTx},
 }
diff --git a/dagconfig/genesis_test.go b/dagconfig/genesis_test.go
index 195b2619f..860d97342 100644
--- a/dagconfig/genesis_test.go
+++ b/dagconfig/genesis_test.go
@@ -121,52 +121,13 @@ func TestSimNetGenesisBlock(t *testing.T) {
 // genesisBlockBytes are the wire encoded bytes for the genesis block of the
 // main network as of protocol version 60002.
 var genesisBlockBytes = []byte{
-	0x01, 0x00, 0x00, 0x00, 0x00, 0x69, 0x1f, 0x2e, /* |.....i..| */
-	0x9c, 0x49, 0x12, 0x54, 0xc5, 0xde, 0x1d, 0x8f, /* |.I.T....| */
-	0xd0, 0x95, 0x40, 0x07, 0xf0, 0xda, 0x1b, 0x4c, /* |..@....L| */
-	0x84, 0x3c, 0x07, 0x94, 0x87, 0x6a, 0xd3, 0x0e, /* |.<...j..| */
-	0xca, 0x87, 0xcc, 0x4b, 0xb9, 0x6c, 0x07, 0xbe, /* |...K.l..| */
-	0x5b, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, /* |[.......| */
-	0x1e, 0x96, 0x87, 0x0d, 0x00, 0x00, 0x00, 0x00, /* |........| */
-	0x80, 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, /* |........| */
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* |........| */
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* |........| */
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* |........| */
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, /* |........| */
-	0xff, 0xff, 0xff, 0x4d, 0x04, 0xff, 0xff, 0x00, /* |...M....| */
-	0x1d, 0x01, 0x04, 0x45, 0x54, 0x68, 0x65, 0x20, /* |...EThe | */
-	0x54, 0x69, 0x6d, 0x65, 0x73, 0x20, 0x30, 0x33, /* |Times 03| */
-	0x2f, 0x4a, 0x61, 0x6e, 0x2f, 0x32, 0x30, 0x30, /* |/Jan/200| */
-	0x39, 0x20, 0x43, 0x68, 0x61, 0x6e, 0x63, 0x65, /* |9 Chance| */
-	0x6c, 0x6c, 0x6f, 0x72, 0x20, 0x6f, 0x6e, 0x20, /* |llor on | */
-	0x62, 0x72, 0x69, 0x6e, 0x6b, 0x20, 0x6f, 0x66, /* |brink of| */
-	0x20, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x20, /* | second | */
-	0x62, 0x61, 0x69, 0x6c, 0x6f, 0x75, 0x74, 0x20, /* |bailout | */
-	0x66, 0x6f, 0x72, 0x20, 0x62, 0x61, 0x6e, 0x6b, /* |for bank| */
-	0x73, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* |s.......| */
-	0xff, 0x01, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, /* |.....*..| */
-	0x00, 0x00, 0x43, 0x41, 0x04, 0x67, 0x8a, 0xfd, /* |..CA.g..| */
-	0xb0, 0xfe, 0x55, 0x48, 0x27, 0x19, 0x67, 0xf1, /* |..UH'.g.| */
-	0xa6, 0x71, 0x30, 0xb7, 0x10, 0x5c, 0xd6, 0xa8, /* |.q0..\..| */
-	0x28, 0xe0, 0x39, 0x09, 0xa6, 0x79, 0x62, 0xe0, /* |(.9..yb.| */
-	0xea, 0x1f, 0x61, 0xde, 0xb6, 0x49, 0xf6, 0xbc, /* |..a..I..| */
-	0x3f, 0x4c, 0xef, 0x38, 0xc4, 0xf3, 0x55, 0x04, /* |?L.8..U.| */
-	0xe5, 0x1e, 0xc1, 0x12, 0xde, 0x5c, 0x38, 0x4d, /* |.....\8M| */
-	0xf7, 0xba, 0x0b, 0x8d, 0x57, 0x8a, 0x4c, 0x70, /* |....W.Lp| */
-	0x2b, 0x6b, 0xf1, 0x1d, 0x5f, 0xac, 0x00, 0x00, /* |+k.._...| */
-	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* |......| */
-}
-
-// regTestGenesisBlockBytes are the wire encoded bytes for the genesis block of
-// the regression test network as of protocol version 60002.
-var regTestGenesisBlockBytes = []byte{
-	0x01, 0x00, 0x00, 0x00, 0x00, 0x69, 0x1f, 0x2e, /* |.....i..| */
-	0x9c, 0x49, 0x12, 0x54, 0xc5, 0xde, 0x1d, 0x8f, /* |.I.T....| */
-	0xd0, 0x95, 0x40, 0x07, 0xf0, 0xda, 0x1b, 0x4c, /* |..@....L| */
-	0x84, 0x3c, 0x07, 0x94, 0x87, 0x6a, 0xd3, 0x0e, /* |.<...j..| */
-	0xca, 0x87, 0xcc, 0x4b, 0xb9, 0x4b, 0x0d, 0xbe, /* |...K.K..| */
-	0x5b, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x7f, /* |[.......| */
-	0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* | .......| */
+	0x01, 0x00, 0x00, 0x00, 0x00, 0x79, 0x6e, 0xd7, /* |.....yn.| */
+	0x12, 0x58, 0xea, 0x3f, 0x88, 0xa1, 0xfa, 0x7a, /* |.X.?...z| */
+	0x67, 0x2b, 0x68, 0x76, 0x6b, 0x39, 0x6b, 0x7d, /* |g+hvk9k}| */
+	0x15, 0x6b, 0x1a, 0xb1, 0x96, 0xe2, 0x17, 0x2c, /* |.k.....,| */
+	0x4a, 0x6a, 0xad, 0x72, 0x96, 0x13, 0x84, 0x23, /* |Jj.r...#| */
+	0x5c, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x7f, /* |\.......| */
+	0x20, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* | .......| */
 	0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, /* |........| */
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* |........| */
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* |........| */
@@ -193,20 +154,61 @@ var regTestGenesisBlockBytes = []byte{
 	0xe5, 0x1e, 0xc1, 0x12, 0xde, 0x5c, 0x38, 0x4d, /* |.....\8M| */
 	0xf7, 0xba, 0x0b, 0x8d, 0x57, 0x8a, 0x4c, 0x70, /* |....W.Lp| */
 	0x2b, 0x6b, 0xf1, 0x1d, 0x5f, 0xac, 0x00, 0x00, /* |+k.._...| */
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, /* |........| */
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* |......| */
+}
+
+// regTestGenesisBlockBytes are the wire encoded bytes for the genesis block of
+// the regression test network as of protocol version 60002.
+var regTestGenesisBlockBytes = []byte{
+	0x01, 0x00, 0x00, 0x00, 0x00, 0x79, 0x6e, 0xd7, /* |.....yn.| */
+	0x12, 0x58, 0xea, 0x3f, 0x88, 0xa1, 0xfa, 0x7a, /* |.X.?...z| */
+	0x67, 0x2b, 0x68, 0x76, 0x6b, 0x39, 0x6b, 0x7d, /* |g+hvk9k}| */
+	0x15, 0x6b, 0x1a, 0xb1, 0x96, 0xe2, 0x17, 0x2c, /* |.k.....,| */
+	0x4a, 0x6a, 0xad, 0x72, 0x96, 0x13, 0x84, 0x23, /* |Jj.r...#| */
+	0x5c, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x7f, /* |\.......| */
+	0x20, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* | .......| */
+	0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, /* |........| */
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* |........| */
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* |........| */
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* |........| */
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, /* |........| */
+	0xff, 0xff, 0xff, 0x4d, 0x04, 0xff, 0xff, 0x00, /* |...M....| */
+	0x1d, 0x01, 0x04, 0x45, 0x54, 0x68, 0x65, 0x20, /* |...EThe | */
+	0x54, 0x69, 0x6d, 0x65, 0x73, 0x20, 0x30, 0x33, /* |Times 03| */
+	0x2f, 0x4a, 0x61, 0x6e, 0x2f, 0x32, 0x30, 0x30, /* |/Jan/200| */
+	0x39, 0x20, 0x43, 0x68, 0x61, 0x6e, 0x63, 0x65, /* |9 Chance| */
+	0x6c, 0x6c, 0x6f, 0x72, 0x20, 0x6f, 0x6e, 0x20, /* |llor on | */
+	0x62, 0x72, 0x69, 0x6e, 0x6b, 0x20, 0x6f, 0x66, /* |brink of| */
+	0x20, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x20, /* | second | */
+	0x62, 0x61, 0x69, 0x6c, 0x6f, 0x75, 0x74, 0x20, /* |bailout | */
+	0x66, 0x6f, 0x72, 0x20, 0x62, 0x61, 0x6e, 0x6b, /* |for bank| */
+	0x73, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* |s.......| */
+	0xff, 0x01, 0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, /* |.....*..| */
+	0x00, 0x00, 0x43, 0x41, 0x04, 0x67, 0x8a, 0xfd, /* |..CA.g..| */
+	0xb0, 0xfe, 0x55, 0x48, 0x27, 0x19, 0x67, 0xf1, /* |..UH'.g.| */
+	0xa6, 0x71, 0x30, 0xb7, 0x10, 0x5c, 0xd6, 0xa8, /* |.q0..\..| */
+	0x28, 0xe0, 0x39, 0x09, 0xa6, 0x79, 0x62, 0xe0, /* |(.9..yb.| */
+	0xea, 0x1f, 0x61, 0xde, 0xb6, 0x49, 0xf6, 0xbc, /* |..a..I..| */
+	0x3f, 0x4c, 0xef, 0x38, 0xc4, 0xf3, 0x55, 0x04, /* |?L.8..U.| */
+	0xe5, 0x1e, 0xc1, 0x12, 0xde, 0x5c, 0x38, 0x4d, /* |.....\8M| */
+	0xf7, 0xba, 0x0b, 0x8d, 0x57, 0x8a, 0x4c, 0x70, /* |....W.Lp| */
+	0x2b, 0x6b, 0xf1, 0x1d, 0x5f, 0xac, 0x00, 0x00, /* |+k.._...| */
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, /* |........| */
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* |......| */
 }
 
 // testNet3GenesisBlockBytes are the wire encoded bytes for the genesis block of
 // the test network (version 3) as of protocol version 60002.
 var testNet3GenesisBlockBytes = []byte{
-	0x01, 0x00, 0x00, 0x00, 0x00, 0x69, 0x1f, 0x2e, /* |.....i..| */
-	0x9c, 0x49, 0x12, 0x54, 0xc5, 0xde, 0x1d, 0x8f, /* |.I.T....| */
-	0xd0, 0x95, 0x40, 0x07, 0xf0, 0xda, 0x1b, 0x4c, /* |..@....L| */
-	0x84, 0x3c, 0x07, 0x94, 0x87, 0x6a, 0xd3, 0x0e, /* |.<...j..| */
-	0xca, 0x87, 0xcc, 0x4b, 0xb9, 0x49, 0x0e, 0xbe, /* |...K.I..| */
-	0x5b, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, /* |[.......| */
-	0x1e, 0x0b, 0x56, 0x32, 0x00, 0x00, 0x00, 0x00, /* |..V2....| */
-	0xc0, 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, /* |........| */
+	0x01, 0x00, 0x00, 0x00, 0x00, 0x79, 0x6e, 0xd7, /* |.....yn.| */
+	0x12, 0x58, 0xea, 0x3f, 0x88, 0xa1, 0xfa, 0x7a, /* |.X.?...z| */
+	0x67, 0x2b, 0x68, 0x76, 0x6b, 0x39, 0x6b, 0x7d, /* |g+hvk9k}| */
+	0x15, 0x6b, 0x1a, 0xb1, 0x96, 0xe2, 0x17, 0x2c, /* |.k.....,| */
+	0x4a, 0x6a, 0xad, 0x72, 0x96, 0x13, 0x84, 0x23, /* |Jj.r...#| */
+	0x5c, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x7f, /* |\.......| */
+	0x20, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* | .......| */
+	0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, /* |........| */
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* |........| */
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* |........| */
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* |........| */
@@ -232,20 +234,21 @@ var testNet3GenesisBlockBytes = []byte{
 	0xe5, 0x1e, 0xc1, 0x12, 0xde, 0x5c, 0x38, 0x4d, /* |.....\8M| */
 	0xf7, 0xba, 0x0b, 0x8d, 0x57, 0x8a, 0x4c, 0x70, /* |....W.Lp| */
 	0x2b, 0x6b, 0xf1, 0x1d, 0x5f, 0xac, 0x00, 0x00, /* |+k.._...| */
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, /* |........| */
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* |......| */
 }
 
 // simNetGenesisBlockBytes are the wire encoded bytes for the genesis block of
 // the simulation test network as of protocol version 70002.
 var simNetGenesisBlockBytes = []byte{
-	0x01, 0x00, 0x00, 0x00, 0x00, 0x69, 0x1f, 0x2e, /* |.....i..| */
-	0x9c, 0x49, 0x12, 0x54, 0xc5, 0xde, 0x1d, 0x8f, /* |.I.T....| */
-	0xd0, 0x95, 0x40, 0x07, 0xf0, 0xda, 0x1b, 0x4c, /* |..@....L| */
-	0x84, 0x3c, 0x07, 0x94, 0x87, 0x6a, 0xd3, 0x0e, /* |.<...j..| */
-	0xca, 0x87, 0xcc, 0x4b, 0xb9, 0xfe, 0x00, 0xbe, /* |...K....| */
-	0x5b, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x7f, /* |[.......| */
-	0x20, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* | .......| */
-	0xdf, 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, /* |........| */
+	0x01, 0x00, 0x00, 0x00, 0x00, 0x79, 0x6e, 0xd7, /* |.....yn.| */
+	0x12, 0x58, 0xea, 0x3f, 0x88, 0xa1, 0xfa, 0x7a, /* |.X.?...z| */
+	0x67, 0x2b, 0x68, 0x76, 0x6b, 0x39, 0x6b, 0x7d, /* |g+hvk9k}| */
+	0x15, 0x6b, 0x1a, 0xb1, 0x96, 0xe2, 0x17, 0x2c, /* |.k.....,| */
+	0x4a, 0x6a, 0xad, 0x72, 0x96, 0x13, 0x84, 0x23, /* |Jj.r...#| */
+	0x5c, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x7f, /* |\.......| */
+	0x20, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* | .......| */
+	0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, /* |........| */
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* |........| */
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* |........| */
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* |........| */
@@ -271,5 +274,6 @@ var simNetGenesisBlockBytes = []byte{
 	0xe5, 0x1e, 0xc1, 0x12, 0xde, 0x5c, 0x38, 0x4d, /* |.....\8M| */
 	0xf7, 0xba, 0x0b, 0x8d, 0x57, 0x8a, 0x4c, 0x70, /* |....W.Lp| */
 	0x2b, 0x6b, 0xf1, 0x1d, 0x5f, 0xac, 0x00, 0x00, /* |+k.._...| */
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, /* |........| */
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* |......| */
 }
diff --git a/database/example_test.go b/database/example_test.go
index f2756382f..251faca2a 100644
--- a/database/example_test.go
+++ b/database/example_test.go
@@ -173,5 +173,5 @@ func Example_blockStorageAndRetrieval() {
 	fmt.Printf("Serialized block size: %d bytes\n", len(loadedBlockBytes))
 
 	// Output:
-	// Serialized block size: 270 bytes
+	// Serialized block size: 278 bytes
 }
diff --git a/database/testdata/blocks1-256.bz2 b/database/testdata/blocks1-256.bz2
index f620d42f8185409cc76f3ad49fb61211429a6b6c..f7da29094fa288759522c7aa7ad1c6543a461de8 100644
GIT binary patch
literal 9966
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
C?0W71

literal 9944
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

diff --git a/database/testdata/generator.go b/database/testdata/generator.go
index 87280ce5e..baec45f3b 100644
--- a/database/testdata/generator.go
+++ b/database/testdata/generator.go
@@ -48,7 +48,7 @@ func generateBlock(parent *wire.MsgBlock) *wire.MsgBlock {
 			ParentHashes: []daghash.Hash{parent.BlockHash()},
 			MerkleRoot:   genesisMerkleRoot,
 			Timestamp:    time.Unix(0x5b28c4c8, 0), // 2018-06-19 08:54:32 +0000 UTC
-			Bits:         0x1e00ffff,               // 503382015 [000000ffff000000000000000000000000000000000000000000000000000000]
+			Bits:         0x2e00ffff,               // 503382015 [000000ffff000000000000000000000000000000000000000000000000000000]
 			Nonce:        0xc0192550,               // 2148484547
 		},
 		Transactions: []*wire.MsgTx{&genesisCoinbaseTx},
@@ -142,7 +142,8 @@ var genesisCoinbaseTx = wire.MsgTx{
 			},
 		},
 	},
-	LockTime: 0,
+	LockTime:     0,
+	SubNetworkID: wire.SubNetworkDAGCoin,
 }
 
 var genesisMerkleRoot = daghash.Hash([daghash.HashSize]byte{ // Make go vet happy.
diff --git a/mining/policy_test.go b/mining/policy_test.go
index 93bb17121..338b3bfce 100644
--- a/mining/policy_test.go
+++ b/mining/policy_test.go
@@ -140,7 +140,7 @@ func TestCalcPriority(t *testing.T) {
 			utxoSet: newUTXOSet([]*wire.MsgTx{commonSourceTx1},
 				[]int32{7}),
 			nextHeight: 169,
-			want:       1.5576923076923077e+10,
+			want:       1.35e+10,
 		},
 		{
 			name: "one height 100 input, prio tx height 169",
@@ -148,7 +148,7 @@ func TestCalcPriority(t *testing.T) {
 			utxoSet: newUTXOSet([]*wire.MsgTx{commonSourceTx1},
 				[]int32{100}),
 			nextHeight: 169,
-			want:       6.634615384615385e+09,
+			want:       5.75e+09,
 		},
 		{
 			name: "one height 7 input, prio tx height 100000",
@@ -156,7 +156,7 @@ func TestCalcPriority(t *testing.T) {
 			utxoSet: newUTXOSet([]*wire.MsgTx{commonSourceTx1},
 				[]int32{7}),
 			nextHeight: 100000,
-			want:       9.61471153846154e+12,
+			want:       8.33275e+12,
 		},
 		{
 			name: "one height 100 input, prio tx height 100000",
@@ -164,7 +164,7 @@ func TestCalcPriority(t *testing.T) {
 			utxoSet: newUTXOSet([]*wire.MsgTx{commonSourceTx1},
 				[]int32{100}),
 			nextHeight: 100000,
-			want:       9.60576923076923e+12,
+			want:       8.325e+12,
 		},
 	}
 
diff --git a/util/block_test.go b/util/block_test.go
index ae7bb5c72..585ecf845 100644
--- a/util/block_test.go
+++ b/util/block_test.go
@@ -54,10 +54,10 @@ func TestBlock(t *testing.T) {
 
 	// Hashes for the transactions in Block100000.
 	wantTxHashes := []string{
-		"8913f1fa776ba67b1bffc156788caa41d914f9d2c90a864421259e5977749669",
-		"0b999b0aed782261104e6417879f2e9b74306f80a92a6bff489d513b68c7be8b",
-		"62bbb36f70ee6d216bf5709eaa7297b1e3b1c3ca81f61e3dcc1079b9a5386e61",
-		"4c6c95b556627e3ecfdd31f3bed5fd6fffc6d4e887b268d0b0bc82c977305b6c",
+		"4f2a5f1e00034ed3222e0e7fae8485ad3154d40b21b1c1b64ec74ce389a1bb1d",
+		"cdd164e1b3c910e1b54349d442d26541830d0551a15c8b2e202aa7f96ccf3b32",
+		"7fb0543009c39a12a0e5b3c23f157c9152f9e956412a825d296d1e3826dcf81c",
+		"ba611a9e39e784e51ea9efe66453de7a0355deae454f63c526a1938a58f683fc",
 	}
 
 	// Create a new block to nuke all cached data.
@@ -146,10 +146,10 @@ func TestBlock(t *testing.T) {
 
 	// Transaction offsets and length for the transaction in Block100000.
 	wantTxLocs := []wire.TxLoc{
-		{TxStart: 122, TxLen: 143},
-		{TxStart: 265, TxLen: 267},
-		{TxStart: 532, TxLen: 265},
-		{TxStart: 797, TxLen: 233},
+		{TxStart: 122, TxLen: 151},
+		{TxStart: 273, TxLen: 275},
+		{TxStart: 548, TxLen: 273},
+		{TxStart: 821, TxLen: 241},
 	}
 
 	// Ensure the transaction location information is accurate.
@@ -361,7 +361,8 @@ var Block100000 = wire.MsgBlock{
 					},
 				},
 			},
-			LockTime: 0,
+			LockTime:     0,
+			SubNetworkID: wire.SubNetworkDAGCoin,
 		},
 		{
 			Version: 1,
@@ -430,7 +431,8 @@ var Block100000 = wire.MsgBlock{
 					},
 				},
 			},
-			LockTime: 0,
+			LockTime:     0,
+			SubNetworkID: wire.SubNetworkDAGCoin,
 		},
 		{
 			Version: 1,
@@ -498,7 +500,8 @@ var Block100000 = wire.MsgBlock{
 					},
 				},
 			},
-			LockTime: 0,
+			LockTime:     0,
+			SubNetworkID: wire.SubNetworkDAGCoin,
 		},
 		{
 			Version: 1,
@@ -554,7 +557,8 @@ var Block100000 = wire.MsgBlock{
 					},
 				},
 			},
-			LockTime: 0,
+			LockTime:     0,
+			SubNetworkID: wire.SubNetworkDAGCoin,
 		},
 	},
 }
diff --git a/util/bloom/filter_test.go b/util/bloom/filter_test.go
index dae301d0a..59eaa15a9 100644
--- a/util/bloom/filter_test.go
+++ b/util/bloom/filter_test.go
@@ -255,7 +255,7 @@ func TestFilterBloomMatch(t *testing.T) {
 		"3D11000000001976A91404943FDD508053C75000106D3BC6" +
 		"E2754DBCFF1988AC2F15DE00000000001976A914A266436D" +
 		"2965547608B9E15D9032A7B9D64FA43188AC000000000000" +
-		"0000"
+		"00000100000000000000"
 	strBytes, err := hex.DecodeString(str)
 	if err != nil {
 		t.Errorf("TestFilterBloomMatch DecodeString failure: %v", err)
@@ -266,8 +266,8 @@ func TestFilterBloomMatch(t *testing.T) {
 		t.Errorf("TestFilterBloomMatch NewTxFromBytes failure: %v", err)
 		return
 	}
-	spendingTxStr := "0100000001549F371382F2653D7F894BC8DC84F4BD219855" +
-		"E7E31270B6DEE3D2B60A46421C000000008C493046022100" +
+	spendingTxStr := "0100000001F66914B25A46137FB0551E95CCE775254B8711" +
+		"D01D7D258C119396E57E105622000000008C493046022100" +
 		"DA0DC6AECEFE1E06EFDF05773757DEB168820930E3B0D03F" +
 		"46F5FCF150BF990C022100D25B5C87040076E4F253F8262E" +
 		"763E2DD51E7FF0BE157727C4BC42807F17BD39014104E6C2" +
@@ -277,7 +277,7 @@ func TestFilterBloomMatch(t *testing.T) {
 		"A7940E000000001976A914BADEECFDEF0507247FC8F74241" +
 		"D73BC039972D7B88AC4094A802000000001976A914C10932" +
 		"483FEC93ED51F5FE95E72559F2CC7043F988AC0000000000" +
-		"00000000"
+		"0000000100000000000000"
 	spendingTxBytes, err := hex.DecodeString(spendingTxStr)
 	if err != nil {
 		t.Errorf("TestFilterBloomMatch DecodeString failed to decode spendingTxStr: %v", err)
@@ -291,7 +291,7 @@ func TestFilterBloomMatch(t *testing.T) {
 	}
 
 	f := bloom.NewFilter(10, 0, 0.000001, wire.BloomUpdateAll)
-	inputStr := "1c42460ab6d2e3deb67012e3e7559821bdf484dcc84b897f3d65f28213379f54" // byte-reversed tx hash
+	inputStr := "2256107ee59693118c257d1dd011874b2575e7cc951e55b07f13465ab21469f6" // byte-reversed tx hash
 	hash, err := daghash.NewHashFromStr(inputStr)
 	if err != nil {
 		t.Errorf("TestFilterBloomMatch NewHashFromStr failed: %v\n", err)
@@ -303,7 +303,7 @@ func TestFilterBloomMatch(t *testing.T) {
 	}
 
 	f = bloom.NewFilter(10, 0, 0.000001, wire.BloomUpdateAll)
-	inputStr = "549f371382f2653d7f894bc8dc84f4bd219855e7e31270b6dee3d2b60a46421c"
+	inputStr = "f66914b25a46137fb0551e95cce775254b8711d01d7d258c119396e57e105622" // non-reversed tx hash
 	hashBytes, err := hex.DecodeString(inputStr)
 	if err != nil {
 		t.Errorf("TestFilterBloomMatch DecodeString failed: %v\n", err)
@@ -510,7 +510,8 @@ func TestFilterInsertP2PubKeyOnly(t *testing.T) {
 		0x1E, 0xC0, 0xF0, 0xDD, 0x5B, 0x2E, 0x86, 0xE7, 0x16, 0x8C, 0xEF,
 		0xE0, 0xD8, 0x11, 0x13, 0xC3, 0x80, 0x74, 0x20, 0xCE, 0x13, 0xAD,
 		0x13, 0x57, 0x23, 0x1A, 0x22, 0x52, 0x24, 0x7D, 0x97, 0xA4, 0x6A,
-		0x91, 0xAC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x91, 0xAC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
 		0x01, 0x00, 0x00, 0x00, 0x01, 0xBC, 0xAD, 0x20, 0xA6, 0xA2, 0x98, // Txs[1]
 		0x27, 0xD1, 0x42, 0x4F, 0x08, 0x98, 0x92, 0x55, 0x12, 0x0B, 0xF7,
@@ -530,7 +531,7 @@ func TestFilterInsertP2PubKeyOnly(t *testing.T) {
 		0x00, 0x19, 0x76, 0xA9, 0x14, 0x1B, 0x8D, 0xD1, 0x3B, 0x99, 0x4B,
 		0xCF, 0xC7, 0x87, 0xB3, 0x2A, 0xEA, 0xDF, 0x58, 0xCC, 0xB3, 0x61,
 		0x5C, 0xBD, 0x54, 0x88, 0xAC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-		0x00, 0x00,
+		0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 		0x01, 0x00, 0x00, 0x00, 0x03, 0xFD, 0xAC, 0xF9, 0xB3, 0xEB, 0x07, // Txs[2]
 		0x74, 0x12, 0xE7, 0xA9, 0x68, 0xD2, 0xE4, 0xF1, 0x1B, 0x9A, 0x9D,
 		0xEE, 0x31, 0x2D, 0x66, 0x61, 0x87, 0xED, 0x77, 0xEE, 0x7D, 0x26,
@@ -573,7 +574,8 @@ func TestFilterInsertP2PubKeyOnly(t *testing.T) {
 		0x44, 0x60, 0x03, 0x00, 0x00, 0x00, 0x19, 0x76, 0xA9, 0x14, 0xC7,
 		0xB5, 0x51, 0x41, 0xD0, 0x97, 0xEA, 0x5D, 0xF7, 0xA0, 0xED, 0x33,
 		0x0C, 0xF7, 0x94, 0x37, 0x6E, 0x53, 0xEC, 0x8D, 0x88, 0xAC, 0x00,
-		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00,
 		0x01, 0x00, 0x00, 0x00, 0x04, 0x5B, 0xF0, 0xE2, 0x14, 0xAA, 0x40, // Txs[3]
 		0x69, 0xA3, 0xE7, 0x92, 0xEC, 0xEE, 0x1E, 0x1B, 0xF0, 0xC1, 0xD3,
 		0x97, 0xCD, 0xE8, 0xDD, 0x08, 0x13, 0x8F, 0x4B, 0x72, 0xA0, 0x06,
@@ -645,7 +647,8 @@ func TestFilterInsertP2PubKeyOnly(t *testing.T) {
 		0x17, 0xA8, 0x04, 0x00, 0x00, 0x00, 0x19, 0x76, 0xA9, 0x14, 0xB6,
 		0xEF, 0xD8, 0x0D, 0x99, 0x17, 0x9F, 0x4F, 0x4F, 0xF6, 0xF4, 0xDD,
 		0x0A, 0x00, 0x7D, 0x01, 0x8C, 0x38, 0x5D, 0x21,
-		0x88, 0xAC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x88, 0xAC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 		0x01, 0x00, 0x00, 0x00, 0x01, 0x83, 0x45, 0x37, 0xB2, 0xF1, 0xCE, // Txs[4]
 		0x8E, 0xF9, 0x37, 0x3A, 0x25, 0x8E, 0x10, 0x54, 0x5C, 0xE5, 0xA5,
 		0x0B, 0x75, 0x8D, 0xF6, 0x16, 0xCD, 0x43, 0x56, 0xE0, 0x03, 0x25,
@@ -670,7 +673,7 @@ func TestFilterInsertP2PubKeyOnly(t *testing.T) {
 		0x00, 0x19, 0x76, 0xA9, 0x14, 0xA8, 0x4E, 0x27, 0x29, 0x33, 0xAA,
 		0xF8, 0x7E, 0x17, 0x15, 0xD7, 0x78, 0x6C, 0x51, 0xDF, 0xAE, 0xB5,
 		0xB6, 0x5A, 0x6F, 0x88, 0xAC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-		0x00, 0x00,
+		0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 		0x01, 0x00, 0x00, 0x00, 0x01, 0x43, 0xAC, 0x81, 0xC8, 0xE6, 0xF6, // Txs[5]
 		0xEF, 0x30, 0x7D, 0xFE, 0x17, 0xF3, 0xD9, 0x06, 0xD9, 0x99, 0xE2,
 		0x3E, 0x01, 0x89, 0xFD, 0xA8, 0x38, 0xC5, 0x51, 0x0D, 0x85, 0x09,
@@ -695,7 +698,7 @@ func TestFilterInsertP2PubKeyOnly(t *testing.T) {
 		0x00, 0x00, 0x19, 0x76, 0xA9, 0x14, 0x64, 0x8D, 0x04, 0x34, 0x1D,
 		0x00, 0xD7, 0x96, 0x8B, 0x34, 0x05, 0xC0, 0x34, 0xAD, 0xC3, 0x8D,
 		0x4D, 0x8F, 0xB9, 0xBD, 0x88, 0xAC, 0x00, 0x00, 0x00, 0x00, 0x00,
-		0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 		0x01, 0x00, 0x00, 0x00, 0x02, 0x48, 0xCC, 0x91, 0x75, 0x01, 0xEA, // Txs[6]
 		0x5C, 0x55, 0xF4, 0xA8, 0xD2, 0x00, 0x9C, 0x05, 0x67, 0xC4, 0x0C,
 		0xFE, 0x03, 0x7C, 0x2E, 0x71, 0xAF, 0x01, 0x7D, 0x0A, 0x45, 0x2F,
@@ -734,7 +737,8 @@ func TestFilterInsertP2PubKeyOnly(t *testing.T) {
 		0x00, 0x00, 0x00, 0x00, 0x19, 0x76, 0xA9, 0x14, 0x8E, 0xDB, 0x68,
 		0x82, 0x2F, 0x1A, 0xD5, 0x80, 0xB0, 0x43, 0xC7, 0xB3, 0xDF, 0x2E,
 		0x40, 0x0F, 0x86, 0x99, 0xEB, 0x48, 0x88, 0xAC, 0x00, 0x00, 0x00,
-		0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00,
 	}
 	block, err := util.NewBlockFromBytes(blockBytes)
 	if err != nil {
@@ -768,7 +772,7 @@ func TestFilterInsertP2PubKeyOnly(t *testing.T) {
 	_, _ = bloom.NewMerkleBlock(block, f)
 
 	// We should match the generation pubkey
-	inputStr = "d0eee4e3257d0d9cc6dcef5180b53a659ce7ba007eb8150124daecfab610c9b8" //1st tx hash
+	inputStr = "807014abe7988704c8097b6ea882489cb1dc54daff96947eab9f6c04f2271252" //1st tx hash
 	hash, err := daghash.NewHashFromStr(inputStr)
 	if err != nil {
 		t.Errorf("TestMerkleBlockP2PubKeyOnly NewHashFromStr failed: %v", err)
diff --git a/util/bloom/merkleblock_test.go b/util/bloom/merkleblock_test.go
index 861f8ac4a..a2626917e 100644
--- a/util/bloom/merkleblock_test.go
+++ b/util/bloom/merkleblock_test.go
@@ -41,7 +41,9 @@ func TestMerkleBlock3(t *testing.T) {
 		0x5F, 0x64, 0x86, 0x81, 0x37, 0xA1, 0x8C, 0xDD, 0x85, 0xCB, 0xBB,
 		0x4C, 0x74, 0xFB, 0xCC, 0xFD, 0x4F, 0x49, 0x63, 0x9C, 0xF1, 0xBD,
 		0xC9, 0x4A, 0x56, 0x72, 0xBB, 0x15, 0xAD, 0x5D, 0x4C, 0xAC, 0x00,
-		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00,
+	}
 
 	blk, err := util.NewBlockFromBytes(blockBytes)
 	if err != nil {
@@ -51,7 +53,7 @@ func TestMerkleBlock3(t *testing.T) {
 
 	f := bloom.NewFilter(10, 0, 0.000001, wire.BloomUpdateAll)
 
-	inputStr := "63194f18be0af63f2c6bc9dc0f777cbefed3d9415c4af83f3ee3a3d669c00cb5"
+	inputStr := "4ee77df1e2c3126a4a3469e7b1ee3c73093f7f79fef726690fde230c47a02dc6"
 	hash, err := daghash.NewHashFromStr(inputStr)
 	if err != nil {
 		t.Errorf("TestMerkleBlock3 NewHashFromStr failed: %v", err)
@@ -63,14 +65,22 @@ func TestMerkleBlock3(t *testing.T) {
 	mBlock, _ := bloom.NewMerkleBlock(blk, f)
 
 	want := []byte{
-		0x01, 0x00, 0x00, 0x00, 0x01, 0x79, 0xcd, 0xa8, 0x56, 0xb1, 0x43, 0xd9, 0xdb, 0x2c, 0x1c, 0xaf,
-		0xf0, 0x1d, 0x1a, 0xec, 0xc8, 0x63, 0x0d, 0x30, 0x62, 0x5d, 0x10, 0xe8, 0xb4, 0xb8, 0xb0, 0x00,
-		0x00, 0x00, 0x00, 0x00, 0x00, 0xb5, 0x0c, 0xc0, 0x69, 0xd6, 0xa3, 0xe3, 0x3e, 0x3f, 0xf8, 0x4a,
-		0x5c, 0x41, 0xd9, 0xd3, 0xfe, 0xbe, 0x7c, 0x77, 0x0f, 0xdc, 0xc9, 0x6b, 0x2c, 0x3f, 0xf6, 0x0a,
-		0xbe, 0x18, 0x4f, 0x19, 0x63, 0x67, 0x29, 0x1b, 0x4d, 0x00, 0x00, 0x00, 0x00, 0x4c, 0x86, 0x04,
-		0x1b, 0x8f, 0xa4, 0x5d, 0x63, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x70, 0x2b,
-		0x1e, 0x73, 0x5a, 0x15, 0xbc, 0xd7, 0xdb, 0xc9, 0x6f, 0xe5, 0x0f, 0x86, 0xe9, 0xd1, 0x9b, 0xdf,
-		0x75, 0x95, 0x30, 0xa6, 0x95, 0x06, 0x6e, 0xe5, 0x1e, 0xb0, 0xb9, 0x94, 0xe8, 0x01, 0x01, 0x00,
+		0x01, 0x00, 0x00, 0x00, 0x01, 0x79, 0xcd, 0xa8,
+		0x56, 0xb1, 0x43, 0xd9, 0xdb, 0x2c, 0x1c, 0xaf,
+		0xf0, 0x1d, 0x1a, 0xec, 0xc8, 0x63, 0x0d, 0x30,
+		0x62, 0x5d, 0x10, 0xe8, 0xb4, 0xb8, 0xb0, 0x00,
+		0x00, 0x00, 0x00, 0x00, 0x00, 0xb5, 0x0c, 0xc0,
+		0x69, 0xd6, 0xa3, 0xe3, 0x3e, 0x3f, 0xf8, 0x4a,
+		0x5c, 0x41, 0xd9, 0xd3, 0xfe, 0xbe, 0x7c, 0x77,
+		0x0f, 0xdc, 0xc9, 0x6b, 0x2c, 0x3f, 0xf6, 0x0a,
+		0xbe, 0x18, 0x4f, 0x19, 0x63, 0x67, 0x29, 0x1b,
+		0x4d, 0x00, 0x00, 0x00, 0x00, 0x4c, 0x86, 0x04,
+		0x1b, 0x8f, 0xa4, 0x5d, 0x63, 0x00, 0x00, 0x00,
+		0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0xaa, 0xda,
+		0x38, 0x18, 0x2c, 0x17, 0xd8, 0x41, 0x3b, 0xd2,
+		0xba, 0xd3, 0x16, 0x26, 0xb0, 0x96, 0x84, 0x6f,
+		0x6b, 0xd4, 0xc4, 0xd3, 0xa6, 0x64, 0x45, 0x78,
+		0x62, 0x5a, 0x23, 0xd4, 0x69, 0x92, 0x01, 0x00,
 	}
 	t.Log(spew.Sdump(want))
 	if err != nil {
diff --git a/util/coinset/coins_test.go b/util/coinset/coins_test.go
index e3b50dcec..ba1fdb8fd 100644
--- a/util/coinset/coins_test.go
+++ b/util/coinset/coins_test.go
@@ -223,19 +223,19 @@ func TestMinPrioritySelector(t *testing.T) {
 var (
 	// should be two outpoints, with 1st one having 0.035BTC value.
 	testSimpleCoinNumConfs = int64(1)
-	testSimpleCoinTxHash   = "a0a82fc00cdfde26119c0795c06eea7c9db5f3c9d26dd1f883ade0ba70b29970"
-	testSimpleCoinTxHex    = "0100000001a214a110f79e4abe073865ea5b3745c6e82c91" +
-		"3bad44be70652804a5e4003b0a010000008c493046022100" +
-		"edd18a69664efa57264be207100c203e6cade1888cbb88a0" +
-		"ad748548256bb2f0022100f1027dc2e6c7f248d78af1dd90" +
-		"027b5b7d8ec563bb62aa85d4e74d6376f3868c0141048f37" +
-		"57b65ed301abd1b0e8942d1ab5b50594d3314cff0299f300" +
-		"c696376a0a9bf72e74710a8af7a5372d4af4bb519e2701a0" +
-		"94ef48c8e48e3b65b28502452dceffffffffffffffff02e0" +
-		"673500000000001976a914686dd149a79b4a559d561fbc39" +
-		"6d3e3c6628b98d88ace86ef102000000001976a914ac3f99" +
-		"5655e81b875b38b64351d6f896ddbfc68588ac0000000000" +
-		"000000"
+	testSimpleCoinTxHash   = "df280b66ce73fbd3713fe280e24bfa8bb21a7ccdfc81829d48bf1e16f8226310"
+	testSimpleCoinTxHex    = "0100000001A214A110F79E4ABE073865EA5B3745C6E82C91" +
+		"3BAD44BE70652804A5E4003B0A010000008C493046022100" +
+		"EDD18A69664EFA57264BE207100C203E6CADE1888CBB88A0" +
+		"AD748548256BB2F0022100F1027DC2E6C7F248D78AF1DD90" +
+		"027B5B7D8EC563BB62AA85D4E74D6376F3868C0141048F37" +
+		"57B65ED301ABD1B0E8942D1AB5B50594D3314CFF0299F300" +
+		"C696376A0A9BF72E74710A8AF7A5372D4AF4BB519E2701A0" +
+		"94EF48C8E48E3B65B28502452DCEFFFFFFFFFFFFFFFF02E0" +
+		"673500000000001976A914686DD149A79B4A559D561FBC39" +
+		"6D3E3C6628B98D88ACE86EF102000000001976A914AC3F99" +
+		"5655E81B875B38B64351D6F896DDBFC68588AC0000000000" +
+		"000000010000000000000000"
 	testSimpleCoinTxValue0            = util.Amount(3500000)
 	testSimpleCoinTxValueAge0         = int64(testSimpleCoinTxValue0) * testSimpleCoinNumConfs
 	testSimpleCoinTxPkScript0Hex      = "76a914686dd149a79b4a559d561fbc396d3e3c6628b98d88ac"
diff --git a/util/tx_test.go b/util/tx_test.go
index ec97a8dca..28059583f 100644
--- a/util/tx_test.go
+++ b/util/tx_test.go
@@ -35,7 +35,7 @@ func TestTx(t *testing.T) {
 	}
 
 	// Hash for block 100,000 transaction 0.
-	wantHashStr := "8913f1fa776ba67b1bffc156788caa41d914f9d2c90a864421259e5977749669"
+	wantHashStr := "4f2a5f1e00034ed3222e0e7fae8485ad3154d40b21b1c1b64ec74ce389a1bb1d"
 	wantHash, err := daghash.NewHashFromStr(wantHashStr)
 	if err != nil {
 		t.Errorf("NewHashFromStr: %v", err)
diff --git a/util/txsort/testdata/bip69-1.hex b/util/txsort/testdata/bip69-1.hex
index 6c8e59c61..005394b14 100644
--- a/util/txsort/testdata/bip69-1.hex
+++ b/util/txsort/testdata/bip69-1.hex
@@ -1 +1 @@
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
\ No newline at end of file
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
\ No newline at end of file
diff --git a/util/txsort/testdata/bip69-2.hex b/util/txsort/testdata/bip69-2.hex
index 5427ef049..f3bfdac3d 100644
--- a/util/txsort/testdata/bip69-2.hex
+++ b/util/txsort/testdata/bip69-2.hex
@@ -1 +1 @@
-010000000255605DC6F5C3DC148B6DA58442B0B2CD422BE385EAB2EBEA4119EE9C268D28350000000049483045022100AA46504BAA86DF8A33B1192B1B9367B4D729DC41E389F2C04F3E5C7F0559AAE702205E82253A54BF5C4F65B7428551554B2045167D6D206DFE6A2E198127D3F7DF1501FFFFFFFFFFFFFFFF55605DC6F5C3DC148B6DA58442B0B2CD422BE385EAB2EBEA4119EE9C268D2835010000004847304402202329484C35FA9D6BB32A55A70C0982F606CE0E3634B69006138683BCD12CBB6602200C28FEB1E2555C3210F1DDDB299738B4FF8BBE9667B68CB8764B5AC17B7ADF0001FFFFFFFFFFFFFFFF0200E1F505000000004341046A0765B5865641CE08DD39690AADE26DFBF5511430CA428A3089261361CEF170E3929A68AEE3D8D4848B0C5111B0A37B82B86AD559FD2A745B44D8E8D9DFDC0CAC00180D8F000000004341044A656F065871A353F216CA26CEF8DDE2F03E8C16202D2E8AD769F02032CB86A5EB5E56842E92E19141D60A01928F8DD2C875A390F67C1F6C94CFC617C0EA45AFAC0000000000000000
\ No newline at end of file
+010000000255605DC6F5C3DC148B6DA58442B0B2CD422BE385EAB2EBEA4119EE9C268D28350000000049483045022100AA46504BAA86DF8A33B1192B1B9367B4D729DC41E389F2C04F3E5C7F0559AAE702205E82253A54BF5C4F65B7428551554B2045167D6D206DFE6A2E198127D3F7DF1501FFFFFFFFFFFFFFFF55605DC6F5C3DC148B6DA58442B0B2CD422BE385EAB2EBEA4119EE9C268D2835010000004847304402202329484C35FA9D6BB32A55A70C0982F606CE0E3634B69006138683BCD12CBB6602200C28FEB1E2555C3210F1DDDB299738B4FF8BBE9667B68CB8764B5AC17B7ADF0001FFFFFFFFFFFFFFFF0200E1F505000000004341046A0765B5865641CE08DD39690AADE26DFBF5511430CA428A3089261361CEF170E3929A68AEE3D8D4848B0C5111B0A37B82B86AD559FD2A745B44D8E8D9DFDC0CAC00180D8F000000004341044A656F065871A353F216CA26CEF8DDE2F03E8C16202D2E8AD769F02032CB86A5EB5E56842E92E19141D60A01928F8DD2C875A390F67C1F6C94CFC617C0EA45AFAC00000000000000000100000000000000
\ No newline at end of file
diff --git a/util/txsort/testdata/bip69-3.hex b/util/txsort/testdata/bip69-3.hex
index 35b0e4b78..63bad5993 100644
--- a/util/txsort/testdata/bip69-3.hex
+++ b/util/txsort/testdata/bip69-3.hex
@@ -1 +1 @@
-0100000001d992e5a888a86d4c7a6a69167a4728ee69497509740fc5f456a24528c340219a000000008b483045022100f0519bdc9282ff476da1323b8ef7ffe33f495c1a8d52cc522b437022d83f6a230220159b61d197fbae01b4a66622a23bc3f1def65d5fa24efd5c26fa872f3a246b8e014104839f9023296a1fabb133140128ca2709f6818c7d099491690bd8ac0fd55279def6a2ceb6ab7b5e4a71889b6e739f09509565eec789e86886f6f936fa42097adeffffffffffffffff02000fe208010000001976a914948c765a6914d43f2a7ac177da2c2f6b52de3d7c88ac00e32321000000001976a9140c34f4e29ab5a615d5ea28d4817f12b137d62ed588ac0000000000000000
\ No newline at end of file
+0100000001d992e5a888a86d4c7a6a69167a4728ee69497509740fc5f456a24528c340219a000000008b483045022100f0519bdc9282ff476da1323b8ef7ffe33f495c1a8d52cc522b437022d83f6a230220159b61d197fbae01b4a66622a23bc3f1def65d5fa24efd5c26fa872f3a246b8e014104839f9023296a1fabb133140128ca2709f6818c7d099491690bd8ac0fd55279def6a2ceb6ab7b5e4a71889b6e739f09509565eec789e86886f6f936fa42097adeffffffffffffffff02000fe208010000001976a914948c765a6914d43f2a7ac177da2c2f6b52de3d7c88ac00e32321000000001976a9140c34f4e29ab5a615d5ea28d4817f12b137d62ed588ac00000000000000000100000000000000
\ No newline at end of file
diff --git a/util/txsort/testdata/bip69-4.hex b/util/txsort/testdata/bip69-4.hex
index 345028ae6..c7dce767b 100644
--- a/util/txsort/testdata/bip69-4.hex
+++ b/util/txsort/testdata/bip69-4.hex
@@ -1 +1 @@
-01000000059daf0abe7a92618546a9dbcfd65869b6178c66ec21ccfda878c1175979cfd9ef000000004a493046022100c2f7f25be5de6ce88ac3c1a519514379e91f39b31ddff279a3db0b1a229b708b022100b29efbdbd9837cc6a6c7318aa4900ed7e4d65662c34d1622a2035a3a5534a99a01ffffffffffffffffd516330ebdf075948da56db13d22632a4fb941122df2884397dda45d451acefb0000000048473044022051243debe6d4f2b433bee0cee78c5c4073ead0e3bde54296dbed6176e128659c022044417bfe16f44eb7b6eb0cdf077b9ce972a332e15395c09ca5e4f602958d266101ffffffffffffffffe1f5aa33961227b3c344e57179417ce01b7ccd421117fe2336289b70489883f900000000484730440220593252bb992ce3c85baf28d6e3aa32065816271d2c822398fe7ee28a856bc943022066d429dd5025d3c86fd8fd8a58e183a844bd94aa312cefe00388f57c85b0ca3201ffffffffffffffffe207e83718129505e6a7484831442f668164ae659fddb82e9e5421a081fb90d50000000049483045022067cf27eb733e5bcae412a586b25a74417c237161a084167c2a0b439abfebdcb2022100efcc6baa6824b4c5205aa967e0b76d31abf89e738d4b6b014e788c9a8cccaf0c01ffffffffffffffffe23b8d9d80a9e9d977fab3c94dbe37befee63822443c3ec5ae5a713ede66c3940000000049483045022020f2eb35036666b1debe0d1d2e77a36d5d9c4e96c1dba23f5100f193dbf524790221008ce79bc1321fb4357c6daee818038d41544749127751726e46b2b320c8b565a201ffffffffffffffff0200ba1dd2050000001976a914366a27645806e817a6cd40bc869bdad92fe5509188ac40420f00000000001976a914ee8bd501094a7d5ca318da2506de35e1cb025ddc88ac0000000000000000
\ No newline at end of file
+01000000059daf0abe7a92618546a9dbcfd65869b6178c66ec21ccfda878c1175979cfd9ef000000004a493046022100c2f7f25be5de6ce88ac3c1a519514379e91f39b31ddff279a3db0b1a229b708b022100b29efbdbd9837cc6a6c7318aa4900ed7e4d65662c34d1622a2035a3a5534a99a01ffffffffffffffffd516330ebdf075948da56db13d22632a4fb941122df2884397dda45d451acefb0000000048473044022051243debe6d4f2b433bee0cee78c5c4073ead0e3bde54296dbed6176e128659c022044417bfe16f44eb7b6eb0cdf077b9ce972a332e15395c09ca5e4f602958d266101ffffffffffffffffe1f5aa33961227b3c344e57179417ce01b7ccd421117fe2336289b70489883f900000000484730440220593252bb992ce3c85baf28d6e3aa32065816271d2c822398fe7ee28a856bc943022066d429dd5025d3c86fd8fd8a58e183a844bd94aa312cefe00388f57c85b0ca3201ffffffffffffffffe207e83718129505e6a7484831442f668164ae659fddb82e9e5421a081fb90d50000000049483045022067cf27eb733e5bcae412a586b25a74417c237161a084167c2a0b439abfebdcb2022100efcc6baa6824b4c5205aa967e0b76d31abf89e738d4b6b014e788c9a8cccaf0c01ffffffffffffffffe23b8d9d80a9e9d977fab3c94dbe37befee63822443c3ec5ae5a713ede66c3940000000049483045022020f2eb35036666b1debe0d1d2e77a36d5d9c4e96c1dba23f5100f193dbf524790221008ce79bc1321fb4357c6daee818038d41544749127751726e46b2b320c8b565a201ffffffffffffffff0200ba1dd2050000001976a914366a27645806e817a6cd40bc869bdad92fe5509188ac40420f00000000001976a914ee8bd501094a7d5ca318da2506de35e1cb025ddc88ac00000000000000000100000000000000
\ No newline at end of file
diff --git a/util/txsort/testdata/bip69-5.hex b/util/txsort/testdata/bip69-5.hex
index b4d5914ac..4632bd54c 100644
--- a/util/txsort/testdata/bip69-5.hex
+++ b/util/txsort/testdata/bip69-5.hex
@@ -1 +1 @@
-01000000011f636d0003f673b3aeea4971daef16b8eed784cf6e8019a5ae7da4985fbb06e5000000008a47304402205103941e2b11e746dfa817888d422f6e7f4d16dbbfb8ffa61d15ffb924a84b8802202fe861b0f23f17139d15a3374bfc6c7196d371f3d1a324e31cc0aadbba87e53c0141049e7e1b251a7e26cae9ee7553b278ef58ef3c28b4b20134d51b747d9b18b0a19b94b66cef320e2549dec0ea3d725cb4c742f368928b1fb74b4603e24a1e262c80ffffffffffffffff0240420f00000000001976a914bcfa0e27218a7c97257b351b03a9eac95c25a23988ac40420f00000000001976a9140c6a68f20bafc678164d171ee4f077adfa9b091688ac0000000000000000
\ No newline at end of file
+01000000011f636d0003f673b3aeea4971daef16b8eed784cf6e8019a5ae7da4985fbb06e5000000008a47304402205103941e2b11e746dfa817888d422f6e7f4d16dbbfb8ffa61d15ffb924a84b8802202fe861b0f23f17139d15a3374bfc6c7196d371f3d1a324e31cc0aadbba87e53c0141049e7e1b251a7e26cae9ee7553b278ef58ef3c28b4b20134d51b747d9b18b0a19b94b66cef320e2549dec0ea3d725cb4c742f368928b1fb74b4603e24a1e262c80ffffffffffffffff0240420f00000000001976a914bcfa0e27218a7c97257b351b03a9eac95c25a23988ac40420f00000000001976a9140c6a68f20bafc678164d171ee4f077adfa9b091688ac00000000000000000100000000000000
\ No newline at end of file
diff --git a/util/txsort/txsort_test.go b/util/txsort/txsort_test.go
index fcc5a230b..0cb21e26c 100644
--- a/util/txsort/txsort_test.go
+++ b/util/txsort/txsort_test.go
@@ -28,36 +28,36 @@ func TestSort(t *testing.T) {
 			name:         "first test case from BIP 69 - sorts inputs only, based on hash",
 			hexFile:      "bip69-1.hex",
 			isSorted:     false,
-			unsortedHash: "652c30fa452b4706db2f4630a99e2e4d5205bc4724b758e02e7f3e5b772f2454",
-			sortedHash:   "cb0d27e995be2d7670c172dd2c2b155cdeb5d6c60e8b13b3e398667a451279e8",
+			unsortedHash: "55721464fe5511e70792da14d7c4f20f6e81d5e7197919e536d0598796daaef3",
+			sortedHash:   "573054025c067ab92e3e8b66cf25d16dbb8ab4ff9e9ef9ece79d2aee83f06785",
 		},
 		{
 			name:         "second test case from BIP 69 - already sorted",
 			hexFile:      "bip69-2.hex",
 			isSorted:     true,
-			unsortedHash: "1b4c7d54847f0a07a018816894cd6ee172802e4166ad0a705ad7c84ae531a2b7",
-			sortedHash:   "1b4c7d54847f0a07a018816894cd6ee172802e4166ad0a705ad7c84ae531a2b7",
+			unsortedHash: "b9ce1181a9f94375000c9a49fc097a9abe9eb85a0f2e6792e1ec0ac24f72172b",
+			sortedHash:   "b9ce1181a9f94375000c9a49fc097a9abe9eb85a0f2e6792e1ec0ac24f72172b",
 		},
 		{
 			name:         "block 100001 tx[1] - sorts outputs only, based on amount",
 			hexFile:      "bip69-3.hex",
 			isSorted:     false,
-			unsortedHash: "fe297f705cf3a08dd398a85187060b45688008c658afa364384931d8cb091e34",
-			sortedHash:   "487caaf688db44e54ed2a0dc0d5b665ad13c399259abd1e8abce1f7e762a52d2",
+			unsortedHash: "a1fd1029514fb555ecaa6126849d66a19c4239b2a77bdace6f6ef7db3cc23f30",
+			sortedHash:   "4234b089ff83ec954b76e8b56449c095718124ebedd4cf8642d49f02ae55ade2",
 		},
 		{
 			name:         "block 100001 tx[2] - sorts both inputs and outputs",
 			hexFile:      "bip69-4.hex",
 			isSorted:     false,
-			unsortedHash: "1132a25b7a18ede0e03dd8472313357512c788faf31da4225579436432b2606f",
-			sortedHash:   "f63e7e1a71c39970e9c92a1c3fdfd50269819431249d5c560213eb270e48371f",
+			unsortedHash: "d2eb3b56e3be83886dc5ee5789c332ba77f0f3f53abe98d306c1b2e9c25045a2",
+			sortedHash:   "280567fe8d4cda60aa1d1b6ca87dd5944d761e8dee72a704af71365696988cda",
 		},
 		{
 			name:         "block 100998 tx[6] - sorts outputs only, based on output script",
 			hexFile:      "bip69-5.hex",
 			isSorted:     false,
-			unsortedHash: "712433780097a8966d5824fb3ea2a87fc0de080d5131d3257dc393f81ba40ce3",
-			sortedHash:   "6bdc745db166942bba7a31ae16ae447897d2223a7d16c057db9ee9f285fea1ef",
+			unsortedHash: "5c83c1b03b7a1c80a44686323ea17d5bc60a976efb5a3de116cb99cac6ec2557",
+			sortedHash:   "23c0abbbd17ca34980c9330e10b2c9230d72cec5aba38306ea676bbfa789a125",
 		},
 	}
 
diff --git a/wire/blockheader_test.go b/wire/blockheader_test.go
index bd9dc0254..70ec4eccb 100644
--- a/wire/blockheader_test.go
+++ b/wire/blockheader_test.go
@@ -75,10 +75,10 @@ func TestBlockHeaderWire(t *testing.T) {
 		0x72, 0xff, 0x3d, 0x8e, 0xdb, 0xbb, 0x2d, 0xe0,
 		0xbf, 0xa6, 0x7b, 0x13, 0x97, 0x4b, 0xb9, 0x91,
 		0x0d, 0x11, 0x6d, 0x5c, 0xbd, 0x86, 0x3e, 0x68,
-		0x3b, 0xa3, 0xed, 0xfd, 0x7a, 0x7b, 0x12, 0xb2, // MerkleRoot
-		0x7a, 0xc7, 0x2c, 0x3e, 0x67, 0x76, 0x8f, 0x61,
-		0x7f, 0xc8, 0x1b, 0xc3, 0x88, 0x8a, 0x51, 0x32,
-		0x3a, 0x9f, 0xb8, 0xaa, 0x4b, 0x1e, 0x5e, 0x4a,
+		0x4a, 0x5e, 0x1e, 0x4b, 0xaa, 0xb8, 0x9f, 0x3a, // MerkleRoot
+		0x32, 0x51, 0x8a, 0x88, 0xc3, 0x1b, 0xc8, 0x7f,
+		0x61, 0x8f, 0x76, 0x67, 0x3e, 0x2c, 0xc7, 0x7a,
+		0xb2, 0x12, 0x7b, 0x7a, 0xfd, 0xed, 0xa3, 0x3b,
 		0x29, 0xab, 0x5f, 0x49, 0x00, 0x00, 0x00, 0x00, // Timestamp
 		0xff, 0xff, 0x00, 0x1d, // Bits
 		0xf3, 0xe0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, // Fake Nonce. TODO: (Ori) Replace to a real nonce
@@ -213,10 +213,10 @@ func TestBlockHeaderSerialize(t *testing.T) {
 		0x72, 0xff, 0x3d, 0x8e, 0xdb, 0xbb, 0x2d, 0xe0,
 		0xbf, 0xa6, 0x7b, 0x13, 0x97, 0x4b, 0xb9, 0x91,
 		0x0d, 0x11, 0x6d, 0x5c, 0xbd, 0x86, 0x3e, 0x68,
-		0x3b, 0xa3, 0xed, 0xfd, 0x7a, 0x7b, 0x12, 0xb2, // MerkleRoot
-		0x7a, 0xc7, 0x2c, 0x3e, 0x67, 0x76, 0x8f, 0x61,
-		0x7f, 0xc8, 0x1b, 0xc3, 0x88, 0x8a, 0x51, 0x32,
-		0x3a, 0x9f, 0xb8, 0xaa, 0x4b, 0x1e, 0x5e, 0x4a,
+		0x4a, 0x5e, 0x1e, 0x4b, 0xaa, 0xb8, 0x9f, 0x3a, // MerkleRoot
+		0x32, 0x51, 0x8a, 0x88, 0xc3, 0x1b, 0xc8, 0x7f,
+		0x61, 0x8f, 0x76, 0x67, 0x3e, 0x2c, 0xc7, 0x7a,
+		0xb2, 0x12, 0x7b, 0x7a, 0xfd, 0xed, 0xa3, 0x3b,
 		0x29, 0xab, 0x5f, 0x49, 0x00, 0x00, 0x00, 0x00, // Timestamp
 		0xff, 0xff, 0x00, 0x1d, // Bits
 		0xf3, 0xe0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, // Fake Nonce. TODO: (Ori) Replace to a real nonce
diff --git a/wire/common_test.go b/wire/common_test.go
index 3d8f15e34..ce7f15d9c 100644
--- a/wire/common_test.go
+++ b/wire/common_test.go
@@ -37,10 +37,10 @@ var simNetGenesisHash = daghash.Hash([daghash.HashSize]byte{ // Make go vet happ
 // mainNetGenesisMerkleRoot is the hash of the first transaction in the genesis
 // block for the main network.
 var mainNetGenesisMerkleRoot = daghash.Hash([daghash.HashSize]byte{ // Make go vet happy.
-	0x3b, 0xa3, 0xed, 0xfd, 0x7a, 0x7b, 0x12, 0xb2,
-	0x7a, 0xc7, 0x2c, 0x3e, 0x67, 0x76, 0x8f, 0x61,
-	0x7f, 0xc8, 0x1b, 0xc3, 0x88, 0x8a, 0x51, 0x32,
-	0x3a, 0x9f, 0xb8, 0xaa, 0x4b, 0x1e, 0x5e, 0x4a,
+	0x4a, 0x5e, 0x1e, 0x4b, 0xaa, 0xb8, 0x9f, 0x3a,
+	0x32, 0x51, 0x8a, 0x88, 0xc3, 0x1b, 0xc8, 0x7f,
+	0x61, 0x8f, 0x76, 0x67, 0x3e, 0x2c, 0xc7, 0x7a,
+	0xb2, 0x12, 0x7b, 0x7a, 0xfd, 0xed, 0xa3, 0x3b,
 })
 
 // fakeRandReader implements the io.Reader interface and is used to force
diff --git a/wire/message_test.go b/wire/message_test.go
index fcab223e3..149ce73c5 100644
--- a/wire/message_test.go
+++ b/wire/message_test.go
@@ -91,11 +91,11 @@ func TestMessage(t *testing.T) {
 		{msgGetAddr, msgGetAddr, pver, MainNet, 24},
 		{msgAddr, msgAddr, pver, MainNet, 25},
 		{msgGetBlocks, msgGetBlocks, pver, MainNet, 61},
-		{msgBlock, msgBlock, pver, MainNet, 288},
+		{msgBlock, msgBlock, pver, MainNet, 296},
 		{msgInv, msgInv, pver, MainNet, 25},
 		{msgGetData, msgGetData, pver, MainNet, 25},
 		{msgNotFound, msgNotFound, pver, MainNet, 25},
-		{msgTx, msgTx, pver, MainNet, 38},
+		{msgTx, msgTx, pver, MainNet, 46},
 		{msgPing, msgPing, pver, MainNet, 32},
 		{msgPong, msgPong, pver, MainNet, 32},
 		{msgGetHeaders, msgGetHeaders, pver, MainNet, 61},
diff --git a/wire/msgblock_test.go b/wire/msgblock_test.go
index bfc600ba7..9a8701869 100644
--- a/wire/msgblock_test.go
+++ b/wire/msgblock_test.go
@@ -72,7 +72,7 @@ func TestBlock(t *testing.T) {
 // hashes from a block accurately.
 func TestBlockTxHashes(t *testing.T) {
 	// Block 1, transaction 1 hash.
-	hashStr := "b7c3332bc138e2c9429818f5fed500bcc1746544218772389054dc8047d7cd3f"
+	hashStr := "603ea191aecb5809c78790a0bd58293086c1b19118e7251a38680dd9e1dc3b32"
 	wantHash, err := daghash.NewHashFromStr(hashStr)
 	if err != nil {
 		t.Errorf("NewHashFromStr: %v", err)
@@ -93,7 +93,7 @@ func TestBlockTxHashes(t *testing.T) {
 // TestBlockHash tests the ability to generate the hash of a block accurately.
 func TestBlockHash(t *testing.T) {
 	// Block 1 hash.
-	hashStr := "5d8486ede1953cb1bc91720f10421ae670ec66565f1cc0b889fba125f79d5de3"
+	hashStr := "f10122ba81929ca2bc907541ebb20302122ce83a24ff9124c9e36402ecd837b7"
 	wantHash, err := daghash.NewHashFromStr(hashStr)
 	if err != nil {
 		t.Errorf("NewHashFromStr: %v", err)
@@ -532,7 +532,8 @@ var blockOne = MsgBlock{
 					},
 				},
 			},
-			LockTime: 0,
+			LockTime:     0,
+			SubNetworkID: SubNetworkDAGCoin,
 		},
 	},
 }
@@ -549,10 +550,10 @@ var blockOneBytes = []byte{
 	0x72, 0xff, 0x3d, 0x8e, 0xdb, 0xbb, 0x2d, 0xe0,
 	0xbf, 0xa6, 0x7b, 0x13, 0x97, 0x4b, 0xb9, 0x91,
 	0x0d, 0x11, 0x6d, 0x5c, 0xbd, 0x86, 0x3e, 0x68,
-	0x3b, 0xa3, 0xed, 0xfd, 0x7a, 0x7b, 0x12, 0xb2, // MerkleRoot
-	0x7a, 0xc7, 0x2c, 0x3e, 0x67, 0x76, 0x8f, 0x61,
-	0x7f, 0xc8, 0x1b, 0xc3, 0x88, 0x8a, 0x51, 0x32,
-	0x3a, 0x9f, 0xb8, 0xaa, 0x4b, 0x1e, 0x5e, 0x4a,
+	0x4a, 0x5e, 0x1e, 0x4b, 0xaa, 0xb8, 0x9f, 0x3a, // MerkleRoot
+	0x32, 0x51, 0x8a, 0x88, 0xc3, 0x1b, 0xc8, 0x7f,
+	0x61, 0x8f, 0x76, 0x67, 0x3e, 0x2c, 0xc7, 0x7a,
+	0xb2, 0x12, 0x7b, 0x7a, 0xfd, 0xed, 0xa3, 0x3b,
 	0x61, 0xbc, 0x66, 0x49, 0x00, 0x00, 0x00, 0x00, // Timestamp
 	0xff, 0xff, 0x00, 0x1d, // Bits
 	0x01, 0xe3, 0x62, 0x99, 0x00, 0x00, 0x00, 0x00, // Fake Nonce. TODO: (Ori) Replace to a real nonce
@@ -582,9 +583,10 @@ var blockOneBytes = []byte{
 	0xee,                                           // 65-byte uncompressed public key
 	0xac,                                           // OP_CHECKSIG
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Lock time
+	0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Subnetwork ID
 }
 
 // Transaction location information for block one transactions.
 var blockOneTxLocs = []TxLoc{
-	{TxStart: 122, TxLen: 142},
+	{TxStart: 122, TxLen: 150},
 }
diff --git a/wire/msgheaders_test.go b/wire/msgheaders_test.go
index 20420e5fa..0d3de3f27 100644
--- a/wire/msgheaders_test.go
+++ b/wire/msgheaders_test.go
@@ -90,10 +90,10 @@ func TestHeadersWire(t *testing.T) {
 		0x72, 0xff, 0x3d, 0x8e, 0xdb, 0xbb, 0x2d, 0xe0,
 		0xbf, 0xa6, 0x7b, 0x13, 0x97, 0x4b, 0xb9, 0x91,
 		0x0d, 0x11, 0x6d, 0x5c, 0xbd, 0x86, 0x3e, 0x68,
-		0x3b, 0xa3, 0xed, 0xfd, 0x7a, 0x7b, 0x12, 0xb2, // MerkleRoot
-		0x7a, 0xc7, 0x2c, 0x3e, 0x67, 0x76, 0x8f, 0x61,
-		0x7f, 0xc8, 0x1b, 0xc3, 0x88, 0x8a, 0x51, 0x32,
-		0x3a, 0x9f, 0xb8, 0xaa, 0x4b, 0x1e, 0x5e, 0x4a,
+		0x4a, 0x5e, 0x1e, 0x4b, 0xaa, 0xb8, 0x9f, 0x3a, // MerkleRoot
+		0x32, 0x51, 0x8a, 0x88, 0xc3, 0x1b, 0xc8, 0x7f,
+		0x61, 0x8f, 0x76, 0x67, 0x3e, 0x2c, 0xc7, 0x7a,
+		0xb2, 0x12, 0x7b, 0x7a, 0xfd, 0xed, 0xa3, 0x3b,
 		0x61, 0xbc, 0x66, 0x49, 0x00, 0x00, 0x00, 0x00, // Timestamp
 		0xff, 0xff, 0x00, 0x1d, // Bits
 		0x01, 0xe3, 0x62, 0x99, 0x00, 0x00, 0x00, 0x00, // Fake Nonce. TODO: (Ori) Replace to a real nonce
diff --git a/wire/msgtx.go b/wire/msgtx.go
index 2db4f6221..682fcd717 100644
--- a/wire/msgtx.go
+++ b/wire/msgtx.go
@@ -6,6 +6,7 @@ package wire
 
 import (
 	"bytes"
+	"encoding/binary"
 	"fmt"
 	"io"
 	"math"
@@ -94,6 +95,15 @@ const (
 	// peers.  Thus, the peak usage of the free list is 12,500 * 512 =
 	// 6,400,000 bytes.
 	freeListMaxItems = 12500
+
+	// SubNetworkSupportsAll is the sub network id that is used to signal to peers that you support all sub-networks
+	SubNetworkSupportsAll = 0
+
+	// SubNetworkDAGCoin is the default sub network which is used for transactions without related payload data
+	SubNetworkDAGCoin = 1
+
+	// SubNetworkRegistry is the sub network which is used for adding new sub networks to the registry
+	SubNetworkRegistry = 2
 )
 
 // scriptFreeList defines a free list of byte slices (up to the maximum number
@@ -242,10 +252,13 @@ func NewTxOut(value uint64, pkScript []byte) *TxOut {
 // Use the AddTxIn and AddTxOut functions to build up the list of transaction
 // inputs and outputs.
 type MsgTx struct {
-	Version  int32
-	TxIn     []*TxIn
-	TxOut    []*TxOut
-	LockTime uint64
+	Version      int32
+	TxIn         []*TxIn
+	TxOut        []*TxOut
+	LockTime     uint64
+	SubNetworkID uint64
+	Gas          uint64
+	Payload      []byte
 }
 
 // AddTxIn adds a transaction input to the message.
@@ -275,10 +288,17 @@ func (msg *MsgTx) Copy() *MsgTx {
 	// Create new tx and start by copying primitive values and making space
 	// for the transaction inputs and outputs.
 	newTx := MsgTx{
-		Version:  msg.Version,
-		TxIn:     make([]*TxIn, 0, len(msg.TxIn)),
-		TxOut:    make([]*TxOut, 0, len(msg.TxOut)),
-		LockTime: msg.LockTime,
+		Version:      msg.Version,
+		TxIn:         make([]*TxIn, 0, len(msg.TxIn)),
+		TxOut:        make([]*TxOut, 0, len(msg.TxOut)),
+		LockTime:     msg.LockTime,
+		SubNetworkID: msg.SubNetworkID,
+		Gas:          msg.Gas,
+	}
+
+	if msg.Payload != nil {
+		newTx.Payload = make([]byte, len(msg.Payload))
+		copy(newTx.Payload, msg.Payload)
 	}
 
 	// Deep copy the old TxIn data.
@@ -435,6 +455,46 @@ func (msg *MsgTx) BtcDecode(r io.Reader, pver uint32) error {
 		return err
 	}
 
+	msg.SubNetworkID, err = binarySerializer.Uint64(r, littleEndian)
+	if err != nil {
+		returnScriptBuffers()
+		return err
+	}
+
+	if msg.SubNetworkID == SubNetworkSupportsAll {
+		str := fmt.Sprintf("%v is a reserved sub network and cannot be used as part of a transaction", msg.SubNetworkID)
+		return messageError("MsgTx.BtcDecode", str)
+	}
+
+	if msg.SubNetworkID != SubNetworkDAGCoin {
+		msg.Gas, err = binarySerializer.Uint64(r, littleEndian)
+		if err != nil {
+			returnScriptBuffers()
+			return err
+		}
+
+		isRegistrySubNetwork := msg.SubNetworkID == SubNetworkRegistry
+
+		if isRegistrySubNetwork && msg.Gas != 0 {
+			str := fmt.Sprintf("Transactions from subnetwork %v should have 0 gas", msg.SubNetworkID)
+			return messageError("MsgTx.BtcDecode", str)
+		}
+
+		payloadLength, err := ReadVarInt(r, pver)
+		if err != nil {
+			returnScriptBuffers()
+			return err
+		}
+
+		if isRegistrySubNetwork && payloadLength != 8 {
+			str := fmt.Sprintf("For registry sub network the payload should always be uint64 (8 bytes length)")
+			return messageError("MsgTx.BtcDecode", str)
+		}
+
+		msg.Payload = make([]byte, payloadLength)
+		_, err = io.ReadFull(r, msg.Payload)
+	}
+
 	// Create a single allocation to house all of the scripts and set each
 	// input signature script and output public key script to the
 	// appropriate subslice of the overall contiguous buffer.  Then, return
@@ -540,7 +600,41 @@ func (msg *MsgTx) BtcEncode(w io.Writer, pver uint32) error {
 		}
 	}
 
-	return binarySerializer.PutUint64(w, littleEndian, msg.LockTime)
+	err = binarySerializer.PutUint64(w, littleEndian, msg.LockTime)
+	if err != nil {
+		return err
+	}
+
+	err = binarySerializer.PutUint64(w, littleEndian, msg.SubNetworkID)
+	if err != nil {
+		return err
+	}
+
+	if msg.SubNetworkID != SubNetworkDAGCoin {
+		if msg.SubNetworkID == SubNetworkRegistry && msg.Gas != 0 {
+			str := fmt.Sprintf("Transactions from subnetwork %v should have 0 gas", msg.SubNetworkID)
+			return messageError("MsgTx.BtcEncode", str)
+		}
+
+		err = binarySerializer.PutUint64(w, littleEndian, msg.Gas)
+		if err != nil {
+			return err
+		}
+
+		err = WriteVarInt(w, pver, uint64(len(msg.Payload)))
+		if err != nil {
+			return err
+		}
+		w.Write(msg.Payload)
+	} else if msg.Payload != nil {
+		str := fmt.Sprintf("Transactions from subnetwork %v should have <nil> payload", msg.SubNetworkID)
+		return messageError("MsgTx.BtcEncode", str)
+	} else if msg.Gas != 0 {
+		str := fmt.Sprintf("Transactions from subnetwork %v should have 0 gas", msg.SubNetworkID)
+		return messageError("MsgTx.BtcEncode", str)
+	}
+
+	return nil
 }
 
 // Serialize encodes the transaction to w using a format that suitable for
@@ -563,11 +657,17 @@ func (msg *MsgTx) Serialize(w io.Writer) error {
 // SerializeSize returns the number of bytes it would take to serialize the
 // the transaction.
 func (msg *MsgTx) SerializeSize() int {
-	// Version 4 bytes + LockTime 8 bytes + Serialized varint size for the
-	// number of transaction inputs and outputs.
-	n := 12 + VarIntSerializeSize(uint64(len(msg.TxIn))) +
+	// Version 4 bytes + LockTime 8 bytes + Subnetwork ID 8
+	// bytes + Serialized varint size for the number of transaction
+	// inputs and outputs.
+	n := 20 + VarIntSerializeSize(uint64(len(msg.TxIn))) +
 		VarIntSerializeSize(uint64(len(msg.TxOut)))
 
+	if msg.SubNetworkID != SubNetworkDAGCoin {
+		// Gas 8 bytes + Serialized varint size for the length of the payload
+		n += 8 + VarIntSerializeSize(uint64(len(msg.Payload)))
+	}
+
 	for _, txIn := range msg.TxIn {
 		n += txIn.SerializeSize()
 	}
@@ -576,6 +676,8 @@ func (msg *MsgTx) SerializeSize() int {
 		n += txOut.SerializeSize()
 	}
 
+	n += len(msg.Payload)
+
 	return n
 }
 
@@ -636,12 +738,21 @@ func (msg *MsgTx) PkScriptLocs() []int {
 // future.
 func NewMsgTx(version int32) *MsgTx {
 	return &MsgTx{
-		Version: version,
-		TxIn:    make([]*TxIn, 0, defaultTxInOutAlloc),
-		TxOut:   make([]*TxOut, 0, defaultTxInOutAlloc),
+		Version:      version,
+		TxIn:         make([]*TxIn, 0, defaultTxInOutAlloc),
+		TxOut:        make([]*TxOut, 0, defaultTxInOutAlloc),
+		SubNetworkID: SubNetworkDAGCoin,
 	}
 }
 
+func newRegistryMsgTx(version int32, gasLimit uint64) *MsgTx {
+	tx := NewMsgTx(version)
+	tx.SubNetworkID = SubNetworkRegistry
+	tx.Payload = make([]byte, 8)
+	binary.LittleEndian.PutUint64(tx.Payload, gasLimit)
+	return tx
+}
+
 // readOutPoint reads the next sequence of bytes from r as an OutPoint.
 func readOutPoint(r io.Reader, pver uint32, version int32, op *OutPoint) error {
 	_, err := io.ReadFull(r, op.Hash[:])
diff --git a/wire/msgtx_test.go b/wire/msgtx_test.go
index 339b3f69a..a60b0efd5 100644
--- a/wire/msgtx_test.go
+++ b/wire/msgtx_test.go
@@ -130,7 +130,7 @@ func TestTx(t *testing.T) {
 // TestTxHash tests the ability to generate the hash of a transaction accurately.
 func TestTxHash(t *testing.T) {
 	// Hash of first transaction from block 113875.
-	hashStr := "768f7e5de1e0a209c9f4e89a5b610d15e888dfe8f32be7f92462edc5815fc025"
+	hashStr := "bc103ee9c89185146ba4e3eb9e936d46acd312cd8d2c5865fa4b0c02e67d0959"
 	wantHash, err := daghash.NewHashFromStr(hashStr)
 	if err != nil {
 		t.Errorf("NewHashFromStr: %v", err)
@@ -186,6 +186,7 @@ func TestTxWire(t *testing.T) {
 		0x00,                                           // Varint for number of input transactions
 		0x00,                                           // Varint for number of output transactions
 		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Lock time
+		0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Sub Network ID
 	}
 
 	tests := []struct {
@@ -379,6 +380,35 @@ func TestTxSerialize(t *testing.T) {
 		0x00,                                           // Varint for number of input transactions
 		0x00,                                           // Varint for number of output transactions
 		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Lock time
+		0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Sub Network ID
+	}
+
+	registryTx := newRegistryMsgTx(1, 16)
+	registryTxEncoded := []byte{
+		0x01, 0x00, 0x00, 0x00, // Version
+		0x00,                                           // Varint for number of input transactions
+		0x00,                                           // Varint for number of output transactions
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Lock time
+		0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Sub Network ID
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Gas
+		0x08,                                           // Payload length varint
+		0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Payload / Gas limit
+	}
+
+	subNetworkTx := NewMsgTx(1)
+	subNetworkTx.SubNetworkID = 0xff
+	subNetworkTx.Gas = 5
+	subNetworkTx.Payload = []byte{0, 1, 2}
+
+	subNetworkTxEncoded := []byte{
+		0x01, 0x00, 0x00, 0x00, // Version
+		0x00,                                           // Varint for number of input transactions
+		0x00,                                           // Varint for number of output transactions
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Lock time
+		0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Sub Network ID
+		0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Gas
+		0x03,             // Payload length varint
+		0x00, 0x01, 0x02, // Payload
 	}
 
 	tests := []struct {
@@ -395,6 +425,22 @@ func TestTxSerialize(t *testing.T) {
 			nil,
 		},
 
+		// Registry Transaction.
+		{
+			registryTx,
+			registryTx,
+			registryTxEncoded,
+			nil,
+		},
+
+		// Sub Network Transaction.
+		{
+			subNetworkTx,
+			subNetworkTx,
+			subNetworkTxEncoded,
+			nil,
+		},
+
 		// Multiple transactions.
 		{
 			multiTx,
@@ -511,6 +557,101 @@ func TestTxSerializeErrors(t *testing.T) {
 			continue
 		}
 	}
+
+	registryTx := NewMsgTx(1)
+	registryTx.SubNetworkID = SubNetworkRegistry
+	registryTx.Gas = 1
+
+	w := bytes.NewBuffer(make([]byte, 0, registryTx.SerializeSize()))
+	err := registryTx.Serialize(w)
+	str := fmt.Sprintf("Transactions from subnetwork %v should have 0 gas", SubNetworkRegistry)
+	expectedErr := messageError("MsgTx.BtcEncode", str)
+	if err == nil || err.Error() != expectedErr.Error() {
+		t.Errorf("TestTxSerializeErrors: expected error %v but got %v", expectedErr, err)
+	}
+
+	dagCoinTx := NewMsgTx(1)
+	dagCoinTx.Gas = 1
+	w = bytes.NewBuffer(make([]byte, 0, registryTx.SerializeSize()))
+	err = dagCoinTx.Serialize(w)
+
+	str = fmt.Sprintf("Transactions from subnetwork %v should have 0 gas", SubNetworkDAGCoin)
+	expectedErr = messageError("MsgTx.BtcEncode", str)
+	if err == nil || err.Error() != expectedErr.Error() {
+		t.Errorf("TestTxSerializeErrors: expected error %v but got %v", expectedErr, err)
+	}
+
+	dagCoinTx.Gas = 0
+	dagCoinTx.Payload = []byte{1, 2, 3}
+	w = bytes.NewBuffer(make([]byte, 0, registryTx.SerializeSize()))
+	err = dagCoinTx.Serialize(w)
+
+	str = fmt.Sprintf("Transactions from subnetwork %v should have <nil> payload", SubNetworkDAGCoin)
+	expectedErr = messageError("MsgTx.BtcEncode", str)
+	if err == nil || err.Error() != expectedErr.Error() {
+		t.Errorf("TestTxSerializeErrors: expected error %v but got %v", expectedErr, err)
+	}
+
+	zeroSubnetworkTxEncoded := []byte{
+		0x01, 0x00, 0x00, 0x00, // Version
+		0x00,                                           // Varint for number of input transactions
+		0x00,                                           // Varint for number of output transactions
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Lock time
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Sub Network ID
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Gas
+		0x08,                                           // Payload length varint
+		0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Payload / Gas limit
+	}
+
+	r := bytes.NewReader(zeroSubnetworkTxEncoded)
+	var tx MsgTx
+	err = tx.Deserialize(r)
+
+	str = fmt.Sprintf("%v is a reserved sub network and cannot be used as part of a transaction", 0)
+	expectedErr = messageError("MsgTx.BtcDecode", str)
+	if err == nil || err.Error() != expectedErr.Error() {
+		t.Errorf("TestTxSerializeErrors: expected error %v but got %v", expectedErr, err)
+	}
+
+	registryWithGasTxEncoded := []byte{
+		0x01, 0x00, 0x00, 0x00, // Version
+		0x00,                                           // Varint for number of input transactions
+		0x00,                                           // Varint for number of output transactions
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Lock time
+		0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Sub Network ID
+		0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Gas
+		0x08,                                           // Payload length varint
+		0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Payload / Gas limit
+	}
+
+	r = bytes.NewReader(registryWithGasTxEncoded)
+	err = tx.Deserialize(r)
+
+	str = fmt.Sprintf("Transactions from subnetwork %v should have 0 gas", SubNetworkRegistry)
+	expectedErr = messageError("MsgTx.BtcDecode", str)
+	if err == nil || err.Error() != expectedErr.Error() {
+		t.Errorf("TestTxSerializeErrors: expected error %v but got %v", expectedErr, err)
+	}
+
+	registryWithWrongPayloadTxEncoded := []byte{
+		0x01, 0x00, 0x00, 0x00, // Version
+		0x00,                                           // Varint for number of input transactions
+		0x00,                                           // Varint for number of output transactions
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Lock time
+		0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Sub Network ID
+		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Gas
+		0x03,             // Payload length varint
+		0x01, 0x02, 0x03, // Payload / Gas limit
+	}
+
+	r = bytes.NewReader(registryWithWrongPayloadTxEncoded)
+	err = tx.Deserialize(r)
+
+	str = fmt.Sprintf("For registry sub network the payload should always be uint64 (8 bytes length)")
+	expectedErr = messageError("MsgTx.BtcDecode", str)
+	if err == nil || err.Error() != expectedErr.Error() {
+		t.Errorf("TestTxSerializeErrors: expected error %v but got %v", expectedErr, err)
+	}
 }
 
 // TestTxOverflowErrors performs tests to ensure deserializing transactions
@@ -621,10 +762,10 @@ func TestTxSerializeSize(t *testing.T) {
 		size int    // Expected serialized size
 	}{
 		// No inputs or outpus.
-		{noTx, 14},
+		{noTx, 22},
 
 		// Transcaction with an input and an output.
-		{multiTx, 218},
+		{multiTx, 226},
 	}
 
 	t.Logf("Running %d tests", len(tests))
@@ -756,7 +897,8 @@ var multiTx = &MsgTx{
 			},
 		},
 	},
-	LockTime: 0,
+	LockTime:     0,
+	SubNetworkID: SubNetworkDAGCoin,
 }
 
 // multiTxEncoded is the wire encoded bytes for multiTx using protocol version
@@ -800,6 +942,7 @@ var multiTxEncoded = []byte{
 	0xa6,                                           // 65-byte signature
 	0xac,                                           // OP_CHECKSIG
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Lock time
+	0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Sub Network ID
 }
 
 // multiTxPkScriptLocs is the location information for the public key scripts