add test for 'InitialHeight' prepare proposals

Co-authored-by: M. J. Fromberger <fromberger@interchain.io>
Co-authored-by: Sergio Mena <sergio@informal.systems>

internal/blocksync/pool.go

@@ -200,16 +200,20 @@ func (pool *BlockPool) IsCaughtUp() bool {
 	return pool.height >= (pool.maxPeerHeight - 1)
 }
 
-// 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.RLock()
 	defer pool.mtx.RUnlock()
 
 	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()
@@ -218,7 +222,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()
@@ -264,10 +269,15 @@ func (pool *BlockPool) RedoRequest(height int64) types.NodeID {
 
 // 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 types.NodeID, block *types.Block, blockSize int) {
+func (pool *BlockPool) AddBlock(peerID types.NodeID, block *types.Block, extCommit *types.ExtendedCommit, blockSize int) {
 	pool.mtx.Lock()
 	defer pool.mtx.Unlock()
 
+	if block.Height != extCommit.Height {
+		pool.logger.Error("heights don't match, not adding block", "block_height", block.Height, "commit_height", extCommit.Height)
+		return
+	}
+
 	requester := pool.requesters[block.Height]
 	if requester == nil {
 		pool.logger.Error("peer sent us a block we didn't expect",
@@ -282,7 +292,7 @@ func (pool *BlockPool) AddBlock(peerID types.NodeID, block *types.Block, blockSi
 		return
 	}
 
-	if requester.setBlock(block, peerID) {
+	if requester.setBlock(block, extCommit, peerID) {
 		atomic.AddInt32(&pool.numPending, -1)
 		peer := pool.peers[peerID]
 		if peer != nil {
@@ -456,6 +466,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
@@ -544,9 +555,10 @@ type bpRequester struct {
 	gotBlockCh chan struct{}
 	redoCh     chan types.NodeID // redo may send multitime, add peerId to identify repeat
 
-	mtx    sync.Mutex
-	peerID types.NodeID
-	block  *types.Block
+	mtx       sync.Mutex
+	peerID    types.NodeID
+	block     *types.Block
+	extCommit *types.ExtendedCommit
 }
 
 func newBPRequester(logger log.Logger, pool *BlockPool, height int64) *bpRequester {
@@ -572,13 +584,14 @@ func (bpr *bpRequester) OnStart(ctx context.Context) error {
 func (*bpRequester) OnStop() {}
 
 // Returns true if the peer matches and block doesn't already exist.
-func (bpr *bpRequester) setBlock(block *types.Block, peerID types.NodeID) bool {
+func (bpr *bpRequester) setBlock(block *types.Block, extCommit *types.ExtendedCommit, peerID types.NodeID) 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 {
@@ -594,6 +607,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() types.NodeID {
 	bpr.mtx.Lock()
 	defer bpr.mtx.Unlock()
@@ -611,6 +630,7 @@ func (bpr *bpRequester) reset() {
 
 	bpr.peerID = ""
 	bpr.block = nil
+	bpr.extCommit = nil
 }
 
 // Tells bpRequester to pick another peer and try again.

internal/blocksync/pool_test.go

@@ -43,7 +43,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)
+	var blockID types.BlockID
+	var extCommitSigs []types.ExtendedCommitSig
+	extCommit := types.NewExtendedCommit(input.request.Height, 0, blockID, extCommitSigs)
+	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
@@ -110,7 +113,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 {
@@ -164,7 +167,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 {

internal/blocksync/reactor.go

@@ -76,7 +76,7 @@ type Reactor struct {
 	stateStore sm.Store
 
 	blockExec   *sm.BlockExecutor
-	store       *store.BlockStore
+	store       sm.BlockStore
 	pool        *BlockPool
 	consReactor consensusReactor
 	blockSync   *atomicBool
@@ -186,15 +186,23 @@ func (r *Reactor) OnStop() {
 func (r *Reactor) respondToPeer(ctx context.Context, msg *bcproto.BlockRequest, peerID types.NodeID, blockSyncCh *p2p.Channel) error {
 	block := r.store.LoadBlock(msg.Height)
 	if block != nil {
+		extCommit := r.store.LoadBlockExtCommit(msg.Height)
+		if extCommit == nil {
+			r.logger.Error("peer requesting a block; we have the block but not its extended commit (%v)", block)
+			return fmt.Errorf("blockstore has block but not extended commit %v", block)
+		}
 		blockProto, err := block.ToProto()
 		if err != nil {
-			r.logger.Error("failed to convert msg to protobuf", "err", err)
+			r.logger.Error("failed to convert block to protobuf", "err", err)
 			return err
 		}
 
 		return blockSyncCh.Send(ctx, p2p.Envelope{
-			To:      peerID,
-			Message: &bcproto.BlockResponse{Block: blockProto},
+			To: peerID,
+			Message: &bcproto.BlockResponse{
+				Block:     blockProto,
+				ExtCommit: extCommit.ToProto(),
+			},
 		})
 	}
 
@@ -236,8 +244,15 @@ func (r *Reactor) handleMessage(ctx context.Context, envelope *p2p.Envelope, blo
 					"err", err)
 				return err
 			}
+			extCommit, err := types.ExtendedCommitFromProto(msg.ExtCommit)
+			if err != nil {
+				r.logger.Error("failed to convert extended commit from proto",
+					"peer", envelope.From,
+					"err", err)
+				return err
+			}
 
-			r.pool.AddBlock(envelope.From, block, block.Size())
+			r.pool.AddBlock(envelope.From, block, extCommit, block.Size())
 
 		case *bcproto.StatusRequest:
 			return blockSyncCh.Send(ctx, p2p.Envelope{
@@ -448,6 +463,19 @@ func (r *Reactor) poolRoutine(ctx context.Context, stateSynced bool, blockSyncCh
 			)
 
 			switch {
+			//case state.LastBlockHeight > 0 && r.store.LoadBlockExtCommit(state.LastBlockHeight) == nil:
+			case state.LastBlockHeight > 0 && blocksSynced == 0:
+				//If we have state-synced, we need to blocksync at least one block
+				r.logger.Info(
+					"no seen commit yet",
+					"height", height,
+					"last_block_height", state.LastBlockHeight,
+					"initial_height", state.InitialHeight,
+					"max_peer_height", r.pool.MaxPeerHeight(),
+					"timeout_in", syncTimeout-time.Since(lastAdvance),
+				)
+				continue
+
 			case r.pool.IsCaughtUp():
 				r.logger.Info("switching to consensus reactor", "height", height)
 
@@ -490,9 +518,12 @@ func (r *Reactor) poolRoutine(ctx context.Context, stateSynced bool, blockSyncCh
 			// TODO: Uncouple from request routine.
 
 			// see if there are any blocks to sync
-			first, second := r.pool.PeekTwoBlocks()
-			if first == nil || second == nil {
-				// we need both to sync the first block
+			first, second, extCommit := r.pool.PeekTwoBlocks()
+			if first == nil || second == nil || extCommit == nil {
+				if first != nil && extCommit == nil {
+					r.logger.Error("peeked a block without extended commit", "height", first.Height)
+				}
+				// we need all to sync the first block
 				continue
 			} else {
 				// try again quickly next loop
@@ -517,6 +548,7 @@ func (r *Reactor) poolRoutine(ctx context.Context, stateSynced bool, blockSyncCh
 			// 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 Should we also validate against the extended commit?
 			if err = state.Validators.VerifyCommitLight(chainID, firstID, first.Height, second.LastCommit); err != nil {
 				err = fmt.Errorf("invalid last commit: %w", err)
 				r.logger.Error(
@@ -549,7 +581,7 @@ func (r *Reactor) poolRoutine(ctx context.Context, stateSynced bool, blockSyncCh
 				r.pool.PopRequest()
 
 				// TODO: batch saves so we do not persist to disk every block
-				r.store.SaveBlock(first, firstParts, second.LastCommit)
+				r.store.SaveBlock(first, firstParts, extCommit)
 
 				var err error
 

internal/blocksync/reactor_test.go

@@ -147,39 +147,43 @@ func (rts *reactorTestSuite) addNode(
 		sm.NopMetrics(),
 	)
 
+	var lastExtCommit *types.ExtendedCommit
+
+	// The commit we are building for the current height.
+	seenExtCommit := types.NewExtendedCommit(0, 0, types.BlockID{}, nil)
+
 	for blockHeight := int64(1); blockHeight <= maxBlockHeight; blockHeight++ {
-		lastCommit := types.NewCommit(blockHeight-1, 0, types.BlockID{}, nil)
+		lastExtCommit = seenExtCommit.Copy()
 
-		if blockHeight > 1 {
-			lastBlockMeta := blockStore.LoadBlockMeta(blockHeight - 1)
-			lastBlock := blockStore.LoadBlock(blockHeight - 1)
-
-			vote, err := factory.MakeVote(
-				ctx,
-				privVal,
-				lastBlock.Header.ChainID, 0,
-				lastBlock.Header.Height, 0, 2,
-				lastBlockMeta.BlockID,
-				time.Now(),
-			)
-			require.NoError(t, err)
-			lastCommit = types.NewCommit(
-				vote.Height,
-				vote.Round,
-				lastBlockMeta.BlockID,
-				[]types.CommitSig{vote.CommitSig()},
-			)
-		}
-
-		thisBlock := sf.MakeBlock(state, blockHeight, lastCommit)
+		thisBlock := sf.MakeBlock(state, blockHeight, lastExtCommit.StripExtensions())
 		thisParts, err := thisBlock.MakePartSet(types.BlockPartSizeBytes)
 		require.NoError(t, err)
 		blockID := types.BlockID{Hash: thisBlock.Hash(), PartSetHeader: thisParts.Header()}
 
+		// Simulate a commit for the current height
+		vote, err := factory.MakeVote(
+			ctx,
+			privVal,
+			thisBlock.Header.ChainID,
+			0,
+			thisBlock.Header.Height,
+			0,
+			2,
+			blockID,
+			time.Now(),
+		)
+		require.NoError(t, err)
+		seenExtCommit = types.NewExtendedCommit(
+			vote.Height,
+			vote.Round,
+			blockID,
+			[]types.ExtendedCommitSig{vote.ExtendedCommitSig()},
+		)
+
 		state, err = blockExec.ApplyBlock(ctx, state, blockID, thisBlock)
 		require.NoError(t, err)
 
-		blockStore.SaveBlock(thisBlock, thisParts, lastCommit)
+		blockStore.SaveBlock(thisBlock, thisParts, seenExtCommit)
 	}
 
 	rts.peerChans[nodeID] = make(chan p2p.PeerUpdate)

internal/consensus/byzantine_test.go

@@ -178,22 +178,22 @@ func TestByzantinePrevoteEquivocation(t *testing.T) {
 	lazyNodeState.decideProposal = func(ctx context.Context, height int64, round int32) {
 		require.NotNil(t, lazyNodeState.privValidator)
 
-		var commit *types.Commit
+		var commit *types.ExtendedCommit
 		switch {
 		case lazyNodeState.Height == lazyNodeState.state.InitialHeight:
 			// We're creating a proposal for the first block.
 			// The commit is empty, but not nil.
-			commit = types.NewCommit(0, 0, types.BlockID{}, nil)
+			commit = types.NewExtendedCommit(0, 0, types.BlockID{}, nil)
 		case lazyNodeState.LastCommit.HasTwoThirdsMajority():
 			// Make the commit from LastCommit
-			commit = lazyNodeState.LastCommit.MakeCommit()
+			commit = lazyNodeState.LastCommit.MakeExtendedCommit()
 		default: // This shouldn't happen.
 			lazyNodeState.logger.Error("enterPropose: Cannot propose anything: No commit for the previous block")
 			return
 		}
 
 		// omit the last signature in the commit
-		commit.Signatures[len(commit.Signatures)-1] = types.NewCommitSigAbsent()
+		commit.ExtendedSignatures[len(commit.ExtendedSignatures)-1] = types.NewExtendedCommitSigAbsent()
 
 		if lazyNodeState.privValidatorPubKey == nil {
 			// If this node is a validator & proposer in the current round, it will
@@ -204,7 +204,7 @@ func TestByzantinePrevoteEquivocation(t *testing.T) {
 		proposerAddr := lazyNodeState.privValidatorPubKey.Address()
 
 		block, err := lazyNodeState.blockExec.CreateProposalBlock(
-			ctx, lazyNodeState.Height, lazyNodeState.state, commit, proposerAddr, lazyNodeState.LastCommit.GetVotes())
+			ctx, lazyNodeState.Height, lazyNodeState.state, commit, proposerAddr)
 		require.NoError(t, err)
 		blockParts, err := block.MakePartSet(types.BlockPartSizeBytes)
 		require.NoError(t, err)

internal/consensus/reactor.go

@@ -794,10 +794,10 @@ func (r *Reactor) gossipVotesRoutine(ctx context.Context, ps *PeerState, voteCh
 		// catchup logic -- if peer is lagging by more than 1, send Commit
 		blockStoreBase := r.state.blockStore.Base()
 		if blockStoreBase > 0 && prs.Height != 0 && rs.Height >= prs.Height+2 && prs.Height >= blockStoreBase {
-			// Load the block commit for prs.Height, which contains precommit
+			// Load the block's extended commit for prs.Height, which contains precommit
 			// signatures for prs.Height.
-			if commit := r.state.blockStore.LoadBlockCommit(prs.Height); commit != nil {
-				if ok, err := r.pickSendVote(ctx, ps, commit, voteCh); err != nil {
+			if extCommit := r.state.blockStore.LoadBlockExtCommit(prs.Height); extCommit != nil {
+				if ok, err := r.pickSendVote(ctx, ps, extCommit, voteCh); err != nil {
 					return
 				} else if ok {
 					logger.Debug("picked Catchup commit to send", "height", prs.Height)

internal/consensus/replay_test.go

@@ -297,7 +297,7 @@ type simulatorTestSuite struct {
 	GenesisState sm.State
 	Config       *config.Config
 	Chain        []*types.Block
-	Commits      []*types.Commit
+	ExtCommits   []*types.ExtendedCommit
 	CleanupFunc  cleanupFunc
 
 	Mempool mempool.Mempool
@@ -579,10 +579,10 @@ func setupSimulator(ctx context.Context, t *testing.T) *simulatorTestSuite {
 	ensureNewRound(t, newRoundCh, height+1, 0)
 
 	sim.Chain = make([]*types.Block, 0)
-	sim.Commits = make([]*types.Commit, 0)
+	sim.ExtCommits = make([]*types.ExtendedCommit, 0)
 	for i := 1; i <= numBlocks; i++ {
 		sim.Chain = append(sim.Chain, css[0].blockStore.LoadBlock(int64(i)))
-		sim.Commits = append(sim.Commits, css[0].blockStore.LoadBlockCommit(int64(i)))
+		sim.ExtCommits = append(sim.ExtCommits, css[0].blockStore.LoadBlockExtCommit(int64(i)))
 	}
 
 	return sim
@@ -679,7 +679,7 @@ func testHandshakeReplay(
 	testValidatorsChange bool,
 ) {
 	var chain []*types.Block
-	var commits []*types.Commit
+	var extCommits []*types.ExtendedCommit
 	var store *mockBlockStore
 	var stateDB dbm.DB
 	var genesisState sm.State
@@ -699,7 +699,7 @@ func testHandshakeReplay(
 		genesisState = sim.GenesisState
 		cfg = sim.Config
 		chain = append([]*types.Block{}, sim.Chain...) // copy chain
-		commits = sim.Commits
+		extCommits = sim.ExtCommits
 		store = newMockBlockStore(t, cfg, genesisState.ConsensusParams)
 	} else { // test single node
 		testConfig, err := ResetConfig(t.TempDir(), fmt.Sprintf("%s_%v_s", t.Name(), mode))
@@ -718,7 +718,7 @@ func testHandshakeReplay(
 		err = wal.Start(ctx)
 		require.NoError(t, err)
 		t.Cleanup(func() { cancel(); wal.Wait() })
-		chain, commits = makeBlockchainFromWAL(t, wal)
+		chain, extCommits = makeBlockchainFromWAL(t, wal)
 		pubKey, err := privVal.GetPubKey(ctx)
 		require.NoError(t, err)
 		stateDB, genesisState, store = stateAndStore(t, cfg, pubKey, kvstore.ProtocolVersion)
@@ -726,7 +726,7 @@ func testHandshakeReplay(
 	}
 	stateStore := sm.NewStore(stateDB)
 	store.chain = chain
-	store.commits = commits
+	store.extCommits = extCommits
 
 	state := genesisState.Copy()
 	// run the chain through state.ApplyBlock to build up the tendermint state
@@ -1034,7 +1034,7 @@ func (app *badApp) Commit(context.Context) (*abci.ResponseCommit, error) {
 //--------------------------
 // utils for making blocks
 
-func makeBlockchainFromWAL(t *testing.T, wal WAL) ([]*types.Block, []*types.Commit) {
+func makeBlockchainFromWAL(t *testing.T, wal WAL) ([]*types.Block, []*types.ExtendedCommit) {
 	t.Helper()
 	var height int64
 
@@ -1047,10 +1047,10 @@ func makeBlockchainFromWAL(t *testing.T, wal WAL) ([]*types.Block, []*types.Comm
 	// 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)
@@ -1082,12 +1082,12 @@ func makeBlockchainFromWAL(t *testing.T, wal WAL) ([]*types.Block, []*types.Comm
 				require.Equal(t, block.Height, height+1,
 					"read bad block from wal. got height %d, expected %d", block.Height, height+1)
 
-				commitHeight := thisBlockCommit.Height
+				commitHeight := thisBlockExtCommit.Height
 				require.Equal(t, commitHeight, height+1,
 					"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:
@@ -1097,8 +1097,8 @@ func makeBlockchainFromWAL(t *testing.T, wal WAL) ([]*types.Block, []*types.Comm
 			require.NoError(t, err)
 		case *types.Vote:
 			if p.Type == tmproto.PrecommitType {
-				thisBlockCommit = types.NewCommit(p.Height, p.Round,
-					p.BlockID, []types.CommitSig{p.CommitSig()})
+				thisBlockExtCommit = types.NewExtendedCommit(p.Height, p.Round,
+					p.BlockID, []types.ExtendedCommitSig{p.ExtendedCommitSig()})
 			}
 		}
 	}
@@ -1113,12 +1113,12 @@ func makeBlockchainFromWAL(t *testing.T, wal WAL) ([]*types.Block, []*types.Comm
 	require.NoError(t, err)
 
 	require.Equal(t, block.Height, height+1, "read bad block from wal. got height %d, expected %d", block.Height, height+1)
-	commitHeight := thisBlockCommit.Height
+	commitHeight := thisBlockExtCommit.Height
 	require.Equal(t, commitHeight, height+1, "commit does not match. got height %d, expected %d", commitHeight, height+1)
 
 	blocks = append(blocks, block)
-	commits = append(commits, thisBlockCommit)
-	return blocks, commits
+	extCommits = append(extCommits, thisBlockExtCommit)
+	return blocks, extCommits
 }
 
 func readPieceFromWAL(msg *TimedWALMessage) interface{} {
@@ -1162,14 +1162,16 @@ 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
 }
 
+var _ sm.BlockStore = &mockBlockStore{}
+
 // TODO: NewBlockStore(db.NewMemDB) ...
 func newMockBlockStore(t *testing.T, cfg *config.Config, params types.ConsensusParams) *mockBlockStore {
 	return &mockBlockStore{
@@ -1198,20 +1200,24 @@ func (bs *mockBlockStore) LoadBlockMeta(height int64) *types.BlockMeta {
 	}
 }
 func (bs *mockBlockStore) LoadBlockPart(height int64, index int) *types.Part { return nil }
-func (bs *mockBlockStore) SaveBlock(block *types.Block, blockParts *types.PartSet, seenCommit *types.Commit) {
+func (bs *mockBlockStore) SaveBlock(block *types.Block, blockParts *types.PartSet, seenCommit *types.ExtendedCommit) {
 }
+
 func (bs *mockBlockStore) LoadBlockCommit(height int64) *types.Commit {
-	return bs.commits[height-1]
+	return bs.extCommits[height-1].StripExtensions()
 }
 func (bs *mockBlockStore) LoadSeenCommit() *types.Commit {
-	return bs.commits[len(bs.commits)-1]
+	return bs.extCommits[len(bs.extCommits)-1].StripExtensions()
+}
+func (bs *mockBlockStore) LoadBlockExtCommit(height int64) *types.ExtendedCommit {
+	return bs.extCommits[height-1]
 }
 
 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

internal/consensus/state.go

@@ -695,19 +695,15 @@ func (cs *State) sendInternalMessage(ctx context.Context, mi msgInfo) {
 // Reconstruct LastCommit from SeenCommit, which we saved along with the block,
 // (which happens even before saving the state)
 func (cs *State) reconstructLastCommit(state sm.State) {
-	commit := cs.blockStore.LoadSeenCommit()
-	if commit == nil || commit.Height != state.LastBlockHeight {
-		commit = cs.blockStore.LoadBlockCommit(state.LastBlockHeight)
-	}
-
-	if commit == nil {
+	extCommit := cs.blockStore.LoadBlockExtCommit(state.LastBlockHeight)
+	if extCommit == nil {
 		panic(fmt.Sprintf(
 			"failed to reconstruct last commit; commit for height %v not found",
 			state.LastBlockHeight,
 		))
 	}
 
-	lastPrecommits := types.CommitToVoteSet(state.ChainID, commit, state.LastValidators)
+	lastPrecommits := extCommit.ToVoteSet(state.ChainID, state.LastValidators)
 	if !lastPrecommits.HasTwoThirdsMajority() {
 		panic("failed to reconstruct last commit; does not have +2/3 maj")
 	}
@@ -1400,16 +1396,17 @@ func (cs *State) createProposalBlock(ctx context.Context) (*types.Block, error)
 		return nil, errors.New("entered createProposalBlock with privValidator being nil")
 	}
 
-	var commit *types.Commit
+	//TODO: wouldn't it be easier if CreateProposalBlock accepted cs.LastCommit directly?
+	var extCommit *types.ExtendedCommit
 	switch {
 	case cs.Height == cs.state.InitialHeight:
 		// We're creating a proposal for the first block.
 		// The commit is empty, but not nil.
-		commit = types.NewCommit(0, 0, types.BlockID{}, nil)
+		extCommit = types.NewExtendedCommit(0, 0, types.BlockID{}, nil)
 
 	case cs.LastCommit.HasTwoThirdsMajority():
 		// Make the commit from LastCommit
-		commit = cs.LastCommit.MakeCommit()
+		extCommit = cs.LastCommit.MakeExtendedCommit()
 
 	default: // This shouldn't happen.
 		cs.logger.Error("propose step; cannot propose anything without commit for the previous block")
@@ -1425,7 +1422,7 @@ func (cs *State) createProposalBlock(ctx context.Context) (*types.Block, error)
 
 	proposerAddr := cs.privValidatorPubKey.Address()
 
-	ret, err := cs.blockExec.CreateProposalBlock(ctx, cs.Height, cs.state, commit, proposerAddr, cs.LastCommit.GetVotes())
+	ret, err := cs.blockExec.CreateProposalBlock(ctx, cs.Height, cs.state, extCommit, proposerAddr)
 	if err != nil {
 		panic(err)
 	}
@@ -1923,8 +1920,7 @@ func (cs *State) finalizeCommit(ctx context.Context, height int64) {
 		// NOTE: the seenCommit is local justification to commit this block,
 		// but may differ from the LastCommit included in the next block
 		precommits := cs.Votes.Precommits(cs.CommitRound)
-		seenCommit := precommits.MakeCommit()
-		cs.blockStore.SaveBlock(block, blockParts, seenCommit)
+		cs.blockStore.SaveBlock(block, blockParts, precommits.MakeExtendedCommit())
 	} else {
 		// Happens during replay if we already saved the block but didn't commit
 		logger.Debug("calling finalizeCommit on already stored block", "height", block.Height)

internal/evidence/pool_test.go

@@ -249,8 +249,8 @@ func TestEvidencePoolUpdate(t *testing.T) {
 		evidenceChainID,
 	)
 	require.NoError(t, err)
-	lastCommit := makeCommit(height, val.PrivKey.PubKey().Address())
-	block := types.MakeBlock(height+1, []types.Tx{}, lastCommit, []types.Evidence{ev})
+	lastExtCommit := makeExtCommit(height, val.PrivKey.PubKey().Address())
+	block := types.MakeBlock(height+1, []types.Tx{}, lastExtCommit.StripExtensions(), []types.Evidence{ev})
 
 	// update state (partially)
 	state.LastBlockHeight = height + 1
@@ -568,8 +568,8 @@ func initializeBlockStore(db dbm.DB, state sm.State, valAddr []byte) (*store.Blo
 	blockStore := store.NewBlockStore(db)
 
 	for i := int64(1); i <= state.LastBlockHeight; i++ {
-		lastCommit := makeCommit(i-1, valAddr)
-		block := sf.MakeBlock(state, i, lastCommit)
+		lastCommit := makeExtCommit(i-1, valAddr)
+		block := sf.MakeBlock(state, i, lastCommit.StripExtensions())
 
 		block.Header.Time = defaultEvidenceTime.Add(time.Duration(i) * time.Minute)
 		block.Header.Version = version.Consensus{Block: version.BlockProtocol, App: 1}
@@ -579,22 +579,22 @@ func initializeBlockStore(db dbm.DB, state sm.State, valAddr []byte) (*store.Blo
 			return nil, err
 		}
 
-		seenCommit := makeCommit(i, valAddr)
+		seenCommit := makeExtCommit(i, valAddr)
 		blockStore.SaveBlock(block, partSet, seenCommit)
 	}
 
 	return blockStore, nil
 }
 
-func makeCommit(height int64, valAddr []byte) *types.Commit {
-	commitSigs := []types.CommitSig{{
+func makeExtCommit(height int64, valAddr []byte) *types.ExtendedCommit {
+	extCommitSigs := []types.ExtendedCommitSig{{
 		BlockIDFlag:      types.BlockIDFlagCommit,
 		ValidatorAddress: valAddr,
 		Timestamp:        defaultEvidenceTime,
 		Signature:        []byte("Signature"),
 	}}
 
-	return types.NewCommit(height, 0, types.BlockID{}, commitSigs)
+	return types.NewExtendedCommit(height, 0, types.BlockID{}, extCommitSigs)
 }
 
 func defaultTestPool(ctx context.Context, t *testing.T, height int64) (*evidence.Pool, types.MockPV, *eventbus.EventBus) {

internal/evidence/verify_test.go

@@ -234,8 +234,9 @@ func TestVerifyLightClientAttack_Equivocation(t *testing.T) {
 	// except the last validator vote twice
 	blockID := factory.MakeBlockIDWithHash(conflictingHeader.Hash())
 	voteSet := types.NewVoteSet(evidenceChainID, 10, 1, tmproto.SignedMsgType(2), conflictingVals)
-	commit, err := factory.MakeCommit(ctx, blockID, 10, 1, voteSet, conflictingPrivVals[:4], defaultEvidenceTime)
+	extCommit, err := factory.MakeExtendedCommit(ctx, blockID, 10, 1, voteSet, conflictingPrivVals[:4], defaultEvidenceTime)
 	require.NoError(t, err)
+	commit := extCommit.StripExtensions()
 
 	ev := &types.LightClientAttackEvidence{
 		ConflictingBlock: &types.LightBlock{
@@ -253,9 +254,10 @@ func TestVerifyLightClientAttack_Equivocation(t *testing.T) {
 
 	trustedBlockID := makeBlockID(trustedHeader.Hash(), 1000, []byte("partshash"))
 	trustedVoteSet := types.NewVoteSet(evidenceChainID, 10, 1, tmproto.SignedMsgType(2), conflictingVals)
-	trustedCommit, err := factory.MakeCommit(ctx, trustedBlockID, 10, 1,
+	trustedExtCommit, err := factory.MakeExtendedCommit(ctx, trustedBlockID, 10, 1,
 		trustedVoteSet, conflictingPrivVals, defaultEvidenceTime)
 	require.NoError(t, err)
+	trustedCommit := trustedExtCommit.StripExtensions()
 
 	trustedSignedHeader := &types.SignedHeader{
 		Header: trustedHeader,
@@ -335,8 +337,9 @@ func TestVerifyLightClientAttack_Amnesia(t *testing.T) {
 	// except the last validator vote twice. However this time the commits are of different rounds.
 	blockID := makeBlockID(conflictingHeader.Hash(), 1000, []byte("partshash"))
 	voteSet := types.NewVoteSet(evidenceChainID, height, 0, tmproto.SignedMsgType(2), conflictingVals)
-	commit, err := factory.MakeCommit(ctx, blockID, height, 0, voteSet, conflictingPrivVals, defaultEvidenceTime)
+	extCommit, err := factory.MakeExtendedCommit(ctx, blockID, height, 0, voteSet, conflictingPrivVals, defaultEvidenceTime)
 	require.NoError(t, err)
+	commit := extCommit.StripExtensions()
 
 	ev := &types.LightClientAttackEvidence{
 		ConflictingBlock: &types.LightBlock{
@@ -354,9 +357,10 @@ func TestVerifyLightClientAttack_Amnesia(t *testing.T) {
 
 	trustedBlockID := makeBlockID(trustedHeader.Hash(), 1000, []byte("partshash"))
 	trustedVoteSet := types.NewVoteSet(evidenceChainID, height, 1, tmproto.SignedMsgType(2), conflictingVals)
-	trustedCommit, err := factory.MakeCommit(ctx, trustedBlockID, height, 1,
+	trustedExtCommit, err := factory.MakeExtendedCommit(ctx, trustedBlockID, height, 1,
 		trustedVoteSet, conflictingPrivVals, defaultEvidenceTime)
 	require.NoError(t, err)
+	trustedCommit := trustedExtCommit.StripExtensions()
 
 	trustedSignedHeader := &types.SignedHeader{
 		Header: trustedHeader,
@@ -550,8 +554,9 @@ func makeLunaticEvidence(
 
 	blockID := factory.MakeBlockIDWithHash(conflictingHeader.Hash())
 	voteSet := types.NewVoteSet(evidenceChainID, height, 1, tmproto.SignedMsgType(2), conflictingVals)
-	commit, err := factory.MakeCommit(ctx, blockID, height, 1, voteSet, conflictingPrivVals, defaultEvidenceTime)
+	extCommit, err := factory.MakeExtendedCommit(ctx, blockID, height, 1, voteSet, conflictingPrivVals, defaultEvidenceTime)
 	require.NoError(t, err)
+	commit := extCommit.StripExtensions()
 
 	ev = &types.LightClientAttackEvidence{
 		ConflictingBlock: &types.LightBlock{
@@ -578,8 +583,9 @@ func makeLunaticEvidence(
 	trustedBlockID := factory.MakeBlockIDWithHash(trustedHeader.Hash())
 	trustedVals, privVals := factory.ValidatorSet(ctx, t, totalVals, defaultVotingPower)
 	trustedVoteSet := types.NewVoteSet(evidenceChainID, height, 1, tmproto.SignedMsgType(2), trustedVals)
-	trustedCommit, err := factory.MakeCommit(ctx, trustedBlockID, height, 1, trustedVoteSet, privVals, defaultEvidenceTime)
+	trustedExtCommit, err := factory.MakeExtendedCommit(ctx, trustedBlockID, height, 1, trustedVoteSet, privVals, defaultEvidenceTime)
 	require.NoError(t, err)
+	trustedCommit := trustedExtCommit.StripExtensions()
 
 	trusted = &types.LightBlock{
 		SignedHeader: &types.SignedHeader{

internal/state/execution.go

@@ -7,7 +7,6 @@ import (
 
 	abciclient "github.com/tendermint/tendermint/abci/client"
 	abci "github.com/tendermint/tendermint/abci/types"
-	"github.com/tendermint/tendermint/crypto"
 	"github.com/tendermint/tendermint/crypto/encoding"
 	"github.com/tendermint/tendermint/crypto/merkle"
 	"github.com/tendermint/tendermint/internal/eventbus"
@@ -87,9 +86,8 @@ func (blockExec *BlockExecutor) CreateProposalBlock(
 	ctx context.Context,
 	height int64,
 	state State,
-	commit *types.Commit,
+	extCommit *types.ExtendedCommit,
 	proposerAddr []byte,
-	votes []*types.Vote,
 ) (*types.Block, error) {
 
 	maxBytes := state.ConsensusParams.Block.MaxBytes
@@ -101,15 +99,15 @@ func (blockExec *BlockExecutor) CreateProposalBlock(
 	maxDataBytes := types.MaxDataBytes(maxBytes, evSize, state.Validators.Size())
 
 	txs := blockExec.mempool.ReapMaxBytesMaxGas(maxDataBytes, maxGas)
+	commit := extCommit.StripExtensions()
 	block := state.MakeBlock(height, txs, commit, evidence, proposerAddr)
 
-	localLastCommit := buildLastCommitInfo(block, blockExec.store, state.InitialHeight)
 	rpp, err := blockExec.appClient.PrepareProposal(
 		ctx,
 		&abci.RequestPrepareProposal{
 			MaxTxBytes:          maxDataBytes,
 			Txs:                 block.Txs.ToSliceOfBytes(),
-			LocalLastCommit:     extendedCommitInfo(localLastCommit, votes),
+			LocalLastCommit:     extendedCommitInfo(*extCommit),
 			ByzantineValidators: block.Evidence.ToABCI(),
 			Height:              block.Height,
 			Time:                block.Time,
@@ -416,43 +414,28 @@ func buildLastCommitInfo(block *types.Block, store Store, initialHeight int64) a
 	}
 }
 
-// extendedCommitInfo expects a CommitInfo struct along with all of the
-// original votes relating to that commit, including their vote extensions. The
-// order of votes does not matter.
-func extendedCommitInfo(c abci.CommitInfo, votes []*types.Vote) abci.ExtendedCommitInfo {
-	if len(c.Votes) != len(votes) {
-		panic(fmt.Sprintf("extendedCommitInfo: number of votes from commit differ from the number of votes supplied (%d != %d)", len(c.Votes), len(votes)))
-	}
-	votesByVal := make(map[string]*types.Vote)
-	for _, vote := range votes {
-		if vote != nil {
-			valAddr := vote.ValidatorAddress.String()
-			if _, ok := votesByVal[valAddr]; ok {
-				panic(fmt.Sprintf("extendedCommitInfo: found duplicate vote for validator with address %s", valAddr))
-			}
-			votesByVal[valAddr] = vote
-		}
-	}
-	vs := make([]abci.ExtendedVoteInfo, len(c.Votes))
-	for i := range vs {
+// extendedCommitInfo expects an ExtendedCommitInfo, which includes the
+// original precommit votes along with their vote extensions.
+// Then, it populates the corresponding ABCI protobuf structures.
+func extendedCommitInfo(extCommit types.ExtendedCommit) abci.ExtendedCommitInfo {
+	vs := make([]abci.ExtendedVoteInfo, len(extCommit.ExtendedSignatures))
+	for i, ecs := range extCommit.ExtendedSignatures {
 		var ext []byte
-		// votes[i] will be nil if c.Votes[i].SignedLastBlock is false
-		if c.Votes[i].SignedLastBlock {
-			valAddr := crypto.Address(c.Votes[i].Validator.Address).String()
-			vote, ok := votesByVal[valAddr]
-			if !ok || vote == nil {
-				panic(fmt.Sprintf("extendedCommitInfo: validator with address %s signed last block, but could not find vote for it", valAddr))
-			}
-			ext = vote.Extension
+		if ecs.ForBlock() {
+			ext = ecs.VoteExtension
 		}
 		vs[i] = abci.ExtendedVoteInfo{
-			Validator:       c.Votes[i].Validator,
-			SignedLastBlock: c.Votes[i].SignedLastBlock,
+			Validator: abci.Validator{
+				Address: ecs.ValidatorAddress,
+				//TODO: Important: why do we need power here?
+				Power: 0,
+			},
+			SignedLastBlock: ecs.ForBlock(),
 			VoteExtension:   ext,
 		}
 	}
 	return abci.ExtendedCommitInfo{
-		Round: c.Round,
+		Round: extCommit.Round,
 		Votes: vs,
 	}
 }

internal/state/execution_test.go

@@ -79,9 +79,10 @@ func TestApplyBlock(t *testing.T) {
 	assert.EqualValues(t, 1, state.Version.Consensus.App, "App version wasn't updated")
 }
 
-// TestFinalizeBlockDecidedLastCommit ensures we correctly send the DecidedLastCommit to the
-// application. The test ensures that the DecidedLastCommit properly reflects
-// which validators signed the preceding block.
+// TestFinalizeBlockDecidedLastCommit ensures we correctly send the
+// DecidedLastCommit to the application. The test ensures that the
+// DecidedLastCommit properly reflects which validators signed the preceding
+// block.
 func TestFinalizeBlockDecidedLastCommit(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
@@ -96,7 +97,7 @@ func TestFinalizeBlockDecidedLastCommit(t *testing.T) {
 
 	state, stateDB, privVals := makeState(t, 7, 1)
 	stateStore := sm.NewStore(stateDB)
-	absentSig := types.NewCommitSigAbsent()
+	absentSig := types.NewExtendedCommitSigAbsent()
 
 	testCases := []struct {
 		name             string
@@ -134,12 +135,12 @@ func TestFinalizeBlockDecidedLastCommit(t *testing.T) {
 
 			for idx, isAbsent := range tc.absentCommitSigs {
 				if isAbsent {
-					lastCommit.Signatures[idx] = absentSig
+					lastCommit.ExtendedSignatures[idx] = absentSig
 				}
 			}
 
 			// block for height 2
-			block := sf.MakeBlock(state, 2, lastCommit)
+			block := sf.MakeBlock(state, 2, lastCommit.StripExtensions())
 			bps, err := block.MakePartSet(testPartSize)
 			require.NoError(t, err)
 			blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: bps.Header()}
@@ -653,8 +654,8 @@ func TestEmptyPrepareProposal(t *testing.T) {
 		sm.NopMetrics(),
 	)
 	pa, _ := state.Validators.GetByIndex(0)
-	commit, votes := makeValidCommit(ctx, t, height, types.BlockID{}, state.Validators, privVals)
-	_, err = blockExec.CreateProposalBlock(ctx, height, state, commit, pa, votes)
+	commit, _ := makeValidCommit(ctx, t, height, types.BlockID{}, state.Validators, privVals)
+	_, err = blockExec.CreateProposalBlock(ctx, height, state, commit, pa)
 	require.NoError(t, err)
 }
 
@@ -708,8 +709,8 @@ func TestPrepareProposalErrorOnNonExistingRemoved(t *testing.T) {
 		sm.NopMetrics(),
 	)
 	pa, _ := state.Validators.GetByIndex(0)
-	commit, votes := makeValidCommit(ctx, t, height, types.BlockID{}, state.Validators, privVals)
-	block, err := blockExec.CreateProposalBlock(ctx, height, state, commit, pa, votes)
+	commit, _ := makeValidCommit(ctx, t, height, types.BlockID{}, state.Validators, privVals)
+	block, err := blockExec.CreateProposalBlock(ctx, height, state, commit, pa)
 	require.ErrorContains(t, err, "new transaction incorrectly marked as removed")
 	require.Nil(t, block)
 
@@ -764,8 +765,8 @@ func TestPrepareProposalRemoveTxs(t *testing.T) {
 		sm.NopMetrics(),
 	)
 	pa, _ := state.Validators.GetByIndex(0)
-	commit, votes := makeValidCommit(ctx, t, height, types.BlockID{}, state.Validators, privVals)
-	block, err := blockExec.CreateProposalBlock(ctx, height, state, commit, pa, votes)
+	commit, _ := makeValidCommit(ctx, t, height, types.BlockID{}, state.Validators, privVals)
+	block, err := blockExec.CreateProposalBlock(ctx, height, state, commit, pa)
 	require.NoError(t, err)
 	require.Len(t, block.Data.Txs.ToSliceOfBytes(), len(trs)-2)
 
@@ -823,8 +824,8 @@ func TestPrepareProposalAddedTxsIncluded(t *testing.T) {
 		sm.NopMetrics(),
 	)
 	pa, _ := state.Validators.GetByIndex(0)
-	commit, votes := makeValidCommit(ctx, t, height, types.BlockID{}, state.Validators, privVals)
-	block, err := blockExec.CreateProposalBlock(ctx, height, state, commit, pa, votes)
+	commit, _ := makeValidCommit(ctx, t, height, types.BlockID{}, state.Validators, privVals)
+	block, err := blockExec.CreateProposalBlock(ctx, height, state, commit, pa)
 	require.NoError(t, err)
 
 	require.Equal(t, txs[0], block.Data.Txs[0])
@@ -879,8 +880,8 @@ func TestPrepareProposalReorderTxs(t *testing.T) {
 		sm.NopMetrics(),
 	)
 	pa, _ := state.Validators.GetByIndex(0)
-	commit, votes := makeValidCommit(ctx, t, height, types.BlockID{}, state.Validators, privVals)
-	block, err := blockExec.CreateProposalBlock(ctx, height, state, commit, pa, votes)
+	commit, _ := makeValidCommit(ctx, t, height, types.BlockID{}, state.Validators, privVals)
+	block, err := blockExec.CreateProposalBlock(ctx, height, state, commit, pa)
 	require.NoError(t, err)
 	for i, tx := range block.Data.Txs {
 		require.Equal(t, types.Tx(trs[i].Tx), tx)
@@ -939,9 +940,8 @@ func TestPrepareProposalErrorOnTooManyTxs(t *testing.T) {
 		sm.NopMetrics(),
 	)
 	pa, _ := state.Validators.GetByIndex(0)
-	commit, votes := makeValidCommit(ctx, t, height, types.BlockID{}, state.Validators, privVals)
-
-	block, err := blockExec.CreateProposalBlock(ctx, height, state, commit, pa, votes)
+	commit, _ := makeValidCommit(ctx, t, height, types.BlockID{}, state.Validators, privVals)
+	block, err := blockExec.CreateProposalBlock(ctx, height, state, commit, pa)
 	require.ErrorContains(t, err, "transaction data size exceeds maximum")
 	require.Nil(t, block, "")
 
@@ -991,15 +991,66 @@ func TestPrepareProposalErrorOnPrepareProposalError(t *testing.T) {
 		sm.NopMetrics(),
 	)
 	pa, _ := state.Validators.GetByIndex(0)
-	commit, votes := makeValidCommit(ctx, t, height, types.BlockID{}, state.Validators, privVals)
-
-	block, err := blockExec.CreateProposalBlock(ctx, height, state, commit, pa, votes)
+	commit, _ := makeValidCommit(ctx, t, height, types.BlockID{}, state.Validators, privVals)
+	block, err := blockExec.CreateProposalBlock(ctx, height, state, commit, pa)
 	require.Nil(t, block)
 	require.ErrorContains(t, err, "an injected error")
 
 	mp.AssertExpectations(t)
 }
 
+// TestPrepareProposalNoErrorOnInitialHeight tests that the initial height edge
+// case does not create an issue for the PrepareProposal call. The initial height
+// does not have a LastCommit nor does it have vote extensions from the previous
+// height, which other calls to PrepareProposal expect
+func TestPrepareProposalNoErrorOnInitialHeight(t *testing.T) {
+	const height = 1
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	logger := log.NewNopLogger()
+	eventBus := eventbus.NewDefault(logger)
+	require.NoError(t, eventBus.Start(ctx))
+
+	state, stateDB, _ := makeState(t, 1, height)
+	require.Equal(t, height, int(state.InitialHeight))
+	stateStore := sm.NewStore(stateDB)
+
+	evpool := &mocks.EvidencePool{}
+	evpool.On("PendingEvidence", mock.Anything).Return([]types.Evidence{}, int64(0))
+
+	txs := factory.MakeNTxs(height, 10)
+	mp := &mpmocks.Mempool{}
+	mp.On("ReapMaxBytesMaxGas", mock.Anything, mock.Anything).Return(types.Txs(txs))
+	app := abcimocks.NewApplication(t)
+	app.On("PrepareProposal", mock.Anything, mock.Anything).Return(&abci.ResponsePrepareProposal{}, nil)
+
+	cc := abciclient.NewLocalClient(logger, app)
+	proxyApp := proxy.New(cc, logger, proxy.NopMetrics())
+	err := proxyApp.Start(ctx)
+	require.NoError(t, err)
+
+	blockExec := sm.NewBlockExecutor(
+		stateStore,
+		logger,
+		proxyApp,
+		mp,
+		evpool,
+		nil,
+		eventBus,
+		sm.NopMetrics(),
+	)
+	pa, _ := state.Validators.GetByIndex(0)
+	// The initial height has an empty commit. There was no previous round
+	// so there are no votes and no vote extensions for the previous block.
+	ec := types.NewExtendedCommit(height, 0, types.BlockID{}, nil)
+	block, err := blockExec.CreateProposalBlock(ctx, height, state, ec, pa)
+	require.NotNil(t, block)
+	require.NoError(t, err)
+
+	mp.AssertExpectations(t)
+}
+
 func makeBlockID(hash []byte, partSetSize uint32, partSetHash []byte) types.BlockID {
 	var (
 		h   = make([]byte, crypto.HashSize)

internal/state/helpers_test.go

@@ -39,7 +39,7 @@ func makeAndCommitGoodBlock(
 	blockExec *sm.BlockExecutor,
 	privVals map[string]types.PrivValidator,
 	evidence []types.Evidence,
-) (sm.State, types.BlockID, *types.Commit) {
+) (sm.State, types.BlockID, *types.ExtendedCommit) {
 	t.Helper()
 
 	// A good block passes
@@ -82,19 +82,19 @@ func makeValidCommit(
 	blockID types.BlockID,
 	vals *types.ValidatorSet,
 	privVals map[string]types.PrivValidator,
-) (*types.Commit, []*types.Vote) {
+) (*types.ExtendedCommit, []*types.Vote) {
 	t.Helper()
-	sigs := make([]types.CommitSig, vals.Size())
+	sigs := make([]types.ExtendedCommitSig, vals.Size())
 	votes := make([]*types.Vote, vals.Size())
 	for i := 0; i < vals.Size(); i++ {
 		_, val := vals.GetByIndex(int32(i))
 		vote, err := factory.MakeVote(ctx, privVals[val.Address.String()], chainID, int32(i), height, 0, 2, blockID, time.Now())
 		require.NoError(t, err)
-		sigs[i] = vote.CommitSig()
+		sigs[i] = vote.ExtendedCommitSig()
 		votes[i] = vote
 	}
 
-	return types.NewCommit(height, 0, blockID, sigs), votes
+	return types.NewExtendedCommit(height, 0, blockID, sigs), votes
 }
 
 func makeState(t *testing.T, nVals, height int) (sm.State, dbm.DB, map[string]types.PrivValidator) {

internal/state/mocks/block_store.go

@@ -107,6 +107,22 @@ func (_m *BlockStore) LoadBlockCommit(height int64) *types.Commit {
 	return r0
 }
 
+// LoadBlockExtCommit provides a mock function with given fields: height
+func (_m *BlockStore) LoadBlockExtCommit(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)
@@ -193,7 +209,7 @@ func (_m *BlockStore) PruneBlocks(height int64) (uint64, error) {
 }
 
 // SaveBlock provides a mock function with given fields: block, blockParts, seenCommit
-func (_m *BlockStore) SaveBlock(block *types.Block, blockParts *types.PartSet, seenCommit *types.Commit) {
+func (_m *BlockStore) SaveBlock(block *types.Block, blockParts *types.PartSet, seenCommit *types.ExtendedCommit) {
 	_m.Called(block, blockParts, seenCommit)
 }
 

internal/state/services.go

@@ -26,7 +26,7 @@ type BlockStore interface {
 	LoadBlockMeta(height int64) *types.BlockMeta
 	LoadBlock(height int64) *types.Block
 
-	SaveBlock(block *types.Block, blockParts *types.PartSet, seenCommit *types.Commit)
+	SaveBlock(block *types.Block, blockParts *types.PartSet, seenCommit *types.ExtendedCommit)
 
 	PruneBlocks(height int64) (uint64, error)
 
@@ -36,6 +36,7 @@ type BlockStore interface {
 
 	LoadBlockCommit(height int64) *types.Commit
 	LoadSeenCommit() *types.Commit
+	LoadBlockExtCommit(height int64) *types.ExtendedCommit
 }
 
 //-----------------------------------------------------------------------------

internal/state/store.go

@@ -26,6 +26,8 @@ const (
 
 //------------------------------------------------------------------------
 
+// NB: Before modifying these, cross-check them with those in
+// internal/store/store.go
 const (
 	// prefixes are unique across all tm db's
 	prefixValidators      = int64(5)

internal/state/validation_test.go

@@ -66,6 +66,7 @@ func TestValidateBlockHeader(t *testing.T) {
 		sm.NopMetrics(),
 	)
 	lastCommit := types.NewCommit(0, 0, types.BlockID{}, nil)
+	var lastExtCommit *types.ExtendedCommit
 
 	// some bad values
 	wrongHash := crypto.Checksum([]byte("this hash is wrong"))
@@ -121,8 +122,9 @@ func TestValidateBlockHeader(t *testing.T) {
 		/*
 			A good block passes
 		*/
-		state, _, lastCommit = makeAndCommitGoodBlock(ctx, t,
+		state, _, lastExtCommit = makeAndCommitGoodBlock(ctx, t,
 			state, height, lastCommit, state.Validators.GetProposer().Address, blockExec, privVals, nil)
+		lastCommit = lastExtCommit.StripExtensions()
 	}
 
 	nextHeight := validationTestsStopHeight
@@ -170,6 +172,7 @@ func TestValidateBlockCommit(t *testing.T) {
 		sm.NopMetrics(),
 	)
 	lastCommit := types.NewCommit(0, 0, types.BlockID{}, nil)
+	var lastExtCommit *types.ExtendedCommit
 	wrongSigsCommit := types.NewCommit(1, 0, types.BlockID{}, nil)
 	badPrivVal := types.NewMockPV()
 
@@ -220,7 +223,7 @@ func TestValidateBlockCommit(t *testing.T) {
 			A good block passes
 		*/
 		var blockID types.BlockID
-		state, blockID, lastCommit = makeAndCommitGoodBlock(
+		state, blockID, lastExtCommit = makeAndCommitGoodBlock(
 			ctx,
 			t,
 			state,
@@ -231,6 +234,7 @@ func TestValidateBlockCommit(t *testing.T) {
 			privVals,
 			nil,
 		)
+		lastCommit = lastExtCommit.StripExtensions()
 
 		/*
 			wrongSigsCommit is fine except for the extra bad precommit
@@ -320,6 +324,7 @@ func TestValidateBlockEvidence(t *testing.T) {
 		sm.NopMetrics(),
 	)
 	lastCommit := types.NewCommit(0, 0, types.BlockID{}, nil)
+	var lastExtCommit *types.ExtendedCommit
 
 	for height := int64(1); height < validationTestsStopHeight; height++ {
 		proposerAddr := state.Validators.GetProposer().Address
@@ -364,7 +369,7 @@ func TestValidateBlockEvidence(t *testing.T) {
 			evidence = append(evidence, newEv)
 		}
 
-		state, _, lastCommit = makeAndCommitGoodBlock(
+		state, _, lastExtCommit = makeAndCommitGoodBlock(
 			ctx,
 			t,
 			state,
@@ -375,6 +380,7 @@ func TestValidateBlockEvidence(t *testing.T) {
 			privVals,
 			evidence,
 		)
+		lastCommit = lastExtCommit.StripExtensions()
 
 	}
 }

internal/statesync/reactor_test.go

@@ -856,12 +856,12 @@ func mockLB(ctx context.Context, t *testing.T, height int64, time time.Time, las
 	header.ConsensusHash = types.DefaultConsensusParams().HashConsensusParams()
 	lastBlockID = factory.MakeBlockIDWithHash(header.Hash())
 	voteSet := types.NewVoteSet(factory.DefaultTestChainID, height, 0, tmproto.PrecommitType, currentVals)
-	commit, err := factory.MakeCommit(ctx, lastBlockID, height, 0, voteSet, currentPrivVals, time)
+	extCommit, err := factory.MakeExtendedCommit(ctx, lastBlockID, height, 0, voteSet, currentPrivVals, time)
 	require.NoError(t, err)
 	return nextVals, nextPrivVals, &types.LightBlock{
 		SignedHeader: &types.SignedHeader{
 			Header: header,
-			Commit: commit,
+			Commit: extCommit.StripExtensions(),
 		},
 		ValidatorSet: currentVals,
 	}

internal/store/store.go

@@ -273,11 +273,31 @@ func (bs *BlockStore) LoadBlockCommit(height int64) *types.Commit {
 	}
 	commit, err := types.CommitFromProto(pbc)
 	if err != nil {
-		panic(fmt.Errorf("error reading block commit: %w", err))
+		panic(fmt.Errorf("error from proto block commit: %w", err))
 	}
 	return commit
 }
 
+func (bs *BlockStore) LoadBlockExtCommit(height int64) *types.ExtendedCommit {
+	var pbec = new(tmproto.ExtendedCommit)
+	bz, err := bs.db.Get(extCommitKey(height))
+	if err != nil {
+		panic(err)
+	}
+	if len(bz) == 0 {
+		return nil
+	}
+	err = proto.Unmarshal(bz, pbec)
+	if err != nil {
+		panic(fmt.Errorf("decoding extended commit: %w", err))
+	}
+	extCommit, err := types.ExtendedCommitFromProto(pbec)
+	if err != nil {
+		panic(fmt.Errorf("converting extended commit: %w", err))
+	}
+	return extCommit
+}
+
 // LoadSeenCommit returns the last locally seen Commit before being
 // cannonicalized. This is useful when we've seen a commit, but there
 // has not yet been a new block at `height + 1` that includes this
@@ -298,7 +318,7 @@ func (bs *BlockStore) LoadSeenCommit() *types.Commit {
 
 	commit, err := types.CommitFromProto(pbc)
 	if err != nil {
-		panic(fmt.Errorf("error from proto commit: %w", err))
+		panic(fmt.Errorf("converting seen commit: %w", err))
 	}
 	return commit
 }
@@ -446,7 +466,7 @@ func (bs *BlockStore) batchDelete(
 //             If all the nodes restart after committing a block,
 //             we need this to reload the precommits to catch-up nodes to the
 //             most recent height.  Otherwise they'd stall at H-1.
-func (bs *BlockStore) SaveBlock(block *types.Block, blockParts *types.PartSet, seenCommit *types.Commit) {
+func (bs *BlockStore) SaveBlock(block *types.Block, blockParts *types.PartSet, seenCommit *types.ExtendedCommit) {
 	if block == nil {
 		panic("BlockStore can only save a non-nil block")
 	}
@@ -462,6 +482,10 @@ func (bs *BlockStore) SaveBlock(block *types.Block, blockParts *types.PartSet, s
 	if !blockParts.IsComplete() {
 		panic("BlockStore can only save complete block part sets")
 	}
+	if height != seenCommit.Height {
+		panic(fmt.Sprintf("BlockStore cannot save seen commit of a different height (block: %d, commit: %d)",
+			height, seenCommit.Height))
+	}
 
 	// Save block parts. This must be done before the block meta, since callers
 	// typically load the block meta first as an indication that the block exists
@@ -494,12 +518,18 @@ func (bs *BlockStore) SaveBlock(block *types.Block, blockParts *types.PartSet, s
 	}
 
 	// Save seen commit (seen +2/3 precommits for block)
-	pbsc := seenCommit.ToProto()
+	pbsc := seenCommit.StripExtensions().ToProto()
 	seenCommitBytes := mustEncode(pbsc)
 	if err := batch.Set(seenCommitKey(), seenCommitBytes); err != nil {
 		panic(err)
 	}
 
+	pbec := seenCommit.ToProto()
+	extCommitBytes := mustEncode(pbec)
+	if err := batch.Set(extCommitKey(height), extCommitBytes); err != nil {
+		panic(err)
+	}
+
 	if err := batch.WriteSync(); err != nil {
 		panic(err)
 	}
@@ -579,6 +609,8 @@ func (bs *BlockStore) Close() error {
 //---------------------------------- KEY ENCODING -----------------------------------------
 
 // key prefixes
+// NB: Before modifying these, cross-check them with those in
+// internal/state/store.go
 const (
 	// prefixes are unique across all tm db's
 	prefixBlockMeta   = int64(0)
@@ -586,6 +618,7 @@ const (
 	prefixBlockCommit = int64(2)
 	prefixSeenCommit  = int64(3)
 	prefixBlockHash   = int64(4)
+	prefixExtCommit   = int64(9)  // 5..8 are used by state/store
 )
 
 func blockMetaKey(height int64) []byte {
@@ -635,6 +668,14 @@ func seenCommitKey() []byte {
 	return key
 }
 
+func extCommitKey(height int64) []byte {
+	key, err := orderedcode.Append(nil, prefixExtCommit, height)
+	if err != nil {
+		panic(err)
+	}
+	return key
+}
+
 func blockHashKey(hash []byte) []byte {
 	key, err := orderedcode.Append(nil, prefixBlockHash, string(hash))
 	if err != nil {

internal/store/store_test.go

@@ -2,7 +2,6 @@ package store
 
 import (
 	"fmt"
-	stdlog "log"
 	"os"
 	"runtime/debug"
 	"strings"
@@ -27,22 +26,24 @@ import (
 // test.
 type cleanupFunc func()
 
-// make a Commit with a single vote containing just the height and a timestamp
-func makeTestCommit(height int64, timestamp time.Time) *types.Commit {
-	commitSigs := []types.CommitSig{{
+// make an extended commit with a single vote containing just the height and a
+// timestamp
+func makeTestExtCommit(height int64, timestamp time.Time) *types.ExtendedCommit {
+	extCommitSigs := []types.ExtendedCommitSig{{
 		BlockIDFlag:      types.BlockIDFlagCommit,
 		ValidatorAddress: tmrand.Bytes(crypto.AddressSize),
 		Timestamp:        timestamp,
 		Signature:        []byte("Signature"),
 	}}
-	return types.NewCommit(
+	return types.NewExtendedCommit(
 		height,
 		0,
 		types.BlockID{
 			Hash:          crypto.CRandBytes(32),
 			PartSetHeader: types.PartSetHeader{Hash: crypto.CRandBytes(32), Total: 2},
 		},
-		commitSigs)
+		extCommitSigs,
+	)
 }
 
 func makeStateAndBlockStore(dir string) (sm.State, *BlockStore, cleanupFunc, error) {
@@ -59,47 +60,11 @@ func makeStateAndBlockStore(dir string) (sm.State, *BlockStore, cleanupFunc, err
 	return state, NewBlockStore(blockDB), func() { os.RemoveAll(cfg.RootDir) }, nil
 }
 
-func freshBlockStore() (*BlockStore, dbm.DB) {
+func newInMemoryBlockStore() (*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
-)
-
-func TestMain(m *testing.M) {
-	dir, err := os.MkdirTemp("", "store_test")
-	if err != nil {
-		stdlog.Fatal(err)
-	}
-	var cleanup cleanupFunc
-
-	state, _, cleanup, err = makeStateAndBlockStore(dir)
-	if err != nil {
-		stdlog.Fatal(err)
-	}
-
-	block = factory.MakeBlock(state, 1, new(types.Commit))
-
-	partSet, err = block.MakePartSet(2)
-	if err != nil {
-		stdlog.Fatal(err)
-	}
-	part1 = partSet.GetPart(0)
-	part2 = partSet.GetPart(1)
-	seenCommit1 = makeTestCommit(10, tmtime.Now())
-	code := m.Run()
-	cleanup()
-	os.RemoveAll(dir) // best-effort
-	os.Exit(code)
-}
-
 // TODO: This test should be simplified ...
 func TestBlockStoreSaveLoadBlock(t *testing.T) {
 	state, bs, cleanup, err := makeStateAndBlockStore(t.TempDir())
@@ -120,8 +85,10 @@ func TestBlockStoreSaveLoadBlock(t *testing.T) {
 	block := factory.MakeBlock(state, bs.Height()+1, new(types.Commit))
 	validPartSet, err := block.MakePartSet(2)
 	require.NoError(t, err)
-	seenCommit := makeTestCommit(10, tmtime.Now())
-	bs.SaveBlock(block, partSet, seenCommit)
+	part2 := validPartSet.GetPart(1)
+
+	seenCommit := makeTestExtCommit(block.Header.Height, tmtime.Now())
+	bs.SaveBlock(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")
 
@@ -139,11 +106,11 @@ func TestBlockStoreSaveLoadBlock(t *testing.T) {
 	}
 
 	// End of setup, test data
-	commitAtH10 := makeTestCommit(10, tmtime.Now())
+	commitAtH10 := makeTestExtCommit(10, tmtime.Now()).StripExtensions()
 	tuples := []struct {
 		block      *types.Block
 		parts      *types.PartSet
-		seenCommit *types.Commit
+		seenCommit *types.ExtendedCommit
 		wantPanic  string
 		wantErr    bool
 
@@ -156,7 +123,7 @@ func TestBlockStoreSaveLoadBlock(t *testing.T) {
 		{
 			block:      newBlock(header1, commitAtH10),
 			parts:      validPartSet,
-			seenCommit: seenCommit1,
+			seenCommit: seenCommit,
 		},
 
 		{
@@ -172,10 +139,10 @@ func TestBlockStoreSaveLoadBlock(t *testing.T) {
 					ChainID:         "block_test",
 					Time:            tmtime.Now(),
 					ProposerAddress: tmrand.Bytes(crypto.AddressSize)},
-				makeTestCommit(5, tmtime.Now()),
+				makeTestExtCommit(5, tmtime.Now()).StripExtensions(),
 			),
 			parts:      validPartSet,
-			seenCommit: makeTestCommit(5, tmtime.Now()),
+			seenCommit: makeTestExtCommit(5, tmtime.Now()),
 		},
 
 		{
@@ -187,7 +154,7 @@ func TestBlockStoreSaveLoadBlock(t *testing.T) {
 		{
 			block:             newBlock(header1, commitAtH10),
 			parts:             validPartSet,
-			seenCommit:        seenCommit1,
+			seenCommit:        seenCommit,
 			corruptCommitInDB: true, // Corrupt the DB's commit entry
 			wantPanic:         "error reading block commit",
 		},
@@ -195,7 +162,7 @@ func TestBlockStoreSaveLoadBlock(t *testing.T) {
 		{
 			block:            newBlock(header1, commitAtH10),
 			parts:            validPartSet,
-			seenCommit:       seenCommit1,
+			seenCommit:       seenCommit,
 			wantPanic:        "unmarshal to tmproto.BlockMeta",
 			corruptBlockInDB: true, // Corrupt the DB's block entry
 		},
@@ -203,7 +170,7 @@ func TestBlockStoreSaveLoadBlock(t *testing.T) {
 		{
 			block:      newBlock(header1, commitAtH10),
 			parts:      validPartSet,
-			seenCommit: seenCommit1,
+			seenCommit: seenCommit,
 
 			// Expecting no error and we want a nil back
 			eraseSeenCommitInDB: true,
@@ -212,7 +179,7 @@ func TestBlockStoreSaveLoadBlock(t *testing.T) {
 		{
 			block:      newBlock(header1, commitAtH10),
 			parts:      validPartSet,
-			seenCommit: seenCommit1,
+			seenCommit: seenCommit,
 
 			corruptSeenCommitInDB: true,
 			wantPanic:             "error reading block seen commit",
@@ -221,7 +188,7 @@ func TestBlockStoreSaveLoadBlock(t *testing.T) {
 		{
 			block:      newBlock(header1, commitAtH10),
 			parts:      validPartSet,
-			seenCommit: seenCommit1,
+			seenCommit: seenCommit,
 
 			// Expecting no error and we want a nil back
 			eraseCommitInDB: true,
@@ -238,7 +205,7 @@ func TestBlockStoreSaveLoadBlock(t *testing.T) {
 
 	for i, tuple := range tuples {
 		tuple := tuple
-		bs, db := freshBlockStore()
+		bs, db := newInMemoryBlockStore()
 		// SaveBlock
 		res, err, panicErr := doFn(func() (interface{}, error) {
 			bs.SaveBlock(tuple.block, tuple.parts, tuple.seenCommit)
@@ -324,7 +291,7 @@ func TestLoadBaseMeta(t *testing.T) {
 		block := factory.MakeBlock(state, h, new(types.Commit))
 		partSet, err := block.MakePartSet(2)
 		require.NoError(t, err)
-		seenCommit := makeTestCommit(h, tmtime.Now())
+		seenCommit := makeTestExtCommit(h, tmtime.Now())
 		bs.SaveBlock(block, partSet, seenCommit)
 	}
 
@@ -338,13 +305,19 @@ func TestLoadBaseMeta(t *testing.T) {
 }
 
 func TestLoadBlockPart(t *testing.T) {
-	bs, db := freshBlockStore()
+	cfg, err := config.ResetTestRoot(t.TempDir(), "blockchain_reactor_test")
+	require.NoError(t, err)
+
+	bs, db := newInMemoryBlockStore()
 	height, index := int64(10), 1
 	loadPart := func() (interface{}, error) {
 		part := bs.LoadBlockPart(height, index)
 		return part, nil
 	}
 
+	state, err := sm.MakeGenesisStateFromFile(cfg.GenesisFile())
+	require.NoError(t, err)
+
 	// Initially no contents.
 	// 1. Requesting for a non-existent block shouldn't fail
 	res, _, panicErr := doFn(loadPart)
@@ -352,13 +325,18 @@ 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(blockPartKey(height, index), []byte("Tendermint"))
+	err = db.Set(blockPartKey(height, index), []byte("Tendermint"))
 	require.NoError(t, err)
 	res, _, panicErr = doFn(loadPart)
 	require.NotNil(t, panicErr, "expecting a non-nil panic")
 	require.Contains(t, panicErr.Error(), "unmarshal to tmproto.Part failed")
 
 	// 3. A good block serialized and saved to the DB should be retrievable
+	block := factory.MakeBlock(state, height, new(types.Commit))
+	partSet, err := block.MakePartSet(2)
+	require.NoError(t, err)
+	part1 := partSet.GetPart(0)
+
 	pb1, err := part1.ToProto()
 	require.NoError(t, err)
 	err = db.Set(blockPartKey(height, index), mustEncode(pb1))
@@ -391,7 +369,7 @@ func TestPruneBlocks(t *testing.T) {
 		block := factory.MakeBlock(state, h, new(types.Commit))
 		partSet, err := block.MakePartSet(2)
 		require.NoError(t, err)
-		seenCommit := makeTestCommit(h, tmtime.Now())
+		seenCommit := makeTestExtCommit(h, tmtime.Now())
 		bs.SaveBlock(block, partSet, seenCommit)
 	}
 
@@ -452,7 +430,7 @@ func TestPruneBlocks(t *testing.T) {
 }
 
 func TestLoadBlockMeta(t *testing.T) {
-	bs, db := freshBlockStore()
+	bs, db := newInMemoryBlockStore()
 	height := int64(10)
 	loadMeta := func() (interface{}, error) {
 		meta := bs.LoadBlockMeta(height)
@@ -499,7 +477,7 @@ func TestBlockFetchAtHeight(t *testing.T) {
 
 	partSet, err := block.MakePartSet(2)
 	require.NoError(t, err)
-	seenCommit := makeTestCommit(10, tmtime.Now())
+	seenCommit := makeTestExtCommit(block.Header.Height, tmtime.Now())
 	bs.SaveBlock(block, partSet, seenCommit)
 	require.Equal(t, bs.Height(), block.Header.Height, "expecting the new height to be changed")
 
@@ -521,9 +499,12 @@ func TestBlockFetchAtHeight(t *testing.T) {
 }
 
 func TestSeenAndCanonicalCommit(t *testing.T) {
-	bs, _ := freshBlockStore()
+	state, store, cleanup, err := makeStateAndBlockStore(t.TempDir())
+	defer cleanup()
+	require.NoError(t, err)
+
 	loadCommit := func() (interface{}, error) {
-		meta := bs.LoadSeenCommit()
+		meta := store.LoadSeenCommit()
 		return meta, nil
 	}
 
@@ -536,19 +517,19 @@ func TestSeenAndCanonicalCommit(t *testing.T) {
 	// produce a few blocks and check that the correct seen and cannoncial commits
 	// are persisted.
 	for h := int64(3); h <= 5; h++ {
-		blockCommit := makeTestCommit(h-1, tmtime.Now())
+		blockCommit := makeTestExtCommit(h-1, tmtime.Now()).StripExtensions()
 		block := factory.MakeBlock(state, h, blockCommit)
 		partSet, err := block.MakePartSet(2)
 		require.NoError(t, err)
-		seenCommit := makeTestCommit(h, tmtime.Now())
-		bs.SaveBlock(block, partSet, seenCommit)
-		c3 := bs.LoadSeenCommit()
+		seenCommit := makeTestExtCommit(h, tmtime.Now())
+		store.SaveBlock(block, partSet, seenCommit)
+		c3 := store.LoadSeenCommit()
 		require.NotNil(t, c3)
 		require.Equal(t, h, c3.Height)
-		require.Equal(t, seenCommit.Hash(), c3.Hash())
-		c5 := bs.LoadBlockCommit(h)
+		require.Equal(t, seenCommit.StripExtensions().Hash(), c3.Hash())
+		c5 := store.LoadBlockCommit(h)
 		require.Nil(t, c5)
-		c6 := bs.LoadBlockCommit(h - 1)
+		c6 := store.LoadBlockCommit(h - 1)
 		require.Equal(t, blockCommit.Hash(), c6.Hash())
 	}
 

internal/test/factory/commit.go

@@ -8,7 +8,7 @@ import (
 	"github.com/tendermint/tendermint/types"
 )
 
-func MakeCommit(ctx context.Context, blockID types.BlockID, height int64, round int32, voteSet *types.VoteSet, validators []types.PrivValidator, now time.Time) (*types.Commit, error) {
+func MakeExtendedCommit(ctx context.Context, blockID types.BlockID, height int64, round int32, voteSet *types.VoteSet, validators []types.PrivValidator, now time.Time) (*types.ExtendedCommit, error) {
 	// all sign
 	for i := 0; i < len(validators); i++ {
 		pubKey, err := validators[i].GetPubKey(ctx)
@@ -37,5 +37,5 @@ func MakeCommit(ctx context.Context, blockID types.BlockID, height int64, round
 		}
 	}
 
-	return voteSet.MakeCommit(), nil
+	return voteSet.MakeExtendedCommit(), nil
 }

node/node_test.go

@@ -339,13 +339,13 @@ func TestCreateProposalBlock(t *testing.T) {
 		sm.NopMetrics(),
 	)
 
-	commit := types.NewCommit(height-1, 0, types.BlockID{}, nil)
+	extCommit := types.NewExtendedCommit(height-1, 0, types.BlockID{}, nil)
 	block, err := blockExec.CreateProposalBlock(
 		ctx,
 		height,
-		state, commit,
+		state,
+		extCommit,
 		proposerAddr,
-		nil,
 	)
 	require.NoError(t, err)
 
@@ -419,13 +419,13 @@ func TestMaxTxsProposalBlockSize(t *testing.T) {
 		sm.NopMetrics(),
 	)
 
-	commit := types.NewCommit(height-1, 0, types.BlockID{}, nil)
+	extCommit := types.NewExtendedCommit(height-1, 0, types.BlockID{}, nil)
 	block, err := blockExec.CreateProposalBlock(
 		ctx,
 		height,
-		state, commit,
+		state,
+		extCommit,
 		proposerAddr,
-		nil,
 	)
 	require.NoError(t, err)
 
@@ -525,14 +525,14 @@ func TestMaxProposalBlockSize(t *testing.T) {
 	}
 	state.ChainID = maxChainID
 
-	cs := types.CommitSig{
+	ecs := types.ExtendedCommitSig{
 		BlockIDFlag:      types.BlockIDFlagNil,
 		ValidatorAddress: crypto.AddressHash([]byte("validator_address")),
 		Timestamp:        timestamp,
 		Signature:        crypto.CRandBytes(types.MaxSignatureSize),
 	}
 
-	commit := &types.Commit{
+	extCommit := &types.ExtendedCommit{
 		Height:  math.MaxInt64,
 		Round:   math.MaxInt32,
 		BlockID: blockID,
@@ -547,16 +547,15 @@ func TestMaxProposalBlockSize(t *testing.T) {
 		votes[i] = &types.Vote{
 			ValidatorAddress: pubKey.Address(),
 		}
-		commit.Signatures = append(commit.Signatures, cs)
+		extCommit.ExtendedSignatures = append(extCommit.ExtendedSignatures, ecs)
 	}
 
 	block, err := blockExec.CreateProposalBlock(
 		ctx,
 		math.MaxInt64,
 		state,
-		commit,
+		extCommit,
 		proposerAddr,
-		votes,
 	)
 	require.NoError(t, err)
 	partSet, err := block.MakePartSet(types.BlockPartSizeBytes)

proto/tendermint/abci/types.proto

@@ -424,6 +424,10 @@ message ExecTxResult {
 // TxResult contains results of executing the transaction.
 //
 // One usage is indexing transaction results.
+// TODO(thane): Remove this struct. It's effectively only used in
+//              types/events.go#EventDataTx and these fields could easily be
+//              introduced directly into that struct. There doesn't seem to be
+//              any other use for this struct via any other interface.
 message TxResult {
   int64        height = 1;
   uint32       index  = 2;

proto/tendermint/blocksync/types.pb.go

@@ -116,7 +116,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{} }
@@ -159,6 +160,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 {
 }
@@ -385,30 +393,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) {
@@ -487,6 +498,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])
@@ -740,6 +763,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
 }
 
@@ -1049,6 +1076,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:])

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 {
@@ -19,6 +20,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.

proto/tendermint/types/types.pb.go

@@ -726,6 +726,158 @@ func (m *CommitSig) GetSignature() []byte {
 	return nil
 }
 
+type ExtendedCommit struct {
+	Height             int64               `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"`
+	Round              int32               `protobuf:"varint,2,opt,name=round,proto3" json:"round,omitempty"`
+	BlockID            BlockID             `protobuf:"bytes,3,opt,name=block_id,json=blockId,proto3" json:"block_id"`
+	ExtendedSignatures []ExtendedCommitSig `protobuf:"bytes,4,rep,name=extended_signatures,json=extendedSignatures,proto3" json:"extended_signatures"`
+}
+
+func (m *ExtendedCommit) Reset()         { *m = ExtendedCommit{} }
+func (m *ExtendedCommit) String() string { return proto.CompactTextString(m) }
+func (*ExtendedCommit) ProtoMessage()    {}
+func (*ExtendedCommit) Descriptor() ([]byte, []int) {
+	return fileDescriptor_d3a6e55e2345de56, []int{8}
+}
+func (m *ExtendedCommit) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *ExtendedCommit) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_ExtendedCommit.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *ExtendedCommit) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ExtendedCommit.Merge(m, src)
+}
+func (m *ExtendedCommit) XXX_Size() int {
+	return m.Size()
+}
+func (m *ExtendedCommit) XXX_DiscardUnknown() {
+	xxx_messageInfo_ExtendedCommit.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ExtendedCommit proto.InternalMessageInfo
+
+func (m *ExtendedCommit) GetHeight() int64 {
+	if m != nil {
+		return m.Height
+	}
+	return 0
+}
+
+func (m *ExtendedCommit) GetRound() int32 {
+	if m != nil {
+		return m.Round
+	}
+	return 0
+}
+
+func (m *ExtendedCommit) GetBlockID() BlockID {
+	if m != nil {
+		return m.BlockID
+	}
+	return BlockID{}
+}
+
+func (m *ExtendedCommit) GetExtendedSignatures() []ExtendedCommitSig {
+	if m != nil {
+		return m.ExtendedSignatures
+	}
+	return nil
+}
+
+type ExtendedCommitSig struct {
+	BlockIdFlag        BlockIDFlag `protobuf:"varint,1,opt,name=block_id_flag,json=blockIdFlag,proto3,enum=tendermint.types.BlockIDFlag" json:"block_id_flag,omitempty"`
+	ValidatorAddress   []byte      `protobuf:"bytes,2,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty"`
+	Timestamp          time.Time   `protobuf:"bytes,3,opt,name=timestamp,proto3,stdtime" json:"timestamp"`
+	Signature          []byte      `protobuf:"bytes,4,opt,name=signature,proto3" json:"signature,omitempty"`
+	VoteExtension      []byte      `protobuf:"bytes,5,opt,name=vote_extension,json=voteExtension,proto3" json:"vote_extension,omitempty"`
+	ExtensionSignature []byte      `protobuf:"bytes,6,opt,name=extension_signature,json=extensionSignature,proto3" json:"extension_signature,omitempty"`
+}
+
+func (m *ExtendedCommitSig) Reset()         { *m = ExtendedCommitSig{} }
+func (m *ExtendedCommitSig) String() string { return proto.CompactTextString(m) }
+func (*ExtendedCommitSig) ProtoMessage()    {}
+func (*ExtendedCommitSig) Descriptor() ([]byte, []int) {
+	return fileDescriptor_d3a6e55e2345de56, []int{9}
+}
+func (m *ExtendedCommitSig) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *ExtendedCommitSig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_ExtendedCommitSig.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *ExtendedCommitSig) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ExtendedCommitSig.Merge(m, src)
+}
+func (m *ExtendedCommitSig) XXX_Size() int {
+	return m.Size()
+}
+func (m *ExtendedCommitSig) XXX_DiscardUnknown() {
+	xxx_messageInfo_ExtendedCommitSig.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ExtendedCommitSig proto.InternalMessageInfo
+
+func (m *ExtendedCommitSig) GetBlockIdFlag() BlockIDFlag {
+	if m != nil {
+		return m.BlockIdFlag
+	}
+	return BlockIDFlagUnknown
+}
+
+func (m *ExtendedCommitSig) GetValidatorAddress() []byte {
+	if m != nil {
+		return m.ValidatorAddress
+	}
+	return nil
+}
+
+func (m *ExtendedCommitSig) GetTimestamp() time.Time {
+	if m != nil {
+		return m.Timestamp
+	}
+	return time.Time{}
+}
+
+func (m *ExtendedCommitSig) GetSignature() []byte {
+	if m != nil {
+		return m.Signature
+	}
+	return nil
+}
+
+func (m *ExtendedCommitSig) GetVoteExtension() []byte {
+	if m != nil {
+		return m.VoteExtension
+	}
+	return nil
+}
+
+func (m *ExtendedCommitSig) GetExtensionSignature() []byte {
+	if m != nil {
+		return m.ExtensionSignature
+	}
+	return nil
+}
+
 type Proposal struct {
 	Type      SignedMsgType `protobuf:"varint,1,opt,name=type,proto3,enum=tendermint.types.SignedMsgType" json:"type,omitempty"`
 	Height    int64         `protobuf:"varint,2,opt,name=height,proto3" json:"height,omitempty"`
@@ -740,7 +892,7 @@ func (m *Proposal) Reset()         { *m = Proposal{} }
 func (m *Proposal) String() string { return proto.CompactTextString(m) }
 func (*Proposal) ProtoMessage()    {}
 func (*Proposal) Descriptor() ([]byte, []int) {
-	return fileDescriptor_d3a6e55e2345de56, []int{8}
+	return fileDescriptor_d3a6e55e2345de56, []int{10}
 }
 func (m *Proposal) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -827,7 +979,7 @@ func (m *SignedHeader) Reset()         { *m = SignedHeader{} }
 func (m *SignedHeader) String() string { return proto.CompactTextString(m) }
 func (*SignedHeader) ProtoMessage()    {}
 func (*SignedHeader) Descriptor() ([]byte, []int) {
-	return fileDescriptor_d3a6e55e2345de56, []int{9}
+	return fileDescriptor_d3a6e55e2345de56, []int{11}
 }
 func (m *SignedHeader) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -879,7 +1031,7 @@ func (m *LightBlock) Reset()         { *m = LightBlock{} }
 func (m *LightBlock) String() string { return proto.CompactTextString(m) }
 func (*LightBlock) ProtoMessage()    {}
 func (*LightBlock) Descriptor() ([]byte, []int) {
-	return fileDescriptor_d3a6e55e2345de56, []int{10}
+	return fileDescriptor_d3a6e55e2345de56, []int{12}
 }
 func (m *LightBlock) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -933,7 +1085,7 @@ func (m *BlockMeta) Reset()         { *m = BlockMeta{} }
 func (m *BlockMeta) String() string { return proto.CompactTextString(m) }
 func (*BlockMeta) ProtoMessage()    {}
 func (*BlockMeta) Descriptor() ([]byte, []int) {
-	return fileDescriptor_d3a6e55e2345de56, []int{11}
+	return fileDescriptor_d3a6e55e2345de56, []int{13}
 }
 func (m *BlockMeta) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1002,7 +1154,7 @@ func (m *TxProof) Reset()         { *m = TxProof{} }
 func (m *TxProof) String() string { return proto.CompactTextString(m) }
 func (*TxProof) ProtoMessage()    {}
 func (*TxProof) Descriptor() ([]byte, []int) {
-	return fileDescriptor_d3a6e55e2345de56, []int{12}
+	return fileDescriptor_d3a6e55e2345de56, []int{14}
 }
 func (m *TxProof) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1063,6 +1215,8 @@ func init() {
 	proto.RegisterType((*Vote)(nil), "tendermint.types.Vote")
 	proto.RegisterType((*Commit)(nil), "tendermint.types.Commit")
 	proto.RegisterType((*CommitSig)(nil), "tendermint.types.CommitSig")
+	proto.RegisterType((*ExtendedCommit)(nil), "tendermint.types.ExtendedCommit")
+	proto.RegisterType((*ExtendedCommitSig)(nil), "tendermint.types.ExtendedCommitSig")
 	proto.RegisterType((*Proposal)(nil), "tendermint.types.Proposal")
 	proto.RegisterType((*SignedHeader)(nil), "tendermint.types.SignedHeader")
 	proto.RegisterType((*LightBlock)(nil), "tendermint.types.LightBlock")
@@ -1073,91 +1227,95 @@ func init() {
 func init() { proto.RegisterFile("tendermint/types/types.proto", fileDescriptor_d3a6e55e2345de56) }
 
 var fileDescriptor_d3a6e55e2345de56 = []byte{
-	// 1341 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x57, 0xcf, 0x73, 0xdb, 0xc4,
-	0x17, 0x8f, 0x62, 0x25, 0xb6, 0x9f, 0xed, 0xc4, 0xd9, 0x6f, 0xda, 0xba, 0x6e, 0xe3, 0x68, 0xfc,
-	0x1d, 0x20, 0x2d, 0x8c, 0x52, 0x52, 0x86, 0x1f, 0x07, 0x0e, 0xb6, 0x93, 0xb6, 0x9e, 0x26, 0x8e,
-	0x91, 0xdd, 0x32, 0x70, 0xd1, 0xc8, 0xd6, 0xd6, 0x16, 0x95, 0x25, 0x8d, 0x76, 0x1d, 0x92, 0xfe,
-	0x05, 0x4c, 0x4e, 0x3d, 0x71, 0xcb, 0x09, 0x0e, 0xdc, 0x39, 0x70, 0x65, 0x38, 0xf5, 0xd8, 0x1b,
-	0x5c, 0x28, 0x4c, 0x3a, 0xc3, 0xdf, 0xc1, 0xec, 0x0f, 0xc9, 0x72, 0x9c, 0x40, 0xa7, 0xd3, 0xe1,
-	0xe2, 0xd1, 0xbe, 0xf7, 0x79, 0x6f, 0xdf, 0x8f, 0xcf, 0xee, 0x5b, 0xc3, 0x75, 0x8a, 0x3d, 0x1b,
-	0x87, 0x23, 0xc7, 0xa3, 0x9b, 0xf4, 0x28, 0xc0, 0x44, 0xfc, 0xea, 0x41, 0xe8, 0x53, 0x1f, 0x15,
-	0x27, 0x5a, 0x9d, 0xcb, 0xcb, 0xab, 0x03, 0x7f, 0xe0, 0x73, 0xe5, 0x26, 0xfb, 0x12, 0xb8, 0xf2,
-	0xfa, 0xc0, 0xf7, 0x07, 0x2e, 0xde, 0xe4, 0xab, 0xde, 0xf8, 0xd1, 0x26, 0x75, 0x46, 0x98, 0x50,
-	0x6b, 0x14, 0x48, 0xc0, 0x5a, 0x62, 0x9b, 0x7e, 0x78, 0x14, 0x50, 0x9f, 0x61, 0xfd, 0x47, 0x52,
-	0x5d, 0x49, 0xa8, 0x0f, 0x70, 0x48, 0x1c, 0xdf, 0x4b, 0xc6, 0x51, 0xd6, 0x66, 0xa2, 0x3c, 0xb0,
-	0x5c, 0xc7, 0xb6, 0xa8, 0x1f, 0x0a, 0x44, 0xf5, 0x13, 0x28, 0xb4, 0xad, 0x90, 0x76, 0x30, 0xbd,
-	0x87, 0x2d, 0x1b, 0x87, 0x68, 0x15, 0x16, 0xa8, 0x4f, 0x2d, 0xb7, 0xa4, 0x68, 0xca, 0x46, 0xc1,
-	0x10, 0x0b, 0x84, 0x40, 0x1d, 0x5a, 0x64, 0x58, 0x9a, 0xd7, 0x94, 0x8d, 0xbc, 0xc1, 0xbf, 0xab,
-	0x43, 0x50, 0x99, 0x29, 0xb3, 0x70, 0x3c, 0x1b, 0x1f, 0x46, 0x16, 0x7c, 0xc1, 0xa4, 0xbd, 0x23,
-	0x8a, 0x89, 0x34, 0x11, 0x0b, 0xf4, 0x01, 0x2c, 0xf0, 0xf8, 0x4b, 0x29, 0x4d, 0xd9, 0xc8, 0x6d,
-	0x95, 0xf4, 0x44, 0xa1, 0x44, 0x7e, 0x7a, 0x9b, 0xe9, 0xeb, 0xea, 0xb3, 0x17, 0xeb, 0x73, 0x86,
-	0x00, 0x57, 0x5d, 0x48, 0xd7, 0x5d, 0xbf, 0xff, 0xb8, 0xb9, 0x1d, 0x07, 0xa2, 0x4c, 0x02, 0x41,
-	0x7b, 0xb0, 0x1c, 0x58, 0x21, 0x35, 0x09, 0xa6, 0xe6, 0x90, 0x67, 0xc1, 0x37, 0xcd, 0x6d, 0xad,
-	0xeb, 0x67, 0xfb, 0xa0, 0x4f, 0x25, 0x2b, 0x77, 0x29, 0x04, 0x49, 0x61, 0xf5, 0x2f, 0x15, 0x16,
-	0x65, 0x31, 0x3e, 0x85, 0xb4, 0x2c, 0x2b, 0xdf, 0x30, 0xb7, 0xb5, 0x96, 0xf4, 0x28, 0x55, 0x7a,
-	0xc3, 0xf7, 0x08, 0xf6, 0xc8, 0x98, 0x48, 0x7f, 0x91, 0x0d, 0x7a, 0x1b, 0x32, 0xfd, 0xa1, 0xe5,
-	0x78, 0xa6, 0x63, 0xf3, 0x88, 0xb2, 0xf5, 0xdc, 0xe9, 0x8b, 0xf5, 0x74, 0x83, 0xc9, 0x9a, 0xdb,
-	0x46, 0x9a, 0x2b, 0x9b, 0x36, 0xba, 0x0c, 0x8b, 0x43, 0xec, 0x0c, 0x86, 0x94, 0x97, 0x25, 0x65,
-	0xc8, 0x15, 0xfa, 0x18, 0x54, 0x46, 0x88, 0x92, 0xca, 0xf7, 0x2e, 0xeb, 0x82, 0x2d, 0x7a, 0xc4,
-	0x16, 0xbd, 0x1b, 0xb1, 0xa5, 0x9e, 0x61, 0x1b, 0x3f, 0xfd, 0x63, 0x5d, 0x31, 0xb8, 0x05, 0x6a,
-	0x40, 0xc1, 0xb5, 0x08, 0x35, 0x7b, 0xac, 0x6c, 0x6c, 0xfb, 0x05, 0xee, 0xe2, 0xea, 0x6c, 0x41,
-	0x64, 0x61, 0x65, 0xe8, 0x39, 0x66, 0x25, 0x44, 0x36, 0xda, 0x80, 0x22, 0x77, 0xd2, 0xf7, 0x47,
-	0x23, 0x87, 0x9a, 0xbc, 0xee, 0x8b, 0xbc, 0xee, 0x4b, 0x4c, 0xde, 0xe0, 0xe2, 0x7b, 0xac, 0x03,
-	0xd7, 0x20, 0x6b, 0x5b, 0xd4, 0x12, 0x90, 0x34, 0x87, 0x64, 0x98, 0x80, 0x2b, 0xdf, 0x81, 0xe5,
-	0x98, 0x75, 0x44, 0x40, 0x32, 0xc2, 0xcb, 0x44, 0xcc, 0x81, 0xb7, 0x60, 0xd5, 0xc3, 0x87, 0xd4,
-	0x3c, 0x8b, 0xce, 0x72, 0x34, 0x62, 0xba, 0x87, 0xd3, 0x16, 0x6f, 0xc1, 0x52, 0x3f, 0x2a, 0xbe,
-	0xc0, 0x02, 0xc7, 0x16, 0x62, 0x29, 0x87, 0x5d, 0x85, 0x8c, 0x15, 0x04, 0x02, 0x90, 0xe3, 0x80,
-	0xb4, 0x15, 0x04, 0x5c, 0x75, 0x13, 0x56, 0x78, 0x8e, 0x21, 0x26, 0x63, 0x97, 0x4a, 0x27, 0x79,
-	0x8e, 0x59, 0x66, 0x0a, 0x43, 0xc8, 0x39, 0xf6, 0xff, 0x50, 0xc0, 0x07, 0x8e, 0x8d, 0xbd, 0x3e,
-	0x16, 0xb8, 0x02, 0xc7, 0xe5, 0x23, 0x21, 0x07, 0xdd, 0x80, 0x62, 0x10, 0xfa, 0x81, 0x4f, 0x70,
-	0x68, 0x5a, 0xb6, 0x1d, 0x62, 0x42, 0x4a, 0x4b, 0xc2, 0x5f, 0x24, 0xaf, 0x09, 0x71, 0xb5, 0x04,
-	0xea, 0xb6, 0x45, 0x2d, 0x54, 0x84, 0x14, 0x3d, 0x24, 0x25, 0x45, 0x4b, 0x6d, 0xe4, 0x0d, 0xf6,
-	0x59, 0xfd, 0x29, 0x05, 0xea, 0x43, 0x9f, 0x62, 0x74, 0x1b, 0x54, 0xd6, 0x26, 0xce, 0xbe, 0xa5,
-	0xf3, 0xf8, 0xdc, 0x71, 0x06, 0x1e, 0xb6, 0xf7, 0xc8, 0xa0, 0x7b, 0x14, 0x60, 0x83, 0x83, 0x13,
-	0x74, 0x9a, 0x9f, 0xa2, 0xd3, 0x2a, 0x2c, 0x84, 0xfe, 0xd8, 0xb3, 0x39, 0xcb, 0x16, 0x0c, 0xb1,
-	0x40, 0x3b, 0x90, 0x89, 0x59, 0xa2, 0xfe, 0x1b, 0x4b, 0x96, 0x19, 0x4b, 0x18, 0x87, 0xa5, 0xc0,
-	0x48, 0xf7, 0x24, 0x59, 0xea, 0x90, 0x8d, 0x2f, 0x2f, 0xc9, 0xb6, 0x57, 0x23, 0xec, 0xc4, 0x0c,
-	0xbd, 0x0b, 0x2b, 0x71, 0xef, 0xe3, 0xe2, 0x09, 0xc6, 0x15, 0x63, 0x85, 0xac, 0xde, 0x14, 0xad,
-	0x4c, 0x71, 0x01, 0xa5, 0x79, 0x5e, 0x13, 0x5a, 0x35, 0xf9, 0x4d, 0x74, 0x1d, 0xb2, 0xc4, 0x19,
-	0x78, 0x16, 0x1d, 0x87, 0x58, 0x32, 0x6f, 0x22, 0x60, 0x5a, 0x7c, 0x48, 0xb1, 0xc7, 0x0f, 0xb9,
-	0x60, 0xda, 0x44, 0x80, 0x36, 0xe1, 0x7f, 0xf1, 0xc2, 0x9c, 0x78, 0x11, 0x2c, 0x43, 0xb1, 0xaa,
-	0x13, 0x69, 0xaa, 0x3f, 0x2b, 0xb0, 0x28, 0x0e, 0x46, 0xa2, 0x0d, 0xca, 0xf9, 0x6d, 0x98, 0xbf,
-	0xa8, 0x0d, 0xa9, 0xd7, 0x6f, 0x43, 0x0d, 0x20, 0x0e, 0x93, 0x94, 0x54, 0x2d, 0xb5, 0x91, 0xdb,
-	0xba, 0x36, 0xeb, 0x48, 0x84, 0xd8, 0x71, 0x06, 0xf2, 0xdc, 0x27, 0x8c, 0xaa, 0xbf, 0x2b, 0x90,
-	0x8d, 0xf5, 0xa8, 0x06, 0x85, 0x28, 0x2e, 0xf3, 0x91, 0x6b, 0x0d, 0x24, 0x15, 0xd7, 0x2e, 0x0c,
-	0xee, 0x8e, 0x6b, 0x0d, 0x8c, 0x9c, 0x8c, 0x87, 0x2d, 0xce, 0x6f, 0xeb, 0xfc, 0x05, 0x6d, 0x9d,
-	0xe2, 0x51, 0xea, 0xf5, 0x78, 0x34, 0xd5, 0x71, 0xf5, 0x4c, 0xc7, 0xab, 0x3f, 0xce, 0x43, 0xa6,
-	0xcd, 0x8f, 0xa2, 0xe5, 0xfe, 0x17, 0x07, 0xec, 0x1a, 0x64, 0x03, 0xdf, 0x35, 0x85, 0x46, 0xe5,
-	0x9a, 0x4c, 0xe0, 0xbb, 0xc6, 0x4c, 0xdb, 0x17, 0xde, 0xd0, 0xe9, 0x5b, 0x7c, 0x03, 0x55, 0x4b,
-	0x9f, 0xad, 0x5a, 0x08, 0x79, 0x51, 0x0a, 0x39, 0x1a, 0x6f, 0xb1, 0x1a, 0xf0, 0x59, 0xab, 0xcc,
-	0x8e, 0x72, 0x11, 0xb6, 0x40, 0x1a, 0x12, 0xc7, 0x2c, 0xc4, 0x24, 0x91, 0xd3, 0xb9, 0x74, 0x11,
-	0x2d, 0x0d, 0x89, 0xab, 0x7e, 0xab, 0x00, 0xec, 0xb2, 0xca, 0xf2, 0x7c, 0xd9, 0x50, 0x23, 0x3c,
-	0x04, 0x73, 0x6a, 0xe7, 0xca, 0x45, 0x4d, 0x93, 0xfb, 0xe7, 0x49, 0x32, 0xee, 0x06, 0x14, 0x26,
-	0x64, 0x24, 0x38, 0x0a, 0xe6, 0x1c, 0x27, 0xf1, 0xac, 0xe9, 0x60, 0x6a, 0xe4, 0x0f, 0x12, 0xab,
-	0xea, 0x2f, 0x0a, 0x64, 0x79, 0x4c, 0x7b, 0x98, 0x5a, 0x53, 0x3d, 0x54, 0x5e, 0xbf, 0x87, 0x6b,
-	0x00, 0xc2, 0x0d, 0x71, 0x9e, 0x60, 0xc9, 0xac, 0x2c, 0x97, 0x74, 0x9c, 0x27, 0x18, 0x7d, 0x18,
-	0x17, 0x3c, 0xf5, 0xcf, 0x05, 0x97, 0x47, 0x3a, 0x2a, 0xfb, 0x15, 0x48, 0x7b, 0xe3, 0x91, 0xc9,
-	0x26, 0x8c, 0x2a, 0xd8, 0xea, 0x8d, 0x47, 0xdd, 0x43, 0x52, 0xfd, 0x0a, 0xd2, 0xdd, 0x43, 0xfe,
-	0xda, 0x62, 0x14, 0x0d, 0x7d, 0x5f, 0x8e, 0x78, 0xf1, 0xb4, 0xca, 0x30, 0x01, 0x9f, 0x68, 0x08,
-	0x54, 0x36, 0xcb, 0xa3, 0xb7, 0x1f, 0xfb, 0x46, 0xfa, 0x2b, 0xbe, 0xe3, 0xe4, 0x0b, 0xee, 0xe6,
-	0xaf, 0x0a, 0xe4, 0x12, 0xf7, 0x03, 0x7a, 0x1f, 0x2e, 0xd5, 0x77, 0xf7, 0x1b, 0xf7, 0xcd, 0xe6,
-	0xb6, 0x79, 0x67, 0xb7, 0x76, 0xd7, 0x7c, 0xd0, 0xba, 0xdf, 0xda, 0xff, 0xbc, 0x55, 0x9c, 0x2b,
-	0x5f, 0x3e, 0x3e, 0xd1, 0x50, 0x02, 0xfb, 0xc0, 0x7b, 0xec, 0xf9, 0x5f, 0xb3, 0xab, 0x78, 0x75,
-	0xda, 0xa4, 0x56, 0xef, 0xec, 0xb4, 0xba, 0x45, 0xa5, 0x7c, 0xe9, 0xf8, 0x44, 0x5b, 0x49, 0x58,
-	0xd4, 0x7a, 0x04, 0x7b, 0x74, 0xd6, 0xa0, 0xb1, 0xbf, 0xb7, 0xd7, 0xec, 0x16, 0xe7, 0x67, 0x0c,
-	0xe4, 0x85, 0x7d, 0x03, 0x56, 0xa6, 0x0d, 0x5a, 0xcd, 0xdd, 0x62, 0xaa, 0x8c, 0x8e, 0x4f, 0xb4,
-	0xa5, 0x04, 0xba, 0xe5, 0xb8, 0xe5, 0xcc, 0x37, 0xdf, 0x55, 0xe6, 0x7e, 0xf8, 0xbe, 0xa2, 0xb0,
-	0xcc, 0x0a, 0x53, 0x77, 0x04, 0x7a, 0x0f, 0xae, 0x74, 0x9a, 0x77, 0x5b, 0x3b, 0xdb, 0xe6, 0x5e,
-	0xe7, 0xae, 0xd9, 0xfd, 0xa2, 0xbd, 0x93, 0xc8, 0x6e, 0xf9, 0xf8, 0x44, 0xcb, 0xc9, 0x94, 0x2e,
-	0x42, 0xb7, 0x8d, 0x9d, 0x87, 0xfb, 0xdd, 0x9d, 0xa2, 0x22, 0xd0, 0xed, 0x10, 0x1f, 0xf8, 0x14,
-	0x73, 0xf4, 0x2d, 0xb8, 0x7a, 0x0e, 0x3a, 0x4e, 0x6c, 0xe5, 0xf8, 0x44, 0x2b, 0xb4, 0x43, 0x2c,
-	0xce, 0x0f, 0xb7, 0xd0, 0xa1, 0x34, 0x6b, 0xb1, 0xdf, 0xde, 0xef, 0xd4, 0x76, 0x8b, 0x5a, 0xb9,
-	0x78, 0x7c, 0xa2, 0xe5, 0xa3, 0xcb, 0x90, 0xe1, 0x27, 0x99, 0xd5, 0x3f, 0x7b, 0x76, 0x5a, 0x51,
-	0x9e, 0x9f, 0x56, 0x94, 0x3f, 0x4f, 0x2b, 0xca, 0xd3, 0x97, 0x95, 0xb9, 0xe7, 0x2f, 0x2b, 0x73,
-	0xbf, 0xbd, 0xac, 0xcc, 0x7d, 0xf9, 0xd1, 0xc0, 0xa1, 0xc3, 0x71, 0x4f, 0xef, 0xfb, 0xa3, 0xcd,
-	0xe4, 0x3f, 0x8c, 0xc9, 0xa7, 0xf8, 0xa7, 0x73, 0xf6, 0xdf, 0x47, 0x6f, 0x91, 0xcb, 0x6f, 0xff,
-	0x1d, 0x00, 0x00, 0xff, 0xff, 0xbb, 0xc0, 0x81, 0x37, 0x3e, 0x0d, 0x00, 0x00,
+	// 1406 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x57, 0xcd, 0x6f, 0x1b, 0x55,
+	0x10, 0xcf, 0xda, 0xeb, 0xaf, 0xb1, 0x9d, 0x38, 0x8f, 0xb4, 0x75, 0xdd, 0xc6, 0xb1, 0x5c, 0x01,
+	0x69, 0x41, 0x4e, 0x49, 0x11, 0x1f, 0x07, 0x0e, 0xb6, 0xe3, 0xb6, 0x56, 0x13, 0xc7, 0xac, 0xdd,
+	0x22, 0x7a, 0x59, 0xad, 0xbd, 0xaf, 0xf6, 0x52, 0x7b, 0x77, 0xb5, 0xfb, 0x1c, 0x9c, 0xfe, 0x05,
+	0x28, 0xa7, 0x9e, 0xb8, 0xe5, 0x04, 0x07, 0xee, 0x1c, 0x38, 0x21, 0x21, 0x4e, 0x3d, 0xf6, 0x06,
+	0x17, 0x0a, 0xa4, 0x12, 0x7f, 0x07, 0x7a, 0x1f, 0xfb, 0xe1, 0x38, 0xa6, 0x55, 0x55, 0x81, 0xc4,
+	0xc5, 0x7a, 0x6f, 0xe6, 0x37, 0xf3, 0xe6, 0xcd, 0xfc, 0xde, 0x78, 0x16, 0x2e, 0x13, 0x6c, 0xea,
+	0xd8, 0x19, 0x1b, 0x26, 0xd9, 0x22, 0x87, 0x36, 0x76, 0xf9, 0x6f, 0xc5, 0x76, 0x2c, 0x62, 0xa1,
+	0x5c, 0xa0, 0xad, 0x30, 0x79, 0x61, 0x6d, 0x60, 0x0d, 0x2c, 0xa6, 0xdc, 0xa2, 0x2b, 0x8e, 0x2b,
+	0x6c, 0x0c, 0x2c, 0x6b, 0x30, 0xc2, 0x5b, 0x6c, 0xd7, 0x9b, 0x3c, 0xd8, 0x22, 0xc6, 0x18, 0xbb,
+	0x44, 0x1b, 0xdb, 0x02, 0xb0, 0x1e, 0x3a, 0xa6, 0xef, 0x1c, 0xda, 0xc4, 0xa2, 0x58, 0xeb, 0x81,
+	0x50, 0x17, 0x43, 0xea, 0x03, 0xec, 0xb8, 0x86, 0x65, 0x86, 0xe3, 0x28, 0x94, 0xe6, 0xa2, 0x3c,
+	0xd0, 0x46, 0x86, 0xae, 0x11, 0xcb, 0xe1, 0x88, 0xf2, 0xc7, 0x90, 0x6d, 0x6b, 0x0e, 0xe9, 0x60,
+	0x72, 0x1b, 0x6b, 0x3a, 0x76, 0xd0, 0x1a, 0xc4, 0x88, 0x45, 0xb4, 0x51, 0x5e, 0x2a, 0x49, 0x9b,
+	0x59, 0x85, 0x6f, 0x10, 0x02, 0x79, 0xa8, 0xb9, 0xc3, 0x7c, 0xa4, 0x24, 0x6d, 0x66, 0x14, 0xb6,
+	0x2e, 0x0f, 0x41, 0xa6, 0xa6, 0xd4, 0xc2, 0x30, 0x75, 0x3c, 0xf5, 0x2c, 0xd8, 0x86, 0x4a, 0x7b,
+	0x87, 0x04, 0xbb, 0xc2, 0x84, 0x6f, 0xd0, 0xfb, 0x10, 0x63, 0xf1, 0xe7, 0xa3, 0x25, 0x69, 0x33,
+	0xbd, 0x9d, 0xaf, 0x84, 0x12, 0xc5, 0xef, 0x57, 0x69, 0x53, 0x7d, 0x4d, 0x7e, 0xf2, 0x6c, 0x63,
+	0x49, 0xe1, 0xe0, 0xf2, 0x08, 0x12, 0xb5, 0x91, 0xd5, 0x7f, 0xd8, 0xdc, 0xf1, 0x03, 0x91, 0x82,
+	0x40, 0xd0, 0x1e, 0xac, 0xd8, 0x9a, 0x43, 0x54, 0x17, 0x13, 0x75, 0xc8, 0x6e, 0xc1, 0x0e, 0x4d,
+	0x6f, 0x6f, 0x54, 0x4e, 0xd7, 0xa1, 0x32, 0x73, 0x59, 0x71, 0x4a, 0xd6, 0x0e, 0x0b, 0xcb, 0x7f,
+	0xc9, 0x10, 0x17, 0xc9, 0xf8, 0x04, 0x12, 0x22, 0xad, 0xec, 0xc0, 0xf4, 0xf6, 0x7a, 0xd8, 0xa3,
+	0x50, 0x55, 0xea, 0x96, 0xe9, 0x62, 0xd3, 0x9d, 0xb8, 0xc2, 0x9f, 0x67, 0x83, 0xde, 0x82, 0x64,
+	0x7f, 0xa8, 0x19, 0xa6, 0x6a, 0xe8, 0x2c, 0xa2, 0x54, 0x2d, 0x7d, 0xf2, 0x6c, 0x23, 0x51, 0xa7,
+	0xb2, 0xe6, 0x8e, 0x92, 0x60, 0xca, 0xa6, 0x8e, 0xce, 0x43, 0x7c, 0x88, 0x8d, 0xc1, 0x90, 0xb0,
+	0xb4, 0x44, 0x15, 0xb1, 0x43, 0x1f, 0x81, 0x4c, 0x09, 0x91, 0x97, 0xd9, 0xd9, 0x85, 0x0a, 0x67,
+	0x4b, 0xc5, 0x63, 0x4b, 0xa5, 0xeb, 0xb1, 0xa5, 0x96, 0xa4, 0x07, 0x3f, 0xfe, 0x7d, 0x43, 0x52,
+	0x98, 0x05, 0xaa, 0x43, 0x76, 0xa4, 0xb9, 0x44, 0xed, 0xd1, 0xb4, 0xd1, 0xe3, 0x63, 0xcc, 0xc5,
+	0xc5, 0xf9, 0x84, 0x88, 0xc4, 0x8a, 0xd0, 0xd3, 0xd4, 0x8a, 0x8b, 0x74, 0xb4, 0x09, 0x39, 0xe6,
+	0xa4, 0x6f, 0x8d, 0xc7, 0x06, 0x51, 0x59, 0xde, 0xe3, 0x2c, 0xef, 0xcb, 0x54, 0x5e, 0x67, 0xe2,
+	0xdb, 0xb4, 0x02, 0x97, 0x20, 0xa5, 0x6b, 0x44, 0xe3, 0x90, 0x04, 0x83, 0x24, 0xa9, 0x80, 0x29,
+	0xdf, 0x86, 0x15, 0x9f, 0x75, 0x2e, 0x87, 0x24, 0xb9, 0x97, 0x40, 0xcc, 0x80, 0xd7, 0x61, 0xcd,
+	0xc4, 0x53, 0xa2, 0x9e, 0x46, 0xa7, 0x18, 0x1a, 0x51, 0xdd, 0xbd, 0x59, 0x8b, 0x37, 0x61, 0xb9,
+	0xef, 0x25, 0x9f, 0x63, 0x81, 0x61, 0xb3, 0xbe, 0x94, 0xc1, 0x2e, 0x42, 0x52, 0xb3, 0x6d, 0x0e,
+	0x48, 0x33, 0x40, 0x42, 0xb3, 0x6d, 0xa6, 0xba, 0x06, 0xab, 0xec, 0x8e, 0x0e, 0x76, 0x27, 0x23,
+	0x22, 0x9c, 0x64, 0x18, 0x66, 0x85, 0x2a, 0x14, 0x2e, 0x67, 0xd8, 0x2b, 0x90, 0xc5, 0x07, 0x86,
+	0x8e, 0xcd, 0x3e, 0xe6, 0xb8, 0x2c, 0xc3, 0x65, 0x3c, 0x21, 0x03, 0x5d, 0x85, 0x9c, 0xed, 0x58,
+	0xb6, 0xe5, 0x62, 0x47, 0xd5, 0x74, 0xdd, 0xc1, 0xae, 0x9b, 0x5f, 0xe6, 0xfe, 0x3c, 0x79, 0x95,
+	0x8b, 0xcb, 0x79, 0x90, 0x77, 0x34, 0xa2, 0xa1, 0x1c, 0x44, 0xc9, 0xd4, 0xcd, 0x4b, 0xa5, 0xe8,
+	0x66, 0x46, 0xa1, 0xcb, 0xf2, 0x0f, 0x51, 0x90, 0xef, 0x59, 0x04, 0xa3, 0x1b, 0x20, 0xd3, 0x32,
+	0x31, 0xf6, 0x2d, 0x9f, 0xc5, 0xe7, 0x8e, 0x31, 0x30, 0xb1, 0xbe, 0xe7, 0x0e, 0xba, 0x87, 0x36,
+	0x56, 0x18, 0x38, 0x44, 0xa7, 0xc8, 0x0c, 0x9d, 0xd6, 0x20, 0xe6, 0x58, 0x13, 0x53, 0x67, 0x2c,
+	0x8b, 0x29, 0x7c, 0x83, 0x1a, 0x90, 0xf4, 0x59, 0x22, 0xbf, 0x88, 0x25, 0x2b, 0x94, 0x25, 0x94,
+	0xc3, 0x42, 0xa0, 0x24, 0x7a, 0x82, 0x2c, 0x35, 0x48, 0xf9, 0xcd, 0x4b, 0xb0, 0xed, 0xe5, 0x08,
+	0x1b, 0x98, 0xa1, 0x77, 0x60, 0xd5, 0xaf, 0xbd, 0x9f, 0x3c, 0xce, 0xb8, 0x9c, 0xaf, 0x10, 0xd9,
+	0x9b, 0xa1, 0x95, 0xca, 0x1b, 0x50, 0x82, 0xdd, 0x2b, 0xa0, 0x55, 0x93, 0x75, 0xa2, 0xcb, 0x90,
+	0x72, 0x8d, 0x81, 0xa9, 0x91, 0x89, 0x83, 0x05, 0xf3, 0x02, 0x01, 0xd5, 0xe2, 0x29, 0xc1, 0x26,
+	0x7b, 0xe4, 0x9c, 0x69, 0x81, 0x00, 0x6d, 0xc1, 0x1b, 0xfe, 0x46, 0x0d, 0xbc, 0x70, 0x96, 0x21,
+	0x5f, 0xd5, 0xf1, 0x34, 0xe5, 0x9f, 0x24, 0x88, 0xf3, 0x87, 0x11, 0x2a, 0x83, 0x74, 0x76, 0x19,
+	0x22, 0x8b, 0xca, 0x10, 0x7d, 0xf5, 0x32, 0x54, 0x01, 0xfc, 0x30, 0xdd, 0xbc, 0x5c, 0x8a, 0x6e,
+	0xa6, 0xb7, 0x2f, 0xcd, 0x3b, 0xe2, 0x21, 0x76, 0x8c, 0x81, 0x78, 0xf7, 0x21, 0xa3, 0xf2, 0x6f,
+	0x12, 0xa4, 0x7c, 0x3d, 0xaa, 0x42, 0xd6, 0x8b, 0x4b, 0x7d, 0x30, 0xd2, 0x06, 0x82, 0x8a, 0xeb,
+	0x0b, 0x83, 0xbb, 0x39, 0xd2, 0x06, 0x4a, 0x5a, 0xc4, 0x43, 0x37, 0x67, 0x97, 0x35, 0xb2, 0xa0,
+	0xac, 0x33, 0x3c, 0x8a, 0xbe, 0x1a, 0x8f, 0x66, 0x2a, 0x2e, 0x9f, 0xaa, 0x78, 0xf9, 0x4f, 0x09,
+	0x96, 0x1b, 0x53, 0x16, 0xbe, 0xfe, 0x5f, 0x96, 0xea, 0xbe, 0xe0, 0x96, 0x8e, 0x75, 0x75, 0xae,
+	0x66, 0x57, 0xe6, 0x3d, 0xce, 0xc6, 0x1c, 0xd4, 0x0e, 0x79, 0x5e, 0x3a, 0x41, 0x0d, 0x7f, 0x8c,
+	0xc0, 0xea, 0x1c, 0xfe, 0xff, 0x57, 0x4b, 0xfa, 0x07, 0x70, 0x60, 0x11, 0xac, 0x06, 0x4f, 0x38,
+	0xc6, 0xff, 0x00, 0xa8, 0xb4, 0xf1, 0xa2, 0x67, 0x1c, 0x5f, 0xf8, 0x8c, 0xbf, 0x8f, 0x40, 0xb2,
+	0xcd, 0xda, 0xb5, 0x36, 0xfa, 0x37, 0x9a, 0xf0, 0x25, 0x48, 0xd9, 0xd6, 0x48, 0xe5, 0x1a, 0x99,
+	0x69, 0x92, 0xb6, 0x35, 0x52, 0xe6, 0xf8, 0x16, 0x7b, 0x4d, 0x1d, 0x3a, 0xfe, 0x1a, 0xaa, 0x91,
+	0x38, 0xfd, 0xb2, 0x1c, 0xc8, 0xf0, 0x54, 0x88, 0xf1, 0xe9, 0x3a, 0xcd, 0x01, 0x9b, 0xc7, 0xa4,
+	0xf9, 0x71, 0x8f, 0x87, 0xcd, 0x91, 0x8a, 0xc0, 0x51, 0x0b, 0x3e, 0x6d, 0x88, 0x09, 0x2e, 0xbf,
+	0xa8, 0x75, 0x29, 0x02, 0x57, 0xfe, 0x5a, 0x02, 0xd8, 0xa5, 0x99, 0x65, 0xf7, 0xa5, 0x83, 0x8f,
+	0xcb, 0x42, 0x50, 0x67, 0x4e, 0x2e, 0x2e, 0x2a, 0x9a, 0x38, 0x3f, 0xe3, 0x86, 0xe3, 0xae, 0x43,
+	0x36, 0x20, 0xb9, 0x8b, 0xbd, 0x60, 0xce, 0x70, 0xe2, 0xcf, 0x23, 0x1d, 0x4c, 0x94, 0xcc, 0x41,
+	0x68, 0x57, 0xfe, 0x59, 0x82, 0x14, 0x8b, 0x69, 0x0f, 0x13, 0x6d, 0xa6, 0x86, 0xd2, 0xab, 0xd7,
+	0x70, 0x1d, 0x80, 0xbb, 0x71, 0x8d, 0x47, 0x58, 0x30, 0x2b, 0xc5, 0x24, 0x1d, 0xe3, 0x11, 0x46,
+	0x1f, 0xf8, 0x09, 0x8f, 0xfe, 0x73, 0xc2, 0x45, 0xeb, 0xf0, 0xd2, 0x7e, 0x01, 0x12, 0xe6, 0x64,
+	0xac, 0xd2, 0x29, 0x44, 0xe6, 0x6c, 0x35, 0x27, 0xe3, 0xee, 0xd4, 0x2d, 0x7f, 0x01, 0x89, 0xee,
+	0x94, 0x4d, 0xe4, 0x94, 0xa2, 0x8e, 0x65, 0x89, 0x31, 0x90, 0x8f, 0xdf, 0x49, 0x2a, 0x60, 0x53,
+	0x0f, 0x02, 0x99, 0xce, 0x7b, 0xde, 0xf7, 0x01, 0x5d, 0xa3, 0xca, 0x4b, 0xce, 0xfa, 0x62, 0xca,
+	0xbf, 0xf6, 0x8b, 0x04, 0xe9, 0x50, 0xdf, 0x41, 0xef, 0xc1, 0xb9, 0xda, 0xee, 0x7e, 0xfd, 0x8e,
+	0xda, 0xdc, 0x51, 0x6f, 0xee, 0x56, 0x6f, 0xa9, 0x77, 0x5b, 0x77, 0x5a, 0xfb, 0x9f, 0xb5, 0x72,
+	0x4b, 0x85, 0xf3, 0x47, 0xc7, 0x25, 0x14, 0xc2, 0xde, 0x35, 0x1f, 0x9a, 0xd6, 0x97, 0xf4, 0x9d,
+	0xaf, 0xcd, 0x9a, 0x54, 0x6b, 0x9d, 0x46, 0xab, 0x9b, 0x93, 0x0a, 0xe7, 0x8e, 0x8e, 0x4b, 0xab,
+	0x21, 0x8b, 0x6a, 0xcf, 0xc5, 0x26, 0x99, 0x37, 0xa8, 0xef, 0xef, 0xed, 0x35, 0xbb, 0xb9, 0xc8,
+	0x9c, 0x81, 0xf8, 0xa7, 0xb8, 0x0a, 0xab, 0xb3, 0x06, 0xad, 0xe6, 0x6e, 0x2e, 0x5a, 0x40, 0x47,
+	0xc7, 0xa5, 0xe5, 0x10, 0xba, 0x65, 0x8c, 0x0a, 0xc9, 0xaf, 0xbe, 0x29, 0x2e, 0x7d, 0xf7, 0x6d,
+	0x51, 0xa2, 0x37, 0xcb, 0xce, 0xf4, 0x08, 0xf4, 0x2e, 0x5c, 0xe8, 0x34, 0x6f, 0xb5, 0x1a, 0x3b,
+	0xea, 0x5e, 0xe7, 0x96, 0xda, 0xfd, 0xbc, 0xdd, 0x08, 0xdd, 0x6e, 0xe5, 0xe8, 0xb8, 0x94, 0x16,
+	0x57, 0x5a, 0x84, 0x6e, 0x2b, 0x8d, 0x7b, 0xfb, 0xdd, 0x46, 0x4e, 0xe2, 0xe8, 0xb6, 0x83, 0x69,
+	0xc7, 0x63, 0xe8, 0xeb, 0x70, 0xf1, 0x0c, 0xb4, 0x7f, 0xb1, 0xd5, 0xa3, 0xe3, 0x52, 0xb6, 0xed,
+	0x60, 0xfe, 0x7e, 0x98, 0x45, 0x05, 0xf2, 0xf3, 0x16, 0xfb, 0xed, 0xfd, 0x4e, 0x75, 0x37, 0x57,
+	0x2a, 0xe4, 0x8e, 0x8e, 0x4b, 0x19, 0xaf, 0x19, 0x52, 0x7c, 0x70, 0xb3, 0xda, 0xa7, 0x4f, 0x4e,
+	0x8a, 0xd2, 0xd3, 0x93, 0xa2, 0xf4, 0xc7, 0x49, 0x51, 0x7a, 0xfc, 0xbc, 0xb8, 0xf4, 0xf4, 0x79,
+	0x71, 0xe9, 0xd7, 0xe7, 0xc5, 0xa5, 0xfb, 0x1f, 0x0e, 0x0c, 0x32, 0x9c, 0xf4, 0x2a, 0x7d, 0x6b,
+	0xbc, 0x15, 0xfe, 0x0a, 0x0d, 0x96, 0xfc, 0x6b, 0xf8, 0xf4, 0x17, 0x6a, 0x2f, 0xce, 0xe4, 0x37,
+	0xfe, 0x0e, 0x00, 0x00, 0xff, 0xff, 0x6a, 0xc1, 0x59, 0xe9, 0x62, 0x0f, 0x00, 0x00,
 }
 
 func (m *PartSetHeader) Marshal() (dAtA []byte, err error) {
@@ -1634,6 +1792,127 @@ func (m *CommitSig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
+func (m *ExtendedCommit) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *ExtendedCommit) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ExtendedCommit) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.ExtendedSignatures) > 0 {
+		for iNdEx := len(m.ExtendedSignatures) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.ExtendedSignatures[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintTypes(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0x22
+		}
+	}
+	{
+		size, err := m.BlockID.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintTypes(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x1a
+	if m.Round != 0 {
+		i = encodeVarintTypes(dAtA, i, uint64(m.Round))
+		i--
+		dAtA[i] = 0x10
+	}
+	if m.Height != 0 {
+		i = encodeVarintTypes(dAtA, i, uint64(m.Height))
+		i--
+		dAtA[i] = 0x8
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *ExtendedCommitSig) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *ExtendedCommitSig) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ExtendedCommitSig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.ExtensionSignature) > 0 {
+		i -= len(m.ExtensionSignature)
+		copy(dAtA[i:], m.ExtensionSignature)
+		i = encodeVarintTypes(dAtA, i, uint64(len(m.ExtensionSignature)))
+		i--
+		dAtA[i] = 0x32
+	}
+	if len(m.VoteExtension) > 0 {
+		i -= len(m.VoteExtension)
+		copy(dAtA[i:], m.VoteExtension)
+		i = encodeVarintTypes(dAtA, i, uint64(len(m.VoteExtension)))
+		i--
+		dAtA[i] = 0x2a
+	}
+	if len(m.Signature) > 0 {
+		i -= len(m.Signature)
+		copy(dAtA[i:], m.Signature)
+		i = encodeVarintTypes(dAtA, i, uint64(len(m.Signature)))
+		i--
+		dAtA[i] = 0x22
+	}
+	n11, err11 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Timestamp, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamp):])
+	if err11 != nil {
+		return 0, err11
+	}
+	i -= n11
+	i = encodeVarintTypes(dAtA, i, uint64(n11))
+	i--
+	dAtA[i] = 0x1a
+	if len(m.ValidatorAddress) > 0 {
+		i -= len(m.ValidatorAddress)
+		copy(dAtA[i:], m.ValidatorAddress)
+		i = encodeVarintTypes(dAtA, i, uint64(len(m.ValidatorAddress)))
+		i--
+		dAtA[i] = 0x12
+	}
+	if m.BlockIdFlag != 0 {
+		i = encodeVarintTypes(dAtA, i, uint64(m.BlockIdFlag))
+		i--
+		dAtA[i] = 0x8
+	}
+	return len(dAtA) - i, nil
+}
+
 func (m *Proposal) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -1661,12 +1940,12 @@ func (m *Proposal) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i--
 		dAtA[i] = 0x3a
 	}
-	n10, err10 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Timestamp, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamp):])
-	if err10 != nil {
-		return 0, err10
+	n12, err12 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Timestamp, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamp):])
+	if err12 != nil {
+		return 0, err12
 	}
-	i -= n10
-	i = encodeVarintTypes(dAtA, i, uint64(n10))
+	i -= n12
+	i = encodeVarintTypes(dAtA, i, uint64(n12))
 	i--
 	dAtA[i] = 0x32
 	{
@@ -2117,6 +2396,59 @@ func (m *CommitSig) Size() (n int) {
 	return n
 }
 
+func (m *ExtendedCommit) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Height != 0 {
+		n += 1 + sovTypes(uint64(m.Height))
+	}
+	if m.Round != 0 {
+		n += 1 + sovTypes(uint64(m.Round))
+	}
+	l = m.BlockID.Size()
+	n += 1 + l + sovTypes(uint64(l))
+	if len(m.ExtendedSignatures) > 0 {
+		for _, e := range m.ExtendedSignatures {
+			l = e.Size()
+			n += 1 + l + sovTypes(uint64(l))
+		}
+	}
+	return n
+}
+
+func (m *ExtendedCommitSig) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.BlockIdFlag != 0 {
+		n += 1 + sovTypes(uint64(m.BlockIdFlag))
+	}
+	l = len(m.ValidatorAddress)
+	if l > 0 {
+		n += 1 + l + sovTypes(uint64(l))
+	}
+	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.Timestamp)
+	n += 1 + l + sovTypes(uint64(l))
+	l = len(m.Signature)
+	if l > 0 {
+		n += 1 + l + sovTypes(uint64(l))
+	}
+	l = len(m.VoteExtension)
+	if l > 0 {
+		n += 1 + l + sovTypes(uint64(l))
+	}
+	l = len(m.ExtensionSignature)
+	if l > 0 {
+		n += 1 + l + sovTypes(uint64(l))
+	}
+	return n
+}
+
 func (m *Proposal) Size() (n int) {
 	if m == nil {
 		return 0
@@ -3823,6 +4155,399 @@ func (m *CommitSig) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *ExtendedCommit) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTypes
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: ExtendedCommit: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: ExtendedCommit: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
+			}
+			m.Height = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Height |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Round", wireType)
+			}
+			m.Round = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Round |= int32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field BlockID", 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 err := m.BlockID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ExtendedSignatures", 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
+			}
+			m.ExtendedSignatures = append(m.ExtendedSignatures, ExtendedCommitSig{})
+			if err := m.ExtendedSignatures[len(m.ExtendedSignatures)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTypes(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *ExtendedCommitSig) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTypes
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: ExtendedCommitSig: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: ExtendedCommitSig: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field BlockIdFlag", wireType)
+			}
+			m.BlockIdFlag = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.BlockIdFlag |= BlockIDFlag(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ValidatorAddress", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthTypes
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.ValidatorAddress = append(m.ValidatorAddress[:0], dAtA[iNdEx:postIndex]...)
+			if m.ValidatorAddress == nil {
+				m.ValidatorAddress = []byte{}
+			}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", 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 err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.Timestamp, dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthTypes
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...)
+			if m.Signature == nil {
+				m.Signature = []byte{}
+			}
+			iNdEx = postIndex
+		case 5:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field VoteExtension", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthTypes
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.VoteExtension = append(m.VoteExtension[:0], dAtA[iNdEx:postIndex]...)
+			if m.VoteExtension == nil {
+				m.VoteExtension = []byte{}
+			}
+			iNdEx = postIndex
+		case 6:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ExtensionSignature", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthTypes
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.ExtensionSignature = append(m.ExtensionSignature[:0], dAtA[iNdEx:postIndex]...)
+			if m.ExtensionSignature == nil {
+				m.ExtensionSignature = []byte{}
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTypes(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func (m *Proposal) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0

proto/tendermint/types/types.proto

@@ -142,6 +142,24 @@ message CommitSig {
   bytes signature = 4;
 }
 
+message ExtendedCommit {
+  int64   height   = 1;
+  int32   round    = 2;
+  BlockID block_id = 3
+      [(gogoproto.nullable) = false, (gogoproto.customname) = "BlockID"];
+  repeated ExtendedCommitSig extended_signatures = 4 [(gogoproto.nullable) = false];
+}
+
+message ExtendedCommitSig {
+  BlockIDFlag               block_id_flag     = 1;
+  bytes                     validator_address = 2;
+  google.protobuf.Timestamp timestamp         = 3
+      [(gogoproto.nullable) = false, (gogoproto.stdtime) = true];
+  bytes signature = 4;
+  bytes vote_extension = 5;
+  bytes extension_signature = 6;
+}
+
 message Proposal {
   SignedMsgType type      = 1;
   int64         height    = 2;

test/e2e/runner/evidence.go

@@ -167,7 +167,7 @@ func generateLightClientAttackEvidence(
 	blockID := makeBlockID(header.Hash(), 1000, []byte("partshash"))
 	voteSet := types.NewVoteSet(chainID, forgedHeight, 0, tmproto.SignedMsgType(2), conflictingVals)
 
-	commit, err := factory.MakeCommit(ctx, blockID, forgedHeight, 0, voteSet, pv, forgedTime)
+	commit, err := factory.MakeExtendedCommit(ctx, blockID, forgedHeight, 0, voteSet, pv, forgedTime)
 	if err != nil {
 		return nil, err
 	}
@@ -176,7 +176,7 @@ func generateLightClientAttackEvidence(
 		ConflictingBlock: &types.LightBlock{
 			SignedHeader: &types.SignedHeader{
 				Header: header,
-				Commit: commit,
+				Commit: commit.StripExtensions(),
 			},
 			ValidatorSet: conflictingVals,
 		},

types/block.go

@@ -730,7 +730,6 @@ func (cs *CommitSig) ToProto() *tmproto.CommitSig {
 // FromProto sets a protobuf CommitSig to the given pointer.
 // It returns an error if the CommitSig is invalid.
 func (cs *CommitSig) FromProto(csp tmproto.CommitSig) error {
-
 	cs.BlockIDFlag = BlockIDFlag(csp.BlockIdFlag)
 	cs.ValidatorAddress = csp.ValidatorAddress
 	cs.Timestamp = csp.Timestamp
@@ -741,6 +740,160 @@ func (cs *CommitSig) FromProto(csp tmproto.CommitSig) error {
 
 //-------------------------------------
 
+// ExtendedCommitSig is similar to CommitSig, except it also contains the vote
+// extension and vote extension signature related to this commit.
+type ExtendedCommitSig struct {
+	BlockIDFlag        BlockIDFlag `json:"block_id_flag"`
+	ValidatorAddress   Address     `json:"validator_address"`
+	Timestamp          time.Time   `json:"timestamp"`
+	Signature          []byte      `json:"signature"`
+	VoteExtension      []byte      `json:"extension"`
+	ExtensionSignature []byte      `json:"extension_signature"`
+}
+
+// NewExtendedCommitSigAbsent returns new ExtendedCommitSig with
+// BlockIDFlagAbsent. Other fields are all empty.
+// TODO(sergio): When all UTs passing, try removing the Commit and CommitSig version of new functions
+func NewExtendedCommitSigAbsent() ExtendedCommitSig {
+	return ExtendedCommitSig{
+		BlockIDFlag: BlockIDFlagAbsent,
+	}
+}
+
+// ForBlock returns true if ExtendedCommitSig is for the block.
+func (ecs ExtendedCommitSig) ForBlock() bool {
+	return ecs.BlockIDFlag == BlockIDFlagCommit
+}
+
+// Absent returns true if ExtendedCommitSig is absent.
+func (ecs ExtendedCommitSig) Absent() bool {
+	//TODO What about BlockIDFlagNil?
+	return ecs.BlockIDFlag == BlockIDFlagAbsent
+}
+
+// String returns a string representation of an ExtendedCommitSig.
+//
+// 1. first 6 bytes of signature
+// 2. first 6 bytes of validator address
+// 3. block ID flag
+// 4. timestamp
+// 5. first 6 bytes of vote extension
+// 6. first 6 bytes of vote extension signature
+func (ecs ExtendedCommitSig) String() string {
+	return fmt.Sprintf("ExtendedCommitSig{%X by %X on %v @ %s with %X %X}",
+		tmbytes.Fingerprint(ecs.Signature),
+		tmbytes.Fingerprint(ecs.ValidatorAddress),
+		ecs.BlockIDFlag,
+		CanonicalTime(ecs.Timestamp),
+		tmbytes.Fingerprint(ecs.VoteExtension),
+		tmbytes.Fingerprint(ecs.ExtensionSignature),
+	)
+}
+
+func (ecs ExtendedCommitSig) BlockID(commitBlockID BlockID) BlockID {
+	var blockID BlockID
+	switch ecs.BlockIDFlag {
+	case BlockIDFlagAbsent:
+		blockID = BlockID{}
+	case BlockIDFlagCommit:
+		blockID = commitBlockID
+	case BlockIDFlagNil:
+		blockID = BlockID{}
+	default:
+		panic(fmt.Sprintf("Unknown BlockIDFlag: %v", ecs.BlockIDFlag))
+	}
+	return blockID
+}
+
+// ValidateBasic checks whether the structure is well-formed.
+func (ecs ExtendedCommitSig) ValidateBasic() error {
+	switch ecs.BlockIDFlag {
+	case BlockIDFlagAbsent:
+	case BlockIDFlagCommit:
+	case BlockIDFlagNil:
+	default:
+		return fmt.Errorf("unknown BlockIDFlag: %v", ecs.BlockIDFlag)
+	}
+
+	switch ecs.BlockIDFlag {
+	case BlockIDFlagAbsent:
+		if len(ecs.ValidatorAddress) != 0 {
+			return errors.New("validator address is present")
+		}
+		if !ecs.Timestamp.IsZero() {
+			return errors.New("time is present")
+		}
+		if len(ecs.Signature) != 0 {
+			return errors.New("signature is present")
+		}
+		if len(ecs.VoteExtension) != 0 {
+			return errors.New("extension is present")
+		}
+		if len(ecs.ExtensionSignature) != 0 {
+			return errors.New("extension signature is present")
+		}
+	default:
+		if len(ecs.ValidatorAddress) != crypto.AddressSize {
+			return fmt.Errorf("expected ValidatorAddress size to be %d bytes, got %d bytes",
+				crypto.AddressSize,
+				len(ecs.ValidatorAddress),
+			)
+		}
+		// NOTE: Timestamp validation is subtle and handled elsewhere.
+		if len(ecs.Signature) == 0 {
+			return errors.New("signature is missing")
+		}
+		if len(ecs.Signature) > MaxSignatureSize {
+			return fmt.Errorf("signature is too big (max: %d)", MaxSignatureSize)
+		}
+		//TODO move this to a better place
+		const MaxExtensionSize = 100
+		if len(ecs.VoteExtension) > 100 {
+			return fmt.Errorf("extension is too big (max: %d)", MaxExtensionSize)
+		}
+		if len(ecs.ExtensionSignature) == 0 {
+			return errors.New("extension signature is missing")
+		}
+		if len(ecs.ExtensionSignature) > MaxSignatureSize {
+			return fmt.Errorf("extension signature is too big (max: %d)", MaxSignatureSize)
+		}
+	}
+
+	return nil
+}
+
+// ToProto converts the ExtendedCommitSig to its Protobuf representation.
+func (ecs *ExtendedCommitSig) ToProto() *tmproto.ExtendedCommitSig {
+	if ecs == nil {
+		return nil
+	}
+
+	return &tmproto.ExtendedCommitSig{
+		BlockIdFlag:        tmproto.BlockIDFlag(ecs.BlockIDFlag),
+		ValidatorAddress:   ecs.ValidatorAddress,
+		Timestamp:          ecs.Timestamp,
+		Signature:          ecs.Signature,
+		VoteExtension:      ecs.VoteExtension,
+		ExtensionSignature: ecs.ExtensionSignature,
+	}
+}
+
+// FromProto populates the ExtendedCommitSig with values from the given
+// Protobuf representation. Returns an error if the ExtendedCommitSig is
+// invalid.
+func (ecs *ExtendedCommitSig) FromProto(ecsp tmproto.ExtendedCommitSig) error {
+	ecs.BlockIDFlag = BlockIDFlag(ecsp.BlockIdFlag)
+	ecs.ValidatorAddress = ecsp.ValidatorAddress
+	ecs.Timestamp = ecsp.Timestamp
+	ecs.Signature = ecsp.Signature
+	ecs.VoteExtension = ecsp.VoteExtension
+	ecs.ExtensionSignature = ecsp.ExtensionSignature
+
+	return ecs.ValidateBasic()
+}
+
+//-------------------------------------
+
 // Commit contains the evidence that a block was committed by a set of validators.
 // NOTE: Commit is empty for height 1, but never nil.
 type Commit struct {
@@ -756,8 +909,8 @@ type Commit struct {
 	// Memoized in first call to corresponding method.
 	// NOTE: can't memoize in constructor because constructor isn't used for
 	// unmarshaling.
-	hash     tmbytes.HexBytes
-	bitArray *bits.BitArray
+	hash tmbytes.HexBytes
+	//bitArray *bits.BitArray
 }
 
 // NewCommit returns a new Commit.
@@ -770,28 +923,23 @@ func NewCommit(height int64, round int32, blockID BlockID, commitSigs []CommitSi
 	}
 }
 
-// CommitToVoteSet constructs a VoteSet from the Commit and validator set.
-// Panics if signatures from the commit can't be added to the voteset.
-// Inverse of VoteSet.MakeCommit().
-func CommitToVoteSet(chainID string, commit *Commit, vals *ValidatorSet) *VoteSet {
-	voteSet := NewVoteSet(chainID, commit.Height, commit.Round, tmproto.PrecommitType, vals)
-	for idx, commitSig := range commit.Signatures {
-		if commitSig.Absent() {
-			continue // OK, some precommits can be missing.
-		}
-		vote := commit.GetVote(int32(idx))
-		if err := vote.ValidateBasic(); err != nil {
-			panic(fmt.Errorf("failed to validate vote reconstructed from LastCommit: %w", err))
-		}
-		added, err := voteSet.AddVote(vote)
-		if !added || err != nil {
-			panic(fmt.Errorf("failed to reconstruct LastCommit: %w", err))
-		}
-	}
-	return voteSet
-}
+// func (commit Commit) ToExtCommitNoExt() *ExtendedCommit {
+// 	// For every validator, get the precommit with extensions
+// 	extCommitSigs := make([]ExtendedCommitSig, len(commit.Signatures))
+// 	for i, cs := range commit.Signatures {
+// 		extCommitSigs[i] = ExtendedCommitSig{
+// 			BlockIDFlag:      cs.BlockIDFlag,
+// 			ValidatorAddress: cs.ValidatorAddress,
+// 			Timestamp:        cs.Timestamp,
+// 			Signature:        cs.Signature,
+// 		}
+// 	}
+// 	return NewExtendedCommit(commit.Height, commit.Round, commit.BlockID, extCommitSigs)
+// }
 
-// GetVote converts the CommitSig for the given valIdx to a Vote.
+// GetVote converts the CommitSig for the given valIdx to a Vote. Commits do
+// not contain vote extensions, so the vote extension and vote extension
+// signature will not be present in the returned vote.
 // Returns nil if the precommit at valIdx is nil.
 // Panics if valIdx >= commit.Size().
 func (commit *Commit) GetVote(valIdx int32) *Vote {
@@ -824,21 +972,21 @@ func (commit *Commit) VoteSignBytes(chainID string, valIdx int32) []byte {
 
 // Type returns the vote type of the commit, which is always VoteTypePrecommit
 // Implements VoteSetReader.
-func (commit *Commit) Type() byte {
-	return byte(tmproto.PrecommitType)
-}
+// func (commit *Commit) Type() byte {
+// 	return byte(tmproto.PrecommitType)
+// }
 
 // GetHeight returns height of the commit.
 // Implements VoteSetReader.
-func (commit *Commit) GetHeight() int64 {
-	return commit.Height
-}
+// func (commit *Commit) GetHeight() int64 {
+// 	return commit.Height
+// }
 
 // GetRound returns height of the commit.
 // Implements VoteSetReader.
-func (commit *Commit) GetRound() int32 {
-	return commit.Round
-}
+// func (commit *Commit) GetRound() int32 {
+// 	return commit.Round
+// }
 
 // Size returns the number of signatures in the commit.
 // Implements VoteSetReader.
@@ -851,30 +999,30 @@ func (commit *Commit) Size() int {
 
 // BitArray returns a BitArray of which validators voted for BlockID or nil in this commit.
 // Implements VoteSetReader.
-func (commit *Commit) BitArray() *bits.BitArray {
-	if commit.bitArray == nil {
-		commit.bitArray = bits.NewBitArray(len(commit.Signatures))
-		for i, commitSig := range commit.Signatures {
-			// TODO: need to check the BlockID otherwise we could be counting conflicts,
-			// not just the one with +2/3 !
-			commit.bitArray.SetIndex(i, !commitSig.Absent())
-		}
-	}
-	return commit.bitArray
-}
+// func (commit *Commit) BitArray() *bits.BitArray {
+// 	if commit.bitArray == nil {
+// 		commit.bitArray = bits.NewBitArray(len(commit.Signatures))
+// 		for i, commitSig := range commit.Signatures {
+// 			// TODO: need to check the BlockID otherwise we could be counting conflicts,
+// 			// not just the one with +2/3 !
+// 			commit.bitArray.SetIndex(i, !commitSig.Absent())
+// 		}
+// 	}
+// 	return commit.bitArray
+// }
 
 // GetByIndex returns the vote corresponding to a given validator index.
 // Panics if `index >= commit.Size()`.
 // Implements VoteSetReader.
-func (commit *Commit) GetByIndex(valIdx int32) *Vote {
-	return commit.GetVote(valIdx)
-}
+// func (commit *Commit) GetByIndex(valIdx int32) *Vote {
+// 	return commit.GetVote(valIdx)
+// }
 
 // IsCommit returns true if there is at least one signature.
 // Implements VoteSetReader.
-func (commit *Commit) IsCommit() bool {
-	return len(commit.Signatures) != 0
-}
+// func (commit *Commit) IsCommit() bool {
+// 	return len(commit.Signatures) != 0
+// }
 
 // ValidateBasic performs basic validation that doesn't involve state data.
 // Does not actually check the cryptographic signatures.
@@ -999,7 +1147,241 @@ func CommitFromProto(cp *tmproto.Commit) (*Commit, error) {
 	return commit, commit.ValidateBasic()
 }
 
-//-----------------------------------------------------------------------------
+//-------------------------------------
+
+// ExtendedCommit is similar to Commit, except that its signatures also retain
+// their corresponding vote extensions and vote extension signatures.
+type ExtendedCommit struct {
+	Height             int64               `json:"height,string"`
+	Round              int32               `json:"round"`
+	BlockID            BlockID             `json:"block_id"`
+	ExtendedSignatures []ExtendedCommitSig `json:"signatures"`
+
+	bitArray *bits.BitArray
+}
+
+// NewExtendedCommit constructs an ExtendedCommit from the given parameters.
+func NewExtendedCommit(height int64, round int32, blockID BlockID, extCommitSigs []ExtendedCommitSig) *ExtendedCommit {
+	return &ExtendedCommit{
+		Height:             height,
+		Round:              round,
+		BlockID:            blockID,
+		ExtendedSignatures: extCommitSigs,
+	}
+}
+
+// Copy creates a copy of this extended commit.
+func (extCommit *ExtendedCommit) Copy() *ExtendedCommit {
+	ec := *extCommit
+	return &ec
+}
+
+// ToVoteSet constructs a VoteSet from the Commit and validator set.
+// Panics if signatures from the commit can't be added to the voteset.
+// Inverse of VoteSet.MakeCommit().
+func (extCommit *ExtendedCommit) ToVoteSet(chainID string, vals *ValidatorSet) *VoteSet {
+	voteSet := NewVoteSet(chainID, extCommit.Height, extCommit.Round, tmproto.PrecommitType, vals)
+	for idx, extCommitSig := range extCommit.ExtendedSignatures {
+		if extCommitSig.Absent() {
+			continue // OK, some precommits can be missing.
+		}
+		vote := extCommit.GetExtendedVote(int32(idx))
+		if err := vote.ValidateWithExtension(); err != nil {
+			panic(fmt.Errorf("failed to validate vote reconstructed from LastCommit: %w", err))
+		}
+		added, err := voteSet.AddVote(vote)
+		if !added || err != nil {
+			panic(fmt.Errorf("failed to reconstruct vote set from extended commit: %w", err))
+		}
+	}
+	return voteSet
+}
+
+// func (extCommit *ExtendedCommit) ExtensionsStripped() bool {
+// 	strippedIdx := -1
+// 	for idx, extCommitSig := range extCommit.Signatures {
+// 		if !extCommitSig.ForBlock() {
+// 			continue
+// 		}
+// 		if len(extCommitSig.ExtensionSignature) == 0 {
+// 			strippedIdx = idx
+// 		} else if strippedIdx != -1 {
+// 			panic(fmt.Sprintf("vote extension signature is missing at index %v but present at index %v in extended commit %v",
+// 				strippedIdx, idx, extCommit))
+// 		}
+// 	}
+// 	return strippedIdx != -1
+// }
+
+// StripExtensions converts an ExtendedCommit to a Commit by removing all vote
+// extension-related fields.
+func (extCommit *ExtendedCommit) StripExtensions() *Commit {
+	commitSigs := make([]CommitSig, len(extCommit.ExtendedSignatures))
+	for idx, extCommitSig := range extCommit.ExtendedSignatures {
+		commitSigs[idx] = CommitSig{
+			BlockIDFlag:      extCommitSig.BlockIDFlag,
+			ValidatorAddress: extCommitSig.ValidatorAddress,
+			Timestamp:        extCommitSig.Timestamp,
+			Signature:        extCommitSig.Signature,
+		}
+	}
+	return NewCommit(extCommit.Height, extCommit.Round, extCommit.BlockID, commitSigs)
+}
+
+// GetExtendedVote converts the ExtendedCommitSig for the given valIdx to a
+// Vote with vote extensions.
+// Panics if valIdx >= extCommit.Size().
+func (extCommit *ExtendedCommit) GetExtendedVote(valIdx int32) *Vote {
+	commitSig := extCommit.ExtendedSignatures[valIdx]
+	return &Vote{
+		Type:               tmproto.PrecommitType,
+		Height:             extCommit.Height,
+		Round:              extCommit.Round,
+		BlockID:            commitSig.BlockID(extCommit.BlockID),
+		Timestamp:          commitSig.Timestamp,
+		ValidatorAddress:   commitSig.ValidatorAddress,
+		ValidatorIndex:     valIdx,
+		Signature:          commitSig.Signature,
+		Extension:          commitSig.VoteExtension,
+		ExtensionSignature: commitSig.ExtensionSignature,
+	}
+}
+
+// Type returns the vote type of the extended commit, which is always
+// VoteTypePrecommit
+// Implements VoteSetReader.
+func (extCommit *ExtendedCommit) Type() byte {
+	return byte(tmproto.PrecommitType)
+}
+
+// GetHeight returns height of the extended commit.
+// Implements VoteSetReader.
+func (extCommit *ExtendedCommit) GetHeight() int64 {
+	return extCommit.Height
+}
+
+// GetRound returns height of the extended commit.
+// Implements VoteSetReader.
+func (extCommit *ExtendedCommit) GetRound() int32 {
+	return extCommit.Round
+}
+
+// Size returns the number of signatures in the extended commit.
+// Implements VoteSetReader.
+func (extCommit *ExtendedCommit) Size() int {
+	if extCommit == nil {
+		return 0
+	}
+	return len(extCommit.ExtendedSignatures)
+}
+
+// BitArray returns a BitArray of which validators voted for BlockID or nil in
+// this extended commit.
+// Implements VoteSetReader.
+func (extCommit *ExtendedCommit) BitArray() *bits.BitArray {
+	if extCommit.bitArray == nil {
+		extCommit.bitArray = bits.NewBitArray(len(extCommit.ExtendedSignatures))
+		for i, extCommitSig := range extCommit.ExtendedSignatures {
+			// TODO: need to check the BlockID otherwise we could be counting conflicts,
+			// not just the one with +2/3 !
+			extCommit.bitArray.SetIndex(i, !extCommitSig.Absent())
+		}
+	}
+	return extCommit.bitArray
+}
+
+// GetByIndex returns the vote corresponding to a given validator index.
+// Panics if `index >= extCommit.Size()`.
+// Implements VoteSetReader.
+func (extCommit *ExtendedCommit) GetByIndex(valIdx int32) *Vote {
+	return extCommit.GetExtendedVote(valIdx)
+}
+
+// IsCommit returns true if there is at least one signature.
+// Implements VoteSetReader.
+func (extCommit *ExtendedCommit) IsCommit() bool {
+	return len(extCommit.ExtendedSignatures) != 0
+}
+
+// ValidateBasic checks whether the extended commit is well-formed. Does not
+// actually check the cryptographic signatures.
+func (extCommit *ExtendedCommit) ValidateBasic() error {
+	if extCommit.Height < 0 {
+		return errors.New("negative Height")
+	}
+	if extCommit.Round < 0 {
+		return errors.New("negative Round")
+	}
+
+	if extCommit.Height >= 1 {
+		if extCommit.BlockID.IsNil() {
+			return errors.New("commit cannot be for nil block")
+		}
+
+		if len(extCommit.ExtendedSignatures) == 0 {
+			return errors.New("no signatures in commit")
+		}
+		for i, extCommitSig := range extCommit.ExtendedSignatures {
+			if err := extCommitSig.ValidateBasic(); err != nil {
+				return fmt.Errorf("wrong ExtendedCommitSig #%d: %v", i, err)
+			}
+		}
+	}
+	return nil
+}
+
+// ToProto converts ExtendedCommit to protobuf
+func (extCommit *ExtendedCommit) ToProto() *tmproto.ExtendedCommit {
+	if extCommit == nil {
+		return nil
+	}
+
+	c := new(tmproto.ExtendedCommit)
+	sigs := make([]tmproto.ExtendedCommitSig, len(extCommit.ExtendedSignatures))
+	for i := range extCommit.ExtendedSignatures {
+		sigs[i] = *extCommit.ExtendedSignatures[i].ToProto()
+	}
+	c.ExtendedSignatures = sigs
+
+	c.Height = extCommit.Height
+	c.Round = extCommit.Round
+	c.BlockID = extCommit.BlockID.ToProto()
+
+	return c
+}
+
+// ExtendedCommitFromProto constructs an ExtendedCommit from the given Protobuf
+// representation. It returns an error if the extended commit is invalid.
+func ExtendedCommitFromProto(ecp *tmproto.ExtendedCommit) (*ExtendedCommit, error) {
+	if ecp == nil {
+		return nil, errors.New("nil ExtendedCommit")
+	}
+
+	var (
+		extCommit = new(ExtendedCommit)
+	)
+
+	bi, err := BlockIDFromProto(&ecp.BlockID)
+	if err != nil {
+		return nil, err
+	}
+
+	sigs := make([]ExtendedCommitSig, len(ecp.ExtendedSignatures))
+	for i := range ecp.ExtendedSignatures {
+		if err := sigs[i].FromProto(ecp.ExtendedSignatures[i]); err != nil {
+			return nil, err
+		}
+	}
+	extCommit.ExtendedSignatures = sigs
+
+	extCommit.Height = ecp.Height
+	extCommit.Round = ecp.Round
+	extCommit.BlockID = *bi
+
+	return extCommit, extCommit.ValidateBasic()
+}
+
+//-------------------------------------
 
 // Data contains the set of transactions included in the block
 type Data struct {

types/block_test.go

@@ -42,14 +42,14 @@ func TestBlockAddEvidence(t *testing.T) {
 	h := int64(3)
 
 	voteSet, _, vals := randVoteSet(ctx, t, h-1, 1, tmproto.PrecommitType, 10, 1)
-	commit, err := makeCommit(ctx, lastID, h-1, 1, voteSet, vals, time.Now())
+	extCommit, err := makeExtCommit(ctx, lastID, h-1, 1, voteSet, vals, time.Now())
 	require.NoError(t, err)
 
 	ev, err := NewMockDuplicateVoteEvidenceWithValidator(ctx, h, time.Now(), vals[0], "block-test-chain")
 	require.NoError(t, err)
 	evList := []Evidence{ev}
 
-	block := MakeBlock(h, txs, commit, evList)
+	block := MakeBlock(h, txs, extCommit.StripExtensions(), evList)
 	require.NotNil(t, block)
 	require.Equal(t, 1, len(block.Evidence))
 	require.NotNil(t, block.EvidenceHash)
@@ -66,9 +66,9 @@ func TestBlockValidateBasic(t *testing.T) {
 	h := int64(3)
 
 	voteSet, valSet, vals := randVoteSet(ctx, t, h-1, 1, tmproto.PrecommitType, 10, 1)
-	commit, err := makeCommit(ctx, lastID, h-1, 1, voteSet, vals, time.Now())
-
+	extCommit, err := makeExtCommit(ctx, lastID, h-1, 1, voteSet, vals, time.Now())
 	require.NoError(t, err)
+	commit := extCommit.StripExtensions()
 
 	ev, err := NewMockDuplicateVoteEvidenceWithValidator(ctx, h, time.Now(), vals[0], "block-test-chain")
 	require.NoError(t, err)
@@ -153,15 +153,14 @@ func TestBlockMakePartSetWithEvidence(t *testing.T) {
 	h := int64(3)
 
 	voteSet, _, vals := randVoteSet(ctx, t, h-1, 1, tmproto.PrecommitType, 10, 1)
-	commit, err := makeCommit(ctx, lastID, h-1, 1, voteSet, vals, time.Now())
-
+	extCommit, err := makeExtCommit(ctx, lastID, h-1, 1, voteSet, vals, time.Now())
 	require.NoError(t, err)
 
 	ev, err := NewMockDuplicateVoteEvidenceWithValidator(ctx, h, time.Now(), vals[0], "block-test-chain")
 	require.NoError(t, err)
 	evList := []Evidence{ev}
 
-	partSet, err := MakeBlock(h, []Tx{Tx("Hello World")}, commit, evList).MakePartSet(512)
+	partSet, err := MakeBlock(h, []Tx{Tx("Hello World")}, extCommit.StripExtensions(), evList).MakePartSet(512)
 	require.NoError(t, err)
 
 	assert.NotNil(t, partSet)
@@ -178,14 +177,14 @@ func TestBlockHashesTo(t *testing.T) {
 	h := int64(3)
 
 	voteSet, valSet, vals := randVoteSet(ctx, t, h-1, 1, tmproto.PrecommitType, 10, 1)
-	commit, err := makeCommit(ctx, lastID, h-1, 1, voteSet, vals, time.Now())
+	extCommit, err := makeExtCommit(ctx, lastID, h-1, 1, voteSet, vals, time.Now())
 	require.NoError(t, err)
 
 	ev, err := NewMockDuplicateVoteEvidenceWithValidator(ctx, h, time.Now(), vals[0], "block-test-chain")
 	require.NoError(t, err)
 	evList := []Evidence{ev}
 
-	block := MakeBlock(h, []Tx{Tx("Hello World")}, commit, evList)
+	block := MakeBlock(h, []Tx{Tx("Hello World")}, extCommit.StripExtensions(), evList)
 	block.ValidatorsHash = valSet.Hash()
 	assert.False(t, block.HashesTo([]byte{}))
 	assert.False(t, block.HashesTo([]byte("something else")))
@@ -260,7 +259,7 @@ func TestCommit(t *testing.T) {
 	lastID := makeBlockIDRandom()
 	h := int64(3)
 	voteSet, _, vals := randVoteSet(ctx, t, h-1, 1, tmproto.PrecommitType, 10, 1)
-	commit, err := makeCommit(ctx, lastID, h-1, 1, voteSet, vals, time.Now())
+	commit, err := makeExtCommit(ctx, lastID, h-1, 1, voteSet, vals, time.Now())
 	require.NoError(t, err)
 
 	assert.Equal(t, h-1, commit.Height)
@@ -273,7 +272,7 @@ func TestCommit(t *testing.T) {
 	require.NotNil(t, commit.BitArray())
 	assert.Equal(t, bits.NewBitArray(10).Size(), commit.BitArray().Size())
 
-	assert.Equal(t, voteWithoutExtension(voteSet.GetByIndex(0)), commit.GetByIndex(0))
+	assert.Equal(t, voteSet.GetByIndex(0), commit.GetByIndex(0))
 	assert.True(t, commit.IsCommit())
 }
 
@@ -477,11 +476,11 @@ func randCommit(ctx context.Context, t *testing.T, now time.Time) *Commit {
 	lastID := makeBlockIDRandom()
 	h := int64(3)
 	voteSet, _, vals := randVoteSet(ctx, t, h-1, 1, tmproto.PrecommitType, 10, 1)
-	commit, err := makeCommit(ctx, lastID, h-1, 1, voteSet, vals, now)
+	commit, err := makeExtCommit(ctx, lastID, h-1, 1, voteSet, vals, now)
 
 	require.NoError(t, err)
 
-	return commit
+	return commit.StripExtensions()
 }
 
 func hexBytesFromString(t *testing.T, s string) bytes.HexBytes {
@@ -554,7 +553,7 @@ func TestBlockMaxDataBytesNoEvidence(t *testing.T) {
 	}
 }
 
-func TestCommitToVoteSet(t *testing.T) {
+func TestExtendedCommitToVoteSet(t *testing.T) {
 	lastID := makeBlockIDRandom()
 	h := int64(3)
 
@@ -562,17 +561,16 @@ func TestCommitToVoteSet(t *testing.T) {
 	defer cancel()
 
 	voteSet, valSet, vals := randVoteSet(ctx, t, h-1, 1, tmproto.PrecommitType, 10, 1)
-	commit, err := makeCommit(ctx, lastID, h-1, 1, voteSet, vals, time.Now())
-
+	extCommit, err := makeExtCommit(ctx, lastID, h-1, 1, voteSet, vals, time.Now())
 	assert.NoError(t, err)
 
 	chainID := voteSet.ChainID()
-	voteSet2 := CommitToVoteSet(chainID, commit, valSet)
+	voteSet2 := extCommit.ToVoteSet(chainID, valSet)
 
 	for i := int32(0); int(i) < len(vals); i++ {
-		vote1 := voteWithoutExtension(voteSet.GetByIndex(i))
+		vote1 := voteSet.GetByIndex(i)
 		vote2 := voteSet2.GetByIndex(i)
-		vote3 := commit.GetVote(i)
+		vote3 := extCommit.GetExtendedVote(i)
 
 		vote1bz, err := vote1.ToProto().Marshal()
 		require.NoError(t, err)
@@ -634,12 +632,12 @@ func TestCommitToVoteSetWithVotesForNilBlock(t *testing.T) {
 		}
 
 		if tc.valid {
-			commit := voteSet.MakeCommit() // panics without > 2/3 valid votes
-			assert.NotNil(t, commit)
-			err := valSet.VerifyCommit(voteSet.ChainID(), blockID, height-1, commit)
+			extCommit := voteSet.MakeExtendedCommit() // panics without > 2/3 valid votes
+			assert.NotNil(t, extCommit)
+			err := valSet.VerifyCommit(voteSet.ChainID(), blockID, height-1, extCommit.StripExtensions())
 			assert.NoError(t, err)
 		} else {
-			assert.Panics(t, func() { voteSet.MakeCommit() })
+			assert.Panics(t, func() { voteSet.MakeExtendedCommit() })
 		}
 	}
 }

types/evidence_test.go

@@ -153,8 +153,10 @@ func TestLightClientAttackEvidenceBasic(t *testing.T) {
 	header := makeHeaderRandom()
 	header.Height = height
 	blockID := makeBlockID(crypto.Checksum([]byte("blockhash")), math.MaxInt32, crypto.Checksum([]byte("partshash")))
-	commit, err := makeCommit(ctx, blockID, height, 1, voteSet, privVals, defaultVoteTime)
+	extCommit, err := makeExtCommit(ctx, blockID, height, 1, voteSet, privVals, defaultVoteTime)
 	require.NoError(t, err)
+	commit := extCommit.StripExtensions()
+
 	lcae := &LightClientAttackEvidence{
 		ConflictingBlock: &LightBlock{
 			SignedHeader: &SignedHeader{
@@ -217,8 +219,10 @@ func TestLightClientAttackEvidenceValidation(t *testing.T) {
 	header.Height = height
 	header.ValidatorsHash = valSet.Hash()
 	blockID := makeBlockID(header.Hash(), math.MaxInt32, crypto.Checksum([]byte("partshash")))
-	commit, err := makeCommit(ctx, blockID, height, 1, voteSet, privVals, time.Now())
+	extCommit, err := makeExtCommit(ctx, blockID, height, 1, voteSet, privVals, time.Now())
 	require.NoError(t, err)
+	commit := extCommit.StripExtensions()
+
 	lcae := &LightClientAttackEvidence{
 		ConflictingBlock: &LightBlock{
 			SignedHeader: &SignedHeader{
@@ -424,13 +428,13 @@ func TestEvidenceVectors(t *testing.T) {
 		ProposerAddress: []byte("2915b7b15f979e48ebc61774bb1d86ba3136b7eb"),
 	}
 	blockID3 := makeBlockID(header.Hash(), math.MaxInt32, crypto.Checksum([]byte("partshash")))
-	commit, err := makeCommit(ctx, blockID3, height, 1, voteSet, privVals, defaultVoteTime)
+	extCommit, err := makeExtCommit(ctx, blockID3, height, 1, voteSet, privVals, defaultVoteTime)
 	require.NoError(t, err)
 	lcae := &LightClientAttackEvidence{
 		ConflictingBlock: &LightBlock{
 			SignedHeader: &SignedHeader{
 				Header: header,
-				Commit: commit,
+				Commit: extCommit.StripExtensions(),
 			},
 			ValidatorSet: valSet,
 		},

types/test_util.go

@@ -8,8 +8,8 @@ import (
 	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
 )
 
-func makeCommit(ctx context.Context, blockID BlockID, height int64, round int32,
-	voteSet *VoteSet, validators []PrivValidator, now time.Time) (*Commit, error) {
+func makeExtCommit(ctx context.Context, blockID BlockID, height int64, round int32,
+	voteSet *VoteSet, validators []PrivValidator, now time.Time) (*ExtendedCommit, error) {
 
 	// all sign
 	for i := 0; i < len(validators); i++ {
@@ -33,7 +33,7 @@ func makeCommit(ctx context.Context, blockID BlockID, height int64, round int32,
 		}
 	}
 
-	return voteSet.MakeCommit(), nil
+	return voteSet.MakeExtendedCommit(), nil
 }
 
 func signAddVote(ctx context.Context, privVal PrivValidator, vote *Vote, voteSet *VoteSet) (signed bool, err error) {
@@ -46,13 +46,3 @@ func signAddVote(ctx context.Context, privVal PrivValidator, vote *Vote, voteSet
 	vote.ExtensionSignature = v.ExtensionSignature
 	return voteSet.AddVote(vote)
 }
-
-// Votes constructed from commits don't have extensions, because we don't store
-// the extensions themselves in the commit. This method is used to construct a
-// copy of a vote, but nil its extension and signature.
-func voteWithoutExtension(v *Vote) *Vote {
-	vc := v.Copy()
-	vc.Extension = nil
-	vc.ExtensionSignature = nil
-	return vc
-}

types/validation_test.go

@@ -146,9 +146,10 @@ func TestValidatorSet_VerifyCommit_CheckAllSignatures(t *testing.T) {
 	defer cancel()
 
 	voteSet, valSet, vals := randVoteSet(ctx, t, h, 0, tmproto.PrecommitType, 4, 10)
-	commit, err := makeCommit(ctx, blockID, h, 0, voteSet, vals, time.Now())
-
+	extCommit, err := makeExtCommit(ctx, blockID, h, 0, voteSet, vals, time.Now())
 	require.NoError(t, err)
+	commit := extCommit.StripExtensions()
+
 	require.NoError(t, valSet.VerifyCommit(chainID, blockID, h, commit))
 
 	// malleate 4th signature
@@ -176,9 +177,10 @@ func TestValidatorSet_VerifyCommitLight_ReturnsAsSoonAsMajorityOfVotingPowerSign
 	defer cancel()
 
 	voteSet, valSet, vals := randVoteSet(ctx, t, h, 0, tmproto.PrecommitType, 4, 10)
-	commit, err := makeCommit(ctx, blockID, h, 0, voteSet, vals, time.Now())
-
+	extCommit, err := makeExtCommit(ctx, blockID, h, 0, voteSet, vals, time.Now())
 	require.NoError(t, err)
+	commit := extCommit.StripExtensions()
+
 	require.NoError(t, valSet.VerifyCommit(chainID, blockID, h, commit))
 
 	// malleate 4th signature (3 signatures are enough for 2/3+)
@@ -203,9 +205,10 @@ func TestValidatorSet_VerifyCommitLightTrusting_ReturnsAsSoonAsTrustLevelOfVotin
 	defer cancel()
 
 	voteSet, valSet, vals := randVoteSet(ctx, t, h, 0, tmproto.PrecommitType, 4, 10)
-	commit, err := makeCommit(ctx, blockID, h, 0, voteSet, vals, time.Now())
-
+	extCommit, err := makeExtCommit(ctx, blockID, h, 0, voteSet, vals, time.Now())
 	require.NoError(t, err)
+	commit := extCommit.StripExtensions()
+
 	require.NoError(t, valSet.VerifyCommit(chainID, blockID, h, commit))
 
 	// malleate 3rd signature (2 signatures are enough for 1/3+ trust level)
@@ -227,10 +230,11 @@ func TestValidatorSet_VerifyCommitLightTrusting(t *testing.T) {
 	var (
 		blockID                       = makeBlockIDRandom()
 		voteSet, originalValset, vals = randVoteSet(ctx, t, 1, 1, tmproto.PrecommitType, 6, 1)
-		commit, err                   = makeCommit(ctx, blockID, 1, 1, voteSet, vals, time.Now())
+		extCommit, err                = makeExtCommit(ctx, blockID, 1, 1, voteSet, vals, time.Now())
 		newValSet, _                  = randValidatorPrivValSet(ctx, t, 2, 1)
 	)
 	require.NoError(t, err)
+	commit := extCommit.StripExtensions()
 
 	testCases := []struct {
 		valSet *ValidatorSet
@@ -271,11 +275,11 @@ func TestValidatorSet_VerifyCommitLightTrustingErrorsOnOverflow(t *testing.T) {
 	var (
 		blockID               = makeBlockIDRandom()
 		voteSet, valSet, vals = randVoteSet(ctx, t, 1, 1, tmproto.PrecommitType, 1, MaxTotalVotingPower)
-		commit, err           = makeCommit(ctx, blockID, 1, 1, voteSet, vals, time.Now())
+		extCommit, err        = makeExtCommit(ctx, blockID, 1, 1, voteSet, vals, time.Now())
 	)
 	require.NoError(t, err)
 
-	err = valSet.VerifyCommitLightTrusting("test_chain_id", commit,
+	err = valSet.VerifyCommitLightTrusting("test_chain_id", extCommit.StripExtensions(),
 		tmmath.Fraction{Numerator: 25, Denominator: 55})
 	if assert.Error(t, err) {
 		assert.Contains(t, err.Error(), "int64 overflow")

types/validator_set_test.go

@@ -1539,8 +1539,9 @@ func BenchmarkValidatorSet_VerifyCommit_Ed25519(b *testing.B) { // nolint
 			// generate n validators
 			voteSet, valSet, vals := randVoteSet(ctx, b, h, 0, tmproto.PrecommitType, n, int64(n*5))
 			// create a commit with n validators
-			commit, err := makeCommit(ctx, blockID, h, 0, voteSet, vals, time.Now())
+			extCommit, err := makeExtCommit(ctx, blockID, h, 0, voteSet, vals, time.Now())
 			require.NoError(b, err)
+			commit := extCommit.StripExtensions()
 
 			for i := 0; i < b.N/n; i++ {
 				err = valSet.VerifyCommit(chainID, blockID, h, commit)
@@ -1567,8 +1568,9 @@ func BenchmarkValidatorSet_VerifyCommitLight_Ed25519(b *testing.B) { // nolint
 			voteSet, valSet, vals := randVoteSet(ctx, b, h, 0, tmproto.PrecommitType, n, int64(n*5))
 
 			// create a commit with n validators
-			commit, err := makeCommit(ctx, blockID, h, 0, voteSet, vals, time.Now())
+			extCommit, err := makeExtCommit(ctx, blockID, h, 0, voteSet, vals, time.Now())
 			require.NoError(b, err)
+			commit := extCommit.StripExtensions()
 
 			for i := 0; i < b.N/n; i++ {
 				err = valSet.VerifyCommitLight(chainID, blockID, h, commit)
@@ -1594,8 +1596,9 @@ func BenchmarkValidatorSet_VerifyCommitLightTrusting_Ed25519(b *testing.B) {
 			// generate n validators
 			voteSet, valSet, vals := randVoteSet(ctx, b, h, 0, tmproto.PrecommitType, n, int64(n*5))
 			// create a commit with n validators
-			commit, err := makeCommit(ctx, blockID, h, 0, voteSet, vals, time.Now())
+			extCommit, err := makeExtCommit(ctx, blockID, h, 0, voteSet, vals, time.Now())
 			require.NoError(b, err)
+			commit := extCommit.StripExtensions()
 
 			for i := 0; i < b.N/n; i++ {
 				err = valSet.VerifyCommitLightTrusting(chainID, commit, tmmath.Fraction{Numerator: 1, Denominator: 3})

types/vote.go

@@ -109,6 +109,37 @@ func (vote *Vote) CommitSig() CommitSig {
 	}
 }
 
+// ExtendedCommitSig attempts to construct an ExtendedCommitSig from this vote.
+// Panics if either the vote extension signature is missing or if the block ID
+// is not either empty or complete.
+func (vote *Vote) ExtendedCommitSig() ExtendedCommitSig {
+	if vote == nil {
+		return NewExtendedCommitSigAbsent()
+	}
+
+	var blockIDFlag BlockIDFlag
+	switch {
+	case vote.BlockID.IsComplete():
+		blockIDFlag = BlockIDFlagCommit
+		if len(vote.ExtensionSignature) == 0 {
+			panic(fmt.Sprintf("Invalid vote %v - a BlockID is complete but missing vote extension signature", vote))
+		}
+	case vote.BlockID.IsNil():
+		blockIDFlag = BlockIDFlagNil
+	default:
+		panic(fmt.Sprintf("Invalid vote %v - expected BlockID to be either empty or complete", vote))
+	}
+
+	return ExtendedCommitSig{
+		BlockIDFlag:        blockIDFlag,
+		ValidatorAddress:   vote.ValidatorAddress,
+		Timestamp:          vote.Timestamp,
+		Signature:          vote.Signature,
+		VoteExtension:      vote.Extension,
+		ExtensionSignature: vote.ExtensionSignature,
+	}
+}
+
 // VoteSignBytes returns the proto-encoding of the canonicalized Vote, for
 // signing. Panics if the marshaling fails.
 //
@@ -219,9 +250,7 @@ func (vote *Vote) VerifyWithExtension(chainID string, pubKey crypto.PubKey) erro
 	// We only verify vote extension signatures for precommits.
 	if vote.Type == tmproto.PrecommitType {
 		extSignBytes := VoteExtensionSignBytes(chainID, v)
-		// TODO: Remove extension signature nil check to enforce vote extension
-		//       signing once we resolve https://github.com/tendermint/tendermint/issues/8272
-		if vote.ExtensionSignature != nil && !pubKey.VerifySignature(extSignBytes, vote.ExtensionSignature) {
+		if !pubKey.VerifySignature(extSignBytes, vote.ExtensionSignature) {
 			return ErrVoteInvalidSignature
 		}
 	}
@@ -296,10 +325,7 @@ func (vote *Vote) ValidateWithExtension() error {
 
 	// We should always see vote extension signatures in precommits
 	if vote.Type == tmproto.PrecommitType {
-		// TODO(thane): Remove extension length check once
-		//              https://github.com/tendermint/tendermint/issues/8272 is
-		//              resolved.
-		if len(vote.Extension) > 0 && len(vote.ExtensionSignature) == 0 {
+		if len(vote.ExtensionSignature) == 0 {
 			return errors.New("vote extension signature is missing")
 		}
 		if len(vote.ExtensionSignature) > MaxSignatureSize {

types/vote_set.go

@@ -606,36 +606,36 @@ func (voteSet *VoteSet) sumTotalFrac() (int64, int64, float64) {
 //--------------------------------------------------------------------------------
 // Commit
 
-// MakeCommit constructs a Commit from the VoteSet. It only includes precommits
-// for the block, which has 2/3+ majority, and nil.
+// MakeExtendedCommit constructs a Commit from the VoteSet. It only includes
+// precommits for the block, which has 2/3+ majority, and nil.
 //
 // Panics if the vote type is not PrecommitType or if there's no +2/3 votes for
 // a single block.
-func (voteSet *VoteSet) MakeCommit() *Commit {
+func (voteSet *VoteSet) MakeExtendedCommit() *ExtendedCommit {
 	if voteSet.signedMsgType != tmproto.PrecommitType {
-		panic("Cannot MakeCommit() unless VoteSet.Type is PrecommitType")
+		panic("Cannot MakeExtendCommit() unless VoteSet.Type is PrecommitType")
 	}
 	voteSet.mtx.Lock()
 	defer voteSet.mtx.Unlock()
 
 	// Make sure we have a 2/3 majority
 	if voteSet.maj23 == nil {
-		panic("Cannot MakeCommit() unless a blockhash has +2/3")
+		panic("Cannot MakeExtendCommit() unless a blockhash has +2/3")
 	}
 
-	// For every validator, get the precommit
-	commitSigs := make([]CommitSig, len(voteSet.votes))
+	// For every validator, get the precommit with extensions
+	extCommitSigs := make([]ExtendedCommitSig, len(voteSet.votes))
 	for i, v := range voteSet.votes {
-		commitSig := v.CommitSig()
+		extCommitSig := v.ExtendedCommitSig()
 		// if block ID exists but doesn't match, exclude sig
-		if commitSig.ForBlock() && !v.BlockID.Equals(*voteSet.maj23) {
-			commitSig = NewCommitSigAbsent()
+		if extCommitSig.ForBlock() && !v.BlockID.Equals(*voteSet.maj23) {
+			extCommitSig = NewExtendedCommitSigAbsent()
 		}
 
-		commitSigs[i] = commitSig
+		extCommitSigs[i] = extCommitSig
 	}
 
-	return NewCommit(voteSet.GetHeight(), voteSet.GetRound(), *voteSet.maj23, commitSigs)
+	return NewExtendedCommit(voteSet.GetHeight(), voteSet.GetRound(), *voteSet.maj23, extCommitSigs)
 }
 
 //--------------------------------------------------------------------------------

types/vote_set_test.go

@@ -450,7 +450,7 @@ func TestVoteSet_MakeCommit(t *testing.T) {
 	}
 
 	// MakeCommit should fail.
-	assert.Panics(t, func() { voteSet.MakeCommit() }, "Doesn't have +2/3 majority")
+	assert.Panics(t, func() { voteSet.MakeExtendedCommit() }, "Doesn't have +2/3 majority")
 
 	// 7th voted for some other block.
 	{
@@ -487,13 +487,13 @@ func TestVoteSet_MakeCommit(t *testing.T) {
 		require.NoError(t, err)
 	}
 
-	commit := voteSet.MakeCommit()
+	extCommit := voteSet.MakeExtendedCommit()
 
 	// Commit should have 10 elements
-	assert.Equal(t, 10, len(commit.Signatures))
+	assert.Equal(t, 10, len(extCommit.ExtendedSignatures))
 
 	// Ensure that Commit is good.
-	if err := commit.ValidateBasic(); err != nil {
+	if err := extCommit.ValidateBasic(); err != nil {
 		t.Errorf("error in Commit.ValidateBasic(): %v", err)
 	}
 }

types/vote_test.go

@@ -223,26 +223,22 @@ func TestVoteExtension(t *testing.T) {
 			includeSignature: true,
 			expectError:      false,
 		},
-		// TODO(thane): Re-enable once
-		// https://github.com/tendermint/tendermint/issues/8272 is resolved
-		//{
-		//	name:             "no extension signature",
-		//	extension:        []byte("extension"),
-		//	includeSignature: false,
-		//	expectError:      true,
-		//},
+		{
+			name:             "no extension signature",
+			extension:        []byte("extension"),
+			includeSignature: false,
+			expectError:      true,
+		},
 		{
 			name:             "empty extension",
 			includeSignature: true,
 			expectError:      false,
 		},
-		// TODO: Re-enable once
-		// https://github.com/tendermint/tendermint/issues/8272 is resolved.
-		//{
-		//	name:             "no extension and no signature",
-		//	includeSignature: false,
-		//	expectError:      true,
-		//},
+		{
+			name:             "no extension and no signature",
+			includeSignature: false,
+			expectError:      true,
+		},
 	}
 
 	for _, tc := range testCases {
@@ -497,11 +493,11 @@ func getSampleCommit(ctx context.Context, t testing.TB) *Commit {
 
 	lastID := makeBlockIDRandom()
 	voteSet, _, vals := randVoteSet(ctx, t, 2, 1, tmproto.PrecommitType, 10, 1)
-	commit, err := makeCommit(ctx, lastID, 2, 1, voteSet, vals, time.Now())
+	commit, err := makeExtCommit(ctx, lastID, 2, 1, voteSet, vals, time.Now())
 
 	require.NoError(t, err)
 
-	return commit
+	return commit.StripExtensions()
 }
 
 func BenchmarkVoteSignBytes(b *testing.B) {