Add the Data Availability Header to BlockID

blockchain/msgs_test.go

@@ -80,7 +80,18 @@ func TestBcStatusResponseMessageValidateBasic(t *testing.T) {
 
 // nolint:lll // ignore line length in tests
 func TestBlockchainMessageVectors(t *testing.T) {
-	block := types.MakeBlock(int64(3), []types.Tx{types.Tx("Hello World")}, nil, nil, types.Messages{}, nil)
+	block := types.MakeBlock(
+		int64(3),
+		[]types.Tx{types.Tx("Hello World")},
+		nil,
+		nil,
+		types.Messages{},
+		&types.Commit{
+			BlockID: types.BlockID{
+				DataAvailabilityHeader: types.MinDataAvailabilityHeader(),
+			},
+		},
+	)
 	block.Version.Block = 11 // overwrite updated protocol version
 
 	bpb, err := block.ToProto()
@@ -97,7 +108,7 @@ func TestBlockchainMessageVectors(t *testing.T) {
 			BlockRequest: &bcproto.BlockRequest{Height: math.MaxInt64}}},
 			"0a0a08ffffffffffffffff7f"},
 		{"BlockResponseMessage", &bcproto.Message{Sum: &bcproto.Message_BlockResponse{
-			BlockResponse: &bcproto.BlockResponse{Block: bpb}}}, "1ac2020abf020a5d0a02080b1803220b088092b8c398feffffff012a021200380142204c149a7cfadc92b669b0cbfa4951a1b18c2d9f3177a3b8756d39ebb96e9d63317220e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b85512130a0b48656c6c6f20576f726c6412001a0022001ac8010a3000000000000000010000000000000001b81cb5596c28d044214b9f935e4af7dbe76e417f6182d86fbee68bfff7b2ff3a0a30ffffffffffffffffffffffffffffffffc4096ba8fccf882c309896e9168fa43fe62fccb752cb12d5160cc1d9c2ebffe7123000000000000000010000000000000001b81cb5596c28d044214b9f935e4af7dbe76e417f6182d86fbee68bfff7b2ff3a1230ffffffffffffffffffffffffffffffffc4096ba8fccf882c309896e9168fa43fe62fccb752cb12d5160cc1d9c2ebffe7"},
+			BlockResponse: &bcproto.BlockResponse{Block: bpb}}}, "1a84060a81060acb020a02080b1803220b088092b8c398feffffff012acd0112001ac8010a30fffffffffffffffefffffffffffffffe669aa8f0d85221a05b6f0917884d30616a6c7d5330a5640a08a04dcc5b092f4f0a30ffffffffffffffffffffffffffffffff293437f3b6a5611e25c90d5a44b84cc4b3720cdba68553defe8b719af1f5c3951230fffffffffffffffefffffffffffffffe669aa8f0d85221a05b6f0917884d30616a6c7d5330a5640a08a04dcc5b092f4f1230ffffffffffffffffffffffffffffffff293437f3b6a5611e25c90d5a44b84cc4b3720cdba68553defe8b719af1f5c3953220e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855380142204c149a7cfadc92b669b0cbfa4951a1b18c2d9f3177a3b8756d39ebb96e9d63317220e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b85512130a0b48656c6c6f20576f726c6412001a0022001ac8010a3000000000000000010000000000000001b81cb5596c28d044214b9f935e4af7dbe76e417f6182d86fbee68bfff7b2ff3a0a30ffffffffffffffffffffffffffffffffc4096ba8fccf882c309896e9168fa43fe62fccb752cb12d5160cc1d9c2ebffe7123000000000000000010000000000000001b81cb5596c28d044214b9f935e4af7dbe76e417f6182d86fbee68bfff7b2ff3a1230ffffffffffffffffffffffffffffffffc4096ba8fccf882c309896e9168fa43fe62fccb752cb12d5160cc1d9c2ebffe722d0011acd0112001ac8010a30fffffffffffffffefffffffffffffffe669aa8f0d85221a05b6f0917884d30616a6c7d5330a5640a08a04dcc5b092f4f0a30ffffffffffffffffffffffffffffffff293437f3b6a5611e25c90d5a44b84cc4b3720cdba68553defe8b719af1f5c3951230fffffffffffffffefffffffffffffffe669aa8f0d85221a05b6f0917884d30616a6c7d5330a5640a08a04dcc5b092f4f1230ffffffffffffffffffffffffffffffff293437f3b6a5611e25c90d5a44b84cc4b3720cdba68553defe8b719af1f5c395"},
 		{"NoBlockResponseMessage", &bcproto.Message{Sum: &bcproto.Message_NoBlockResponse{
 			NoBlockResponse: &bcproto.NoBlockResponse{Height: 1}}}, "12020801"},
 		{"NoBlockResponseMessage", &bcproto.Message{Sum: &bcproto.Message_NoBlockResponse{

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

@@ -96,7 +96,12 @@ func newBlockchainReactor(
 
 	// let's add some blocks in
 	for blockHeight := int64(1); blockHeight <= maxBlockHeight; blockHeight++ {
-		lastCommit := types.NewCommit(blockHeight-1, 0, types.BlockID{}, nil)
+		lastCommit := types.NewCommit(
+			blockHeight-1,
+			0,
+			types.EmptyBlockID(),
+			nil,
+		)
 		if blockHeight > 1 {
 			lastBlockMeta := blockStore.LoadBlockMeta(blockHeight - 1)
 			lastBlock := blockStore.LoadBlock(blockHeight - 1)
@@ -117,10 +122,14 @@ func newBlockchainReactor(
 		}
 
 		thisBlock := makeBlock(blockHeight, state, lastCommit)
+		thisBlock.Hash()
 
 		thisParts := thisBlock.MakePartSet(types.BlockPartSizeBytes)
-		blockID := types.BlockID{Hash: thisBlock.Hash(), PartSetHeader: thisParts.Header()}
-
+		blockID := types.BlockID{
+			Hash:                   thisBlock.Hash(),
+			PartSetHeader:          thisParts.Header(),
+			DataAvailabilityHeader: &thisBlock.DataAvailabilityHeader,
+		}
 		state, _, err = blockExec.ApplyBlock(state, blockID, thisBlock)
 		if err != nil {
 			panic(fmt.Errorf("error apply block: %w", err))
@@ -173,11 +182,23 @@ func TestNoBlockResponse(t *testing.T) {
 	}
 
 	for {
+		fmt.Println("is caught up?")
 		if reactorPairs[1].reactor.pool.IsCaughtUp() {
 			break
 		}
 
-		time.Sleep(10 * 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())
@@ -295,6 +316,8 @@ func makeTxs(height int64) (txs []types.Tx) {
 func makeBlock(height int64, state sm.State, lastCommit *types.Commit) *types.Block {
 	block, _ := state.MakeBlock(height, makeTxs(height), nil,
 		nil, types.Messages{}, lastCommit, state.Validators.GetProposer().Address)
+
+	block.LastBlockID = lastCommit.BlockID
 	return block
 }
 

consensus/byzantine_test.go

@@ -131,9 +131,18 @@ func TestByzantinePrevoteEquivocation(t *testing.T) {
 		// allow first height to happen normally so that byzantine validator is no longer proposer
 		if height == prevoteHeight {
 			bcs.Logger.Info("Sending two votes")
-			prevote1, err := bcs.signVote(tmproto.PrevoteType, bcs.ProposalBlock.Hash(), bcs.ProposalBlockParts.Header())
+			prevote1, err := bcs.signVote(tmproto.PrevoteType,
+				types.BlockID{
+					Hash:                   bcs.ProposalBlock.Hash(),
+					PartSetHeader:          bcs.ProposalBlockParts.Header(),
+					DataAvailabilityHeader: &bcs.ProposalBlock.DataAvailabilityHeader,
+				},
+			)
 			require.NoError(t, err)
-			prevote2, err := bcs.signVote(tmproto.PrevoteType, nil, types.PartSetHeader{})
+			prevote2, err := bcs.signVote(
+				tmproto.PrevoteType,
+				types.EmptyBlockID(),
+			)
 			require.NoError(t, err)
 			peerList := reactors[byzantineNode].Switch.Peers().List()
 			bcs.Logger.Info("Getting peer list", "peers", peerList)
@@ -374,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 {
@@ -389,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 {
@@ -407,9 +424,29 @@ func byzantineDecideProposalFunc(t *testing.T, height int64, round int32, cs *St
 	t.Logf("Byzantine: broadcasting conflicting proposals to %d peers", len(peers))
 	for i, peer := range peers {
 		if i < len(peers)/2 {
-			go sendProposalAndParts(height, round, cs, peer, proposal1, block1Hash, blockParts1)
+			go sendProposalAndParts(
+				height,
+				round,
+				cs,
+				peer,
+				proposal1,
+				block1Hash,
+				blockParts1,
+				&block1.DataAvailabilityHeader,
+			)
+
 		} else {
-			go sendProposalAndParts(height, round, cs, peer, proposal2, block2Hash, blockParts2)
+			go sendProposalAndParts(
+				height,
+				round,
+				cs,
+				peer,
+				proposal2,
+				block2Hash,
+				blockParts2,
+				&block2.DataAvailabilityHeader,
+			)
+
 		}
 	}
 }
@@ -422,6 +459,7 @@ func sendProposalAndParts(
 	proposal *types.Proposal,
 	blockHash []byte,
 	parts *types.PartSet,
+	dah *types.DataAvailabilityHeader,
 ) {
 	// proposal
 	msg := &ProposalMessage{Proposal: proposal}
@@ -440,8 +478,13 @@ func sendProposalAndParts(
 
 	// votes
 	cs.mtx.Lock()
-	prevote, _ := cs.signVote(tmproto.PrevoteType, blockHash, parts.Header())
-	precommit, _ := cs.signVote(tmproto.PrecommitType, blockHash, parts.Header())
+	blockID := types.BlockID{
+		Hash:                   blockHash,
+		PartSetHeader:          parts.Header(),
+		DataAvailabilityHeader: dah,
+	}
+	prevote, _ := cs.signVote(tmproto.PrevoteType, blockID)
+	precommit, _ := cs.signVote(tmproto.PrecommitType, blockID)
 	cs.mtx.Unlock()
 
 	peer.Send(VoteChannel, MustEncode(&VoteMessage{prevote}))

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...)
 }