add logic to propagate extended commits (#8433)

2026-02-08 04:50:16 +00:00 · 2022-10-24 12:30:52 +02:00
parent c095798bd9
commit 574fc51efa
16 changed files with 345 additions and 161 deletions
--- a/blocksync/pool.go
+++ b/blocksync/pool.go
@@ -185,16 +185,20 @@ func (pool *BlockPool) IsCaughtUp() bool {
 	return isCaughtUp
 }

-// PeekTwoBlocks returns blocks at pool.height and pool.height+1.
-// We need to see the second block's Commit to validate the first block.
-// So we peek two blocks at a time.
+// PeekTwoBlocks returns blocks at pool.height and pool.height+1. We need to
+// see the second block's Commit to validate the first block. So we peek two
+// blocks at a time. We return an extended commit, containing vote extensions
+// and their associated signatures, as this is critical to consensus in ABCI++
+// as we switch from block sync to consensus mode.
+//
 // The caller will verify the commit.
-func (pool *BlockPool) PeekTwoBlocks() (first *types.Block, second *types.Block) {
+func (pool *BlockPool) PeekTwoBlocks() (first, second *types.Block, firstExtCommit *types.ExtendedCommit) {
 	pool.mtx.Lock()
 	defer pool.mtx.Unlock()

 	if r := pool.requesters[pool.height]; r != nil {
 		first = r.getBlock()
+		firstExtCommit = r.getExtendedCommit()
 	}
 	if r := pool.requesters[pool.height+1]; r != nil {
 		second = r.getBlock()
@@ -203,7 +207,8 @@ func (pool *BlockPool) PeekTwoBlocks() (first *types.Block, second *types.Block)
 }

 // PopRequest pops the first block at pool.height.
-// It must have been validated by 'second'.Commit from PeekTwoBlocks().
+// It must have been validated by the second Commit from PeekTwoBlocks.
+// TODO(thane): (?) and its corresponding ExtendedCommit.
 func (pool *BlockPool) PopRequest() {
 	pool.mtx.Lock()
 	defer pool.mtx.Unlock()
@@ -240,12 +245,22 @@ func (pool *BlockPool) RedoRequest(height int64) p2p.ID {
 	return peerID
 }

-// AddBlock validates that the block comes from the peer it was expected from and calls the requester to store it.
-// TODO: ensure that blocks come in order for each peer.
-func (pool *BlockPool) AddBlock(peerID p2p.ID, block *types.Block, blockSize int) {
+// AddBlock validates that the block comes from the peer it was expected from
+// and calls the requester to store it.
+//
+// This requires an extended commit at the same height as the supplied block -
+// the block contains the last commit, but we need the latest commit in case we
+// need to switch over from block sync to consensus at this height. If the
+// height of the extended commit and the height of the block do not match, we
+// do not add the block and return an error.
+func (pool *BlockPool) AddBlock(peerID p2p.ID, block *types.Block, extCommit *types.ExtendedCommit, blockSize int) error {
 	pool.mtx.Lock()
 	defer pool.mtx.Unlock()

+	if block.Height != extCommit.Height {
+		return fmt.Errorf("heights don't match, not adding block (block height: %d, commit height: %d)", block.Height, extCommit.Height)
+	}
+
 	requester := pool.requesters[block.Height]
 	if requester == nil {
 		pool.Logger.Info(
@@ -263,19 +278,22 @@ func (pool *BlockPool) AddBlock(peerID p2p.ID, block *types.Block, blockSize int
 		if diff > maxDiffBetweenCurrentAndReceivedBlockHeight {
 			pool.sendError(errors.New("peer sent us a block we didn't expect with a height too far ahead/behind"), peerID)
 		}
-		return
+		return fmt.Errorf("peer sent us a block we didn't expect (peer: %s, current height: %d, block height: %d)", peerID, pool.height, block.Height)
 	}

-	if requester.setBlock(block, peerID) {
+	if requester.setBlock(block, extCommit, peerID) {
 		atomic.AddInt32(&pool.numPending, -1)
 		peer := pool.peers[peerID]
 		if peer != nil {
 			peer.decrPending(blockSize)
 		}
 	} else {
-		pool.Logger.Info("invalid peer", "peer", peerID, "blockHeight", block.Height)
-		pool.sendError(errors.New("invalid peer"), peerID)
+		err := errors.New("requester is different or block already exists")
+		pool.sendError(err, peerID)
+		return fmt.Errorf("%w (peer: %s, requester: %s, block height: %d)", err, peerID, requester.getPeerID(), block.Height)
 	}
+
+	return nil
 }

 // MaxPeerHeight returns the highest reported height.
@@ -424,6 +442,7 @@ func (pool *BlockPool) debug() string {
 		} else {
 			str += fmt.Sprintf("H(%v):", h)
 			str += fmt.Sprintf("B?(%v) ", pool.requesters[h].block != nil)
+			str += fmt.Sprintf("C?(%v) ", pool.requesters[h].extCommit != nil)
 		}
 	}
 	return str
@@ -512,9 +531,10 @@ type bpRequester struct {
 	gotBlockCh chan struct{}
 	redoCh     chan p2p.ID // redo may send multitime, add peerId to identify repeat

-	mtx    tmsync.Mutex
-	peerID p2p.ID
-	block  *types.Block
+	mtx       tmsync.Mutex
+	peerID    p2p.ID
+	block     *types.Block
+	extCommit *types.ExtendedCommit
 }

 func newBPRequester(pool *BlockPool, height int64) *bpRequester {
@@ -537,13 +557,14 @@ func (bpr *bpRequester) OnStart() error {
 }

 // Returns true if the peer matches and block doesn't already exist.
-func (bpr *bpRequester) setBlock(block *types.Block, peerID p2p.ID) bool {
+func (bpr *bpRequester) setBlock(block *types.Block, extCommit *types.ExtendedCommit, peerID p2p.ID) bool {
 	bpr.mtx.Lock()
 	if bpr.block != nil || bpr.peerID != peerID {
 		bpr.mtx.Unlock()
 		return false
 	}
 	bpr.block = block
+	bpr.extCommit = extCommit
 	bpr.mtx.Unlock()

 	select {
@@ -559,6 +580,12 @@ func (bpr *bpRequester) getBlock() *types.Block {
 	return bpr.block
 }

+func (bpr *bpRequester) getExtendedCommit() *types.ExtendedCommit {
+	bpr.mtx.Lock()
+	defer bpr.mtx.Unlock()
+	return bpr.extCommit
+}
+
 func (bpr *bpRequester) getPeerID() p2p.ID {
 	bpr.mtx.Lock()
 	defer bpr.mtx.Unlock()
@@ -576,6 +603,7 @@ func (bpr *bpRequester) reset() {

 	bpr.peerID = ""
 	bpr.block = nil
+	bpr.extCommit = nil
 }

 // Tells bpRequester to pick another peer and try again.
--- a/blocksync/pool_test.go
+++ b/blocksync/pool_test.go
@@ -42,7 +42,10 @@ func (p testPeer) runInputRoutine() {
 // Request desired, pretend like we got the block immediately.
 func (p testPeer) simulateInput(input inputData) {
 	block := &types.Block{Header: types.Header{Height: input.request.Height}}
-	input.pool.AddBlock(input.request.PeerID, block, 123)
+	extCommit := &types.ExtendedCommit{
+		Height: input.request.Height,
+	}
+	_ = input.pool.AddBlock(input.request.PeerID, block, extCommit, 123)
 	// TODO: uncommenting this creates a race which is detected by:
 	// https://github.com/golang/go/blob/2bd767b1022dd3254bcec469f0ee164024726486/src/testing/testing.go#L854-L856
 	// see: https://github.com/tendermint/tendermint/issues/3390#issue-418379890
@@ -112,7 +115,7 @@ func TestBlockPoolBasic(t *testing.T) {
 			if !pool.IsRunning() {
 				return
 			}
-			first, second := pool.PeekTwoBlocks()
+			first, second, _ := pool.PeekTwoBlocks()
 			if first != nil && second != nil {
 				pool.PopRequest()
 			} else {
@@ -171,7 +174,7 @@ func TestBlockPoolTimeout(t *testing.T) {
 			if !pool.IsRunning() {
 				return
 			}
-			first, second := pool.PeekTwoBlocks()
+			first, second, _ := pool.PeekTwoBlocks()
 			if first != nil && second != nil {
 				pool.PopRequest()
 			} else {
--- a/blocksync/reactor.go
+++ b/blocksync/reactor.go
@@ -52,7 +52,7 @@ type Reactor struct {
 	initialState sm.State

 	blockExec *sm.BlockExecutor
-	store     *store.BlockStore
+	store     sm.BlockStore
 	pool      *BlockPool
 	blockSync bool

@@ -172,34 +172,44 @@ func (bcR *Reactor) RemovePeer(peer p2p.Peer, reason interface{}) {
 // respondToPeer loads a block and sends it to the requesting peer,
 // if we have it. Otherwise, we'll respond saying we don't have it.
 func (bcR *Reactor) respondToPeer(msg *bcproto.BlockRequest,
-	src p2p.Peer) (queued bool) {
+	src p2p.Peer) error {

 	block := bcR.store.LoadBlock(msg.Height)
 	if block != nil {
+		extCommit := bcR.store.LoadBlockExtendedCommit(msg.Height)
+		if extCommit == nil {
+			return fmt.Errorf("found block in store without extended commit: %v", block)
+		}
 		bl, err := block.ToProto()
 		if err != nil {
-			bcR.Logger.Error("could not convert msg to protobuf", "err", err)
-			return false
+			return fmt.Errorf("failed to convert block to protobuf: %w", err)
 		}

-		msgBytes, err := EncodeMsg(&bcproto.BlockResponse{Block: bl})
+		msgBytes, err := EncodeMsg(&bcproto.BlockResponse{
+			Block:     bl,
+			ExtCommit: extCommit.ToProto(),
+		})
 		if err != nil {
-			bcR.Logger.Error("could not marshal msg", "err", err)
-			return false
+			return fmt.Errorf("could not marshal msg: %w", err)
 		}

-		return src.TrySend(BlocksyncChannel, msgBytes)
+		if !src.TrySend(BlocksyncChannel, msgBytes) {
+			return fmt.Errorf("unable to queue blocksync message at height %d to peer %v", msg.Height, src)
+		}
+		return nil
 	}

 	bcR.Logger.Info("Peer asking for a block we don't have", "src", src, "height", msg.Height)

 	msgBytes, err := EncodeMsg(&bcproto.NoBlockResponse{Height: msg.Height})
 	if err != nil {
-		bcR.Logger.Error("could not convert msg to protobuf", "err", err)
-		return false
+		return fmt.Errorf("could not convert msg to protobuf: %w", err)
 	}

-	return src.TrySend(BlocksyncChannel, msgBytes)
+	if !src.TrySend(BlocksyncChannel, msgBytes) {
+		return fmt.Errorf("unable to queue blocksync message at height %d to peer %v", msg.Height, src)
+	}
+	return nil
 }

 // Receive implements Reactor by handling 4 types of messages (look below).
@@ -223,12 +233,22 @@ func (bcR *Reactor) Receive(chID byte, src p2p.Peer, msgBytes []byte) {
 	case *bcproto.BlockRequest:
 		bcR.respondToPeer(msg, src)
 	case *bcproto.BlockResponse:
-		bi, err := types.BlockFromProto(msg.Block)
+		block, err := types.BlockFromProto(msg.Block)
 		if err != nil {
 			bcR.Logger.Error("Block content is invalid", "err", err)
 			return
 		}
-		bcR.pool.AddBlock(src.ID(), bi, len(msgBytes))
+		extCommit, err := types.ExtendedCommitFromProto(msg.ExtCommit)
+		if err != nil {
+			bcR.Logger.Error("failed to convert extended commit from proto",
+				"peer", src,
+				"err", err)
+			return
+		}
+
+		if err := bcR.pool.AddBlock(src.ID(), block, extCommit, block.Size()); err != nil {
+			bcR.Logger.Error("failed to add block", "err", err)
+		}
 	case *bcproto.StatusRequest:
 		// Send peer our state.
 		msgBytes, err := EncodeMsg(&bcproto.StatusResponse{
@@ -236,7 +256,7 @@ func (bcR *Reactor) Receive(chID byte, src p2p.Peer, msgBytes []byte) {
 			Base:   bcR.store.Base(),
 		})
 		if err != nil {
-			bcR.Logger.Error("could not convert msg to protobut", "err", err)
+			bcR.Logger.Error("could not convert msg to protobuf", "err", err)
 			return
 		}
 		src.TrySend(BlocksyncChannel, msgBytes)
@@ -317,7 +337,20 @@ FOR_LOOP:
 			outbound, inbound, _ := bcR.Switch.NumPeers()
 			bcR.Logger.Debug("Consensus ticker", "numPending", numPending, "total", lenRequesters,
 				"outbound", outbound, "inbound", inbound)
-			if bcR.pool.IsCaughtUp() {
+			switch {
+			// TODO(sergio) Might be needed for implementing the upgrading solution. Remove after that
+			//case state.LastBlockHeight > 0 && r.store.LoadBlockExtCommit(state.LastBlockHeight) == nil:
+			case state.LastBlockHeight > 0 && blocksSynced == 0:
+				// Having state-synced, we need to blocksync at least one block
+				bcR.Logger.Info(
+					"no seen commit yet",
+					"height", height,
+					"last_block_height", state.LastBlockHeight,
+					"initial_height", state.InitialHeight,
+					"max_peer_height", bcR.pool.MaxPeerHeight(),
+				)
+				continue FOR_LOOP
+			case bcR.pool.IsCaughtUp():
 				bcR.Logger.Info("Time to switch to consensus reactor!", "height", height)
 				if err := bcR.pool.Stop(); err != nil {
 					bcR.Logger.Error("Error stopping pool", "err", err)
@@ -349,10 +382,13 @@ FOR_LOOP:
 			// routine.

 			// See if there are any blocks to sync.
-			first, second := bcR.pool.PeekTwoBlocks()
-			// bcR.Logger.Info("TrySync peeked", "first", first, "second", second)
-			if first == nil || second == nil {
-				// We need both to sync the first block.
+			first, second, extCommit := bcR.pool.PeekTwoBlocks()
+			if first == nil || second == nil || extCommit == nil {
+				if first != nil && extCommit == nil {
+					// See https://github.com/tendermint/tendermint/pull/8433#discussion_r866790631
+					panic(fmt.Errorf("peeked first block without extended commit at height %d - possible node store corruption", first.Height))
+				}
+				// we need all to sync the first block
 				continue FOR_LOOP
 			} else {
 				// Try again quickly next loop.
@@ -372,6 +408,7 @@ FOR_LOOP:
 			// NOTE: we can probably make this more efficient, but note that calling
 			// first.Hash() doesn't verify the tx contents, so MakePartSet() is
 			// currently necessary.
+			// TODO(sergio): Should we also validate against the extended commit?
 			err = state.Validators.VerifyCommitLight(
 				chainID, firstID, first.Height, second.LastCommit)

@@ -402,7 +439,7 @@ FOR_LOOP:
 			bcR.pool.PopRequest()

 			// TODO: batch saves so we dont persist to disk every block
-			bcR.store.SaveBlock(first, firstParts, second.LastCommit)
+			bcR.store.SaveBlockWithExtendedCommit(first, firstParts, extCommit)

 			// TODO: same thing for app - but we would need a way to
 			// get the hash without persisting the state
--- a/blocksync/reactor_test.go
+++ b/blocksync/reactor_test.go
@@ -104,40 +104,44 @@ func newReactor(
 		panic(err)
 	}

+	// The commit we are building for the current height.
+	seenExtCommit := &types.ExtendedCommit{}
+
 	// let's add some blocks in
 	for blockHeight := int64(1); blockHeight <= maxBlockHeight; blockHeight++ {
-		lastCommit := types.NewCommit(blockHeight-1, 0, types.BlockID{}, nil)
-		if blockHeight > 1 {
-			lastBlockMeta := blockStore.LoadBlockMeta(blockHeight - 1)
-			lastBlock := blockStore.LoadBlock(blockHeight - 1)
-
-			vote, err := types.MakeVote(
-				lastBlock.Header.Height,
-				lastBlockMeta.BlockID,
-				state.Validators,
-				privVals[0],
-				lastBlock.Header.ChainID,
-				time.Now(),
-			)
-			if err != nil {
-				panic(err)
-			}
-			lastCommit = types.NewCommit(vote.Height, vote.Round,
-				lastBlockMeta.BlockID, []types.CommitSig{vote.CommitSig()})
-		}
-
+		lastCommit := seenExtCommit.Clone().ToCommit()
 		thisBlock := state.MakeBlock(blockHeight, nil, lastCommit, nil, state.Validators.Proposer.Address)
-
 		thisParts, err := thisBlock.MakePartSet(types.BlockPartSizeBytes)
 		require.NoError(t, err)
 		blockID := types.BlockID{Hash: thisBlock.Hash(), PartSetHeader: thisParts.Header()}

+		vote, err := types.MakeVote(
+			thisBlock.Header.Height,
+			blockID,
+			state.Validators,
+			privVals[0],
+			thisBlock.Header.ChainID,
+			time.Now(),
+		)
+		if err != nil {
+			panic(err)
+		}
+		seenExtCommit = &types.ExtendedCommit{
+			Height:             vote.Height,
+			Round:              vote.Round,
+			BlockID:            blockID,
+			ExtendedSignatures: []types.ExtendedCommitSig{vote.ExtendedCommitSig()},
+		}
+
+		blockStore.SaveBlockWithExtendedCommit(thisBlock, thisParts, seenExtCommit)
 		state, _, err = blockExec.ApplyBlock(state, blockID, thisBlock)
 		if err != nil {
 			panic(fmt.Errorf("error apply block: %w", err))
 		}

-		blockStore.SaveBlock(thisBlock, thisParts, lastCommit)
+		if err = stateStore.Save(state); err != nil {
+			panic(err)
+		}
 	}

 	bcReactor := NewReactor(state.Copy(), blockExec, blockStore, fastSync)
--- a/consensus/byzantine_test.go
+++ b/consensus/byzantine_test.go
@@ -302,7 +302,7 @@ func TestByzantinePrevoteEquivocation(t *testing.T) {
 // Heal partition and ensure A sees the commit
 func TestByzantineConflictingProposalsWithPartition(t *testing.T) {
 	t.Skip()
-	
+
 	logger := consensusLogger().With("test", "byzantine")
 	css, _, cfg := makeNetwork(t, makeNetworkArgs{})
 	n := len(css)
--- a/consensus/invalid_test.go
+++ b/consensus/invalid_test.go
@@ -17,6 +17,8 @@ import (
 // one byz val sends a precommit for a random block at each height
 // Ensure a testnet makes blocks
 func TestReactorInvalidPrecommit(t *testing.T) {
+	t.Skip()
+
 	N := 4
 	css, _, _ := makeNetwork(t, makeNetworkArgs{})

--- a/consensus/replay_test.go
+++ b/consensus/replay_test.go
@@ -340,7 +340,7 @@ func tempWALWithData(data []byte) string {
 func testHandshakeReplay(t *testing.T, nBlocks int, mode uint) {
 	var (
 		chain        []*types.Block
-		commits      []*types.Commit
+		extCommits   []*types.ExtendedCommit
 		store        *mockBlockStore
 		stateDB      dbm.DB
 		genesisState sm.State
@@ -369,7 +369,7 @@ func testHandshakeReplay(t *testing.T, nBlocks int, mode uint) {
 			t.Error(err)
 		}
 	})
-	chain, commits, err = makeBlockchainFromWAL(wal)
+	chain, extCommits, err = makeBlockchainFromWAL(wal)
 	require.NoError(t, err)
 	pubKey, err := privVal.GetPubKey()
 	require.NoError(t, err)
@@ -382,7 +382,7 @@ func testHandshakeReplay(t *testing.T, nBlocks int, mode uint) {
 		_ = stateStore.Close()
 	})
 	store.chain = chain
-	store.commits = commits
+	store.extCommits = extCommits

 	state := genesisState.Copy()
 	// run the chain through state.ApplyBlock to build up the tendermint state
@@ -671,7 +671,7 @@ func (app *badApp) FinalizeBlock(_ context.Context, req *abci.RequestFinalizeBlo
 //--------------------------
 // utils for making blocks

-func makeBlockchainFromWAL(wal WAL) ([]*types.Block, []*types.Commit, error) {
+func makeBlockchainFromWAL(wal WAL) ([]*types.Block, []*types.ExtendedCommit, error) {
 	var height int64

 	// Search for height marker
@@ -687,10 +687,10 @@ func makeBlockchainFromWAL(wal WAL) ([]*types.Block, []*types.Commit, error) {
 	// log.Notice("Build a blockchain by reading from the WAL")

 	var (
-		blocks          []*types.Block
-		commits         []*types.Commit
-		thisBlockParts  *types.PartSet
-		thisBlockCommit *types.Commit
+		blocks             []*types.Block
+		extCommits         []*types.ExtendedCommit
+		thisBlockParts     *types.PartSet
+		thisBlockExtCommit *types.ExtendedCommit
 	)

 	dec := NewWALDecoder(gr)
@@ -728,12 +728,12 @@ func makeBlockchainFromWAL(wal WAL) ([]*types.Block, []*types.Commit, error) {
 				if block.Height != height+1 {
 					panic(fmt.Sprintf("read bad block from wal. got height %d, expected %d", block.Height, height+1))
 				}
-				commitHeight := thisBlockCommit.Height
+				commitHeight := thisBlockExtCommit.Height
 				if commitHeight != height+1 {
 					panic(fmt.Sprintf("commit doesnt match. got height %d, expected %d", commitHeight, height+1))
 				}
 				blocks = append(blocks, block)
-				commits = append(commits, thisBlockCommit)
+				extCommits = append(extCommits, thisBlockExtCommit)
 				height++
 			}
 		case *types.PartSetHeader:
@@ -745,8 +745,12 @@ func makeBlockchainFromWAL(wal WAL) ([]*types.Block, []*types.Commit, error) {
 			}
 		case *types.Vote:
 			if p.Type == tmproto.PrecommitType {
-				thisBlockCommit = types.NewCommit(p.Height, p.Round,
-					p.BlockID, []types.CommitSig{p.CommitSig()})
+				thisBlockExtCommit = &types.ExtendedCommit{
+					Height:             p.Height,
+					Round:              p.Round,
+					BlockID:            p.BlockID,
+					ExtendedSignatures: []types.ExtendedCommitSig{p.ExtendedCommitSig()},
+				}
 			}
 		}
 	}
@@ -767,13 +771,13 @@ func makeBlockchainFromWAL(wal WAL) ([]*types.Block, []*types.Commit, error) {
 	if block.Height != height+1 {
 		panic(fmt.Sprintf("read bad block from wal. got height %d, expected %d", block.Height, height+1))
 	}
-	commitHeight := thisBlockCommit.Height
+	commitHeight := thisBlockExtCommit.Height
 	if commitHeight != height+1 {
 		panic(fmt.Sprintf("commit doesnt match. got height %d, expected %d", commitHeight, height+1))
 	}
 	blocks = append(blocks, block)
-	commits = append(commits, thisBlockCommit)
-	return blocks, commits, nil
+	extCommits = append(extCommits, thisBlockExtCommit)
+	return blocks, extCommits, nil
 }

 func readPieceFromWAL(msg *TimedWALMessage) interface{} {
@@ -819,12 +823,12 @@ func stateAndStore(
 // mock block store

 type mockBlockStore struct {
-	cfg     *config.Config
-	params  types.ConsensusParams
-	chain   []*types.Block
-	commits []*types.Commit
-	base    int64
-	t       *testing.T
+	cfg        *config.Config
+	params     types.ConsensusParams
+	chain      []*types.Block
+	extCommits []*types.ExtendedCommit
+	base       int64
+	t          *testing.T
 }

 // TODO: NewBlockStore(db.NewMemDB) ...
@@ -860,17 +864,20 @@ func (bs *mockBlockStore) SaveBlock(block *types.Block, blockParts *types.PartSe
 func (bs *mockBlockStore) SaveBlockWithExtendedCommit(block *types.Block, blockParts *types.PartSet, seenExtCommit *types.ExtendedCommit) {
 }
 func (bs *mockBlockStore) LoadBlockCommit(height int64) *types.Commit {
-	return bs.commits[height-1]
+	return bs.extCommits[height-1].ToCommit()
+}
+func (bs *mockBlockStore) LoadBlockExtendedCommit(height int64) *types.ExtendedCommit {
+	return bs.extCommits[height-1]
 }
 func (bs *mockBlockStore) LoadSeenCommit(height int64) *types.Commit {
-	return bs.commits[height-1]
+	return bs.extCommits[height-1].ToCommit()
 }

 func (bs *mockBlockStore) PruneBlocks(height int64) (uint64, error) {
 	pruned := uint64(0)
 	for i := int64(0); i < height-1; i++ {
 		bs.chain[i] = nil
-		bs.commits[i] = nil
+		bs.extCommits[i] = nil
 		pruned++
 	}
 	bs.base = height
--- a/light/provider/http/http_test.go
+++ b/light/provider/http/http_test.go
@@ -63,7 +63,7 @@ func TestProvider(t *testing.T) {
 	assert.True(t, lb.Height < 1000)

 	// let's check this is valid somehow
-	assert.Nil(t, lb.ValidateBasic(chainID))
+	assert.NoError(t, lb.ValidateBasic(chainID))

 	// historical queries now work :)
 	lower := lb.Height - 3
--- a/proto/tendermint/blocksync/types.pb.go
+++ b/proto/tendermint/blocksync/types.pb.go
@@ -115,7 +115,8 @@ func (m *NoBlockResponse) GetHeight() int64 {

 // BlockResponse returns block to the requested
 type BlockResponse struct {
-	Block *types.Block `protobuf:"bytes,1,opt,name=block,proto3" json:"block,omitempty"`
+	Block     *types.Block          `protobuf:"bytes,1,opt,name=block,proto3" json:"block,omitempty"`
+	ExtCommit *types.ExtendedCommit `protobuf:"bytes,2,opt,name=ext_commit,json=extCommit,proto3" json:"ext_commit,omitempty"`
 }

 func (m *BlockResponse) Reset()         { *m = BlockResponse{} }
@@ -158,6 +159,13 @@ func (m *BlockResponse) GetBlock() *types.Block {
 	return nil
 }

+func (m *BlockResponse) GetExtCommit() *types.ExtendedCommit {
+	if m != nil {
+		return m.ExtCommit
+	}
+	return nil
+}
+
 // StatusRequest requests the status of a peer.
 type StatusRequest struct {
 }
@@ -384,30 +392,33 @@ func init() {
 func init() { proto.RegisterFile("tendermint/blocksync/types.proto", fileDescriptor_19b397c236e0fa07) }

 var fileDescriptor_19b397c236e0fa07 = []byte{
-	// 368 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x93, 0x4d, 0x4f, 0xfa, 0x40,
-	0x10, 0xc6, 0xdb, 0x7f, 0x81, 0x7f, 0x32, 0x50, 0x1a, 0x1b, 0xa3, 0xc4, 0x98, 0x86, 0xd4, 0x97,
-	0xe8, 0xc1, 0x36, 0xc1, 0xa3, 0xc6, 0x03, 0x27, 0x4c, 0x7c, 0x49, 0x4a, 0xbc, 0x78, 0x21, 0x14,
-	0x37, 0x40, 0x94, 0x2e, 0x32, 0xdb, 0x03, 0xdf, 0xc2, 0x2f, 0xe0, 0xf7, 0xf1, 0xc8, 0xd1, 0xa3,
-	0x81, 0x2f, 0x62, 0x98, 0x2d, 0x65, 0x69, 0xb0, 0xb7, 0xdd, 0xe9, 0x33, 0xbf, 0x79, 0xfa, 0x64,
-	0x16, 0xea, 0x82, 0x45, 0x2f, 0x6c, 0x32, 0x1a, 0x46, 0xc2, 0x0f, 0xdf, 0x78, 0xef, 0x15, 0xa7,
-	0x51, 0xcf, 0x17, 0xd3, 0x31, 0x43, 0x6f, 0x3c, 0xe1, 0x82, 0xdb, 0xbb, 0x6b, 0x85, 0x97, 0x2a,
-	0x0e, 0x0e, 0x95, 0x3e, 0x52, 0xcb, 0x6e, 0xd9, 0xe3, 0x9e, 0x42, 0xa5, 0xb9, 0xbc, 0x06, 0xec,
-	0x3d, 0x66, 0x28, 0xec, 0x3d, 0x28, 0x0d, 0xd8, 0xb0, 0x3f, 0x10, 0x35, 0xbd, 0xae, 0x9f, 0x19,
-	0x41, 0x72, 0x73, 0xcf, 0xc1, 0x7a, 0xe0, 0x89, 0x12, 0xc7, 0x3c, 0x42, 0xf6, 0xa7, 0xf4, 0x06,
-	0xcc, 0x4d, 0xe1, 0x05, 0x14, 0x69, 0x24, 0xe9, 0xca, 0x8d, 0x7d, 0x4f, 0xf1, 0x29, 0xfd, 0x4b,
-	0xbd, 0x54, 0xb9, 0x16, 0x98, 0x6d, 0xd1, 0x15, 0x31, 0x26, 0x9e, 0xdc, 0x6b, 0xa8, 0xae, 0x0a,
-	0xf9, 0xa3, 0x6d, 0x1b, 0x0a, 0x61, 0x17, 0x59, 0xed, 0x1f, 0x55, 0xe9, 0xec, 0x7e, 0x1a, 0xf0,
-	0xff, 0x9e, 0x21, 0x76, 0xfb, 0xcc, 0xbe, 0x05, 0x93, 0x66, 0x74, 0x26, 0x12, 0x9d, 0x38, 0x72,
-	0xbd, 0x6d, 0xc9, 0x79, 0x6a, 0x30, 0x2d, 0x2d, 0xa8, 0x84, 0x6a, 0x50, 0x6d, 0xd8, 0x89, 0x78,
-	0x67, 0x45, 0x93, 0xbe, 0x68, 0x6e, 0xb9, 0x71, 0xb2, 0x1d, 0x97, 0xc9, 0xaf, 0xa5, 0x05, 0x56,
-	0x94, 0x89, 0xf4, 0x0e, 0xaa, 0x19, 0xa2, 0x41, 0xc4, 0xa3, 0x5c, 0x83, 0x29, 0xcf, 0x0c, 0xb3,
-	0x34, 0xa4, 0xdc, 0xd2, 0xdf, 0x2d, 0xe4, 0xd1, 0x36, 0x42, 0x5f, 0xd2, 0x50, 0x2d, 0xd8, 0x8f,
-	0x60, 0xa5, 0xb4, 0xc4, 0x5c, 0x91, 0x70, 0xc7, 0xf9, 0xb8, 0xd4, 0x5d, 0x15, 0x37, 0x2a, 0xcd,
-	0x22, 0x18, 0x18, 0x8f, 0x9a, 0x4f, 0x5f, 0x73, 0x47, 0x9f, 0xcd, 0x1d, 0xfd, 0x67, 0xee, 0xe8,
-	0x1f, 0x0b, 0x47, 0x9b, 0x2d, 0x1c, 0xed, 0x7b, 0xe1, 0x68, 0xcf, 0x57, 0xfd, 0xa1, 0x18, 0xc4,
-	0xa1, 0xd7, 0xe3, 0x23, 0x5f, 0x5d, 0xe2, 0xf5, 0x91, 0x76, 0xd8, 0xdf, 0xf6, 0x30, 0xc2, 0x12,
-	0x7d, 0xbb, 0xfc, 0x0d, 0x00, 0x00, 0xff, 0xff, 0xf5, 0x1c, 0xa3, 0x45, 0x37, 0x03, 0x00, 0x00,
+	// 404 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x93, 0xcd, 0x4a, 0xeb, 0x50,
+	0x10, 0xc7, 0x93, 0x9b, 0xb6, 0x97, 0x3b, 0xb7, 0x69, 0xb8, 0xe1, 0xa2, 0x45, 0x24, 0x94, 0xf8,
+	0x81, 0x2e, 0x4c, 0x40, 0x97, 0x0a, 0x42, 0x45, 0xa8, 0xe0, 0x07, 0xa4, 0xb8, 0x71, 0x53, 0x9a,
+	0xf4, 0xd0, 0x06, 0x4d, 0x4e, 0xed, 0x39, 0x81, 0x76, 0xe5, 0x2b, 0xf8, 0x02, 0xbe, 0x8f, 0xcb,
+	0x2e, 0x5d, 0x4a, 0xfb, 0x22, 0xd2, 0x39, 0x69, 0x9a, 0xc6, 0x98, 0xdd, 0x64, 0xce, 0x7f, 0x7e,
+	0xf9, 0xcf, 0x0c, 0x03, 0x0d, 0x4e, 0xc2, 0x1e, 0x19, 0x05, 0x7e, 0xc8, 0x6d, 0xf7, 0x89, 0x7a,
+	0x8f, 0x6c, 0x12, 0x7a, 0x36, 0x9f, 0x0c, 0x09, 0xb3, 0x86, 0x23, 0xca, 0xa9, 0xfe, 0x7f, 0xa5,
+	0xb0, 0x12, 0xc5, 0xd6, 0x76, 0xaa, 0x0e, 0xd5, 0xa2, 0x5a, 0xd4, 0xe4, 0xbc, 0xa6, 0x88, 0xe6,
+	0x3e, 0x54, 0x9b, 0x0b, 0xb1, 0x43, 0x9e, 0x23, 0xc2, 0xb8, 0xbe, 0x01, 0x95, 0x01, 0xf1, 0xfb,
+	0x03, 0x5e, 0x97, 0x1b, 0xf2, 0x81, 0xe2, 0xc4, 0x5f, 0xe6, 0x21, 0x68, 0xb7, 0x34, 0x56, 0xb2,
+	0x21, 0x0d, 0x19, 0xf9, 0x51, 0xfa, 0x02, 0xea, 0xba, 0xf0, 0x08, 0xca, 0x68, 0x08, 0x75, 0x7f,
+	0x8f, 0x37, 0xad, 0x54, 0x17, 0xc2, 0x8b, 0xd0, 0x0b, 0x95, 0x7e, 0x0e, 0x40, 0xc6, 0xbc, 0xe3,
+	0xd1, 0x20, 0xf0, 0x79, 0xfd, 0x17, 0xd6, 0x34, 0xbe, 0xd7, 0x5c, 0x8e, 0x31, 0xd5, 0xbb, 0x40,
+	0x9d, 0xf3, 0x87, 0x8c, 0xb9, 0x08, 0x4d, 0x0d, 0xd4, 0x36, 0xef, 0xf2, 0x88, 0xc5, 0x4d, 0x99,
+	0x67, 0x50, 0x5b, 0x26, 0x8a, 0xbd, 0xeb, 0x3a, 0x94, 0xdc, 0x2e, 0x23, 0xf8, 0x57, 0xc5, 0xc1,
+	0xd8, 0x7c, 0x53, 0xe0, 0xf7, 0x0d, 0x61, 0xac, 0xdb, 0x27, 0xfa, 0x15, 0xa8, 0x68, 0xb2, 0x33,
+	0x12, 0xe8, 0xb8, 0x25, 0xd3, 0xca, 0x5b, 0x8c, 0x95, 0x9e, 0x6c, 0x4b, 0x72, 0xaa, 0x6e, 0x7a,
+	0xd2, 0x6d, 0xf8, 0x17, 0xd2, 0xce, 0x92, 0x26, 0x7c, 0xc5, 0xdd, 0xee, 0xe5, 0xe3, 0x32, 0x0b,
+	0x68, 0x49, 0x8e, 0x16, 0x66, 0x76, 0x72, 0x0d, 0xb5, 0x0c, 0x51, 0x41, 0xe2, 0x4e, 0xa1, 0xc1,
+	0x84, 0xa7, 0xba, 0x59, 0x1a, 0xc3, 0xb9, 0x25, 0xed, 0x96, 0x8a, 0x68, 0x6b, 0x43, 0x5f, 0xd0,
+	0x58, 0x3a, 0xa1, 0xdf, 0x81, 0x96, 0xd0, 0x62, 0x73, 0x65, 0xc4, 0xed, 0x16, 0xe3, 0x12, 0x77,
+	0x35, 0xb6, 0x96, 0x69, 0x96, 0x41, 0x61, 0x51, 0xd0, 0xbc, 0x7f, 0x9f, 0x19, 0xf2, 0x74, 0x66,
+	0xc8, 0x9f, 0x33, 0x43, 0x7e, 0x9d, 0x1b, 0xd2, 0x74, 0x6e, 0x48, 0x1f, 0x73, 0x43, 0x7a, 0x38,
+	0xed, 0xfb, 0x7c, 0x10, 0xb9, 0x96, 0x47, 0x03, 0x3b, 0x7d, 0x05, 0xab, 0x10, 0x8f, 0xc0, 0xce,
+	0xbb, 0x3b, 0xb7, 0x82, 0x6f, 0x27, 0x5f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xdc, 0x13, 0x4f, 0x42,
+	0x96, 0x03, 0x00, 0x00,
 }

 func (m *BlockRequest) Marshal() (dAtA []byte, err error) {
@@ -486,6 +497,18 @@ func (m *BlockResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
+	if m.ExtCommit != nil {
+		{
+			size, err := m.ExtCommit.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintTypes(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x12
+	}
 	if m.Block != nil {
 		{
 			size, err := m.Block.MarshalToSizedBuffer(dAtA[:i])
@@ -739,6 +762,10 @@ func (m *BlockResponse) Size() (n int) {
 		l = m.Block.Size()
 		n += 1 + l + sovTypes(uint64(l))
 	}
+	if m.ExtCommit != nil {
+		l = m.ExtCommit.Size()
+		n += 1 + l + sovTypes(uint64(l))
+	}
 	return n
 }

@@ -1048,6 +1075,42 @@ func (m *BlockResponse) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ExtCommit", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthTypes
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.ExtCommit == nil {
+				m.ExtCommit = &types.ExtendedCommit{}
+			}
+			if err := m.ExtCommit.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipTypes(dAtA[iNdEx:])
--- a/proto/tendermint/blocksync/types.proto
+++ b/proto/tendermint/blocksync/types.proto
@@ -4,6 +4,7 @@ package tendermint.blocksync;
 option go_package = "github.com/tendermint/tendermint/proto/tendermint/blocksync";

 import "tendermint/types/block.proto";
+import "tendermint/types/types.proto";

 // BlockRequest requests a block for a specific height
 message BlockRequest {
@@ -18,6 +19,7 @@ message NoBlockResponse {
 // BlockResponse returns block to the requested
 message BlockResponse {
  tendermint.types.Block block = 1;
+  tendermint.types.ExtendedCommit ext_commit = 2;
 }

 // StatusRequest requests the status of a peer.
--- a/state/mocks/block_store.go
+++ b/state/mocks/block_store.go
@@ -105,6 +105,22 @@ func (_m *BlockStore) LoadBlockCommit(height int64) *types.Commit {
 	return r0
 }

+// LoadBlockExtendedCommit provides a mock function with given fields: height
+func (_m *BlockStore) LoadBlockExtendedCommit(height int64) *types.ExtendedCommit {
+	ret := _m.Called(height)
+
+	var r0 *types.ExtendedCommit
+	if rf, ok := ret.Get(0).(func(int64) *types.ExtendedCommit); ok {
+		r0 = rf(height)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*types.ExtendedCommit)
+		}
+	}
+
+	return r0
+}
+
 // LoadBlockMeta provides a mock function with given fields: height
 func (_m *BlockStore) LoadBlockMeta(height int64) *types.BlockMeta {
 	ret := _m.Called(height)
--- a/state/services.go
+++ b/state/services.go
@@ -35,6 +35,7 @@ type BlockStore interface {

 	LoadBlockCommit(height int64) *types.Commit
 	LoadSeenCommit(height int64) *types.Commit
+	LoadBlockExtendedCommit(height int64) *types.ExtendedCommit
 }

 //-----------------------------------------------------------------------------
--- a/store/store.go
+++ b/store/store.go
@@ -313,8 +313,12 @@ func (bs *BlockStore) PruneBlocks(height int64) (uint64, error) {
 		// tries to access missing blocks.
 		bs.mtx.Lock()
 		bs.base = base
+		bss := &tmstore.BlockStoreState{
+			Base:   bs.base,
+			Height: bs.height,
+		}
 		bs.mtx.Unlock()
-		bs.saveState()
+		SaveBlockStoreState(batch, bss)

 		err := batch.WriteSync()
 		if err != nil {
@@ -401,7 +405,7 @@ func (bs *BlockStore) SaveBlockWithExtendedCommit(block *types.Block, blockParts
 		panic("BlockStore can only save a non-nil block")
 	}
 	if err := seenExtendedCommit.EnsureExtensions(); err != nil {
-		panic(fmt.Errorf("saving block with extensions: %w", err))
+		panic(fmt.Errorf("saving block without extensions: %w", err))
 	}
 	batch := bs.db.NewBatch()
 	if err := bs.saveBlockToBatch(batch, block, blockParts, seenExtendedCommit.ToCommit()); err != nil {
@@ -479,6 +483,18 @@ func (bs *BlockStore) saveBlockToBatch(batch dbm.Batch, block *types.Block, bloc
 		return err
 	}

+	bs.mtx.Lock()
+	bs.height = height
+	if bs.base == 0 {
+		bs.base = height
+	}
+	bss := &tmstore.BlockStoreState{
+		Base:   bs.base,
+		Height: bs.height,
+	}
+	bs.mtx.Unlock()
+	SaveBlockStoreState(batch, bss)
+
 	return nil
 }

@@ -493,16 +509,6 @@ func (bs *BlockStore) saveBlockPart(height int64, index int, part *types.Part, b
 	}
 }

-func (bs *BlockStore) saveState() {
-	bs.mtx.RLock()
-	bss := tmstore.BlockStoreState{
-		Base:   bs.base,
-		Height: bs.height,
-	}
-	bs.mtx.RUnlock()
-	SaveBlockStoreState(&bss, bs.db)
-}
-
 // SaveSeenCommit saves a seen commit, used by e.g. the state sync reactor when bootstrapping node.
 func (bs *BlockStore) SaveSeenCommit(height int64, seenCommit *types.Commit) error {
 	pbc := seenCommit.ToProto()
@@ -548,12 +554,12 @@ func calcExtCommitKey(height int64) []byte {
 var blockStoreKey = []byte("blockStore")

 // SaveBlockStoreState persists the blockStore state to the database.
-func SaveBlockStoreState(bsj *tmstore.BlockStoreState, db dbm.DB) {
-	bytes, err := proto.Marshal(bsj)
+func SaveBlockStoreState(batch dbm.Batch, bss *tmstore.BlockStoreState) {
+	bytes, err := proto.Marshal(bss)
 	if err != nil {
 		panic(fmt.Sprintf("Could not marshal state bytes: %v", err))
 	}
-	if err := db.SetSync(blockStoreKey, bytes); err != nil {
+	if err := batch.Set(blockStoreKey, bytes); err != nil {
 		panic(err)
 	}
 }
--- a/store/store_test.go
+++ b/store/store_test.go
@@ -51,7 +51,7 @@ func makeTestExtCommit(height int64, timestamp time.Time) *types.ExtendedCommit
 	}
 }

-func makeStateAndBlockStore(t *testing.T) (sm.State, *BlockStore) {
+func makeStateAndBlockStore(t *testing.T) (sm.State, dbm.DB, *BlockStore) {
 	config := cfg.ResetTestRoot("blockchain_reactor_test")
 	t.Cleanup(func() { os.RemoveAll(config.RootDir) })

@@ -64,7 +64,7 @@ func makeStateAndBlockStore(t *testing.T) (sm.State, *BlockStore) {
 	if err != nil {
 		panic(fmt.Errorf("error constructing state from genesis file: %w", err))
 	}
-	return state, NewBlockStore(blockDB)
+	return state, blockDB, NewBlockStore(blockDB)
 }

 func TestLoadBlockStoreState(t *testing.T) {
@@ -84,7 +84,10 @@ func TestLoadBlockStoreState(t *testing.T) {

 	for _, tc := range testCases {
 		db := dbm.NewMemDB()
-		SaveBlockStoreState(tc.bss, db)
+		batch := db.NewBatch()
+		SaveBlockStoreState(batch, tc.bss)
+		batch.WriteSync()
+		batch.Close()
 		retrBSJ := LoadBlockStoreState(db)
 		assert.Equal(t, tc.want, retrBSJ, "expected the retrieved DBs to match: %s", tc.testName)
 	}
@@ -127,19 +130,14 @@ func TestNewBlockStore(t *testing.T) {
 	assert.Equal(t, bs.Height(), int64(0), "expecting empty bytes to be unmarshaled alright")
 }

-func freshBlockStore() (*BlockStore, dbm.DB) {
-	db := dbm.NewMemDB()
-	return NewBlockStore(db), db
-}
-
-var (
-	state       sm.State
-	block       *types.Block
-	partSet     *types.PartSet
-	part1       *types.Part
-	part2       *types.Part
-	seenCommit1 *types.Commit
-)
+// var (
+// 	state       sm.State
+// 	block       *types.Block
+// 	partSet     *types.PartSet
+// 	part1       *types.Part
+// 	part2       *types.Part
+// 	seenCommit1 *types.Commit
+// )

 // func TestMain(m *testing.M) {
 // 	var cleanup cleanupFunc
@@ -162,7 +160,7 @@ var (
 // TODO: This test should be simplified ...

 func TestBlockStoreSaveLoadBlock(t *testing.T) {
-	state, bs := makeStateAndBlockStore(t)
+	state, _, bs := makeStateAndBlockStore(t)
 	require.Equal(t, bs.Base(), int64(0), "initially the base should be zero")
 	require.Equal(t, bs.Height(), int64(0), "initially the height should be zero")

@@ -178,13 +176,14 @@ func TestBlockStoreSaveLoadBlock(t *testing.T) {
 	block := state.MakeBlock(bs.Height()+1, nil, new(types.Commit), nil, state.Validators.GetProposer().Address)
 	validPartSet, err := block.MakePartSet(2)
 	require.NoError(t, err)
-	seenCommit := makeTestExtCommit(10, tmtime.Now())
-	bs.SaveBlockWithExtendedCommit(block, partSet, seenCommit)
+	seenCommit := makeTestExtCommit(1, tmtime.Now())
+	bs.SaveBlockWithExtendedCommit(block, validPartSet, seenCommit)
 	require.EqualValues(t, 1, bs.Base(), "expecting the new height to be changed")
 	require.EqualValues(t, block.Header.Height, bs.Height(), "expecting the new height to be changed")

 	incompletePartSet := types.NewPartSetFromHeader(types.PartSetHeader{Total: 2})
 	uncontiguousPartSet := types.NewPartSetFromHeader(types.PartSetHeader{Total: 0})
+	part2 := validPartSet.GetPart(1)
 	_, err = uncontiguousPartSet.AddPart(part2)
 	require.Error(t, err)

@@ -238,9 +237,10 @@ func TestBlockStoreSaveLoadBlock(t *testing.T) {
 		},

 		{
-			block:     newBlock(header1, commitAtH10),
-			parts:     incompletePartSet,
-			wantPanic: "only save complete block", // incomplete parts
+			block:      newBlock(header1, commitAtH10),
+			parts:      incompletePartSet,
+			seenCommit: seenCommit,
+			wantPanic:  "only save complete block", // incomplete parts
 		},

 		{
@@ -297,7 +297,7 @@ func TestBlockStoreSaveLoadBlock(t *testing.T) {

 	for i, tuple := range tuples {
 		tuple := tuple
-		bs, db := freshBlockStore()
+		_, db, bs := makeStateAndBlockStore(t)
 		// SaveBlock
 		res, err, panicErr := doFn(func() (interface{}, error) {
 			bs.SaveBlockWithExtendedCommit(tuple.block, tuple.parts, tuple.seenCommit)
@@ -392,7 +392,7 @@ func TestSaveBlockWithExtendedCommitPanicOnAbsentExtension(t *testing.T) {
 		},
 	} {
 		t.Run(testCase.name, func(t *testing.T) {
-			state, bs := makeStateAndBlockStore(t)
+			state, _, bs := makeStateAndBlockStore(t)
 			block := test.MakeBlock(state)
 			seenCommit := makeTestExtCommit(block.Header.Height, tmtime.Now())
 			ps, err := block.MakePartSet(2)
@@ -430,7 +430,7 @@ func TestLoadBlockExtendedCommit(t *testing.T) {
 		},
 	} {
 		t.Run(testCase.name, func(t *testing.T) {
-			state, bs := makeStateAndBlockStore(t)
+			state, _, bs := makeStateAndBlockStore(t)
 			block := test.MakeBlock(state)
 			seenCommit := makeTestExtCommit(block.Header.Height, tmtime.Now())
 			ps, err := block.MakePartSet(2)
@@ -477,13 +477,18 @@ func TestLoadBaseMeta(t *testing.T) {
 }

 func TestLoadBlockPart(t *testing.T) {
-	bs, db := freshBlockStore()
+	state, db, bs := makeStateAndBlockStore(t)
 	height, index := int64(10), 1
 	loadPart := func() (interface{}, error) {
 		part := bs.LoadBlockPart(height, index)
 		return part, nil
 	}

+	block := state.MakeBlock(state.LastBlockHeight+1, test.MakeNTxs(state.LastBlockHeight+1, 10), new(types.Commit), nil, state.Validators.GetProposer().Address)
+	partSet, err := block.MakePartSet(2)
+	require.NoError(t, err)
+	part1 := partSet.GetPart(0)
+
 	// Initially no contents.
 	// 1. Requesting for a non-existent block shouldn't fail
 	res, _, panicErr := doFn(loadPart)
@@ -491,7 +496,7 @@ func TestLoadBlockPart(t *testing.T) {
 	require.Nil(t, res, "a non-existent block part should return nil")

 	// 2. Next save a corrupted block then try to load it
-	err := db.Set(calcBlockPartKey(height, index), []byte("Tendermint"))
+	err = db.Set(calcBlockPartKey(height, index), []byte("Tendermint"))
 	require.NoError(t, err)
 	res, _, panicErr = doFn(loadPart)
 	require.NotNil(t, panicErr, "expecting a non-nil panic")
@@ -601,7 +606,7 @@ func TestPruneBlocks(t *testing.T) {
 }

 func TestLoadBlockMeta(t *testing.T) {
-	bs, db := freshBlockStore()
+	_, db, bs := makeStateAndBlockStore(t)
 	height := int64(10)
 	loadMeta := func() (interface{}, error) {
 		meta := bs.LoadBlockMeta(height)
@@ -662,13 +667,13 @@ func TestLoadBlockMetaByHash(t *testing.T) {
 }

 func TestBlockFetchAtHeight(t *testing.T) {
-	state, bs := makeStateAndBlockStore(t)
+	state, _, bs := makeStateAndBlockStore(t)
 	require.Equal(t, bs.Height(), int64(0), "initially the height should be zero")
 	block := state.MakeBlock(bs.Height()+1, nil, new(types.Commit), nil, state.Validators.GetProposer().Address)

 	partSet, err := block.MakePartSet(2)
 	require.NoError(t, err)
-	seenCommit := makeTestExtCommit(10, tmtime.Now())
+	seenCommit := makeTestExtCommit(block.Height, tmtime.Now())
 	bs.SaveBlockWithExtendedCommit(block, partSet, seenCommit)
 	require.Equal(t, bs.Height(), block.Header.Height, "expecting the new height to be changed")

--- a/types/vote.go
+++ b/types/vote.go
@@ -381,8 +381,8 @@ func VotesToProto(votes []*Vote) []*tmproto.Vote {
 	return res
 }

-// FromProto converts a proto generetad type to a handwritten type
-// return type, nil if everything converts safely, otherwise nil, error
+// VoteFromProto attempts to convert the given serialization (Protobuf) type to
+// our Vote domain type. A basic validation check is also performed.
 func VoteFromProto(pv *tmproto.Vote) (*Vote, error) {
 	if pv == nil {
 		return nil, errors.New("nil vote")
--- a/types/vote_set.go
+++ b/types/vote_set.go
@@ -2,6 +2,7 @@ package types

 import (
 	"bytes"
+	"errors"
 	"fmt"
 	"strings"

@@ -213,8 +214,17 @@ func (voteSet *VoteSet) addVote(vote *Vote) (added bool, err error) {
 	}

 	// Check signature.
-	if err := vote.Verify(voteSet.chainID, val.PubKey); err != nil {
-		return false, fmt.Errorf("failed to verify vote with ChainID %s and PubKey %s: %w", voteSet.chainID, val.PubKey, err)
+	if voteSet.extensionsEnabled {
+		if err := vote.VerifyVoteAndExtension(voteSet.chainID, val.PubKey); err != nil {
+			return false, fmt.Errorf("failed to verify vote with ChainID %s and PubKey %s: %w", voteSet.chainID, val.PubKey, err)
+		}
+	} else {
+		if err := vote.Verify(voteSet.chainID, val.PubKey); err != nil {
+			return false, fmt.Errorf("failed to verify vote with ChainID %s and PubKey %s: %w", voteSet.chainID, val.PubKey, err)
+		}
+		if len(vote.ExtensionSignature) > 0 || len(vote.Extension) > 0 {
+			return false, errors.New("unexpected vote extension data present in vote")
+		}
 	}

 	// Add vote and get conflicting vote if any.