From b1d3ca020642af3f4911c58093ae9ca25cf580f0 Mon Sep 17 00:00:00 2001
From: stasatdaglabs <39559713+stasatdaglabs@users.noreply.github.com>
Date: Wed, 15 May 2019 16:16:57 +0300
Subject: [PATCH] [NOD-177] Remove idMerkleRoot (#299)

* [NOD-177] Removed references to idMerkleRoot.

* [NOD-177] Generated new genesis hashes.

* [NOD-177] Generated new blk_ blocks.

* [NOD-177] Fixed TestHaveBlock.

* [NOD-177] Fixed The rest of the tests.

* [NOD-177] Fixed a couple of comments and a duplicate test.

* [NOD-177] Fixed blocks1-256.bz2.
---
 blockdag/blocknode.go             |   3 --
 blockdag/common_test.go           |   1 -
 blockdag/dag_test.go              |   9 ++---
 blockdag/dagio.go                 |   1 -
 blockdag/example_test.go          |   2 +-
 blockdag/merkle_test.go           |   8 +++-
 blockdag/testdata/blk_0_to_4.dat  | Bin 2108 -> 1948 bytes
 blockdag/testdata/blk_3A.dat      | Bin 489 -> 457 bytes
 blockdag/testdata/blk_3B.dat      | Bin 376 -> 344 bytes
 blockdag/testdata/blk_3C.dat      | Bin 408 -> 376 bytes
 blockdag/testdata/blk_3D.dat      | Bin 534 -> 502 bytes
 blockdag/validate.go              |   9 -----
 blockdag/validate_test.go         |  25 ++----------
 btcjson/dagsvrresults.go          |   2 -
 dagconfig/genesis.go              |  26 ++++++-------
 dagconfig/genesis_test.go         |  62 ++++++++++++++----------------
 database/example_test.go          |   2 +-
 database/ffldb/blockio_test.go    |   4 +-
 database/ffldb/db_test.go         |   4 +-
 database/testdata/blocks1-256.bz2 | Bin 9972 -> 9938 bytes
 database/testdata/generator.go    |   1 -
 integration/rpctest/blockgen.go   |   2 -
 mempool/estimatefee_test.go       |   1 -
 mining/mining.go                  |   4 --
 mining/simulator/mineloop.go      |   3 +-
 mining/test_utils.go              |   1 -
 peer/peer_test.go                 |   4 +-
 server/rpc/rpcserver.go           |   4 --
 server/rpc/rpcserverhelp.go       |   2 -
 util/block_test.go                |  18 +++------
 util/bloom/filter_test.go         |   3 --
 util/bloom/merkleblock_test.go    |   9 +----
 util/daghash/hash_test.go         |  12 +++---
 wire/bench_test.go                |   4 +-
 wire/blockheader.go               |  23 ++++-------
 wire/blockheader_test.go          |  36 ++++++-----------
 wire/common_test.go               |  15 ++------
 wire/message_test.go              |   6 +--
 wire/msgblock_test.go             |  59 +++++++++++-----------------
 wire/msgheaders_test.go           |  35 +++++------------
 wire/msgmerkleblock_test.go       |  47 +++++++++-------------
 wire/msgreject_test.go            |   8 ++--
 42 files changed, 155 insertions(+), 300 deletions(-)

diff --git a/blockdag/blocknode.go b/blockdag/blocknode.go
index 0f233941f..f28e024c2 100644
--- a/blockdag/blocknode.go
+++ b/blockdag/blocknode.go
@@ -102,7 +102,6 @@ type blockNode struct {
 	nonce                uint64
 	timestamp            int64
 	hashMerkleRoot       *daghash.Hash
-	idMerkleRoot         *daghash.Hash
 	acceptedIDMerkleRoot *daghash.Hash
 	utxoCommitment       *daghash.Hash
 
@@ -131,7 +130,6 @@ func initBlockNode(node *blockNode, blockHeader *wire.BlockHeader, parents block
 		node.nonce = blockHeader.Nonce
 		node.timestamp = blockHeader.Timestamp.Unix()
 		node.hashMerkleRoot = blockHeader.HashMerkleRoot
-		node.idMerkleRoot = blockHeader.IDMerkleRoot
 		node.acceptedIDMerkleRoot = blockHeader.AcceptedIDMerkleRoot
 		node.utxoCommitment = blockHeader.UTXOCommitment
 	} else {
@@ -183,7 +181,6 @@ func (node *blockNode) Header() *wire.BlockHeader {
 		Version:              node.version,
 		ParentHashes:         node.ParentHashes(),
 		HashMerkleRoot:       node.hashMerkleRoot,
-		IDMerkleRoot:         node.idMerkleRoot,
 		AcceptedIDMerkleRoot: node.acceptedIDMerkleRoot,
 		UTXOCommitment:       node.utxoCommitment,
 		Timestamp:            time.Unix(node.timestamp, 0),
diff --git a/blockdag/common_test.go b/blockdag/common_test.go
index 7384ed9ae..1a661523d 100644
--- a/blockdag/common_test.go
+++ b/blockdag/common_test.go
@@ -205,7 +205,6 @@ func newTestNode(parents blockSet, blockVersion int32, bits uint32, timestamp ti
 		Bits:                 bits,
 		Timestamp:            timestamp,
 		HashMerkleRoot:       &daghash.ZeroHash,
-		IDMerkleRoot:         &daghash.ZeroHash,
 		AcceptedIDMerkleRoot: &daghash.ZeroHash,
 		UTXOCommitment:       &daghash.ZeroHash,
 	}
diff --git a/blockdag/dag_test.go b/blockdag/dag_test.go
index 731974a91..d9a19cf76 100644
--- a/blockdag/dag_test.go
+++ b/blockdag/dag_test.go
@@ -174,8 +174,7 @@ func TestHaveBlock(t *testing.T) {
 	}
 
 	// Insert an orphan block.
-	isOrphan, err = dag.ProcessBlock(util.NewBlock(&Block100000),
-		BFNoPoWCheck)
+	isOrphan, err = dag.ProcessBlock(util.NewBlock(&Block100000), BFNoPoWCheck)
 	if err != nil {
 		t.Fatalf("Unable to process block: %v", err)
 	}
@@ -192,10 +191,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: "6733a86f4e3a46c0d4df76d6fbfab88eacadf8e44f54eb544a18d6b95570510c", want: true},
+		{hash: "3f2ded16b7115e69a48cee5f4be743ff23ad8d41da16d059c38cc83d14459863", want: true},
 
 		// Block 100000 should be present (as an orphan).
-		{hash: "18bcf45b8c0dbccd7690a728f3486c6d5fc84971688f89f4554297b6a278e554", want: true},
+		{hash: "4e530ee9f967de3b2cd47ac5cd00109bb9ed7b0e30a60485c94badad29ecb4ce", want: true},
 
 		// Random hashes should not be available.
 		{hash: "123", want: false},
@@ -555,7 +554,6 @@ func chainedNodes(parents blockSet, numNodes int) []*blockNode {
 		// synthetic tests to work.
 		header := wire.BlockHeader{
 			Nonce:                testNoncePrng.Uint64(),
-			IDMerkleRoot:         &daghash.ZeroHash,
 			HashMerkleRoot:       &daghash.ZeroHash,
 			AcceptedIDMerkleRoot: &daghash.ZeroHash,
 			UTXOCommitment:       &daghash.ZeroHash,
@@ -919,7 +917,6 @@ func TestValidateFeeTransaction(t *testing.T) {
 				Bits:                 dag.genesis.Header().Bits,
 				ParentHashes:         parentHashes,
 				HashMerkleRoot:       BuildHashMerkleTreeStore(utilTxs).Root(),
-				IDMerkleRoot:         BuildIDMerkleTreeStore(utilTxs).Root(),
 				AcceptedIDMerkleRoot: acceptedIDMerkleRoot,
 				UTXOCommitment:       &daghash.ZeroHash,
 			},
diff --git a/blockdag/dagio.go b/blockdag/dagio.go
index 06d2bab73..edf78eca9 100644
--- a/blockdag/dagio.go
+++ b/blockdag/dagio.go
@@ -623,7 +623,6 @@ func (dag *BlockDAG) deserializeBlockNode(blockRow []byte) (*blockNode, error) {
 		nonce:                header.Nonce,
 		timestamp:            header.Timestamp.Unix(),
 		hashMerkleRoot:       header.HashMerkleRoot,
-		idMerkleRoot:         header.IDMerkleRoot,
 		acceptedIDMerkleRoot: header.AcceptedIDMerkleRoot,
 		utxoCommitment:       header.UTXOCommitment,
 	}
diff --git a/blockdag/example_test.go b/blockdag/example_test.go
index 994c12071..a3f797e50 100644
--- a/blockdag/example_test.go
+++ b/blockdag/example_test.go
@@ -67,5 +67,5 @@ func ExampleBlockDAG_ProcessBlock() {
 	fmt.Printf("Block accepted. Is it an orphan?: %v", isOrphan)
 
 	// Output:
-	// Failed to process block: already have block 5804d0207bdbfd88dd035271fab95944585eb57017b0709d5a0a10a7edb37795
+	// Failed to process block: already have block 63bbcfdd699ffd8cb19878564b14d3af8ba4d7ee4d1dd54925a7c21d5b5b5fdc
 }
diff --git a/blockdag/merkle_test.go b/blockdag/merkle_test.go
index 573a33da4..4fc09a8d7 100644
--- a/blockdag/merkle_test.go
+++ b/blockdag/merkle_test.go
@@ -5,6 +5,7 @@
 package blockdag
 
 import (
+	"github.com/daglabs/btcd/util/daghash"
 	"testing"
 
 	"github.com/daglabs/btcd/util"
@@ -24,8 +25,11 @@ func TestMerkle(t *testing.T) {
 
 	idMerkleTree := BuildIDMerkleTreeStore(block.Transactions())
 	calculatedIDMerkleRoot := idMerkleTree.Root()
-	wantIDMerkleRoot := Block100000.Header.IDMerkleRoot
-	if !wantIDMerkleRoot.IsEqual(calculatedIDMerkleRoot) {
+	wantIDMerkleRoot, err := daghash.NewHashFromStr("65308857c92c4e5dd3c5e61b73d6b78a87456b5f8f16b13c1e02c47768a0b881")
+	if err != nil {
+		t.Errorf("BuildIDMerkleTreeStore: unexpected error: %s", err)
+	}
+	if !calculatedIDMerkleRoot.IsEqual(wantIDMerkleRoot) {
 		t.Errorf("BuildIDMerkleTreeStore: ID merkle root mismatch - "+
 			"got %v, want %v", calculatedIDMerkleRoot, wantIDMerkleRoot)
 	}
diff --git a/blockdag/testdata/blk_0_to_4.dat b/blockdag/testdata/blk_0_to_4.dat
index 67e4e30771d29f496d5f524c0114a7ec17922dbc..10a82ca25783a0f298b7bb2d41c480050521ec9b 100644
GIT binary patch
delta 664
zcmdlZFo&P_=e{jBA2Kj7Faj~dMBN154M%RpfY|^4*DEkgoK@@@0G479V7wC_9W8rk
zxvJ+?S>JcpmvpbcEaDwjF=J!T-}#w$&+ksI{LdZdI8E!4QcT%0oo~gD3X{J({yP+|
z(V)L}qOrZV@I+k)(Tzx^GlQ%F0;b72tXh-5GCC;`vSIQ<cCB2Hix0xw6r;Z*`i1*f
zr@dwuKi$x~UD%)&_4J?kga7|lOE8AL{8s(krs>>8NB?c-7tB@Pm9oXoD6HI!;roVr
zUl;!<J2`>tJ<sN^sdDXy7R3I^G|hXe*4I+;lWY1v^AB^sNgbKptv!8WpaS!zBey0S
zGS?{(vJ2=s{mK8B3o_xZbE>rTNt^iM8~=edTNZ6!{IKHYt#vd1?DZ`cTx`EEN3Oo?
z@1z^*&zHCtXRos^*tFtPZ^xGx5obUApCG&b*EfYuK4$TZb$Oy2^1bHwEV4bcsNQ&<
zrOKp?&1^aCm!IYod))=OZZptz%<MLk!&sdZ2-ydA;d53b7aG3$-E8A{kmI@F;@G;4
z?>9{{`R!LI_bB?QL#f<~m+8{sqNdix>l`k9&suEy?ORU7MotOlqWCkdhnSXK-_@O^
z>7Ab|xZ>NIcbh7_@;&c&?9-3<F8%1oo`0Qc>*UL>e8~s7a0@v6Y$n^YJ1G#d59q?#
E0Bk`x;{X5v

literal 2108
zcmeylZ_7<aMg|5TVqmy(r+Y_P_}to;bJyMep>&CN(SzOl-fp<P>$QZh6XXB4a|y|V
z%%B7;u)Prj(*OT|y#m-lKsLy65Z8fZaDo3oz{kMAtsh_%?4h4jlANLs5&{86hEJ?o
zU_%0N=?01a1O`L_#8LsqspXsBE*Id6np?0zykKiwgiGYkUxh);cRT*xu2#6f5-~Z=
zX8qR8TQ?_cj61gCP@Axv=Ksadwn?npWpMTA(iQo!gybm=$c0D&1@jaW@c|VWNI^h>
ztsxXZpnwNPBLu))h?NF~`$Jf`TO~z(GuZ37N9)b2=dXq2Cb&i&Q|$lu%v$<L<SOMx
z6<LP=XRhk>pO?M!+Wh1C_TTj<i)$0zOd1Y&E;N30e!Y4HA^EpvO{eFD{gwB!dAjF%
zzuEK|EBYDMss?ehT@qb0wQjW&Ru>`(E<y@-h?^N0n28Vfpdd=aolpRQ0-U&T2fKQ1
z>zd=QyB6B3>773rRQrB<PxCyt%%r<qx!>=c`%$&@BiQTESVUwb$+DFqw(r~v^K5>F
z-**)>DPCr%w{P8N!HzXZL50CYiRcSc4xacC-v8QjjmLu1yv1cEs}-0pKX~~3+q;~%
z#>ccJE~})(&Nn@~(n$Nc<GYB<UpA!8E#2{>E9mU@!Vjv(e5{1z9U|<7_Qi<U*1Lb{
z_m$w6KA3869<sa0VO=!i|4WaqL}0iMO<*xnM6*EUNQmg*U`ivJPymq_(bqY$&C^!T
zW#g1MmmjnF!mA@oU;fqM=eM46XF-D2jGzr*FVZ5S^JS!7NF9Fm(CbUip@pAsu9r@$
zH~rUTeXvAxzC~IqyWchm{;<vJvYS86=RG9B`72jYFK&ZzkAb{Xx98S~-*LML$$#^F
z(|h;tWh=e*Z+r)idTnc&Y5(ESx$w7BrhVqfKhNue7OxoGB}fqslO!RcLqaHxXhH!*
rVni=9toXd=uiE^dYCK$whV_${AE~Q$w2L~nn=>GJ#k#jT)Qo5V9#E75

diff --git a/blockdag/testdata/blk_3A.dat b/blockdag/testdata/blk_3A.dat
index 77b98c2ffc5ead12a3a307395a1f7d064fbce410..8bdda0902cacc36548462adf9025e6e3873187c1 100644
GIT binary patch
delta 174
zcmaFKe3Ci$=e{jB4>B@<fB>UYrKL~W#24TA53Jd;X#3)a6*q6KoB3z2Z?WKF`-M4j
z^(pVx|4u9wE!sQhzUqrF&RRcjXP&*j-uhI##aqUU`EM(k#WU9BiEhaEn%}d?_Rykw
z<9U`UlQK55<+NXZnp5m`cj82ui3?bGHy^nb1G4b{|9S=HiMvV^2-!Q?k8w5tYvWcr

delta 207
zcmX@f{F1r;=e{jBA2Kq4fB@r#DF;vd2=9OGxyEC`Y2M;8lhq2$mmfTQ{_S1PTjOKe
z67~_ceyjCY&Iot?^z&GpNQee|ZHnf0^R3ErqL#=o8Z#4;cZjeT+7}~YTkrm*-&cZP
z`d})by?My)B8PR+jQ=k^x)L$5P-bES3-4mv8!;dk{r_LDz%+4Ii2@;qP1a+a4FJSp
BTM7UG

diff --git a/blockdag/testdata/blk_3B.dat b/blockdag/testdata/blk_3B.dat
index eaf5ff6c340ffae635ba93e48293ab94fbf9ef31..ac21c81088aadab41aa564ac4127e073a997357b 100644
GIT binary patch
delta 174
zcmeytbb~4P=e{jB0~i@VK!DMy($Xhw;)`$m2i9y^w0-fzikr9A&HS_1w^(qo{lXl%
z`n>uT&$dmwc*AdlputyJ_Y6m2-6sbPBNP+NBp17Mto_I=p0O@ZbVI(^{GLU&hZfZv
y&$CpSl(CsDr~UHNoMNxL6DP_{T)@J+`N*vpkcI#M*DEki+*P7L$ll3*j9LJhiBX3D

literal 376
zcmeylZ_CXBMg|ZNV7xHp;E5mM{jWXOcq};0TU=(cT7miUgNM(*y~}xPd`w$nUb#u^
z%imm<S^QPW0`pI7TkXJ?w#?-8)%~R#riPje)f19;h_Dyh7b9X@@BXFVSAt*qV5+@&
z$nGMCb<vFfFFm>v0d@u+VzKRw7?AY;|MdzmWlSK)Lp%Tz!b1NC0>0odZv6nGU=RJI
mlH?S9kPrwkGJImy0vi&DMI&4Ytb$Mgfy@KC4g%m>u`vKu9Cc^_

diff --git a/blockdag/testdata/blk_3C.dat b/blockdag/testdata/blk_3C.dat
index a33cd826751acb768ffacf3395c1c932a6f0d02a..57ef5b56efc7087b5f074ac0a95db064cfd150d5 100644
GIT binary patch
delta 197
zcmbQi{DZ0f=e{jB3m6$dK!7Pme@FBS_peTS%`Serp?ABmK`rX(Kk*0u|E-o_414*l
z+NsjgCvD=3Z~O<=Y+1B@@xzLnx7N-4v)8v+aIyWu9J%`XoTODB-_*>u{N>A5yT|g$
z!t)9$|9*X}-=ePeY>(C}+5F^bm7EQE_v<gqT~o6WIO%4~cV?dUJZW(+zwTBO4!1`W
ZH_A*rz{0%w$gPPN>J$iBH#v_{3jj6+VyFNB

literal 408
zcmeylZ_CXIj0_+kz;t2C!4p5i`(Jym@mO%0x46t?wF2|y2M?crdzbUp_?WhYRZ`S9
zgT0=6wBEdW{#r<Gf@{<<#r}WKtfh}cu2ODPk@cD3v@GI|?i8W_K?2H34k^{4HJ0Mq
zs=goWf4xw6An}Eey#LZ_(IszLYi|g*?KPOvyKUK4$2+|f7jAva_pJH*zwl77Gw~3M
zZEwVYr2qe~SAZ#F0(lPNL6{I0`aclx1&4F%2N(r==qHsVr|5%(K!B0q6RQ^3kU%UN
V;X+^)gaQy`9?*3V0N09*0RU+NhNu7l

diff --git a/blockdag/testdata/blk_3D.dat b/blockdag/testdata/blk_3D.dat
index 0251c506225a99dde2f322bbd3657d39c5a819b8..8c856d15f9a841ec2725008a7f47ee85cbdae6f6 100644
GIT binary patch
delta 164
zcmbQn@{Kw7=e{jB-!U?PfB>UYrKL~W#24TA53Jd;X#3)a6*q6KoB3z2Z?WKF`-M4j
z_5Iv#t;T9>VF@kOT~i;nUEW@}ej>A6>4h`bBC~Vf*XQRaPpjl?$h%*ES?-#ejlfAa
p+cWdD=Shou`E|FNaJW61I8kQe0v6`YM{Z5rP^Uo1w#j~sCjh$*PGbN7

delta 197
zcmeyyJdLIP=e{jB`Is0$K!EYWl!GUJg!jMpT;s9eG;eX4$!Z1W%MTtt|Mo8Dt?@B!
ziDY(7-{N<>^t{%3E!cnP(HaLk#|bSS(iM!ygD=g$CjFa`y#LZ_(IszLYi|g*?KPOv
uyKUK4KF2$~6BllM%lEAL`@iteiG?x~8(5eZ+uoQsp-zF2b0+ICo&W%i>|u-m

diff --git a/blockdag/validate.go b/blockdag/validate.go
index 02eeaf625..e3fb94a9f 100644
--- a/blockdag/validate.go
+++ b/blockdag/validate.go
@@ -563,15 +563,6 @@ func (dag *BlockDAG) checkBlockSanity(block *util.Block, flags BehaviorFlags) er
 		return ruleError(ErrBadMerkleRoot, str)
 	}
 
-	idMerkleTree := BuildIDMerkleTreeStore(block.Transactions())
-	calculatedIDMerkleRoot := idMerkleTree.Root()
-	if !header.IDMerkleRoot.IsEqual(calculatedIDMerkleRoot) {
-		str := fmt.Sprintf("block ID merkle root is invalid - block "+
-			"header indicates %s, but calculated value is %s",
-			header.IDMerkleRoot, calculatedIDMerkleRoot)
-		return ruleError(ErrBadMerkleRoot, str)
-	}
-
 	// Check for duplicate transactions.  This check will be fairly quick
 	// since the transaction IDs are already cached due to building the
 	// merkle tree above.
diff --git a/blockdag/validate_test.go b/blockdag/validate_test.go
index 01b2a31bd..3f95599cf 100644
--- a/blockdag/validate_test.go
+++ b/blockdag/validate_test.go
@@ -222,12 +222,6 @@ func TestCheckBlockSanity(t *testing.T) {
 				0x48, 0x3e, 0x8b, 0xe1, 0xcf, 0xdc, 0x20, 0xba,
 				0xae, 0xec, 0x0a, 0x2f, 0xe4, 0x85, 0x31, 0x30,
 			},
-			IDMerkleRoot: &daghash.Hash{
-				0x4e, 0x06, 0xba, 0x64, 0xd7, 0x61, 0xda, 0x25,
-				0x1a, 0x0e, 0x21, 0xd4, 0x64, 0x49, 0x02, 0xa2,
-				0x80, 0xf7, 0x00, 0xe3, 0x16, 0x3d, 0x04, 0x95,
-				0x5b, 0x7e, 0xaf, 0x84, 0x7e, 0x1b, 0x6b, 0x06,
-			},
 			AcceptedIDMerkleRoot: &daghash.Hash{
 				0x80, 0xf7, 0x00, 0xe3, 0x16, 0x3d, 0x04, 0x95,
 				0x5b, 0x7e, 0xaf, 0x84, 0x7e, 0x1b, 0x6b, 0x06,
@@ -242,7 +236,7 @@ func TestCheckBlockSanity(t *testing.T) {
 			},
 			Timestamp: time.Unix(0x5cd18053, 0),
 			Bits:      0x207fffff,
-			Nonce:     0x0,
+			Nonce:     0x1,
 		},
 		Transactions: []*wire.MsgTx{
 			{
@@ -526,7 +520,7 @@ func TestCheckSerializedHeight(t *testing.T) {
 		msgTx := coinbaseTx.Copy()
 		msgTx.TxIn[0].SignatureScript = test.sigScript
 
-		msgBlock := wire.NewMsgBlock(wire.NewBlockHeader(1, []*daghash.Hash{}, &daghash.Hash{}, &daghash.Hash{}, &daghash.Hash{}, &daghash.Hash{}, 0, 0))
+		msgBlock := wire.NewMsgBlock(wire.NewBlockHeader(1, []*daghash.Hash{}, &daghash.Hash{}, &daghash.Hash{}, &daghash.Hash{}, 0, 0))
 		msgBlock.AddTransaction(msgTx)
 		block := util.NewBlock(msgBlock)
 		block.SetHeight(test.wantHeight)
@@ -634,7 +628,6 @@ func TestValidateParents(t *testing.T) {
 	c := generateNode(genesisNode)
 
 	fakeBlockHeader := &wire.BlockHeader{
-		IDMerkleRoot:         &daghash.ZeroHash,
 		HashMerkleRoot:       &daghash.ZeroHash,
 		AcceptedIDMerkleRoot: &daghash.ZeroHash,
 		UTXOCommitment:       &daghash.ZeroHash,
@@ -770,12 +763,6 @@ var Block100000 = wire.MsgBlock{
 			0x6f, 0x22, 0xfa, 0x60, 0x36, 0x80, 0x99, 0xc3,
 			0x6e, 0x39, 0x14, 0x9b, 0xcc, 0x1f, 0x31, 0xa9,
 		},
-		IDMerkleRoot: &daghash.Hash{
-			0x81, 0xb8, 0xa0, 0x68, 0x77, 0xc4, 0x02, 0x1e,
-			0x3c, 0xb1, 0x16, 0x8f, 0x5f, 0x6b, 0x45, 0x87,
-			0x8a, 0xb7, 0xd6, 0x73, 0x1b, 0xe6, 0xc5, 0xd3,
-			0x5d, 0x4e, 0x2c, 0xc9, 0x57, 0x88, 0x30, 0x65,
-		},
 		AcceptedIDMerkleRoot: &daghash.Hash{
 			0x8a, 0xb7, 0xd6, 0x73, 0x1b, 0xe6, 0xc5, 0xd3,
 			0x5d, 0x4e, 0x2c, 0xc9, 0x57, 0x88, 0x30, 0x65,
@@ -1068,12 +1055,6 @@ var BlockWithWrongTxOrder = wire.MsgBlock{
 			0xf3, 0x2d, 0xd1, 0x05, 0x64, 0xb5, 0x16, 0x76,
 			0xe4, 0x66, 0x7d, 0x51, 0x53, 0x18, 0x6d, 0xb1,
 		},
-		IDMerkleRoot: &daghash.Hash{
-			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,
-		},
 		AcceptedIDMerkleRoot: &daghash.Hash{
 			0xa0, 0x69, 0x2d, 0x16, 0xb5, 0xd7, 0xe4, 0xf3,
 			0xcd, 0xc7, 0xc9, 0xaf, 0xfb, 0xd2, 0x1b, 0x85,
@@ -1088,7 +1069,7 @@ var BlockWithWrongTxOrder = wire.MsgBlock{
 		},
 		Timestamp: time.Unix(0x5cd16eaa, 0),
 		Bits:      0x207fffff,
-		Nonce:     0x2,
+		Nonce:     0x0,
 	},
 	Transactions: []*wire.MsgTx{
 		{
diff --git a/btcjson/dagsvrresults.go b/btcjson/dagsvrresults.go
index d4e84c5d4..48336fb5c 100644
--- a/btcjson/dagsvrresults.go
+++ b/btcjson/dagsvrresults.go
@@ -16,7 +16,6 @@ type GetBlockHeaderVerboseResult struct {
 	Version              int32    `json:"version"`
 	VersionHex           string   `json:"versionHex"`
 	HashMerkleRoot       string   `json:"hashMerkleRoot"`
-	IDMerkleRoot         string   `json:"idMerkleRoot"`
 	AcceptedIDMerkleRoot string   `json:"acceptedIdMerkleRoot"`
 	Time                 int64    `json:"time"`
 	Nonce                uint64   `json:"nonce"`
@@ -37,7 +36,6 @@ type GetBlockVerboseResult struct {
 	Version              int32         `json:"version"`
 	VersionHex           string        `json:"versionHex"`
 	HashMerkleRoot       string        `json:"hashMerkleRoot"`
-	IDMerkleRoot         string        `json:"idMerkleRoot"`
 	AcceptedIDMerkleRoot string        `json:"acceptedIdMerkleRoot"`
 	Tx                   []string      `json:"tx,omitempty"`
 	RawTx                []TxRawResult `json:"rawRx,omitempty"`
diff --git a/dagconfig/genesis.go b/dagconfig/genesis.go
index fb0910ced..2d90e2def 100644
--- a/dagconfig/genesis.go
+++ b/dagconfig/genesis.go
@@ -41,10 +41,10 @@ var genesisCoinbaseTx = wire.NewNativeMsgTx(1, genesisTxIns, genesisTxOuts)
 // 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{
-	0x95, 0x77, 0xb3, 0xed, 0xa7, 0x10, 0x0a, 0x5a,
-	0x9d, 0x70, 0xb0, 0x17, 0x70, 0xb5, 0x5e, 0x58,
-	0x44, 0x59, 0xb9, 0xfa, 0x71, 0x52, 0x03, 0xdd,
-	0x88, 0xfd, 0xdb, 0x7b, 0x20, 0xd0, 0x04, 0x58,
+	0xdc, 0x5f, 0x5b, 0x5b, 0x1d, 0xc2, 0xa7, 0x25,
+	0x49, 0xd5, 0x1d, 0x4d, 0xee, 0xd7, 0xa4, 0x8b,
+	0xaf, 0xd3, 0x14, 0x4b, 0x56, 0x78, 0x98, 0xb1,
+	0x8c, 0xfd, 0x9f, 0x69, 0xdd, 0xcf, 0xbb, 0x63,
 })
 
 // genesisMerkleRoot is the hash of the first transaction in the genesis block
@@ -63,12 +63,11 @@ var genesisBlock = wire.MsgBlock{
 		Version:              1,
 		ParentHashes:         []*daghash.Hash{},
 		HashMerkleRoot:       &genesisMerkleRoot,
-		IDMerkleRoot:         &genesisMerkleRoot,
 		AcceptedIDMerkleRoot: &daghash.Hash{},
 		UTXOCommitment:       &daghash.Hash{},
-		Timestamp:            time.Unix(0x5cd83da0, 0),
+		Timestamp:            time.Unix(0x5cdac4b0, 0),
 		Bits:                 0x207fffff,
-		Nonce:                0x1,
+		Nonce:                0x0,
 	},
 	Transactions: []*wire.MsgTx{genesisCoinbaseTx},
 }
@@ -119,10 +118,10 @@ var devNetGenesisCoinbaseTx = genesisCoinbaseTx
 // devGenesisHash is the hash of the first block in the block chain for the development
 // network (genesis block).
 var devNetGenesisHash = daghash.Hash([daghash.HashSize]byte{
-	0x53, 0x68, 0x95, 0xd4, 0xf7, 0xc7, 0x3b, 0x94,
-	0x64, 0xfa, 0x98, 0xc7, 0xcb, 0x92, 0x53, 0x71,
-	0x5e, 0x14, 0xd1, 0x83, 0x01, 0xd4, 0x1e, 0x17,
-	0xd4, 0xc4, 0xd3, 0x50, 0xa7, 0x64, 0x00, 0x00,
+	0xab, 0x03, 0xe2, 0x8e, 0xd4, 0x66, 0xf9, 0x75,
+	0x21, 0xd8, 0x8b, 0x49, 0xb2, 0xb4, 0xeb, 0xc6,
+	0x4a, 0x03, 0xbf, 0x9b, 0x41, 0xcb, 0x36, 0x79,
+	0x33, 0x03, 0xc4, 0x4d, 0x37, 0x17, 0x00, 0x00,
 })
 
 // devNetGenesisMerkleRoot is the hash of the first transaction in the genesis block
@@ -136,12 +135,11 @@ var devNetGenesisBlock = wire.MsgBlock{
 		Version:              1,
 		ParentHashes:         []*daghash.Hash{},
 		HashMerkleRoot:       &devNetGenesisMerkleRoot,
-		IDMerkleRoot:         &devNetGenesisMerkleRoot,
 		AcceptedIDMerkleRoot: &daghash.Hash{},
 		UTXOCommitment:       &daghash.Hash{},
-		Timestamp:            time.Unix(0x5cd83da0, 0),
+		Timestamp:            time.Unix(0x5cdac4b0, 0),
 		Bits:                 0x1e7fffff,
-		Nonce:                0xfe2a,
+		Nonce:                0xc79c,
 	},
 	Transactions: []*wire.MsgTx{devNetGenesisCoinbaseTx},
 }
diff --git a/dagconfig/genesis_test.go b/dagconfig/genesis_test.go
index b3eddfff0..b98fb2c12 100644
--- a/dagconfig/genesis_test.go
+++ b/dagconfig/genesis_test.go
@@ -121,39 +121,35 @@ 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, 0xd4, 0xdc, 0x8b,
-	0xb8, 0x76, 0x57, 0x9d, 0x7d, 0xe9, 0x9d, 0xae,
-	0xdb, 0xf8, 0x22, 0xd2, 0x0d, 0xa2, 0xe0, 0xbb,
-	0xbe, 0xed, 0xb0, 0xdb, 0xba, 0xeb, 0x18, 0x4d,
-	0x42, 0x01, 0xff, 0xed, 0x9d, 0xd4, 0xdc, 0x8b,
-	0xb8, 0x76, 0x57, 0x9d, 0x7d, 0xe9, 0x9d, 0xae,
-	0xdb, 0xf8, 0x22, 0xd2, 0x0d, 0xa2, 0xe0, 0xbb,
-	0xbe, 0xed, 0xb0, 0xdb, 0xba, 0xeb, 0x18, 0x4d,
-	0x42, 0x01, 0xff, 0xed, 0x9d, 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, 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, 0xa0, 0x3d, 0xd8,
-	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, 0x0e, 0x00, 0x00, 0x0b, 0x2f,
-	0x50, 0x32, 0x53, 0x48, 0x2f, 0x62, 0x74, 0x63,
-	0x64, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-	0xff, 0xff, 0x01, 0x00, 0xf2, 0x05, 0x2a, 0x01,
-	0x00, 0x00, 0x00, 0x01, 0x51, 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,
+	0x01, 0x00, 0x00, 0x00, 0x00, 0xd4, 0xdc, 0x8b, /* |........| */
+	0xb8, 0x76, 0x57, 0x9d, 0x7d, 0xe9, 0x9d, 0xae, /* |.vW.}...| */
+	0xdb, 0xf8, 0x22, 0xd2, 0x0d, 0xa2, 0xe0, 0xbb, /* |..".....| */
+	0xbe, 0xed, 0xb0, 0xdb, 0xba, 0xeb, 0x18, 0x4d, /* |.......M| */
+	0x42, 0x01, 0xff, 0xed, 0x9d, 0x00, 0x00, 0x00, /* |B.......| */
+	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, /* |........| */
+	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, 0xb0, 0xc4, 0xda, /* |........| */
+	0x5c, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x7f, /* |\.......| */
+	0x20, 0x00, 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, 0x0e, 0x00, 0x00, 0x0b, 0x2f, /* |......./| */
+	0x50, 0x32, 0x53, 0x48, 0x2f, 0x62, 0x74, 0x63, /* |P2SH/btc| */
+	0x64, 0x2f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* |d/......| */
+	0xff, 0xff, 0x01, 0x00, 0xf2, 0x05, 0x2a, 0x01, /* |......*.| */
+	0x00, 0x00, 0x00, 0x01, 0x51, 0x00, 0x00, 0x00, /* |....Q...| */
+	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, /* |.| */
 }
 
 // regTestGenesisBlockBytes are the wire encoded bytes for the genesis block of
diff --git a/database/example_test.go b/database/example_test.go
index b5cc906af..93b1afcd1 100644
--- a/database/example_test.go
+++ b/database/example_test.go
@@ -175,5 +175,5 @@ func Example_blockStorageAndRetrieval() {
 	fmt.Printf("Serialized block size: %d bytes\n", len(loadedBlockBytes))
 
 	// Output:
-	// Serialized block size: 257 bytes
+	// Serialized block size: 225 bytes
 }
diff --git a/database/ffldb/blockio_test.go b/database/ffldb/blockio_test.go
index 6fd57063b..3d380501c 100644
--- a/database/ffldb/blockio_test.go
+++ b/database/ffldb/blockio_test.go
@@ -16,7 +16,7 @@ import (
 
 func TestDeleteFile(t *testing.T) {
 	testBlock := util.NewBlock(wire.NewMsgBlock(
-		wire.NewBlockHeader(1, []*daghash.Hash{}, &daghash.Hash{}, &daghash.Hash{}, &daghash.Hash{}, &daghash.Hash{}, 0, 0)))
+		wire.NewBlockHeader(1, []*daghash.Hash{}, &daghash.Hash{}, &daghash.Hash{}, &daghash.Hash{}, 0, 0)))
 
 	tests := []struct {
 		fileNum     uint32
@@ -69,7 +69,7 @@ func TestDeleteFile(t *testing.T) {
 // and makes sure no panic occurs, as well as ensures the writeCursor was updated correctly.
 func TestHandleRollbackErrors(t *testing.T) {
 	testBlock := util.NewBlock(wire.NewMsgBlock(
-		wire.NewBlockHeader(1, []*daghash.Hash{}, &daghash.Hash{}, &daghash.Hash{}, &daghash.Hash{}, &daghash.Hash{}, 0, 0)))
+		wire.NewBlockHeader(1, []*daghash.Hash{}, &daghash.Hash{}, &daghash.Hash{}, &daghash.Hash{}, 0, 0)))
 
 	testBlockSize := uint32(testBlock.MsgBlock().SerializeSize())
 	tests := []struct {
diff --git a/database/ffldb/db_test.go b/database/ffldb/db_test.go
index 021e9e10f..9086f7857 100644
--- a/database/ffldb/db_test.go
+++ b/database/ffldb/db_test.go
@@ -553,7 +553,7 @@ func TestForEachBucket(t *testing.T) {
 // TestStoreBlockErrors tests all error-cases in *tx.StoreBlock().
 // The non-error-cases are tested in the more general tests.
 func TestStoreBlockErrors(t *testing.T) {
-	testBlock := util.NewBlock(wire.NewMsgBlock(wire.NewBlockHeader(1, []*daghash.Hash{}, &daghash.Hash{}, &daghash.Hash{}, &daghash.Hash{}, &daghash.Hash{}, 0, 0)))
+	testBlock := util.NewBlock(wire.NewMsgBlock(wire.NewBlockHeader(1, []*daghash.Hash{}, &daghash.Hash{}, &daghash.Hash{}, &daghash.Hash{}, 0, 0)))
 
 	tests := []struct {
 		name        string
@@ -716,7 +716,7 @@ func TestWritePendingAndCommitErrors(t *testing.T) {
 	rollbackCalled = false
 	err = pdb.Update(func(dbTx database.Tx) error {
 		return dbTx.StoreBlock(util.NewBlock(wire.NewMsgBlock(
-			wire.NewBlockHeader(1, []*daghash.Hash{}, &daghash.Hash{}, &daghash.Hash{}, &daghash.Hash{}, &daghash.Hash{}, 0, 0))))
+			wire.NewBlockHeader(1, []*daghash.Hash{}, &daghash.Hash{}, &daghash.Hash{}, &daghash.Hash{}, 0, 0))))
 	})
 	if err == nil {
 		t.Errorf("No error returned when blockIdx.Put() should have returned an error")
diff --git a/database/testdata/blocks1-256.bz2 b/database/testdata/blocks1-256.bz2
index ad970d81368e50f39171f7b364868dad7dfd6ee3..41874ec34080c052c3b69dc8765fc55ce9cdac01 100644
GIT binary patch
literal 9938
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
b5q)=5BqUCxe!$DdiDC&BAxb*R!Jq#Df8sh5

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

diff --git a/database/testdata/generator.go b/database/testdata/generator.go
index 239e9e20a..d31ca7e85 100644
--- a/database/testdata/generator.go
+++ b/database/testdata/generator.go
@@ -47,7 +47,6 @@ func generateBlock(parent *wire.MsgBlock) *wire.MsgBlock {
 			Version:              1,
 			ParentHashes:         []*daghash.Hash{parent.BlockHash()},
 			HashMerkleRoot:       &genesisMerkleRoot,
-			IDMerkleRoot:         &daghash.ZeroHash,
 			AcceptedIDMerkleRoot: &daghash.ZeroHash,
 			UTXOCommitment:       &daghash.ZeroHash,
 			Timestamp:            time.Unix(0x5b28c4c8, 0), // 2018-06-19 08:54:32 +0000 UTC
diff --git a/integration/rpctest/blockgen.go b/integration/rpctest/blockgen.go
index d44b3c2e7..da02ca018 100644
--- a/integration/rpctest/blockgen.go
+++ b/integration/rpctest/blockgen.go
@@ -183,13 +183,11 @@ func CreateBlock(parentBlock *util.Block, inclusionTxs []*util.Tx,
 		blockTxns = append(blockTxns, inclusionTxs...)
 	}
 	hashMerkleTree := blockdag.BuildHashMerkleTreeStore(blockTxns)
-	idMerkleTree := blockdag.BuildIDMerkleTreeStore(blockTxns)
 	var block wire.MsgBlock
 	block.Header = wire.BlockHeader{
 		Version:              blockVersion,
 		ParentHashes:         []*daghash.Hash{parentHash},
 		HashMerkleRoot:       hashMerkleTree.Root(),
-		IDMerkleRoot:         idMerkleTree.Root(),
 		AcceptedIDMerkleRoot: &daghash.ZeroHash,
 		UTXOCommitment:       &daghash.ZeroHash,
 		Timestamp:            ts,
diff --git a/mempool/estimatefee_test.go b/mempool/estimatefee_test.go
index 51f3a5a0c..83a07c91d 100644
--- a/mempool/estimatefee_test.go
+++ b/mempool/estimatefee_test.go
@@ -71,7 +71,6 @@ func (eft *estimateFeeTester) newBlock(txs []*wire.MsgTx) {
 
 	block := util.NewBlock(&wire.MsgBlock{
 		Header: wire.BlockHeader{
-			IDMerkleRoot:         &daghash.ZeroHash,
 			HashMerkleRoot:       &daghash.ZeroHash,
 			AcceptedIDMerkleRoot: &daghash.ZeroHash,
 			UTXOCommitment:       &daghash.ZeroHash,
diff --git a/mining/mining.go b/mining/mining.go
index 71a65b83a..d85af6968 100644
--- a/mining/mining.go
+++ b/mining/mining.go
@@ -652,7 +652,6 @@ func (g *BlkTmplGenerator) NewBlockTemplate(payToAddress util.Address) (*BlockTe
 
 	// Create a new block ready to be solved.
 	hashMerkleTree := blockdag.BuildHashMerkleTreeStore(blockTxns)
-	idMerkleTree := blockdag.BuildIDMerkleTreeStore(blockTxns)
 	acceptedIDMerkleRoot, err := g.dag.NextAcceptedIDMerkleRoot()
 	if err != nil {
 		return nil, err
@@ -662,7 +661,6 @@ func (g *BlkTmplGenerator) NewBlockTemplate(payToAddress util.Address) (*BlockTe
 		Version:              nextBlockVersion,
 		ParentHashes:         g.dag.TipHashes(),
 		HashMerkleRoot:       hashMerkleTree.Root(),
-		IDMerkleRoot:         idMerkleTree.Root(),
 		AcceptedIDMerkleRoot: acceptedIDMerkleRoot,
 		UTXOCommitment:       &daghash.ZeroHash,
 		Timestamp:            ts,
@@ -747,8 +745,6 @@ func (g *BlkTmplGenerator) UpdateExtraNonce(msgBlock *wire.MsgBlock, blockHeight
 	block := util.NewBlock(msgBlock)
 	hashMerkleTree := blockdag.BuildHashMerkleTreeStore(block.Transactions())
 	msgBlock.Header.HashMerkleRoot = hashMerkleTree.Root()
-	idMerkleTree := blockdag.BuildIDMerkleTreeStore(block.Transactions())
-	msgBlock.Header.IDMerkleRoot = idMerkleTree.Root()
 
 	return nil
 }
diff --git a/mining/simulator/mineloop.go b/mining/simulator/mineloop.go
index 889adecb7..93ae55d1a 100644
--- a/mining/simulator/mineloop.go
+++ b/mining/simulator/mineloop.go
@@ -37,7 +37,7 @@ func parseBlock(template *btcjson.GetBlockTemplateResult) (*util.Block, error) {
 	bits := uint32(bitsInt64)
 
 	// parse rest of block
-	msgBlock := wire.NewMsgBlock(wire.NewBlockHeader(template.Version, parentHashes, &daghash.Hash{}, &daghash.Hash{}, &daghash.Hash{}, &daghash.Hash{}, uint32(bits), 0))
+	msgBlock := wire.NewMsgBlock(wire.NewBlockHeader(template.Version, parentHashes, &daghash.Hash{}, &daghash.Hash{}, &daghash.Hash{}, uint32(bits), 0))
 
 	for i, txResult := range append([]btcjson.GetBlockTemplateResultTx{*template.CoinbaseTxn}, template.Transactions...) {
 		reader := hex.NewDecoder(strings.NewReader(txResult.Data))
@@ -127,7 +127,6 @@ func solveLoop(newTemplateChan chan *btcjson.GetBlockTemplateResult, foundBlock
 		msgBlock := block.MsgBlock()
 
 		msgBlock.Header.HashMerkleRoot = blockdag.BuildHashMerkleTreeStore(block.Transactions()).Root()
-		msgBlock.Header.IDMerkleRoot = blockdag.BuildIDMerkleTreeStore(block.Transactions()).Root()
 
 		go solveBlock(block, stopOldTemplateSolving, foundBlock)
 	}
diff --git a/mining/test_utils.go b/mining/test_utils.go
index 706c465dd..b5271273d 100644
--- a/mining/test_utils.go
+++ b/mining/test_utils.go
@@ -115,7 +115,6 @@ func PrepareBlockForTest(dag *blockdag.BlockDAG, params *dagconfig.Params, paren
 			utilTxs[i] = util.NewTx(tx)
 		}
 		template.Block.Header.HashMerkleRoot = blockdag.BuildHashMerkleTreeStore(utilTxs).Root()
-		template.Block.Header.IDMerkleRoot = blockdag.BuildIDMerkleTreeStore(utilTxs).Root()
 
 		acceptedIDMerkleRoot, err := dag.NextAcceptedIDMerkleRoot()
 		if err != nil {
diff --git a/peer/peer_test.go b/peer/peer_test.go
index 5c28974b8..e6893d315 100644
--- a/peer/peer_test.go
+++ b/peer/peer_test.go
@@ -494,7 +494,7 @@ func TestPeerListeners(t *testing.T) {
 		{
 			"OnBlock",
 			wire.NewMsgBlock(wire.NewBlockHeader(1,
-				[]*daghash.Hash{}, &daghash.Hash{}, &daghash.Hash{}, &daghash.Hash{}, &daghash.Hash{}, 1, 1)),
+				[]*daghash.Hash{}, &daghash.Hash{}, &daghash.Hash{}, &daghash.Hash{}, 1, 1)),
 		},
 		{
 			"OnInv",
@@ -560,7 +560,7 @@ func TestPeerListeners(t *testing.T) {
 		{
 			"OnMerkleBlock",
 			wire.NewMsgMerkleBlock(wire.NewBlockHeader(1,
-				[]*daghash.Hash{}, &daghash.Hash{}, &daghash.Hash{}, &daghash.Hash{}, &daghash.Hash{}, 1, 1)),
+				[]*daghash.Hash{}, &daghash.Hash{}, &daghash.Hash{}, &daghash.Hash{}, 1, 1)),
 		},
 		// only one version message is allowed
 		// only one verack message is allowed
diff --git a/server/rpc/rpcserver.go b/server/rpc/rpcserver.go
index 6dbde4a47..661eca64a 100644
--- a/server/rpc/rpcserver.go
+++ b/server/rpc/rpcserver.go
@@ -1198,7 +1198,6 @@ func handleGetBlock(s *Server, cmd interface{}, closeChan <-chan struct{}) (inte
 		Version:              blockHeader.Version,
 		VersionHex:           fmt.Sprintf("%08x", blockHeader.Version),
 		HashMerkleRoot:       blockHeader.HashMerkleRoot.String(),
-		IDMerkleRoot:         blockHeader.IDMerkleRoot.String(),
 		AcceptedIDMerkleRoot: blockHeader.AcceptedIDMerkleRoot.String(),
 		ParentHashes:         daghash.Strings(blockHeader.ParentHashes),
 		Nonce:                blockHeader.Nonce,
@@ -1401,7 +1400,6 @@ func handleGetBlockHeader(s *Server, cmd interface{}, closeChan <-chan struct{})
 		Version:              blockHeader.Version,
 		VersionHex:           fmt.Sprintf("%08x", blockHeader.Version),
 		HashMerkleRoot:       blockHeader.HashMerkleRoot.String(),
-		IDMerkleRoot:         blockHeader.IDMerkleRoot.String(),
 		AcceptedIDMerkleRoot: blockHeader.AcceptedIDMerkleRoot.String(),
 		NextHashes:           nextHashStrings,
 		ParentHashes:         daghash.Strings(blockHeader.ParentHashes),
@@ -1680,8 +1678,6 @@ func (state *gbtWorkState) updateBlockTemplate(s *Server, useCoinbaseValue bool)
 			block := util.NewBlock(template.Block)
 			hashMerkleTree := blockdag.BuildHashMerkleTreeStore(block.Transactions())
 			template.Block.Header.HashMerkleRoot = hashMerkleTree.Root()
-			idMerkleTree := blockdag.BuildIDMerkleTreeStore(block.Transactions())
-			template.Block.Header.IDMerkleRoot = idMerkleTree.Root()
 		}
 
 		// Set locals for convenience.
diff --git a/server/rpc/rpcserverhelp.go b/server/rpc/rpcserverhelp.go
index ea2d0e525..284c7dee9 100644
--- a/server/rpc/rpcserverhelp.go
+++ b/server/rpc/rpcserverhelp.go
@@ -242,7 +242,6 @@ var helpDescsEnUS = map[string]string{
 	"getBlockVerboseResult-version":              "The block version",
 	"getBlockVerboseResult-versionHex":           "The block version in hexadecimal",
 	"getBlockVerboseResult-hashMerkleRoot":       "Merkle tree reference to hash of all transactions for the block",
-	"getBlockVerboseResult-idMerkleRoot":         "Merkle tree reference to hash of all transactions' IDs for the block",
 	"getBlockVerboseResult-acceptedIdMerkleRoot": "Merkle tree reference to hash all transactions accepted form the block blues",
 	"getBlockVerboseResult-tx":                   "The transaction hashes (only when verbosetx=false)",
 	"getBlockVerboseResult-rawRx":                "The transactions as JSON objects (only when verbosetx=true)",
@@ -277,7 +276,6 @@ var helpDescsEnUS = map[string]string{
 	"getBlockHeaderVerboseResult-version":              "The block version",
 	"getBlockHeaderVerboseResult-versionHex":           "The block version in hexadecimal",
 	"getBlockHeaderVerboseResult-hashMerkleRoot":       "Merkle tree reference to hash of all transactions for the block",
-	"getBlockHeaderVerboseResult-idMerkleRoot":         "Merkle tree reference to hash of all transactions' IDs for the block",
 	"getBlockHeaderVerboseResult-acceptedIdMerkleRoot": "Merkle tree reference to hash all transactions accepted form the block blues",
 	"getBlockHeaderVerboseResult-time":                 "The block time in seconds since 1 Jan 1970 GMT",
 	"getBlockHeaderVerboseResult-nonce":                "The block nonce",
diff --git a/util/block_test.go b/util/block_test.go
index 2f2973c47..bfb25e859 100644
--- a/util/block_test.go
+++ b/util/block_test.go
@@ -38,7 +38,7 @@ func TestBlock(t *testing.T) {
 	}
 
 	// Hash for block 100,000.
-	wantHashStr := "df1b3cc747f665f36df84bdaa54a9ea695fbe12e102156fc1fc61d89366bc2d7"
+	wantHashStr := "839a8e072e6d402128f6f9a32ffc012e471e071e8ef8405552b1e58ef7b681f0"
 	wantHash, err := daghash.NewHashFromStr(wantHashStr)
 	if err != nil {
 		t.Errorf("NewHashFromStr: %v", err)
@@ -147,10 +147,10 @@ func TestBlock(t *testing.T) {
 
 	// Transaction offsets and length for the transaction in Block100000.
 	wantTxLocs := []wire.TxLoc{
-		{TxStart: 218, TxLen: 163},
-		{TxStart: 381, TxLen: 287},
-		{TxStart: 668, TxLen: 285},
-		{TxStart: 953, TxLen: 253},
+		{TxStart: 186, TxLen: 163},
+		{TxStart: 349, TxLen: 287},
+		{TxStart: 636, TxLen: 285},
+		{TxStart: 921, TxLen: 253},
 	}
 
 	// Ensure the transaction location information is accurate.
@@ -259,7 +259,7 @@ func TestBlockErrors(t *testing.T) {
 	}
 
 	// Truncate the block byte buffer to force errors.
-	shortBytes := block100000Bytes[:218]
+	shortBytes := block100000Bytes[:186]
 	_, err = util.NewBlockFromBytes(shortBytes)
 	if err != io.EOF {
 		t.Errorf("NewBlockFromBytes: did not get expected error - "+
@@ -325,12 +325,6 @@ var Block100000 = wire.MsgBlock{
 			0x28, 0xc3, 0x06, 0x7c, 0xc3, 0x8d, 0x48, 0x85,
 			0xef, 0xb5, 0xa4, 0xac, 0x42, 0x47, 0xe9, 0xf3,
 		}, // f3e94742aca4b5ef85488dc37c06c3282295ffec960994b2c0d5ac2a25a95766
-		IDMerkleRoot: &daghash.Hash{
-			0x66, 0x57, 0xa9, 0x25, 0x2a, 0xac, 0xd5, 0xc0,
-			0xb2, 0x94, 0x09, 0x96, 0xec, 0xff, 0x95, 0x22,
-			0x28, 0xc3, 0x06, 0x7c, 0xc3, 0x8d, 0x48, 0x85,
-			0xef, 0xb5, 0xa4, 0xac, 0x42, 0x47, 0xe9, 0xf3,
-		}, // f3e94742aca4b5ef85488dc37c06c3282295ffec960994b2c0d5ac2a25a95766
 		AcceptedIDMerkleRoot: &daghash.Hash{
 			0x28, 0xc3, 0x06, 0x7c, 0xc3, 0x8d, 0x48, 0x85,
 			0xef, 0xb5, 0xa4, 0xac, 0x42, 0x47, 0xe9, 0xf3,
diff --git a/util/bloom/filter_test.go b/util/bloom/filter_test.go
index 9509e9baf..8e490f98b 100644
--- a/util/bloom/filter_test.go
+++ b/util/bloom/filter_test.go
@@ -537,9 +537,6 @@ func TestFilterInsertP2PubKeyOnly(t *testing.T) {
 		0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63, 0x65, 0x9C, 0x79, // HashMerkleRoot
 		0x3C, 0xE3, 0x70, 0xD9, 0x5F, 0x09, 0x3B, 0xC7, 0xE3, 0x67, 0x11,
 		0x7B, 0x3C, 0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
-		0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63, 0x65, 0x9C, 0x79, // Fake IDMerkleRoot. TODO: (Ori) Replace to a real IDMerkleRoot
-		0x3C, 0xE3, 0x70, 0xD9, 0x5F, 0x09, 0x3B, 0xC7, 0xE3, 0x67, 0x11,
-		0x7B, 0x3C, 0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
 		0x3C, 0xE3, 0x70, 0xD9, 0x5F, 0x09, 0x3B, 0xC7, 0xE3, 0x67, 0x11, // AcceptedIDMerkleRoot
 		0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63, 0x65, 0x9C, 0x79,
 		0x7B, 0x3C, 0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
diff --git a/util/bloom/merkleblock_test.go b/util/bloom/merkleblock_test.go
index 0ebbac165..ccce48497 100644
--- a/util/bloom/merkleblock_test.go
+++ b/util/bloom/merkleblock_test.go
@@ -25,9 +25,6 @@ func TestMerkleBlock3(t *testing.T) {
 		0xB5, 0x0C, 0xC0, 0x69, 0xD6, 0xA3, 0xE3, 0x3E, 0x3F, 0xF8, 0x4A, // HashMerkleRoot
 		0x5C, 0x41, 0xD9, 0xD3, 0xFE, 0xBE, 0x7C, 0x77, 0x0F, 0xDC, 0xC9,
 		0x6B, 0x2C, 0x3F, 0xF6, 0x0A, 0xBE, 0x18, 0x4F, 0x19, 0x63,
-		0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63, 0x65, 0x9C, 0x79, // Fake IDMerkleRoot. TODO: (Ori) Replace to a real IDMerkleRoot
-		0x3C, 0xE3, 0x70, 0xD9, 0x5F, 0x09, 0x3B, 0xC7, 0xE3, 0x67, 0x11,
-		0x7B, 0x3C, 0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
 		0x3C, 0xE3, 0x70, 0xD9, 0x5F, 0x09, 0x3B, 0xC7, 0xE3, 0x67, 0x11, // AcceptedIDMerkleRoot
 		0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63, 0x65, 0x9C, 0x79,
 		0x7B, 0x3C, 0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
@@ -84,11 +81,7 @@ func TestMerkleBlock3(t *testing.T) {
 		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, 0x7f, 0x16, 0xc5,
-		0x96, 0x2e, 0x8b, 0xd9, 0x63, 0x65, 0x9c, 0x79,
-		0x3c, 0xe3, 0x70, 0xd9, 0x5f, 0x09, 0x3b, 0xc7,
-		0xe3, 0x67, 0x11, 0x7b, 0x3c, 0x30, 0xc1, 0xf8,
-		0xfd, 0xd0, 0xd9, 0x72, 0x87, 0x3c, 0xe3, 0x70,
+		0xbe, 0x18, 0x4f, 0x19, 0x63, 0x3c, 0xe3, 0x70,
 		0xd9, 0x5f, 0x09, 0x3b, 0xc7, 0xe3, 0x67, 0x11,
 		0x7f, 0x16, 0xc5, 0x96, 0x2e, 0x8b, 0xd9, 0x63,
 		0x65, 0x9c, 0x79, 0x7b, 0x3c, 0x30, 0xc1, 0xf8,
diff --git a/util/daghash/hash_test.go b/util/daghash/hash_test.go
index 29151d3ff..e69b9a88f 100644
--- a/util/daghash/hash_test.go
+++ b/util/daghash/hash_test.go
@@ -15,10 +15,10 @@ import (
 // mainNetGenesisHash is the hash of the first block in the block chain for the
 // main network (genesis block).
 var mainNetGenesisHash = Hash([HashSize]byte{
-	0x6f, 0xe2, 0x8c, 0x0a, 0xb6, 0xf1, 0xb3, 0x72,
-	0xc1, 0xa6, 0xa2, 0x46, 0xae, 0x63, 0xf7, 0x4f,
-	0x93, 0x1e, 0x83, 0x65, 0xe1, 0x5a, 0x08, 0x9c,
-	0x68, 0xd6, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0xdc, 0x5f, 0x5b, 0x5b, 0x1d, 0xc2, 0xa7, 0x25,
+	0x49, 0xd5, 0x1d, 0x4d, 0xee, 0xd7, 0xa4, 0x8b,
+	0xaf, 0xd3, 0x14, 0x4b, 0x56, 0x78, 0x98, 0xb1,
+	0x8c, 0xfd, 0x9f, 0x69, 0xdd, 0xcf, 0xbb, 0x63,
 })
 
 // TestHash tests the Hash API.
@@ -151,14 +151,14 @@ func TestNewHashFromStr(t *testing.T) {
 	}{
 		// Genesis hash.
 		{
-			"000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f",
+			"63bbcfdd699ffd8cb19878564b14d3af8ba4d7ee4d1dd54925a7c21d5b5b5fdc",
 			mainNetGenesisHash,
 			nil,
 		},
 
 		// Genesis hash with stripped leading zeros.
 		{
-			"19d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f",
+			"63bbcfdd699ffd8cb19878564b14d3af8ba4d7ee4d1dd54925a7c21d5b5b5fdc",
 			mainNetGenesisHash,
 			nil,
 		},
diff --git a/wire/bench_test.go b/wire/bench_test.go
index 6098ce8b6..0e49ca142 100644
--- a/wire/bench_test.go
+++ b/wire/bench_test.go
@@ -426,7 +426,7 @@ func BenchmarkDecodeHeaders(b *testing.B) {
 			}
 			parentHashes[i] = hash
 		}
-		m.AddBlockHeader(NewBlockHeader(1, parentHashes, hash, hash, hash, hash, 0, uint64(i)))
+		m.AddBlockHeader(NewBlockHeader(1, parentHashes, hash, hash, hash, 0, uint64(i)))
 	}
 
 	// Serialize it so the bytes are available to test the decode below.
@@ -572,7 +572,7 @@ func BenchmarkDecodeMerkleBlock(b *testing.B) {
 	if err != nil {
 		b.Fatalf("NewHashFromStr: unexpected error: %v", err)
 	}
-	m.Header = *NewBlockHeader(1, []*daghash.Hash{hash}, hash, hash, hash, hash, 0, uint64(10000))
+	m.Header = *NewBlockHeader(1, []*daghash.Hash{hash}, hash, hash, hash, 0, uint64(10000))
 	for i := 0; i < 105; i++ {
 		hash, err := daghash.NewHashFromStr(fmt.Sprintf("%x", i))
 		if err != nil {
diff --git a/wire/blockheader.go b/wire/blockheader.go
index 1a1325a42..7fc78acc5 100644
--- a/wire/blockheader.go
+++ b/wire/blockheader.go
@@ -15,11 +15,11 @@ import (
 // BaseBlockHeaderPayload is the base number of bytes a block header can be,
 // not including the list of parent block headers.
 // Version 4 bytes + Timestamp 8 bytes + Bits 4 bytes + Nonce 8 bytes +
-// + NumParentBlocks 1 byte + HashMerkleRoot hash + IDMerkleRoot hash +
+// + NumParentBlocks 1 byte + HashMerkleRoot hash +
 // + AcceptedIDMerkleRoot hash + UTXOCommitment hash.
 // To get total size of block header len(ParentHashes) * daghash.HashSize should be
 // added to this value
-const BaseBlockHeaderPayload = 25 + 4*(daghash.HashSize)
+const BaseBlockHeaderPayload = 25 + 3*(daghash.HashSize)
 
 // MaxNumParentBlocks is the maximum number of parent blocks a block can reference.
 // Currently set to 255 as the maximum number NumParentBlocks can be due to it being a byte
@@ -41,9 +41,6 @@ type BlockHeader struct {
 	// HashMerkleRoot is the merkle tree reference to hash of all transactions for the block.
 	HashMerkleRoot *daghash.Hash
 
-	// IDMerkleRoot is the merkle tree reference to hash of all transactions' IDs for the block.
-	IDMerkleRoot *daghash.Hash
-
 	// AcceptedIDMerkleRoot is merkle tree reference to hash all transactions
 	// accepted form the block.Blues
 	AcceptedIDMerkleRoot *daghash.Hash
@@ -126,12 +123,10 @@ func (h *BlockHeader) SerializeSize() int {
 }
 
 // NewBlockHeader returns a new BlockHeader using the provided version, previous
-// block hash, hash merkle root, ID merkle root difficulty bits, and nonce used to generate the
+// block hash, hash merkle root, accepted ID merkle root, difficulty bits, and nonce used to generate the
 // block with defaults or calclulated values for the remaining fields.
 func NewBlockHeader(version int32, parentHashes []*daghash.Hash, hashMerkleRoot *daghash.Hash,
-	idMerkleRoot *daghash.Hash, acceptedIDMerkleRoot *daghash.Hash,
-	utxoCommitment *daghash.Hash,
-	bits uint32, nonce uint64) *BlockHeader {
+	acceptedIDMerkleRoot *daghash.Hash, utxoCommitment *daghash.Hash, bits uint32, nonce uint64) *BlockHeader {
 
 	// Limit the timestamp to one second precision since the protocol
 	// doesn't support better.
@@ -139,7 +134,6 @@ func NewBlockHeader(version int32, parentHashes []*daghash.Hash, hashMerkleRoot
 		Version:              version,
 		ParentHashes:         parentHashes,
 		HashMerkleRoot:       hashMerkleRoot,
-		IDMerkleRoot:         idMerkleRoot,
 		AcceptedIDMerkleRoot: acceptedIDMerkleRoot,
 		UTXOCommitment:       utxoCommitment,
 		Timestamp:            time.Unix(time.Now().Unix(), 0),
@@ -168,12 +162,10 @@ func readBlockHeader(r io.Reader, pver uint32, bh *BlockHeader) error {
 		bh.ParentHashes[i] = hash
 	}
 	bh.HashMerkleRoot = &daghash.Hash{}
-	bh.IDMerkleRoot = &daghash.Hash{}
 	bh.AcceptedIDMerkleRoot = &daghash.Hash{}
 	bh.UTXOCommitment = &daghash.Hash{}
-	return readElements(r, bh.HashMerkleRoot, bh.IDMerkleRoot,
-		bh.AcceptedIDMerkleRoot, bh.UTXOCommitment, (*int64Time)(&bh.Timestamp),
-		&bh.Bits, &bh.Nonce)
+	return readElements(r, bh.HashMerkleRoot, bh.AcceptedIDMerkleRoot, bh.UTXOCommitment,
+		(*int64Time)(&bh.Timestamp), &bh.Bits, &bh.Nonce)
 }
 
 // writeBlockHeader writes a bitcoin block header to w.  See Serialize for
@@ -189,6 +181,5 @@ func writeBlockHeader(w io.Writer, pver uint32, bh *BlockHeader) error {
 			return err
 		}
 	}
-	return writeElements(w, bh.HashMerkleRoot, bh.IDMerkleRoot,
-		bh.AcceptedIDMerkleRoot, bh.UTXOCommitment, sec, bh.Bits, bh.Nonce)
+	return writeElements(w, bh.HashMerkleRoot, bh.AcceptedIDMerkleRoot, bh.UTXOCommitment, sec, bh.Bits, bh.Nonce)
 }
diff --git a/wire/blockheader_test.go b/wire/blockheader_test.go
index 632bc7352..65bf9d959 100644
--- a/wire/blockheader_test.go
+++ b/wire/blockheader_test.go
@@ -25,11 +25,9 @@ func TestBlockHeader(t *testing.T) {
 	hashes := []*daghash.Hash{mainNetGenesisHash, simNetGenesisHash}
 
 	merkleHash := mainNetGenesisMerkleRoot
-	idMerkleRoot := exampleIDMerkleRoot
 	acceptedIDMerkleRoot := exampleAcceptedIDMerkleRoot
 	bits := uint32(0x1d00ffff)
-	bh := NewBlockHeader(1, hashes, merkleHash, idMerkleRoot,
-		acceptedIDMerkleRoot, exampleUTXOCommitment, bits, nonce)
+	bh := NewBlockHeader(1, hashes, merkleHash, acceptedIDMerkleRoot, exampleUTXOCommitment, bits, nonce)
 
 	// Ensure we get the same data back out.
 	if !reflect.DeepEqual(bh.ParentHashes, hashes) {
@@ -62,7 +60,6 @@ func TestBlockHeaderWire(t *testing.T) {
 		Version:              1,
 		ParentHashes:         []*daghash.Hash{mainNetGenesisHash, simNetGenesisHash},
 		HashMerkleRoot:       mainNetGenesisMerkleRoot,
-		IDMerkleRoot:         exampleIDMerkleRoot,
 		AcceptedIDMerkleRoot: exampleAcceptedIDMerkleRoot,
 		UTXOCommitment:       exampleUTXOCommitment,
 		Timestamp:            time.Unix(0x495fab29, 0), // 2009-01-03 12:15:05 -0600 CST
@@ -74,10 +71,10 @@ func TestBlockHeaderWire(t *testing.T) {
 	baseBlockHdrEncoded := []byte{
 		0x01, 0x00, 0x00, 0x00, // Version 1
 		0x02,                                           // NumParentBlocks
-		0x6f, 0xe2, 0x8c, 0x0a, 0xb6, 0xf1, 0xb3, 0x72, // mainNetGenesisHash
-		0xc1, 0xa6, 0xa2, 0x46, 0xae, 0x63, 0xf7, 0x4f,
-		0x93, 0x1e, 0x83, 0x65, 0xe1, 0x5a, 0x08, 0x9c,
-		0x68, 0xd6, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0xdc, 0x5f, 0x5b, 0x5b, 0x1d, 0xc2, 0xa7, 0x25, // mainNetGenesisHash
+		0x49, 0xd5, 0x1d, 0x4d, 0xee, 0xd7, 0xa4, 0x8b,
+		0xaf, 0xd3, 0x14, 0x4b, 0x56, 0x78, 0x98, 0xb1,
+		0x8c, 0xfd, 0x9f, 0x69, 0xdd, 0xcf, 0xbb, 0x63,
 		0xf6, 0x7a, 0xd7, 0x69, 0x5d, 0x9b, 0x66, 0x2a, // simNetGenesisHash
 		0x72, 0xff, 0x3d, 0x8e, 0xdb, 0xbb, 0x2d, 0xe0,
 		0xbf, 0xa6, 0x7b, 0x13, 0x97, 0x4b, 0xb9, 0x91,
@@ -86,10 +83,6 @@ func TestBlockHeaderWire(t *testing.T) {
 		0x32, 0x51, 0x8a, 0x88, 0xc3, 0x1b, 0xc8, 0x7f,
 		0x61, 0x8f, 0x76, 0x67, 0x3e, 0x2c, 0xc7, 0x7a,
 		0xb2, 0x12, 0x7b, 0x7a, 0xfd, 0xed, 0xa3, 0x3b,
-		0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63, // IDMerkleRoot
-		0x65, 0x9C, 0x79, 0x3C, 0xE3, 0x70, 0xD9, 0x5F,
-		0x09, 0x3B, 0xC7, 0xE3, 0x67, 0x11, 0x7B, 0x3C,
-		0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
 		0x09, 0x3B, 0xC7, 0xE3, 0x67, 0x11, 0x7B, 0x3C, // AcceptedIDMerkleRoot
 		0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
 		0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63,
@@ -183,7 +176,6 @@ func TestBlockHeaderSerialize(t *testing.T) {
 		Version:              1,
 		ParentHashes:         []*daghash.Hash{mainNetGenesisHash, simNetGenesisHash},
 		HashMerkleRoot:       mainNetGenesisMerkleRoot,
-		IDMerkleRoot:         exampleIDMerkleRoot,
 		AcceptedIDMerkleRoot: exampleAcceptedIDMerkleRoot,
 		UTXOCommitment:       exampleUTXOCommitment,
 		Timestamp:            time.Unix(0x495fab29, 0), // 2009-01-03 12:15:05 -0600 CST
@@ -195,10 +187,10 @@ func TestBlockHeaderSerialize(t *testing.T) {
 	baseBlockHdrEncoded := []byte{
 		0x01, 0x00, 0x00, 0x00, // Version 1
 		0x02,                                           // NumParentBlocks
-		0x6f, 0xe2, 0x8c, 0x0a, 0xb6, 0xf1, 0xb3, 0x72, // mainNetGenesisHash
-		0xc1, 0xa6, 0xa2, 0x46, 0xae, 0x63, 0xf7, 0x4f,
-		0x93, 0x1e, 0x83, 0x65, 0xe1, 0x5a, 0x08, 0x9c,
-		0x68, 0xd6, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0xdc, 0x5f, 0x5b, 0x5b, 0x1d, 0xc2, 0xa7, 0x25, // mainNetGenesisHash
+		0x49, 0xd5, 0x1d, 0x4d, 0xee, 0xd7, 0xa4, 0x8b,
+		0xaf, 0xd3, 0x14, 0x4b, 0x56, 0x78, 0x98, 0xb1,
+		0x8c, 0xfd, 0x9f, 0x69, 0xdd, 0xcf, 0xbb, 0x63,
 		0xf6, 0x7a, 0xd7, 0x69, 0x5d, 0x9b, 0x66, 0x2a, // simNetGenesisHash
 		0x72, 0xff, 0x3d, 0x8e, 0xdb, 0xbb, 0x2d, 0xe0,
 		0xbf, 0xa6, 0x7b, 0x13, 0x97, 0x4b, 0xb9, 0x91,
@@ -207,10 +199,6 @@ func TestBlockHeaderSerialize(t *testing.T) {
 		0x32, 0x51, 0x8a, 0x88, 0xc3, 0x1b, 0xc8, 0x7f,
 		0x61, 0x8f, 0x76, 0x67, 0x3e, 0x2c, 0xc7, 0x7a,
 		0xb2, 0x12, 0x7b, 0x7a, 0xfd, 0xed, 0xa3, 0x3b,
-		0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63, // IDMerkleRoot
-		0x65, 0x9C, 0x79, 0x3C, 0xE3, 0x70, 0xD9, 0x5F,
-		0x09, 0x3B, 0xC7, 0xE3, 0x67, 0x11, 0x7B, 0x3C,
-		0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
 		0x09, 0x3B, 0xC7, 0xE3, 0x67, 0x11, 0x7B, 0x3C, // AcceptedIDMerkleRoot
 		0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
 		0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63,
@@ -277,7 +265,6 @@ func TestBlockHeaderSerializeSize(t *testing.T) {
 		Version:              1,
 		ParentHashes:         []*daghash.Hash{mainNetGenesisHash, simNetGenesisHash},
 		HashMerkleRoot:       mainNetGenesisMerkleRoot,
-		IDMerkleRoot:         mainNetGenesisMerkleRoot,
 		AcceptedIDMerkleRoot: &daghash.ZeroHash,
 		UTXOCommitment:       &daghash.ZeroHash,
 		Timestamp:            timestamp,
@@ -289,7 +276,6 @@ func TestBlockHeaderSerializeSize(t *testing.T) {
 		Version:              1,
 		ParentHashes:         []*daghash.Hash{},
 		HashMerkleRoot:       mainNetGenesisMerkleRoot,
-		IDMerkleRoot:         mainNetGenesisMerkleRoot,
 		AcceptedIDMerkleRoot: &daghash.ZeroHash,
 		UTXOCommitment:       &daghash.ZeroHash,
 		Timestamp:            timestamp,
@@ -301,10 +287,10 @@ func TestBlockHeaderSerializeSize(t *testing.T) {
 		size int          // Expected serialized size
 	}{
 		// Block with no transactions.
-		{genesisBlockHdr, 153},
+		{genesisBlockHdr, 121},
 
 		// First block in the mainnet block DAG.
-		{baseBlockHdr, 217},
+		{baseBlockHdr, 185},
 	}
 
 	t.Logf("Running %d tests", len(tests))
diff --git a/wire/common_test.go b/wire/common_test.go
index b4c9a787b..259d8c342 100644
--- a/wire/common_test.go
+++ b/wire/common_test.go
@@ -18,10 +18,10 @@ import (
 // mainNetGenesisHash is the hash of the first block in the block chain for the
 // main network (genesis block).
 var mainNetGenesisHash = &daghash.Hash{
-	0x6f, 0xe2, 0x8c, 0x0a, 0xb6, 0xf1, 0xb3, 0x72,
-	0xc1, 0xa6, 0xa2, 0x46, 0xae, 0x63, 0xf7, 0x4f,
-	0x93, 0x1e, 0x83, 0x65, 0xe1, 0x5a, 0x08, 0x9c,
-	0x68, 0xd6, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0xdc, 0x5f, 0x5b, 0x5b, 0x1d, 0xc2, 0xa7, 0x25,
+	0x49, 0xd5, 0x1d, 0x4d, 0xee, 0xd7, 0xa4, 0x8b,
+	0xaf, 0xd3, 0x14, 0x4b, 0x56, 0x78, 0x98, 0xb1,
+	0x8c, 0xfd, 0x9f, 0x69, 0xdd, 0xcf, 0xbb, 0x63,
 }
 
 // simNetGenesisHash is the hash of the first block in the block chain for the
@@ -42,13 +42,6 @@ var mainNetGenesisMerkleRoot = &daghash.Hash{
 	0xb2, 0x12, 0x7b, 0x7a, 0xfd, 0xed, 0xa3, 0x3b,
 }
 
-var exampleIDMerkleRoot = &daghash.Hash{
-	0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63,
-	0x65, 0x9C, 0x79, 0x3C, 0xE3, 0x70, 0xD9, 0x5F,
-	0x09, 0x3B, 0xC7, 0xE3, 0x67, 0x11, 0x7B, 0x3C,
-	0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
-}
-
 var exampleAcceptedIDMerkleRoot = &daghash.Hash{
 	0x09, 0x3B, 0xC7, 0xE3, 0x67, 0x11, 0x7B, 0x3C,
 	0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
diff --git a/wire/message_test.go b/wire/message_test.go
index 9c6b902fe..38924dd29 100644
--- a/wire/message_test.go
+++ b/wire/message_test.go
@@ -68,7 +68,7 @@ func TestMessage(t *testing.T) {
 	msgFilterAdd := NewMsgFilterAdd([]byte{0x01})
 	msgFilterClear := NewMsgFilterClear()
 	msgFilterLoad := NewMsgFilterLoad([]byte{0x01}, 10, 0, BloomUpdateNone)
-	bh := NewBlockHeader(1, []*daghash.Hash{mainNetGenesisHash, simNetGenesisHash}, &daghash.Hash{}, &daghash.Hash{}, &daghash.Hash{}, &daghash.Hash{}, 0, 0)
+	bh := NewBlockHeader(1, []*daghash.Hash{mainNetGenesisHash, simNetGenesisHash}, &daghash.Hash{}, &daghash.Hash{}, &daghash.Hash{}, 0, 0)
 	msgMerkleBlock := NewMsgMerkleBlock(bh)
 	msgReject := NewMsgReject("block", RejectDuplicate, "duplicate block")
 	msgGetCFilters := NewMsgGetCFilters(GCSFilterExtended, 0, &daghash.Hash{})
@@ -91,7 +91,7 @@ func TestMessage(t *testing.T) {
 		{msgGetAddr, msgGetAddr, pver, MainNet, 26},
 		{msgAddr, msgAddr, pver, MainNet, 27},
 		{msgGetBlocks, msgGetBlocks, pver, MainNet, 61},
-		{msgBlock, msgBlock, pver, MainNet, 404},
+		{msgBlock, msgBlock, pver, MainNet, 372},
 		{msgInv, msgInv, pver, MainNet, 25},
 		{msgGetData, msgGetData, pver, MainNet, 25},
 		{msgNotFound, msgNotFound, pver, MainNet, 25},
@@ -107,7 +107,7 @@ func TestMessage(t *testing.T) {
 		{msgFilterAdd, msgFilterAdd, pver, MainNet, 26},
 		{msgFilterClear, msgFilterClear, pver, MainNet, 24},
 		{msgFilterLoad, msgFilterLoad, pver, MainNet, 35},
-		{msgMerkleBlock, msgMerkleBlock, pver, MainNet, 247},
+		{msgMerkleBlock, msgMerkleBlock, pver, MainNet, 215},
 		{msgReject, msgReject, pver, MainNet, 79},
 		{msgGetCFilters, msgGetCFilters, pver, MainNet, 65},
 		{msgGetCFHeaders, msgGetCFHeaders, pver, MainNet, 65},
diff --git a/wire/msgblock_test.go b/wire/msgblock_test.go
index 56eb1981c..82b47a339 100644
--- a/wire/msgblock_test.go
+++ b/wire/msgblock_test.go
@@ -25,13 +25,11 @@ func TestBlock(t *testing.T) {
 	// Block 1 header.
 	parentHashes := blockOne.Header.ParentHashes
 	hashMerkleRoot := blockOne.Header.HashMerkleRoot
-	idMerkleRoot := blockOne.Header.IDMerkleRoot
 	acceptedIDMerkleRoot := blockOne.Header.AcceptedIDMerkleRoot
 	utxoCommitment := blockOne.Header.UTXOCommitment
 	bits := blockOne.Header.Bits
 	nonce := blockOne.Header.Nonce
-	bh := NewBlockHeader(1, parentHashes, hashMerkleRoot, idMerkleRoot,
-		acceptedIDMerkleRoot, utxoCommitment, bits, nonce)
+	bh := NewBlockHeader(1, parentHashes, hashMerkleRoot, acceptedIDMerkleRoot, utxoCommitment, bits, nonce)
 
 	// Ensure the command is expected value.
 	wantCmd := "block"
@@ -77,7 +75,7 @@ func TestBlock(t *testing.T) {
 // TestBlockHash tests the ability to generate the hash of a block accurately.
 func TestBlockHash(t *testing.T) {
 	// Block 1 hash.
-	hashStr := "8a3a27a37c9e3342b4b38ae9ef29e59fe37b59618adafbf36a106b6d62f80654"
+	hashStr := "22e72b61a572bfb32b8739f4e5db3eebe9870e394288467958e93e4a3d3b749f"
 	wantHash, err := daghash.NewHashFromStr(hashStr)
 	if err != nil {
 		t.Errorf("NewHashFromStr: %v", err)
@@ -221,22 +219,20 @@ func TestBlockWireErrors(t *testing.T) {
 		{&blockOne, blockOneBytes, pver, 37, io.ErrShortWrite, io.EOF},
 		// Force error in hash merkle root.
 		{&blockOne, blockOneBytes, pver, 69, io.ErrShortWrite, io.EOF},
-		// Force error in ID merkle root.
-		{&blockOne, blockOneBytes, pver, 101, io.ErrShortWrite, io.EOF},
 		// Force error in accepted ID merkle root.
-		{&blockOne, blockOneBytes, pver, 133, io.ErrShortWrite, io.EOF},
+		{&blockOne, blockOneBytes, pver, 101, io.ErrShortWrite, io.EOF},
 		// Force error in utxo commitment.
-		{&blockOne, blockOneBytes, pver, 165, io.ErrShortWrite, io.EOF},
+		{&blockOne, blockOneBytes, pver, 133, io.ErrShortWrite, io.EOF},
 		// Force error in timestamp.
-		{&blockOne, blockOneBytes, pver, 197, io.ErrShortWrite, io.EOF},
+		{&blockOne, blockOneBytes, pver, 165, io.ErrShortWrite, io.EOF},
 		// Force error in difficulty bits.
-		{&blockOne, blockOneBytes, pver, 205, io.ErrShortWrite, io.EOF},
+		{&blockOne, blockOneBytes, pver, 173, io.ErrShortWrite, io.EOF},
 		// Force error in header nonce.
-		{&blockOne, blockOneBytes, pver, 209, io.ErrShortWrite, io.EOF},
+		{&blockOne, blockOneBytes, pver, 177, io.ErrShortWrite, io.EOF},
 		// Force error in transaction count.
-		{&blockOne, blockOneBytes, pver, 217, io.ErrShortWrite, io.EOF},
+		{&blockOne, blockOneBytes, pver, 185, io.ErrShortWrite, io.EOF},
 		// Force error in transactions.
-		{&blockOne, blockOneBytes, pver, 218, io.ErrShortWrite, io.EOF},
+		{&blockOne, blockOneBytes, pver, 186, io.ErrShortWrite, io.EOF},
 	}
 
 	t.Logf("Running %d tests", len(tests))
@@ -349,22 +345,20 @@ func TestBlockSerializeErrors(t *testing.T) {
 		{&blockOne, blockOneBytes, 37, io.ErrShortWrite, io.EOF},
 		// Force error in hash merkle root.
 		{&blockOne, blockOneBytes, 69, io.ErrShortWrite, io.EOF},
-		// Force error in ID merkle root.
-		{&blockOne, blockOneBytes, 101, io.ErrShortWrite, io.EOF},
 		// Force error in accepted ID merkle root.
-		{&blockOne, blockOneBytes, 133, io.ErrShortWrite, io.EOF},
+		{&blockOne, blockOneBytes, 101, io.ErrShortWrite, io.EOF},
 		// Force error in utxo commitment.
-		{&blockOne, blockOneBytes, 165, io.ErrShortWrite, io.EOF},
+		{&blockOne, blockOneBytes, 133, io.ErrShortWrite, io.EOF},
 		// Force error in timestamp.
-		{&blockOne, blockOneBytes, 197, io.ErrShortWrite, io.EOF},
+		{&blockOne, blockOneBytes, 165, io.ErrShortWrite, io.EOF},
 		// Force error in difficulty bits.
-		{&blockOne, blockOneBytes, 205, io.ErrShortWrite, io.EOF},
+		{&blockOne, blockOneBytes, 173, io.ErrShortWrite, io.EOF},
 		// Force error in header nonce.
-		{&blockOne, blockOneBytes, 209, io.ErrShortWrite, io.EOF},
+		{&blockOne, blockOneBytes, 177, io.ErrShortWrite, io.EOF},
 		// Force error in transaction count.
-		{&blockOne, blockOneBytes, 217, io.ErrShortWrite, io.EOF},
+		{&blockOne, blockOneBytes, 185, io.ErrShortWrite, io.EOF},
 		// Force error in transactions.
-		{&blockOne, blockOneBytes, 218, io.ErrShortWrite, io.EOF},
+		{&blockOne, blockOneBytes, 186, io.ErrShortWrite, io.EOF},
 	}
 
 	t.Logf("Running %d tests", len(tests))
@@ -428,10 +422,6 @@ func TestBlockOverflowErrors(t *testing.T) {
 				0x7a, 0xc7, 0x2c, 0x3e, 0x67, 0x76, 0x8f, 0x61,
 				0x7f, 0xc8, 0x1b, 0xc3, 0x88, 0x8a, 0x51, 0x32,
 				0x3a, 0x9f, 0xb8, 0xaa, 0x4b, 0x1e, 0x5e, 0x4a,
-				0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63, // IDMerkleRoot
-				0x65, 0x9C, 0x79, 0x3C, 0xE3, 0x70, 0xD9, 0x5F,
-				0x09, 0x3B, 0xC7, 0xE3, 0x67, 0x11, 0x7B, 0x3C,
-				0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
 				0x09, 0x3B, 0xC7, 0xE3, 0x67, 0x11, 0x7B, 0x3C, // AcceptedIDMerkleRoot
 				0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
 				0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63,
@@ -492,7 +482,7 @@ func TestBlockSerializeSize(t *testing.T) {
 		size int       // Expected serialized size
 	}{
 		// Block with no transactions.
-		{noTxBlock, 218},
+		{noTxBlock, 186},
 
 		// First block in the mainnet block chain.
 		{&blockOne, len(blockOneBytes)},
@@ -516,7 +506,6 @@ var blockOne = MsgBlock{
 		Version:              1,
 		ParentHashes:         []*daghash.Hash{mainNetGenesisHash, simNetGenesisHash},
 		HashMerkleRoot:       mainNetGenesisMerkleRoot,
-		IDMerkleRoot:         exampleIDMerkleRoot,
 		AcceptedIDMerkleRoot: exampleAcceptedIDMerkleRoot,
 		UTXOCommitment:       exampleUTXOCommitment,
 		Timestamp:            time.Unix(0x4966bc61, 0), // 2009-01-08 20:54:25 -0600 CST
@@ -562,10 +551,10 @@ var blockOne = MsgBlock{
 var blockOneBytes = []byte{
 	0x01, 0x00, 0x00, 0x00, // Version 1
 	0x02,                                           // NumParentBlocks
-	0x6f, 0xe2, 0x8c, 0x0a, 0xb6, 0xf1, 0xb3, 0x72, // mainNetGenesisHash
-	0xc1, 0xa6, 0xa2, 0x46, 0xae, 0x63, 0xf7, 0x4f,
-	0x93, 0x1e, 0x83, 0x65, 0xe1, 0x5a, 0x08, 0x9c,
-	0x68, 0xd6, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0xdc, 0x5f, 0x5b, 0x5b, 0x1d, 0xc2, 0xa7, 0x25, // mainNetGenesisHash
+	0x49, 0xd5, 0x1d, 0x4d, 0xee, 0xd7, 0xa4, 0x8b,
+	0xaf, 0xd3, 0x14, 0x4b, 0x56, 0x78, 0x98, 0xb1,
+	0x8c, 0xfd, 0x9f, 0x69, 0xdd, 0xcf, 0xbb, 0x63,
 	0xf6, 0x7a, 0xd7, 0x69, 0x5d, 0x9b, 0x66, 0x2a, // simNetGenesisHash
 	0x72, 0xff, 0x3d, 0x8e, 0xdb, 0xbb, 0x2d, 0xe0,
 	0xbf, 0xa6, 0x7b, 0x13, 0x97, 0x4b, 0xb9, 0x91,
@@ -574,10 +563,6 @@ var blockOneBytes = []byte{
 	0x32, 0x51, 0x8a, 0x88, 0xc3, 0x1b, 0xc8, 0x7f,
 	0x61, 0x8f, 0x76, 0x67, 0x3e, 0x2c, 0xc7, 0x7a,
 	0xb2, 0x12, 0x7b, 0x7a, 0xfd, 0xed, 0xa3, 0x3b,
-	0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63, // Fake IDMerkleRoot. TODO: (Ori) Replace to a real IDMerkleRoot
-	0x65, 0x9C, 0x79, 0x3C, 0xE3, 0x70, 0xD9, 0x5F,
-	0x09, 0x3B, 0xC7, 0xE3, 0x67, 0x11, 0x7B, 0x3C,
-	0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
 	0x09, 0x3B, 0xC7, 0xE3, 0x67, 0x11, 0x7B, 0x3C, // AcceptedIDMerkleRoot
 	0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
 	0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63,
@@ -622,5 +607,5 @@ var blockOneBytes = []byte{
 
 // Transaction location information for block one transactions.
 var blockOneTxLocs = []TxLoc{
-	{TxStart: 218, TxLen: 162},
+	{TxStart: 186, TxLen: 162},
 }
diff --git a/wire/msgheaders_test.go b/wire/msgheaders_test.go
index ebe789424..567503cf6 100644
--- a/wire/msgheaders_test.go
+++ b/wire/msgheaders_test.go
@@ -29,7 +29,7 @@ func TestHeaders(t *testing.T) {
 	// Ensure max payload is expected value for latest protocol version.
 	// Num headers (varInt) + max allowed headers (header length + 1 byte
 	// for the number of transactions which is always 0).
-	wantPayload := uint32(16628009)
+	wantPayload := uint32(16564009)
 	maxPayload := msg.MaxPayloadLength(pver)
 	if maxPayload != wantPayload {
 		t.Errorf("MaxPayloadLength: wrong max payload length for "+
@@ -63,13 +63,11 @@ func TestHeaders(t *testing.T) {
 func TestHeadersWire(t *testing.T) {
 	hashes := []*daghash.Hash{mainNetGenesisHash, simNetGenesisHash}
 	hashMerkleRoot := blockOne.Header.HashMerkleRoot
-	idMerkleRoot := blockOne.Header.IDMerkleRoot
 	acceptedIDMerkleRoot := blockOne.Header.AcceptedIDMerkleRoot
 	utxoCommitment := blockOne.Header.UTXOCommitment
 	bits := uint32(0x1d00ffff)
 	nonce := uint64(0x9962e301)
-	bh := NewBlockHeader(1, hashes, hashMerkleRoot, idMerkleRoot,
-		acceptedIDMerkleRoot, utxoCommitment, bits, nonce)
+	bh := NewBlockHeader(1, hashes, hashMerkleRoot, acceptedIDMerkleRoot, utxoCommitment, bits, nonce)
 	bh.Version = blockOne.Header.Version
 	bh.Timestamp = blockOne.Header.Timestamp
 
@@ -86,10 +84,10 @@ func TestHeadersWire(t *testing.T) {
 		0x01,                   // VarInt for number of headers.
 		0x01, 0x00, 0x00, 0x00, // Version 1
 		0x02,                                           // NumParentBlocks
-		0x6f, 0xe2, 0x8c, 0x0a, 0xb6, 0xf1, 0xb3, 0x72, // mainNetGenesisHash
-		0xc1, 0xa6, 0xa2, 0x46, 0xae, 0x63, 0xf7, 0x4f,
-		0x93, 0x1e, 0x83, 0x65, 0xe1, 0x5a, 0x08, 0x9c,
-		0x68, 0xd6, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0xdc, 0x5f, 0x5b, 0x5b, 0x1d, 0xc2, 0xa7, 0x25, // mainNetGenesisHash
+		0x49, 0xd5, 0x1d, 0x4d, 0xee, 0xd7, 0xa4, 0x8b,
+		0xaf, 0xd3, 0x14, 0x4b, 0x56, 0x78, 0x98, 0xb1,
+		0x8c, 0xfd, 0x9f, 0x69, 0xdd, 0xcf, 0xbb, 0x63,
 		0xf6, 0x7a, 0xd7, 0x69, 0x5d, 0x9b, 0x66, 0x2a, // simNetGenesisHash
 		0x72, 0xff, 0x3d, 0x8e, 0xdb, 0xbb, 0x2d, 0xe0,
 		0xbf, 0xa6, 0x7b, 0x13, 0x97, 0x4b, 0xb9, 0x91,
@@ -98,10 +96,6 @@ func TestHeadersWire(t *testing.T) {
 		0x32, 0x51, 0x8a, 0x88, 0xc3, 0x1b, 0xc8, 0x7f,
 		0x61, 0x8f, 0x76, 0x67, 0x3e, 0x2c, 0xc7, 0x7a,
 		0xb2, 0x12, 0x7b, 0x7a, 0xfd, 0xed, 0xa3, 0x3b,
-		0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63, // IDMerkleRoot
-		0x65, 0x9C, 0x79, 0x3C, 0xE3, 0x70, 0xD9, 0x5F,
-		0x09, 0x3B, 0xC7, 0xE3, 0x67, 0x11, 0x7B, 0x3C,
-		0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
 		0x09, 0x3B, 0xC7, 0xE3, 0x67, 0x11, 0x7B, 0x3C, // AcceptedIDMerkleRoot
 		0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
 		0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63,
@@ -178,13 +172,11 @@ func TestHeadersWireErrors(t *testing.T) {
 
 	hashes := []*daghash.Hash{mainNetGenesisHash, simNetGenesisHash}
 	hashMerkleRoot := blockOne.Header.HashMerkleRoot
-	idMerkleRoot := blockOne.Header.IDMerkleRoot
 	acceptedIDMerkleRoot := blockOne.Header.AcceptedIDMerkleRoot
 	utxoCommitment := blockOne.Header.UTXOCommitment
 	bits := uint32(0x1d00ffff)
 	nonce := uint64(0x9962e301)
-	bh := NewBlockHeader(1, hashes, hashMerkleRoot, idMerkleRoot,
-		acceptedIDMerkleRoot, utxoCommitment, bits, nonce)
+	bh := NewBlockHeader(1, hashes, hashMerkleRoot, acceptedIDMerkleRoot, utxoCommitment, bits, nonce)
 	bh.Version = blockOne.Header.Version
 	bh.Timestamp = blockOne.Header.Timestamp
 
@@ -207,10 +199,6 @@ func TestHeadersWireErrors(t *testing.T) {
 		0x7a, 0xc7, 0x2c, 0x3e, 0x67, 0x76, 0x8f, 0x61,
 		0x7f, 0xc8, 0x1b, 0xc3, 0x88, 0x8a, 0x51, 0x32,
 		0x3a, 0x9f, 0xb8, 0xaa, 0x4b, 0x1e, 0x5e, 0x4a,
-		0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63, // IDMerkleRoot
-		0x65, 0x9C, 0x79, 0x3C, 0xE3, 0x70, 0xD9, 0x5F,
-		0x09, 0x3B, 0xC7, 0xE3, 0x67, 0x11, 0x7B, 0x3C,
-		0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
 		0x09, 0x3B, 0xC7, 0xE3, 0x67, 0x11, 0x7B, 0x3C, // AcceptedIDMerkleRoot
 		0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
 		0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63,
@@ -238,8 +226,7 @@ func TestHeadersWireErrors(t *testing.T) {
 
 	// Intentionally invalid block header that has a transaction count used
 	// to force errors.
-	bhTrans := NewBlockHeader(1, hashes, hashMerkleRoot, idMerkleRoot,
-		acceptedIDMerkleRoot, utxoCommitment, bits, nonce)
+	bhTrans := NewBlockHeader(1, hashes, hashMerkleRoot, acceptedIDMerkleRoot, utxoCommitment, bits, nonce)
 	bhTrans.Version = blockOne.Header.Version
 	bhTrans.Timestamp = blockOne.Header.Timestamp
 
@@ -261,10 +248,6 @@ func TestHeadersWireErrors(t *testing.T) {
 		0x7a, 0xc7, 0x2c, 0x3e, 0x67, 0x76, 0x8f, 0x61,
 		0x7f, 0xc8, 0x1b, 0xc3, 0x88, 0x8a, 0x51, 0x32,
 		0x3a, 0x9f, 0xb8, 0xaa, 0x4b, 0x1e, 0x5e, 0x4a,
-		0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63, // IDMerkleRoot
-		0x65, 0x9C, 0x79, 0x3C, 0xE3, 0x70, 0xD9, 0x5F,
-		0x09, 0x3B, 0xC7, 0xE3, 0x67, 0x11, 0x7B, 0x3C,
-		0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
 		0x09, 0x3B, 0xC7, 0xE3, 0x67, 0x11, 0x7B, 0x3C, // AcceptedIDMerkleRoot
 		0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
 		0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63,
@@ -295,7 +278,7 @@ func TestHeadersWireErrors(t *testing.T) {
 		// Force error with greater than max headers.
 		{maxHeaders, maxHeadersEncoded, pver, 3, wireErr, wireErr},
 		// Force error with number of transactions.
-		{transHeader, transHeaderEncoded, pver, 210, io.ErrShortWrite, io.EOF},
+		{transHeader, transHeaderEncoded, pver, 178, io.ErrShortWrite, io.EOF},
 		// Force error with included transactions.
 		{transHeader, transHeaderEncoded, pver, len(transHeaderEncoded), nil, wireErr},
 	}
diff --git a/wire/msgmerkleblock_test.go b/wire/msgmerkleblock_test.go
index 0dd67218d..30d4c45d5 100644
--- a/wire/msgmerkleblock_test.go
+++ b/wire/msgmerkleblock_test.go
@@ -23,13 +23,11 @@ func TestMerkleBlock(t *testing.T) {
 	// Block 1 header.
 	parentHashes := blockOne.Header.ParentHashes
 	hashMerkleRoot := blockOne.Header.HashMerkleRoot
-	idMerkleRoot := blockOne.Header.IDMerkleRoot
 	acceptedIDMerkleRoot := blockOne.Header.AcceptedIDMerkleRoot
 	utxoCommitment := blockOne.Header.UTXOCommitment
 	bits := blockOne.Header.Bits
 	nonce := blockOne.Header.Nonce
-	bh := NewBlockHeader(1, parentHashes, hashMerkleRoot, idMerkleRoot,
-		acceptedIDMerkleRoot, utxoCommitment, bits, nonce)
+	bh := NewBlockHeader(1, parentHashes, hashMerkleRoot, acceptedIDMerkleRoot, utxoCommitment, bits, nonce)
 
 	// Ensure the command is expected value.
 	wantCmd := "merkleblock"
@@ -119,13 +117,11 @@ func TestMerkleBlockCrossProtocol(t *testing.T) {
 	// Block 1 header.
 	parentHashes := blockOne.Header.ParentHashes
 	hashMerkleRoot := blockOne.Header.HashMerkleRoot
-	idMerkleRoot := blockOne.Header.IDMerkleRoot
 	acceptedIDMerkleRoot := blockOne.Header.AcceptedIDMerkleRoot
 	utxoCommitment := blockOne.Header.UTXOCommitment
 	bits := blockOne.Header.Bits
 	nonce := blockOne.Header.Nonce
-	bh := NewBlockHeader(1, parentHashes, hashMerkleRoot, idMerkleRoot,
-		acceptedIDMerkleRoot, utxoCommitment, bits, nonce)
+	bh := NewBlockHeader(1, parentHashes, hashMerkleRoot, acceptedIDMerkleRoot, utxoCommitment, bits, nonce)
 
 	msg := NewMsgMerkleBlock(bh)
 
@@ -207,28 +203,26 @@ func TestMerkleBlockWireErrors(t *testing.T) {
 		{&merkleBlockOne, merkleBlockOneBytes, pver, 37, io.ErrShortWrite, io.EOF},
 		// Force error in hash merkle root.
 		{&merkleBlockOne, merkleBlockOneBytes, pver, 69, io.ErrShortWrite, io.EOF},
-		// Force error in hash merkle root.
-		{&merkleBlockOne, merkleBlockOneBytes, pver, 101, io.ErrShortWrite, io.EOF},
 		// Force error in accepted ID merkle root.
-		{&merkleBlockOne, merkleBlockOneBytes, pver, 133, io.ErrShortWrite, io.EOF},
+		{&merkleBlockOne, merkleBlockOneBytes, pver, 101, io.ErrShortWrite, io.EOF},
 		// Force error in utxo commitment.
-		{&merkleBlockOne, merkleBlockOneBytes, pver, 165, io.ErrShortWrite, io.EOF},
+		{&merkleBlockOne, merkleBlockOneBytes, pver, 133, io.ErrShortWrite, io.EOF},
 		// Force error in timestamp.
-		{&merkleBlockOne, merkleBlockOneBytes, pver, 197, io.ErrShortWrite, io.EOF},
+		{&merkleBlockOne, merkleBlockOneBytes, pver, 165, io.ErrShortWrite, io.EOF},
 		// Force error in difficulty bits.
-		{&merkleBlockOne, merkleBlockOneBytes, pver, 205, io.ErrShortWrite, io.EOF},
+		{&merkleBlockOne, merkleBlockOneBytes, pver, 173, io.ErrShortWrite, io.EOF},
 		// Force error in header nonce.
-		{&merkleBlockOne, merkleBlockOneBytes, pver, 209, io.ErrShortWrite, io.EOF},
+		{&merkleBlockOne, merkleBlockOneBytes, pver, 177, io.ErrShortWrite, io.EOF},
 		// Force error in transaction count.
-		{&merkleBlockOne, merkleBlockOneBytes, pver, 217, io.ErrShortWrite, io.EOF},
+		{&merkleBlockOne, merkleBlockOneBytes, pver, 185, io.ErrShortWrite, io.EOF},
 		// Force error in num hashes.
-		{&merkleBlockOne, merkleBlockOneBytes, pver, 221, io.ErrShortWrite, io.EOF},
+		{&merkleBlockOne, merkleBlockOneBytes, pver, 189, io.ErrShortWrite, io.EOF},
 		// Force error in hashes.
-		{&merkleBlockOne, merkleBlockOneBytes, pver, 222, io.ErrShortWrite, io.EOF},
+		{&merkleBlockOne, merkleBlockOneBytes, pver, 190, io.ErrShortWrite, io.EOF},
 		// Force error in num flag bytes.
-		{&merkleBlockOne, merkleBlockOneBytes, pver, 254, io.ErrShortWrite, io.EOF},
+		{&merkleBlockOne, merkleBlockOneBytes, pver, 222, io.ErrShortWrite, io.EOF},
 		// Force error in flag bytes.
-		{&merkleBlockOne, merkleBlockOneBytes, pver, 255, io.ErrShortWrite, io.EOF},
+		{&merkleBlockOne, merkleBlockOneBytes, pver, 223, io.ErrShortWrite, io.EOF},
 	}
 
 	t.Logf("Running %d tests", len(tests))
@@ -285,7 +279,7 @@ func TestMerkleBlockOverflowErrors(t *testing.T) {
 	// allowed tx hashes.
 	var buf bytes.Buffer
 	WriteVarInt(&buf, maxTxPerBlock+1)
-	numHashesOffset := 221
+	numHashesOffset := 189
 	exceedMaxHashes := make([]byte, numHashesOffset)
 	copy(exceedMaxHashes, merkleBlockOneBytes[:numHashesOffset])
 	spew.Dump(exceedMaxHashes)
@@ -295,7 +289,7 @@ func TestMerkleBlockOverflowErrors(t *testing.T) {
 	// allowed flag bytes.
 	buf.Reset()
 	WriteVarInt(&buf, maxFlagsPerMerkleBlock+1)
-	numFlagBytesOffset := 254
+	numFlagBytesOffset := 222
 	exceedMaxFlagBytes := make([]byte, numFlagBytesOffset)
 	copy(exceedMaxFlagBytes, merkleBlockOneBytes[:numFlagBytesOffset])
 	exceedMaxFlagBytes = append(exceedMaxFlagBytes, buf.Bytes()...)
@@ -337,7 +331,6 @@ var merkleBlockOne = MsgMerkleBlock{
 			0x7b, 0xa1, 0xa3, 0xc3, 0x54, 0x0b, 0xf7, 0xb1,
 			0xcd, 0xb6, 0x06, 0xe8, 0x57, 0x23, 0x3e, 0x0e,
 		},
-		IDMerkleRoot:         exampleIDMerkleRoot,
 		AcceptedIDMerkleRoot: exampleAcceptedIDMerkleRoot,
 		UTXOCommitment:       exampleUTXOCommitment,
 		Timestamp:            time.Unix(0x4966bc61, 0), // 2009-01-08 20:54:25 -0600 CST
@@ -361,10 +354,10 @@ var merkleBlockOne = MsgMerkleBlock{
 var merkleBlockOneBytes = []byte{
 	0x01, 0x00, 0x00, 0x00, // Version 1
 	0x02,                                           // NumParentBlocks
-	0x6f, 0xe2, 0x8c, 0x0a, 0xb6, 0xf1, 0xb3, 0x72, // mainNetGenesisHash
-	0xc1, 0xa6, 0xa2, 0x46, 0xae, 0x63, 0xf7, 0x4f,
-	0x93, 0x1e, 0x83, 0x65, 0xe1, 0x5a, 0x08, 0x9c,
-	0x68, 0xd6, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0xdc, 0x5f, 0x5b, 0x5b, 0x1d, 0xc2, 0xa7, 0x25, // mainNetGenesisHash
+	0x49, 0xd5, 0x1d, 0x4d, 0xee, 0xd7, 0xa4, 0x8b,
+	0xaf, 0xd3, 0x14, 0x4b, 0x56, 0x78, 0x98, 0xb1,
+	0x8c, 0xfd, 0x9f, 0x69, 0xdd, 0xcf, 0xbb, 0x63,
 	0xf6, 0x7a, 0xd7, 0x69, 0x5d, 0x9b, 0x66, 0x2a, // simNetGenesisHash
 	0x72, 0xff, 0x3d, 0x8e, 0xdb, 0xbb, 0x2d, 0xe0,
 	0xbf, 0xa6, 0x7b, 0x13, 0x97, 0x4b, 0xb9, 0x91,
@@ -373,10 +366,6 @@ var merkleBlockOneBytes = []byte{
 	0xbb, 0xbe, 0x68, 0x0e, 0x1f, 0xee, 0x14, 0x67,
 	0x7b, 0xa1, 0xa3, 0xc3, 0x54, 0x0b, 0xf7, 0xb1,
 	0xcd, 0xb6, 0x06, 0xe8, 0x57, 0x23, 0x3e, 0x0e,
-	0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63, // IDMerkleRoot
-	0x65, 0x9C, 0x79, 0x3C, 0xE3, 0x70, 0xD9, 0x5F,
-	0x09, 0x3B, 0xC7, 0xE3, 0x67, 0x11, 0x7B, 0x3C,
-	0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
 	0x09, 0x3B, 0xC7, 0xE3, 0x67, 0x11, 0x7B, 0x3C, // AcceptedIDMerkleRoot
 	0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
 	0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63,
diff --git a/wire/msgreject_test.go b/wire/msgreject_test.go
index c79ae115d..626e71514 100644
--- a/wire/msgreject_test.go
+++ b/wire/msgreject_test.go
@@ -174,10 +174,10 @@ func TestRejectWire(t *testing.T) {
 				0x12, // RejectDuplicate
 				0x0f, 0x64, 0x75, 0x70, 0x6c, 0x69, 0x63, 0x61,
 				0x74, 0x65, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, // "duplicate block"
-				0x6f, 0xe2, 0x8c, 0x0a, 0xb6, 0xf1, 0xb3, 0x72,
-				0xc1, 0xa6, 0xa2, 0x46, 0xae, 0x63, 0xf7, 0x4f,
-				0x93, 0x1e, 0x83, 0x65, 0xe1, 0x5a, 0x08, 0x9c,
-				0x68, 0xd6, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, // mainNetGenesisHash
+				0xdc, 0x5f, 0x5b, 0x5b, 0x1d, 0xc2, 0xa7, 0x25,
+				0x49, 0xd5, 0x1d, 0x4d, 0xee, 0xd7, 0xa4, 0x8b,
+				0xaf, 0xd3, 0x14, 0x4b, 0x56, 0x78, 0x98, 0xb1,
+				0x8c, 0xfd, 0x9f, 0x69, 0xdd, 0xcf, 0xbb, 0x63, // mainNetGenesisHash
 			},
 			ProtocolVersion,
 		},