Add the Data Availability Header to BlockID

blockchain/v0/reactor.go

@@ -382,10 +382,17 @@ FOR_LOOP:
 				didProcessCh <- struct{}{}
 			}
 
+			first.DataHash = nil
+			first.Hash()
+
 			var (
 				firstParts         = first.MakePartSet(types.BlockPartSizeBytes)
 				firstPartSetHeader = firstParts.Header()
-				firstID            = types.BlockID{Hash: first.Hash(), PartSetHeader: firstPartSetHeader}
+				firstID            = types.BlockID{
+					Hash:                   first.Hash(),
+					PartSetHeader:          firstPartSetHeader,
+					DataAvailabilityHeader: &first.DataAvailabilityHeader,
+				}
 			)
 
 			// Finally, verify the first block using the second's commit

blockchain/v0/reactor_test.go

@@ -99,7 +99,7 @@ func newBlockchainReactor(
 		lastCommit := types.NewCommit(
 			blockHeight-1,
 			0,
-			types.BlockID{DataAvailabilityHeader: types.MinDataAvailabilityHeader()},
+			types.EmptyBlockID(),
 			nil,
 		)
 		if blockHeight > 1 {
@@ -162,8 +162,6 @@ func TestNoBlockResponse(t *testing.T) {
 
 	}, p2p.Connect2Switches)
 
-	fmt.Println("after make conns", len(reactorPairs[0].reactor.pool.peers), len(reactorPairs[1].reactor.pool.peers))
-
 	defer func() {
 		for _, r := range reactorPairs {
 			err := r.reactor.Stop()
@@ -184,19 +182,29 @@ func TestNoBlockResponse(t *testing.T) {
 	}
 
 	for {
+		fmt.Println("is caught up?")
 		if reactorPairs[1].reactor.pool.IsCaughtUp() {
 			break
 		}
 
-		time.Sleep(1000 * time.Millisecond)
+		// The mutex is getting hit now, I don't know why
+
+		// fmt.Println(
+		// 	"ahead reactor peer count",
+		// 	// "is running", reactorPairs[0].reactor.pool.IsRunning(),
+		// 	len(reactorPairs[0].reactor.pool.peers),
+		// 	"behind reactor peer count",
+		// 	// "is running", reactorPairs[1].reactor.pool.IsRunning(),
+		// 	len(reactorPairs[1].reactor.pool.peers),
+		// )
+
+		time.Sleep(100 * time.Millisecond)
 	}
 
 	assert.Equal(t, maxBlockHeight, reactorPairs[0].reactor.store.Height())
 
-	for i, tt := range tests {
-		fmt.Println("test", i, "loading block")
+	for _, tt := range tests {
 		block := reactorPairs[1].reactor.store.LoadBlock(tt.height)
-		fmt.Println("finished loading block")
 		if tt.existent {
 			assert.True(t, block != nil)
 		} else {

consensus/byzantine_test.go

@@ -383,8 +383,12 @@ func byzantineDecideProposalFunc(t *testing.T, height int64, round int32, cs *St
 
 	// Create a new proposal block from state/txs from the mempool.
 	block1, blockParts1 := cs.createProposalBlock()
-	polRound, propBlockID := cs.ValidRound, types.BlockID{Hash: block1.Hash(), PartSetHeader: blockParts1.Header()}
-	proposal1 := types.NewProposal(height, round, polRound, propBlockID, &block1.DataAvailabilityHeader)
+	polRound, propBlockID := cs.ValidRound, types.BlockID{
+		Hash:                   block1.Hash(),
+		PartSetHeader:          blockParts1.Header(),
+		DataAvailabilityHeader: &block1.DataAvailabilityHeader,
+	}
+	proposal1 := types.NewProposal(height, round, polRound, propBlockID)
 	p1, err := proposal1.ToProto()
 	require.NoError(t, err)
 	if err := cs.privValidator.SignProposal(cs.state.ChainID, p1); err != nil {
@@ -398,8 +402,12 @@ func byzantineDecideProposalFunc(t *testing.T, height int64, round int32, cs *St
 
 	// Create a new proposal block from state/txs from the mempool.
 	block2, blockParts2 := cs.createProposalBlock()
-	polRound, propBlockID = cs.ValidRound, types.BlockID{Hash: block2.Hash(), PartSetHeader: blockParts2.Header()}
-	proposal2 := types.NewProposal(height, round, polRound, propBlockID, &block2.DataAvailabilityHeader)
+	polRound, propBlockID = cs.ValidRound, types.BlockID{
+		Hash:                   block2.Hash(),
+		PartSetHeader:          blockParts2.Header(),
+		DataAvailabilityHeader: &block2.DataAvailabilityHeader,
+	}
+	proposal2 := types.NewProposal(height, round, polRound, propBlockID)
 	p2, err := proposal2.ToProto()
 	require.NoError(t, err)
 	if err := cs.privValidator.SignProposal(cs.state.ChainID, p2); err != nil {

consensus/common_test.go

@@ -86,10 +86,7 @@ func newValidatorStub(privValidator types.PrivValidator, valIndex int32) *valida
 	}
 }
 
-func (vs *validatorStub) signVote(
-	voteType tmproto.SignedMsgType,
-	hash []byte,
-	header types.PartSetHeader) (*types.Vote, error) {
+func (vs *validatorStub) signVote(voteType tmproto.SignedMsgType, blockID types.BlockID) (*types.Vote, error) {
 
 	pubKey, err := vs.PrivValidator.GetPubKey()
 	if err != nil {
@@ -103,7 +100,7 @@ func (vs *validatorStub) signVote(
 		Round:            vs.Round,
 		Timestamp:        tmtime.Now(),
 		Type:             voteType,
-		BlockID:          types.BlockID{Hash: hash, PartSetHeader: header},
+		BlockID:          blockID,
 	}
 	v := vote.ToProto()
 	err = vs.PrivValidator.SignVote(config.ChainID(), v)
@@ -113,8 +110,8 @@ func (vs *validatorStub) signVote(
 }
 
 // Sign vote for type/hash/header
-func signVote(vs *validatorStub, voteType tmproto.SignedMsgType, hash []byte, header types.PartSetHeader) *types.Vote {
-	v, err := vs.signVote(voteType, hash, header)
+func signVote(vs *validatorStub, voteType tmproto.SignedMsgType, blockID types.BlockID) *types.Vote {
+	v, err := vs.signVote(voteType, blockID)
 	if err != nil {
 		panic(fmt.Errorf("failed to sign vote: %v", err))
 	}
@@ -123,12 +120,11 @@ func signVote(vs *validatorStub, voteType tmproto.SignedMsgType, hash []byte, he
 
 func signVotes(
 	voteType tmproto.SignedMsgType,
-	hash []byte,
-	header types.PartSetHeader,
+	blockID types.BlockID,
 	vss ...*validatorStub) []*types.Vote {
 	votes := make([]*types.Vote, len(vss))
 	for i, vs := range vss {
-		votes[i] = signVote(vs, voteType, hash, header)
+		votes[i] = signVote(vs, voteType, blockID)
 	}
 	return votes
 }
@@ -200,8 +196,12 @@ func decideProposal(
 	}
 
 	// Make proposal
-	polRound, propBlockID := validRound, types.BlockID{Hash: block.Hash(), PartSetHeader: blockParts.Header()}
-	proposal = types.NewProposal(height, round, polRound, propBlockID, &block.DataAvailabilityHeader)
+	polRound, propBlockID := validRound, types.BlockID{
+		Hash:                   block.Hash(),
+		PartSetHeader:          blockParts.Header(),
+		DataAvailabilityHeader: &block.DataAvailabilityHeader,
+	}
+	proposal = types.NewProposal(height, round, polRound, propBlockID)
 	p, err := proposal.ToProto()
 	if err != nil {
 		panic(err)
@@ -224,11 +224,10 @@ func addVotes(to *State, votes ...*types.Vote) {
 func signAddVotes(
 	to *State,
 	voteType tmproto.SignedMsgType,
-	hash []byte,
-	header types.PartSetHeader,
+	blockID types.BlockID,
 	vss ...*validatorStub,
 ) {
-	votes := signVotes(voteType, hash, header, vss...)
+	votes := signVotes(voteType, blockID, vss...)
 	addVotes(to, votes...)
 }
 

consensus/replay_test.go

@@ -351,7 +351,12 @@ func TestSimulateValidatorsChange(t *testing.T) {
 	ensureNewRound(newRoundCh, height, 0)
 	ensureNewProposal(proposalCh, height, round)
 	rs := css[0].GetRoundState()
-	signAddVotes(css[0], tmproto.PrecommitType, rs.ProposalBlock.Hash(), rs.ProposalBlockParts.Header(), vss[1:nVals]...)
+	propBlockID := types.BlockID{
+		Hash:                   rs.ProposalBlock.Hash(),
+		PartSetHeader:          rs.ProposalBlockParts.Header(),
+		DataAvailabilityHeader: &rs.ProposalBlock.DataAvailabilityHeader,
+	}
+	signAddVotes(css[0], tmproto.PrecommitType, propBlockID, vss[1:nVals]...)
 	ensureNewRound(newRoundCh, height+1, 0)
 
 	// HEIGHT 2
@@ -366,9 +371,13 @@ func TestSimulateValidatorsChange(t *testing.T) {
 	assert.Nil(t, err)
 	propBlock, _ := css[0].createProposalBlock() // changeProposer(t, cs1, vs2)
 	propBlockParts := propBlock.MakePartSet(partSize)
-	blockID := types.BlockID{Hash: propBlock.Hash(), PartSetHeader: propBlockParts.Header()}
+	blockID := types.BlockID{
+		Hash:                   propBlock.Hash(),
+		PartSetHeader:          propBlockParts.Header(),
+		DataAvailabilityHeader: &propBlock.DataAvailabilityHeader,
+	}
 
-	proposal := types.NewProposal(vss[1].Height, round, -1, blockID, &propBlock.DataAvailabilityHeader)
+	proposal := types.NewProposal(vss[1].Height, round, -1, blockID)
 	p, err := proposal.ToProto()
 	require.NoError(t, err)
 	if err := vss[1].SignProposal(config.ChainID(), p); err != nil {
@@ -382,7 +391,14 @@ func TestSimulateValidatorsChange(t *testing.T) {
 	}
 	ensureNewProposal(proposalCh, height, round)
 	rs = css[0].GetRoundState()
-	signAddVotes(css[0], tmproto.PrecommitType, rs.ProposalBlock.Hash(), rs.ProposalBlockParts.Header(), vss[1:nVals]...)
+
+	propBlockID = types.BlockID{
+		Hash:                   rs.ProposalBlock.Hash(),
+		PartSetHeader:          rs.ProposalBlockParts.Header(),
+		DataAvailabilityHeader: &rs.ProposalBlock.DataAvailabilityHeader,
+	}
+
+	signAddVotes(css[0], tmproto.PrecommitType, propBlockID, vss[1:nVals]...)
 	ensureNewRound(newRoundCh, height+1, 0)
 
 	// HEIGHT 3
@@ -397,9 +413,13 @@ func TestSimulateValidatorsChange(t *testing.T) {
 	assert.Nil(t, err)
 	propBlock, _ = css[0].createProposalBlock() // changeProposer(t, cs1, vs2)
 	propBlockParts = propBlock.MakePartSet(partSize)
-	blockID = types.BlockID{Hash: propBlock.Hash(), PartSetHeader: propBlockParts.Header()}
+	blockID = types.BlockID{
+		Hash:                   propBlock.Hash(),
+		PartSetHeader:          propBlockParts.Header(),
+		DataAvailabilityHeader: &propBlock.DataAvailabilityHeader,
+	}
 
-	proposal = types.NewProposal(vss[2].Height, round, -1, blockID, &propBlock.DataAvailabilityHeader)
+	proposal = types.NewProposal(vss[2].Height, round, -1, blockID)
 	p, err = proposal.ToProto()
 	require.NoError(t, err)
 	if err := vss[2].SignProposal(config.ChainID(), p); err != nil {
@@ -413,7 +433,14 @@ func TestSimulateValidatorsChange(t *testing.T) {
 	}
 	ensureNewProposal(proposalCh, height, round)
 	rs = css[0].GetRoundState()
-	signAddVotes(css[0], tmproto.PrecommitType, rs.ProposalBlock.Hash(), rs.ProposalBlockParts.Header(), vss[1:nVals]...)
+
+	propBlockID = types.BlockID{
+		Hash:                   rs.ProposalBlock.Hash(),
+		PartSetHeader:          rs.ProposalBlockParts.Header(),
+		DataAvailabilityHeader: &rs.ProposalBlock.DataAvailabilityHeader,
+	}
+
+	signAddVotes(css[0], tmproto.PrecommitType, propBlockID, vss[1:nVals]...)
 	ensureNewRound(newRoundCh, height+1, 0)
 
 	// HEIGHT 4
@@ -435,7 +462,11 @@ func TestSimulateValidatorsChange(t *testing.T) {
 	assert.Nil(t, err)
 	propBlock, _ = css[0].createProposalBlock() // changeProposer(t, cs1, vs2)
 	propBlockParts = propBlock.MakePartSet(partSize)
-	blockID = types.BlockID{Hash: propBlock.Hash(), PartSetHeader: propBlockParts.Header()}
+	blockID = types.BlockID{
+		Hash:                   propBlock.Hash(),
+		PartSetHeader:          propBlockParts.Header(),
+		DataAvailabilityHeader: &propBlock.DataAvailabilityHeader,
+	}
 	newVss := make([]*validatorStub, nVals+1)
 	copy(newVss, vss[:nVals+1])
 	sort.Sort(ValidatorStubsByPower(newVss))
@@ -457,7 +488,7 @@ func TestSimulateValidatorsChange(t *testing.T) {
 
 	selfIndex := valIndexFn(0)
 
-	proposal = types.NewProposal(vss[3].Height, round, -1, blockID, &propBlock.DataAvailabilityHeader)
+	proposal = types.NewProposal(vss[3].Height, round, -1, blockID)
 	p, err = proposal.ToProto()
 	require.NoError(t, err)
 	if err := vss[3].SignProposal(config.ChainID(), p); err != nil {
@@ -476,11 +507,16 @@ func TestSimulateValidatorsChange(t *testing.T) {
 	assert.Nil(t, err)
 
 	rs = css[0].GetRoundState()
+	blockID = types.BlockID{
+		Hash:                   rs.ProposalBlock.Hash(),
+		PartSetHeader:          rs.ProposalBlockParts.Header(),
+		DataAvailabilityHeader: &rs.ProposalBlock.DataAvailabilityHeader,
+	}
 	for i := 0; i < nVals+1; i++ {
 		if i == selfIndex {
 			continue
 		}
-		signAddVotes(css[0], tmproto.PrecommitType, rs.ProposalBlock.Hash(), rs.ProposalBlockParts.Header(), newVss[i])
+		signAddVotes(css[0], tmproto.PrecommitType, blockID, newVss[i])
 	}
 
 	ensureNewRound(newRoundCh, height+1, 0)
@@ -495,11 +531,16 @@ func TestSimulateValidatorsChange(t *testing.T) {
 	selfIndex = valIndexFn(0)
 	ensureNewProposal(proposalCh, height, round)
 	rs = css[0].GetRoundState()
+	blockID = types.BlockID{
+		Hash:                   rs.ProposalBlock.Hash(),
+		PartSetHeader:          rs.ProposalBlockParts.Header(),
+		DataAvailabilityHeader: &rs.ProposalBlock.DataAvailabilityHeader,
+	}
 	for i := 0; i < nVals+1; i++ {
 		if i == selfIndex {
 			continue
 		}
-		signAddVotes(css[0], tmproto.PrecommitType, rs.ProposalBlock.Hash(), rs.ProposalBlockParts.Header(), newVss[i])
+		signAddVotes(css[0], tmproto.PrecommitType, blockID, newVss[i])
 	}
 	ensureNewRound(newRoundCh, height+1, 0)
 
@@ -511,13 +552,17 @@ func TestSimulateValidatorsChange(t *testing.T) {
 	assert.Nil(t, err)
 	propBlock, _ = css[0].createProposalBlock() // changeProposer(t, cs1, vs2)
 	propBlockParts = propBlock.MakePartSet(partSize)
-	blockID = types.BlockID{Hash: propBlock.Hash(), PartSetHeader: propBlockParts.Header()}
+	blockID = types.BlockID{
+		Hash:                   propBlock.Hash(),
+		PartSetHeader:          propBlockParts.Header(),
+		DataAvailabilityHeader: &propBlock.DataAvailabilityHeader,
+	}
 	newVss = make([]*validatorStub, nVals+3)
 	copy(newVss, vss[:nVals+3])
 	sort.Sort(ValidatorStubsByPower(newVss))
 
 	selfIndex = valIndexFn(0)
-	proposal = types.NewProposal(vss[1].Height, round, -1, blockID, &propBlock.DataAvailabilityHeader)
+	proposal = types.NewProposal(vss[1].Height, round, -1, blockID)
 	p, err = proposal.ToProto()
 	require.NoError(t, err)
 	if err := vss[1].SignProposal(config.ChainID(), p); err != nil {
@@ -531,11 +576,16 @@ func TestSimulateValidatorsChange(t *testing.T) {
 	}
 	ensureNewProposal(proposalCh, height, round)
 	rs = css[0].GetRoundState()
+	blockID = types.BlockID{
+		Hash:                   rs.ProposalBlock.Hash(),
+		PartSetHeader:          rs.ProposalBlockParts.Header(),
+		DataAvailabilityHeader: &rs.ProposalBlock.DataAvailabilityHeader,
+	}
 	for i := 0; i < nVals+3; i++ {
 		if i == selfIndex {
 			continue
 		}
-		signAddVotes(css[0], tmproto.PrecommitType, rs.ProposalBlock.Hash(), rs.ProposalBlockParts.Header(), newVss[i])
+		signAddVotes(css[0], tmproto.PrecommitType, blockID, newVss[i])
 	}
 	ensureNewRound(newRoundCh, height+1, 0)
 
@@ -785,7 +835,11 @@ func applyBlock(stateStore sm.Store, st sm.State, blk *types.Block, proxyApp pro
 	testPartSize := types.BlockPartSizeBytes
 	blockExec := sm.NewBlockExecutor(stateStore, log.TestingLogger(), proxyApp.Consensus(), mempool, evpool)
 
-	blkID := types.BlockID{Hash: blk.Hash(), PartSetHeader: blk.MakePartSet(testPartSize).Header()}
+	blkID := types.BlockID{
+		Hash:                   blk.Hash(),
+		PartSetHeader:          blk.MakePartSet(testPartSize).Header(),
+		DataAvailabilityHeader: &blk.DataAvailabilityHeader,
+	}
 	newState, _, err := blockExec.ApplyBlock(st, blkID, blk)
 	if err != nil {
 		panic(err)
@@ -983,7 +1037,7 @@ func makeBlocks(n int, state *sm.State, privVal types.PrivValidator) []*types.Bl
 func makeBlock(state sm.State, lastBlock *types.Block, lastBlockMeta *types.BlockMeta,
 	privVal types.PrivValidator, height int64) (*types.Block, *types.PartSet) {
 
-	lastCommit := types.NewCommit(height-1, 0, types.BlockID{}, nil)
+	lastCommit := types.NewCommit(height-1, 0, types.EmptyBlockID(), nil)
 	if height > 1 {
 		vote, _ := types.MakeVote(
 			lastBlock.Header.Height,
@@ -1199,8 +1253,12 @@ func (bs *mockBlockStore) LoadBlockByHash(hash []byte) *types.Block {
 func (bs *mockBlockStore) LoadBlockMeta(height int64) *types.BlockMeta {
 	block := bs.chain[height-1]
 	return &types.BlockMeta{
-		BlockID: types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(types.BlockPartSizeBytes).Header()},
-		Header:  block.Header,
+		BlockID: types.BlockID{
+			Hash:                   block.Hash(),
+			PartSetHeader:          block.MakePartSet(types.BlockPartSizeBytes).Header(),
+			DataAvailabilityHeader: &block.DataAvailabilityHeader,
+		},
+		Header: block.Header,
 	}
 }
 func (bs *mockBlockStore) LoadBlockPart(height int64, index int) *types.Part { return nil }