Merge branch 'master' into marko/bringbackdocs

This is a follow-up to #8352. The check for legacy evidence keys is only based
on the prefix of the key. Hashes, which are unprefixed, could easily have this
form and be misdiagnosed.

Because the conversion for evidence checks the key structure, this should not
cause corruption. The probability that a hash is a syntactically valid evidence
key is negligible.  The tool will report an error rather than storing bad data.
But this does mean that such transaction hashes could cause the migration to
stop and report an error before it is complete.

To ensure we convert all the data, refine the legacy key check to filter these
keys more precisely. Update the test cases to exercise this condition.

* Update upgrading instructions.

.github/workflows/docs.yaml

@@ -0,0 +1,32 @@
+name: Documentation
+# This workflow builds the static documentation site, and publishes the results to GitHub Pages.
+# It runs on every push to the main branch, with changes in the docs and spec directories
+on:
+  workflow_dispatch:  # allow manual updates
+  push:
+    branches:
+      - master
+    paths:
+      - "docs/**"
+      - "spec/**"
+
+jobs:
+  build-and-deploy:
+    runs-on: ubuntu-latest
+    container:
+      image: tendermintdev/docker-website-deployment
+    steps:
+      - name: Checkout 🛎️
+        uses: actions/checkout@v3
+
+      - name: Install and Build 🔧
+        run: |
+          apk add rsync
+          make build-docs
+      - name: Deploy 🚀
+        uses: JamesIves/github-pages-deploy-action@v4.3.0
+        with:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          BRANCH: gh-pages
+          FOLDER: ~/output
+          single-commit: true

UPGRADING.md

@@ -212,22 +212,25 @@ and one function have moved to the Tendermint `crypto` package:
 
 The format of all tendermint on-disk database keys changes in
 0.35. Upgrading nodes must either re-sync all data or run a migration
-script provided in this release. The script located in
-`github.com/tendermint/tendermint/scripts/keymigrate/migrate.go`
-provides the function `Migrate(context.Context, db.DB)` which you can
-operationalize as makes sense for your deployment.
+script provided in this release.
+
+The script located in
+`github.com/tendermint/tendermint/scripts/keymigrate/migrate.go` provides the
+function `Migrate(context.Context, db.DB)` which you can operationalize as
+makes sense for your deployment.
 
 For ease of use the `tendermint` command includes a CLI version of the
 migration script, which you can invoke, as in:
 
 	tendermint key-migrate
 
-This reads the configuration file as normal and allows the
-`--db-backend` and `--db-dir` flags to change database operations as
-needed.
+This reads the configuration file as normal and allows the `--db-backend` and
+`--db-dir` flags to override the database location as needed.
 
-The migration operation is idempotent and can be run more than once,
-if needed.
+The migration operation is intended to be idempotent, and should be safe to
+rerun on the same database multiple times.  As a safety measure, however, we
+recommend that operators test out the migration on a copy of the database
+first, if it is practical to do so, before applying it to the production data.
 
 ### CLI Changes
 

docs/tendermint-core/consensus/proposer-based-timestamps.md

@@ -13,14 +13,15 @@ order: 3
 The PBTS algorithm defines a way for a Tendermint blockchain to create block
 timestamps that are within a reasonable bound of the clocks of the validators on
 the network. This replaces the original BFTTime algorithm for timestamp
-assignment that relied on the timestamps included in precommit messages.
+assignment that computed a timestamp using the timestamps included in precommit
+messages.
 
 ## Algorithm Parameters
 
 The functionality of the PBTS algorithm is governed by two parameters within
 Tendermint. These two parameters are [consensus
 parameters](https://github.com/tendermint/tendermint/blob/master/spec/abci/apps.md#L291),
-meaning they are configured by the ABCI application and are expected to be the
+meaning they are configured by the ABCI application and are therefore the same
 same across all nodes on the network.
 
 ### `Precision`
@@ -51,7 +52,7 @@ useful for the protocols and applications built on top of Tendermint.
 The following protocols and application features require a reliable source of time:
 
 * Tendermint Light Clients [rely on correspondence between their known time](https://github.com/tendermint/tendermint/blob/master/spec/light-client/verification/README.md#definitions-1) and the block time for block verification.
-* Tendermint Evidence validity is determined [either in terms of heights or in terms of time](https://github.com/tendermint/tendermint/blob/master/spec/consensus/evidence.md#verification).
+* Tendermint Evidence expiration is determined [either in terms of heights or in terms of time](https://github.com/tendermint/tendermint/blob/master/spec/consensus/evidence.md#verification).
 * Unbonding of staked assets in the Cosmos Hub [occurs after a period of 21
  days](https://github.com/cosmos/governance/blob/master/params-change/Staking.md#unbondingtime).
 * IBC packets can use either a [timestamp or a height to timeout packet

internal/blocksync/pool.go

@@ -200,20 +200,16 @@ 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. 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.
-//
+// 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.
 // The caller will verify the commit.
-func (pool *BlockPool) PeekTwoBlocks() (first, second *types.Block, firstExtCommit *types.ExtendedCommit) {
+func (pool *BlockPool) PeekTwoBlocks() (first *types.Block, second *types.Block) {
 	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()
@@ -222,8 +218,7 @@ func (pool *BlockPool) PeekTwoBlocks() (first, second *types.Block, firstExtComm
 }
 
 // PopRequest pops the first block at pool.height.
-// It must have been validated by the second Commit from PeekTwoBlocks.
-// TODO(thane): (?) and its corresponding ExtendedCommit.
+// It must have been validated by 'second'.Commit from PeekTwoBlocks().
 func (pool *BlockPool) PopRequest() {
 	pool.mtx.Lock()
 	defer pool.mtx.Unlock()
@@ -269,15 +264,10 @@ 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, extCommit *types.ExtendedCommit, blockSize int) {
+func (pool *BlockPool) AddBlock(peerID types.NodeID, block *types.Block, 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",
@@ -292,7 +282,7 @@ func (pool *BlockPool) AddBlock(peerID types.NodeID, block *types.Block, extComm
 		return
 	}
 
-	if requester.setBlock(block, extCommit, peerID) {
+	if requester.setBlock(block, peerID) {
 		atomic.AddInt32(&pool.numPending, -1)
 		peer := pool.peers[peerID]
 		if peer != nil {
@@ -466,7 +456,6 @@ 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
@@ -555,10 +544,9 @@ 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
-	extCommit *types.ExtendedCommit
+	mtx    sync.Mutex
+	peerID types.NodeID
+	block  *types.Block
 }
 
 func newBPRequester(logger log.Logger, pool *BlockPool, height int64) *bpRequester {
@@ -584,14 +572,13 @@ 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, extCommit *types.ExtendedCommit, peerID types.NodeID) bool {
+func (bpr *bpRequester) setBlock(block *types.Block, 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 {
@@ -607,12 +594,6 @@ 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()
@@ -630,7 +611,6 @@ 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,10 +43,7 @@ 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}}
-	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)
+	input.pool.AddBlock(input.request.PeerID, block, 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
@@ -113,7 +110,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 {
@@ -167,7 +164,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       sm.BlockStore
+	store       *store.BlockStore
 	pool        *BlockPool
 	consReactor consensusReactor
 	blockSync   *atomicBool
@@ -186,23 +186,15 @@ 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 block to protobuf", "err", err)
+			r.logger.Error("failed to convert msg to protobuf", "err", err)
 			return err
 		}
 
 		return blockSyncCh.Send(ctx, p2p.Envelope{
-			To: peerID,
-			Message: &bcproto.BlockResponse{
-				Block:     blockProto,
-				ExtCommit: extCommit.ToProto(),
-			},
+			To:      peerID,
+			Message: &bcproto.BlockResponse{Block: blockProto},
 		})
 	}
 
@@ -244,15 +236,8 @@ 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, extCommit, block.Size())
+			r.pool.AddBlock(envelope.From, block, block.Size())
 
 		case *bcproto.StatusRequest:
 			return blockSyncCh.Send(ctx, p2p.Envelope{
@@ -463,19 +448,6 @@ 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)
 
@@ -518,12 +490,9 @@ 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, 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
+			first, second := r.pool.PeekTwoBlocks()
+			if first == nil || second == nil {
+				// we need both to sync the first block
 				continue
 			} else {
 				// try again quickly next loop
@@ -548,7 +517,6 @@ 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(
@@ -581,7 +549,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, extCommit)
+				r.store.SaveBlock(first, firstParts, second.LastCommit)
 
 				var err error
 

internal/blocksync/reactor_test.go

@@ -147,43 +147,39 @@ 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++ {
-		lastExtCommit = seenExtCommit.Copy()
+		lastCommit := types.NewCommit(blockHeight-1, 0, types.BlockID{}, nil)
 
-		thisBlock := sf.MakeBlock(state, blockHeight, lastExtCommit.StripExtensions())
+		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)
 		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, seenExtCommit)
+		blockStore.SaveBlock(thisBlock, thisParts, lastCommit)
 	}
 
 	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.ExtendedCommit
+		var commit *types.Commit
 		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.NewExtendedCommit(0, 0, types.BlockID{}, nil)
+			commit = types.NewCommit(0, 0, types.BlockID{}, nil)
 		case lazyNodeState.LastCommit.HasTwoThirdsMajority():
 			// Make the commit from LastCommit
-			commit = lazyNodeState.LastCommit.MakeExtendedCommit()
+			commit = lazyNodeState.LastCommit.MakeCommit()
 		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.ExtendedSignatures[len(commit.ExtendedSignatures)-1] = types.NewExtendedCommitSigAbsent()
+		commit.Signatures[len(commit.Signatures)-1] = types.NewCommitSigAbsent()
 
 		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)
+			ctx, lazyNodeState.Height, lazyNodeState.state, commit, proposerAddr, lazyNodeState.LastCommit.GetVotes())
 		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's extended commit for prs.Height, which contains precommit
+			// Load the block commit for prs.Height, which contains precommit
 			// signatures for prs.Height.
-			if extCommit := r.state.blockStore.LoadBlockExtCommit(prs.Height); extCommit != nil {
-				if ok, err := r.pickSendVote(ctx, ps, extCommit, voteCh); err != nil {
+			if commit := r.state.blockStore.LoadBlockCommit(prs.Height); commit != nil {
+				if ok, err := r.pickSendVote(ctx, ps, commit, 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
-	ExtCommits   []*types.ExtendedCommit
+	Commits      []*types.Commit
 	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.ExtCommits = make([]*types.ExtendedCommit, 0)
+	sim.Commits = make([]*types.Commit, 0)
 	for i := 1; i <= numBlocks; i++ {
 		sim.Chain = append(sim.Chain, css[0].blockStore.LoadBlock(int64(i)))
-		sim.ExtCommits = append(sim.ExtCommits, css[0].blockStore.LoadBlockExtCommit(int64(i)))
+		sim.Commits = append(sim.Commits, css[0].blockStore.LoadBlockCommit(int64(i)))
 	}
 
 	return sim
@@ -679,7 +679,7 @@ func testHandshakeReplay(
 	testValidatorsChange bool,
 ) {
 	var chain []*types.Block
-	var extCommits []*types.ExtendedCommit
+	var commits []*types.Commit
 	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
-		extCommits = sim.ExtCommits
+		commits = sim.Commits
 		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, extCommits = makeBlockchainFromWAL(t, wal)
+		chain, commits = 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.extCommits = extCommits
+	store.commits = commits
 
 	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.ExtendedCommit) {
+func makeBlockchainFromWAL(t *testing.T, wal WAL) ([]*types.Block, []*types.Commit) {
 	t.Helper()
 	var height int64
 
@@ -1047,10 +1047,10 @@ func makeBlockchainFromWAL(t *testing.T, wal WAL) ([]*types.Block, []*types.Exte
 	// log.Notice("Build a blockchain by reading from the WAL")
 
 	var (
-		blocks             []*types.Block
-		extCommits         []*types.ExtendedCommit
-		thisBlockParts     *types.PartSet
-		thisBlockExtCommit *types.ExtendedCommit
+		blocks          []*types.Block
+		commits         []*types.Commit
+		thisBlockParts  *types.PartSet
+		thisBlockCommit *types.Commit
 	)
 
 	dec := NewWALDecoder(gr)
@@ -1082,12 +1082,12 @@ func makeBlockchainFromWAL(t *testing.T, wal WAL) ([]*types.Block, []*types.Exte
 				require.Equal(t, block.Height, height+1,
 					"read bad block from wal. got height %d, expected %d", block.Height, height+1)
 
-				commitHeight := thisBlockExtCommit.Height
+				commitHeight := thisBlockCommit.Height
 				require.Equal(t, commitHeight, height+1,
 					"commit doesnt match. got height %d, expected %d", commitHeight, height+1)
 
 				blocks = append(blocks, block)
-				extCommits = append(extCommits, thisBlockExtCommit)
+				commits = append(commits, thisBlockCommit)
 				height++
 			}
 		case *types.PartSetHeader:
@@ -1097,8 +1097,8 @@ func makeBlockchainFromWAL(t *testing.T, wal WAL) ([]*types.Block, []*types.Exte
 			require.NoError(t, err)
 		case *types.Vote:
 			if p.Type == tmproto.PrecommitType {
-				thisBlockExtCommit = types.NewExtendedCommit(p.Height, p.Round,
-					p.BlockID, []types.ExtendedCommitSig{p.ExtendedCommitSig()})
+				thisBlockCommit = types.NewCommit(p.Height, p.Round,
+					p.BlockID, []types.CommitSig{p.CommitSig()})
 			}
 		}
 	}
@@ -1113,12 +1113,12 @@ func makeBlockchainFromWAL(t *testing.T, wal WAL) ([]*types.Block, []*types.Exte
 	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 := thisBlockExtCommit.Height
+	commitHeight := thisBlockCommit.Height
 	require.Equal(t, commitHeight, height+1, "commit does not match. got height %d, expected %d", commitHeight, height+1)
 
 	blocks = append(blocks, block)
-	extCommits = append(extCommits, thisBlockExtCommit)
-	return blocks, extCommits
+	commits = append(commits, thisBlockCommit)
+	return blocks, commits
 }
 
 func readPieceFromWAL(msg *TimedWALMessage) interface{} {
@@ -1162,16 +1162,14 @@ func stateAndStore(
 // mock block store
 
 type mockBlockStore struct {
-	cfg        *config.Config
-	params     types.ConsensusParams
-	chain      []*types.Block
-	extCommits []*types.ExtendedCommit
-	base       int64
-	t          *testing.T
+	cfg     *config.Config
+	params  types.ConsensusParams
+	chain   []*types.Block
+	commits []*types.Commit
+	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{
@@ -1200,24 +1198,20 @@ 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.ExtendedCommit) {
+func (bs *mockBlockStore) SaveBlock(block *types.Block, blockParts *types.PartSet, seenCommit *types.Commit) {
 }
-
 func (bs *mockBlockStore) LoadBlockCommit(height int64) *types.Commit {
-	return bs.extCommits[height-1].StripExtensions()
+	return bs.commits[height-1]
 }
 func (bs *mockBlockStore) LoadSeenCommit() *types.Commit {
-	return bs.extCommits[len(bs.extCommits)-1].StripExtensions()
-}
-func (bs *mockBlockStore) LoadBlockExtCommit(height int64) *types.ExtendedCommit {
-	return bs.extCommits[height-1]
+	return bs.commits[len(bs.commits)-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.extCommits[i] = nil
+		bs.commits[i] = nil
 		pruned++
 	}
 	bs.base = height

internal/consensus/state.go

@@ -695,15 +695,19 @@ 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) {
-	extCommit := cs.blockStore.LoadBlockExtCommit(state.LastBlockHeight)
-	if extCommit == nil {
+	commit := cs.blockStore.LoadSeenCommit()
+	if commit == nil || commit.Height != state.LastBlockHeight {
+		commit = cs.blockStore.LoadBlockCommit(state.LastBlockHeight)
+	}
+
+	if commit == nil {
 		panic(fmt.Sprintf(
 			"failed to reconstruct last commit; commit for height %v not found",
 			state.LastBlockHeight,
 		))
 	}
 
-	lastPrecommits := extCommit.ToVoteSet(state.ChainID, state.LastValidators)
+	lastPrecommits := types.CommitToVoteSet(state.ChainID, commit, state.LastValidators)
 	if !lastPrecommits.HasTwoThirdsMajority() {
 		panic("failed to reconstruct last commit; does not have +2/3 maj")
 	}
@@ -1396,17 +1400,16 @@ func (cs *State) createProposalBlock(ctx context.Context) (*types.Block, error)
 		return nil, errors.New("entered createProposalBlock with privValidator being nil")
 	}
 
-	//TODO: wouldn't it be easier if CreateProposalBlock accepted cs.LastCommit directly?
-	var extCommit *types.ExtendedCommit
+	var commit *types.Commit
 	switch {
 	case cs.Height == cs.state.InitialHeight:
 		// We're creating a proposal for the first block.
 		// The commit is empty, but not nil.
-		extCommit = types.NewExtendedCommit(0, 0, types.BlockID{}, nil)
+		commit = types.NewCommit(0, 0, types.BlockID{}, nil)
 
 	case cs.LastCommit.HasTwoThirdsMajority():
 		// Make the commit from LastCommit
-		extCommit = cs.LastCommit.MakeExtendedCommit()
+		commit = cs.LastCommit.MakeCommit()
 
 	default: // This shouldn't happen.
 		cs.logger.Error("propose step; cannot propose anything without commit for the previous block")
@@ -1422,7 +1425,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, extCommit, proposerAddr)
+	ret, err := cs.blockExec.CreateProposalBlock(ctx, cs.Height, cs.state, commit, proposerAddr, cs.LastCommit.GetVotes())
 	if err != nil {
 		panic(err)
 	}
@@ -1920,7 +1923,8 @@ 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)
-		cs.blockStore.SaveBlock(block, blockParts, precommits.MakeExtendedCommit())
+		seenCommit := precommits.MakeCommit()
+		cs.blockStore.SaveBlock(block, blockParts, seenCommit)
 	} 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)
-	lastExtCommit := makeExtCommit(height, val.PrivKey.PubKey().Address())
-	block := types.MakeBlock(height+1, []types.Tx{}, lastExtCommit.StripExtensions(), []types.Evidence{ev})
+	lastCommit := makeCommit(height, val.PrivKey.PubKey().Address())
+	block := types.MakeBlock(height+1, []types.Tx{}, lastCommit, []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 := makeExtCommit(i-1, valAddr)
-		block := sf.MakeBlock(state, i, lastCommit.StripExtensions())
+		lastCommit := makeCommit(i-1, valAddr)
+		block := sf.MakeBlock(state, i, lastCommit)
 
 		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 := makeExtCommit(i, valAddr)
+		seenCommit := makeCommit(i, valAddr)
 		blockStore.SaveBlock(block, partSet, seenCommit)
 	}
 
 	return blockStore, nil
 }
 
-func makeExtCommit(height int64, valAddr []byte) *types.ExtendedCommit {
-	extCommitSigs := []types.ExtendedCommitSig{{
+func makeCommit(height int64, valAddr []byte) *types.Commit {
+	commitSigs := []types.CommitSig{{
 		BlockIDFlag:      types.BlockIDFlagCommit,
 		ValidatorAddress: valAddr,
 		Timestamp:        defaultEvidenceTime,
 		Signature:        []byte("Signature"),
 	}}
 
-	return types.NewExtendedCommit(height, 0, types.BlockID{}, extCommitSigs)
+	return types.NewCommit(height, 0, types.BlockID{}, commitSigs)
 }
 
 func defaultTestPool(ctx context.Context, t *testing.T, height int64) (*evidence.Pool, types.MockPV, *eventbus.EventBus) {

internal/evidence/verify_test.go

@@ -234,9 +234,8 @@ 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)
-	extCommit, err := factory.MakeExtendedCommit(ctx, blockID, 10, 1, voteSet, conflictingPrivVals[:4], defaultEvidenceTime)
+	commit, err := factory.MakeCommit(ctx, blockID, 10, 1, voteSet, conflictingPrivVals[:4], defaultEvidenceTime)
 	require.NoError(t, err)
-	commit := extCommit.StripExtensions()
 
 	ev := &types.LightClientAttackEvidence{
 		ConflictingBlock: &types.LightBlock{
@@ -254,10 +253,9 @@ func TestVerifyLightClientAttack_Equivocation(t *testing.T) {
 
 	trustedBlockID := makeBlockID(trustedHeader.Hash(), 1000, []byte("partshash"))
 	trustedVoteSet := types.NewVoteSet(evidenceChainID, 10, 1, tmproto.SignedMsgType(2), conflictingVals)
-	trustedExtCommit, err := factory.MakeExtendedCommit(ctx, trustedBlockID, 10, 1,
+	trustedCommit, err := factory.MakeCommit(ctx, trustedBlockID, 10, 1,
 		trustedVoteSet, conflictingPrivVals, defaultEvidenceTime)
 	require.NoError(t, err)
-	trustedCommit := trustedExtCommit.StripExtensions()
 
 	trustedSignedHeader := &types.SignedHeader{
 		Header: trustedHeader,
@@ -337,9 +335,8 @@ 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)
-	extCommit, err := factory.MakeExtendedCommit(ctx, blockID, height, 0, voteSet, conflictingPrivVals, defaultEvidenceTime)
+	commit, err := factory.MakeCommit(ctx, blockID, height, 0, voteSet, conflictingPrivVals, defaultEvidenceTime)
 	require.NoError(t, err)
-	commit := extCommit.StripExtensions()
 
 	ev := &types.LightClientAttackEvidence{
 		ConflictingBlock: &types.LightBlock{
@@ -357,10 +354,9 @@ func TestVerifyLightClientAttack_Amnesia(t *testing.T) {
 
 	trustedBlockID := makeBlockID(trustedHeader.Hash(), 1000, []byte("partshash"))
 	trustedVoteSet := types.NewVoteSet(evidenceChainID, height, 1, tmproto.SignedMsgType(2), conflictingVals)
-	trustedExtCommit, err := factory.MakeExtendedCommit(ctx, trustedBlockID, height, 1,
+	trustedCommit, err := factory.MakeCommit(ctx, trustedBlockID, height, 1,
 		trustedVoteSet, conflictingPrivVals, defaultEvidenceTime)
 	require.NoError(t, err)
-	trustedCommit := trustedExtCommit.StripExtensions()
 
 	trustedSignedHeader := &types.SignedHeader{
 		Header: trustedHeader,
@@ -554,9 +550,8 @@ func makeLunaticEvidence(
 
 	blockID := factory.MakeBlockIDWithHash(conflictingHeader.Hash())
 	voteSet := types.NewVoteSet(evidenceChainID, height, 1, tmproto.SignedMsgType(2), conflictingVals)
-	extCommit, err := factory.MakeExtendedCommit(ctx, blockID, height, 1, voteSet, conflictingPrivVals, defaultEvidenceTime)
+	commit, err := factory.MakeCommit(ctx, blockID, height, 1, voteSet, conflictingPrivVals, defaultEvidenceTime)
 	require.NoError(t, err)
-	commit := extCommit.StripExtensions()
 
 	ev = &types.LightClientAttackEvidence{
 		ConflictingBlock: &types.LightBlock{
@@ -583,9 +578,8 @@ 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)
-	trustedExtCommit, err := factory.MakeExtendedCommit(ctx, trustedBlockID, height, 1, trustedVoteSet, privVals, defaultEvidenceTime)
+	trustedCommit, err := factory.MakeCommit(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,6 +7,7 @@ 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"
@@ -86,8 +87,9 @@ func (blockExec *BlockExecutor) CreateProposalBlock(
 	ctx context.Context,
 	height int64,
 	state State,
-	extCommit *types.ExtendedCommit,
+	commit *types.Commit,
 	proposerAddr []byte,
+	votes []*types.Vote,
 ) (*types.Block, error) {
 
 	maxBytes := state.ConsensusParams.Block.MaxBytes
@@ -99,15 +101,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(*extCommit),
+			LocalLastCommit:     extendedCommitInfo(localLastCommit, votes),
 			ByzantineValidators: block.Evidence.ToABCI(),
 			Height:              block.Height,
 			Time:                block.Time,
@@ -414,28 +416,43 @@ func buildLastCommitInfo(block *types.Block, store Store, initialHeight int64) a
 	}
 }
 
-// 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 {
+// 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 {
 		var ext []byte
-		if ecs.ForBlock() {
-			ext = ecs.VoteExtension
+		// 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
 		}
 		vs[i] = abci.ExtendedVoteInfo{
-			Validator: abci.Validator{
-				Address: ecs.ValidatorAddress,
-				//TODO: Important: why do we need power here?
-				Power: 0,
-			},
-			SignedLastBlock: ecs.ForBlock(),
+			Validator:       c.Votes[i].Validator,
+			SignedLastBlock: c.Votes[i].SignedLastBlock,
 			VoteExtension:   ext,
 		}
 	}
 	return abci.ExtendedCommitInfo{
-		Round: extCommit.Round,
+		Round: c.Round,
 		Votes: vs,
 	}
 }

internal/state/execution_test.go

@@ -79,10 +79,9 @@ 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()
@@ -97,7 +96,7 @@ func TestFinalizeBlockDecidedLastCommit(t *testing.T) {
 
 	state, stateDB, privVals := makeState(t, 7, 1)
 	stateStore := sm.NewStore(stateDB)
-	absentSig := types.NewExtendedCommitSigAbsent()
+	absentSig := types.NewCommitSigAbsent()
 
 	testCases := []struct {
 		name             string
@@ -135,12 +134,12 @@ func TestFinalizeBlockDecidedLastCommit(t *testing.T) {
 
 			for idx, isAbsent := range tc.absentCommitSigs {
 				if isAbsent {
-					lastCommit.ExtendedSignatures[idx] = absentSig
+					lastCommit.Signatures[idx] = absentSig
 				}
 			}
 
 			// block for height 2
-			block := sf.MakeBlock(state, 2, lastCommit.StripExtensions())
+			block := sf.MakeBlock(state, 2, lastCommit)
 			bps, err := block.MakePartSet(testPartSize)
 			require.NoError(t, err)
 			blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: bps.Header()}
@@ -654,8 +653,8 @@ func TestEmptyPrepareProposal(t *testing.T) {
 		sm.NopMetrics(),
 	)
 	pa, _ := state.Validators.GetByIndex(0)
-	commit, _ := makeValidCommit(ctx, t, height, types.BlockID{}, state.Validators, privVals)
-	_, err = blockExec.CreateProposalBlock(ctx, height, state, commit, pa)
+	commit, votes := makeValidCommit(ctx, t, height, types.BlockID{}, state.Validators, privVals)
+	_, err = blockExec.CreateProposalBlock(ctx, height, state, commit, pa, votes)
 	require.NoError(t, err)
 }
 
@@ -709,8 +708,8 @@ func TestPrepareProposalErrorOnNonExistingRemoved(t *testing.T) {
 		sm.NopMetrics(),
 	)
 	pa, _ := state.Validators.GetByIndex(0)
-	commit, _ := makeValidCommit(ctx, t, height, types.BlockID{}, state.Validators, privVals)
-	block, err := blockExec.CreateProposalBlock(ctx, height, state, commit, pa)
+	commit, votes := makeValidCommit(ctx, t, height, types.BlockID{}, state.Validators, privVals)
+	block, err := blockExec.CreateProposalBlock(ctx, height, state, commit, pa, votes)
 	require.ErrorContains(t, err, "new transaction incorrectly marked as removed")
 	require.Nil(t, block)
 
@@ -765,8 +764,8 @@ func TestPrepareProposalRemoveTxs(t *testing.T) {
 		sm.NopMetrics(),
 	)
 	pa, _ := state.Validators.GetByIndex(0)
-	commit, _ := makeValidCommit(ctx, t, height, types.BlockID{}, state.Validators, privVals)
-	block, err := blockExec.CreateProposalBlock(ctx, height, state, commit, pa)
+	commit, votes := makeValidCommit(ctx, t, height, types.BlockID{}, state.Validators, privVals)
+	block, err := blockExec.CreateProposalBlock(ctx, height, state, commit, pa, votes)
 	require.NoError(t, err)
 	require.Len(t, block.Data.Txs.ToSliceOfBytes(), len(trs)-2)
 
@@ -824,8 +823,8 @@ func TestPrepareProposalAddedTxsIncluded(t *testing.T) {
 		sm.NopMetrics(),
 	)
 	pa, _ := state.Validators.GetByIndex(0)
-	commit, _ := makeValidCommit(ctx, t, height, types.BlockID{}, state.Validators, privVals)
-	block, err := blockExec.CreateProposalBlock(ctx, height, state, commit, pa)
+	commit, votes := makeValidCommit(ctx, t, height, types.BlockID{}, state.Validators, privVals)
+	block, err := blockExec.CreateProposalBlock(ctx, height, state, commit, pa, votes)
 	require.NoError(t, err)
 
 	require.Equal(t, txs[0], block.Data.Txs[0])
@@ -880,8 +879,8 @@ func TestPrepareProposalReorderTxs(t *testing.T) {
 		sm.NopMetrics(),
 	)
 	pa, _ := state.Validators.GetByIndex(0)
-	commit, _ := makeValidCommit(ctx, t, height, types.BlockID{}, state.Validators, privVals)
-	block, err := blockExec.CreateProposalBlock(ctx, height, state, commit, pa)
+	commit, votes := makeValidCommit(ctx, t, height, types.BlockID{}, state.Validators, privVals)
+	block, err := blockExec.CreateProposalBlock(ctx, height, state, commit, pa, votes)
 	require.NoError(t, err)
 	for i, tx := range block.Data.Txs {
 		require.Equal(t, types.Tx(trs[i].Tx), tx)
@@ -940,8 +939,9 @@ func TestPrepareProposalErrorOnTooManyTxs(t *testing.T) {
 		sm.NopMetrics(),
 	)
 	pa, _ := state.Validators.GetByIndex(0)
-	commit, _ := makeValidCommit(ctx, t, height, types.BlockID{}, state.Validators, privVals)
-	block, err := blockExec.CreateProposalBlock(ctx, height, state, commit, pa)
+	commit, votes := makeValidCommit(ctx, t, height, types.BlockID{}, state.Validators, privVals)
+
+	block, err := blockExec.CreateProposalBlock(ctx, height, state, commit, pa, votes)
 	require.ErrorContains(t, err, "transaction data size exceeds maximum")
 	require.Nil(t, block, "")
 
@@ -991,66 +991,15 @@ func TestPrepareProposalErrorOnPrepareProposalError(t *testing.T) {
 		sm.NopMetrics(),
 	)
 	pa, _ := state.Validators.GetByIndex(0)
-	commit, _ := makeValidCommit(ctx, t, height, types.BlockID{}, state.Validators, privVals)
-	block, err := blockExec.CreateProposalBlock(ctx, height, state, commit, pa)
+	commit, votes := makeValidCommit(ctx, t, height, types.BlockID{}, state.Validators, privVals)
+
+	block, err := blockExec.CreateProposalBlock(ctx, height, state, commit, pa, votes)
 	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.ExtendedCommit) {
+) (sm.State, types.BlockID, *types.Commit) {
 	t.Helper()
 
 	// A good block passes
@@ -82,19 +82,19 @@ func makeValidCommit(
 	blockID types.BlockID,
 	vals *types.ValidatorSet,
 	privVals map[string]types.PrivValidator,
-) (*types.ExtendedCommit, []*types.Vote) {
+) (*types.Commit, []*types.Vote) {
 	t.Helper()
-	sigs := make([]types.ExtendedCommitSig, vals.Size())
+	sigs := make([]types.CommitSig, 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.ExtendedCommitSig()
+		sigs[i] = vote.CommitSig()
 		votes[i] = vote
 	}
 
-	return types.NewExtendedCommit(height, 0, blockID, sigs), votes
+	return types.NewCommit(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,22 +107,6 @@ 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)
@@ -209,7 +193,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.ExtendedCommit) {
+func (_m *BlockStore) SaveBlock(block *types.Block, blockParts *types.PartSet, seenCommit *types.Commit) {
 	_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.ExtendedCommit)
+	SaveBlock(block *types.Block, blockParts *types.PartSet, seenCommit *types.Commit)
 
 	PruneBlocks(height int64) (uint64, error)
 
@@ -36,7 +36,6 @@ type BlockStore interface {
 
 	LoadBlockCommit(height int64) *types.Commit
 	LoadSeenCommit() *types.Commit
-	LoadBlockExtCommit(height int64) *types.ExtendedCommit
 }
 
 //-----------------------------------------------------------------------------

internal/state/store.go

@@ -26,8 +26,6 @@ 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,7 +66,6 @@ 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"))
@@ -122,9 +121,8 @@ func TestValidateBlockHeader(t *testing.T) {
 		/*
 			A good block passes
 		*/
-		state, _, lastExtCommit = makeAndCommitGoodBlock(ctx, t,
+		state, _, lastCommit = makeAndCommitGoodBlock(ctx, t,
 			state, height, lastCommit, state.Validators.GetProposer().Address, blockExec, privVals, nil)
-		lastCommit = lastExtCommit.StripExtensions()
 	}
 
 	nextHeight := validationTestsStopHeight
@@ -172,7 +170,6 @@ 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()
 
@@ -223,7 +220,7 @@ func TestValidateBlockCommit(t *testing.T) {
 			A good block passes
 		*/
 		var blockID types.BlockID
-		state, blockID, lastExtCommit = makeAndCommitGoodBlock(
+		state, blockID, lastCommit = makeAndCommitGoodBlock(
 			ctx,
 			t,
 			state,
@@ -234,7 +231,6 @@ func TestValidateBlockCommit(t *testing.T) {
 			privVals,
 			nil,
 		)
-		lastCommit = lastExtCommit.StripExtensions()
 
 		/*
 			wrongSigsCommit is fine except for the extra bad precommit
@@ -324,7 +320,6 @@ 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
@@ -369,7 +364,7 @@ func TestValidateBlockEvidence(t *testing.T) {
 			evidence = append(evidence, newEv)
 		}
 
-		state, _, lastExtCommit = makeAndCommitGoodBlock(
+		state, _, lastCommit = makeAndCommitGoodBlock(
 			ctx,
 			t,
 			state,
@@ -380,7 +375,6 @@ 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)
-	extCommit, err := factory.MakeExtendedCommit(ctx, lastBlockID, height, 0, voteSet, currentPrivVals, time)
+	commit, err := factory.MakeCommit(ctx, lastBlockID, height, 0, voteSet, currentPrivVals, time)
 	require.NoError(t, err)
 	return nextVals, nextPrivVals, &types.LightBlock{
 		SignedHeader: &types.SignedHeader{
 			Header: header,
-			Commit: extCommit.StripExtensions(),
+			Commit: commit,
 		},
 		ValidatorSet: currentVals,
 	}

internal/store/store.go

@@ -273,31 +273,11 @@ func (bs *BlockStore) LoadBlockCommit(height int64) *types.Commit {
 	}
 	commit, err := types.CommitFromProto(pbc)
 	if err != nil {
-		panic(fmt.Errorf("error from proto block commit: %w", err))
+		panic(fmt.Errorf("error reading 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
@@ -318,7 +298,7 @@ func (bs *BlockStore) LoadSeenCommit() *types.Commit {
 
 	commit, err := types.CommitFromProto(pbc)
 	if err != nil {
-		panic(fmt.Errorf("converting seen commit: %w", err))
+		panic(fmt.Errorf("error from proto commit: %w", err))
 	}
 	return commit
 }
@@ -466,7 +446,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.ExtendedCommit) {
+func (bs *BlockStore) SaveBlock(block *types.Block, blockParts *types.PartSet, seenCommit *types.Commit) {
 	if block == nil {
 		panic("BlockStore can only save a non-nil block")
 	}
@@ -482,10 +462,6 @@ 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
@@ -518,18 +494,12 @@ func (bs *BlockStore) SaveBlock(block *types.Block, blockParts *types.PartSet, s
 	}
 
 	// Save seen commit (seen +2/3 precommits for block)
-	pbsc := seenCommit.StripExtensions().ToProto()
+	pbsc := seenCommit.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)
 	}
@@ -609,8 +579,6 @@ 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)
@@ -618,7 +586,6 @@ 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 {
@@ -668,14 +635,6 @@ 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,6 +2,7 @@ package store
 
 import (
 	"fmt"
+	stdlog "log"
 	"os"
 	"runtime/debug"
 	"strings"
@@ -26,24 +27,22 @@ import (
 // test.
 type cleanupFunc func()
 
-// 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{{
+// 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{{
 		BlockIDFlag:      types.BlockIDFlagCommit,
 		ValidatorAddress: tmrand.Bytes(crypto.AddressSize),
 		Timestamp:        timestamp,
 		Signature:        []byte("Signature"),
 	}}
-	return types.NewExtendedCommit(
+	return types.NewCommit(
 		height,
 		0,
 		types.BlockID{
 			Hash:          crypto.CRandBytes(32),
 			PartSetHeader: types.PartSetHeader{Hash: crypto.CRandBytes(32), Total: 2},
 		},
-		extCommitSigs,
-	)
+		commitSigs)
 }
 
 func makeStateAndBlockStore(dir string) (sm.State, *BlockStore, cleanupFunc, error) {
@@ -60,11 +59,47 @@ func makeStateAndBlockStore(dir string) (sm.State, *BlockStore, cleanupFunc, err
 	return state, NewBlockStore(blockDB), func() { os.RemoveAll(cfg.RootDir) }, nil
 }
 
-func newInMemoryBlockStore() (*BlockStore, dbm.DB) {
+func freshBlockStore() (*BlockStore, dbm.DB) {
 	db := dbm.NewMemDB()
 	return NewBlockStore(db), db
 }
 
+var (
+	state       sm.State
+	block       *types.Block
+	partSet     *types.PartSet
+	part1       *types.Part
+	part2       *types.Part
+	seenCommit1 *types.Commit
+)
+
+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())
@@ -85,10 +120,8 @@ func TestBlockStoreSaveLoadBlock(t *testing.T) {
 	block := factory.MakeBlock(state, bs.Height()+1, new(types.Commit))
 	validPartSet, err := block.MakePartSet(2)
 	require.NoError(t, err)
-	part2 := validPartSet.GetPart(1)
-
-	seenCommit := makeTestExtCommit(block.Header.Height, tmtime.Now())
-	bs.SaveBlock(block, validPartSet, seenCommit)
+	seenCommit := makeTestCommit(10, tmtime.Now())
+	bs.SaveBlock(block, partSet, 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")
 
@@ -106,11 +139,11 @@ func TestBlockStoreSaveLoadBlock(t *testing.T) {
 	}
 
 	// End of setup, test data
-	commitAtH10 := makeTestExtCommit(10, tmtime.Now()).StripExtensions()
+	commitAtH10 := makeTestCommit(10, tmtime.Now())
 	tuples := []struct {
 		block      *types.Block
 		parts      *types.PartSet
-		seenCommit *types.ExtendedCommit
+		seenCommit *types.Commit
 		wantPanic  string
 		wantErr    bool
 
@@ -123,7 +156,7 @@ func TestBlockStoreSaveLoadBlock(t *testing.T) {
 		{
 			block:      newBlock(header1, commitAtH10),
 			parts:      validPartSet,
-			seenCommit: seenCommit,
+			seenCommit: seenCommit1,
 		},
 
 		{
@@ -139,10 +172,10 @@ func TestBlockStoreSaveLoadBlock(t *testing.T) {
 					ChainID:         "block_test",
 					Time:            tmtime.Now(),
 					ProposerAddress: tmrand.Bytes(crypto.AddressSize)},
-				makeTestExtCommit(5, tmtime.Now()).StripExtensions(),
+				makeTestCommit(5, tmtime.Now()),
 			),
 			parts:      validPartSet,
-			seenCommit: makeTestExtCommit(5, tmtime.Now()),
+			seenCommit: makeTestCommit(5, tmtime.Now()),
 		},
 
 		{
@@ -154,7 +187,7 @@ func TestBlockStoreSaveLoadBlock(t *testing.T) {
 		{
 			block:             newBlock(header1, commitAtH10),
 			parts:             validPartSet,
-			seenCommit:        seenCommit,
+			seenCommit:        seenCommit1,
 			corruptCommitInDB: true, // Corrupt the DB's commit entry
 			wantPanic:         "error reading block commit",
 		},
@@ -162,7 +195,7 @@ func TestBlockStoreSaveLoadBlock(t *testing.T) {
 		{
 			block:            newBlock(header1, commitAtH10),
 			parts:            validPartSet,
-			seenCommit:       seenCommit,
+			seenCommit:       seenCommit1,
 			wantPanic:        "unmarshal to tmproto.BlockMeta",
 			corruptBlockInDB: true, // Corrupt the DB's block entry
 		},
@@ -170,7 +203,7 @@ func TestBlockStoreSaveLoadBlock(t *testing.T) {
 		{
 			block:      newBlock(header1, commitAtH10),
 			parts:      validPartSet,
-			seenCommit: seenCommit,
+			seenCommit: seenCommit1,
 
 			// Expecting no error and we want a nil back
 			eraseSeenCommitInDB: true,
@@ -179,7 +212,7 @@ func TestBlockStoreSaveLoadBlock(t *testing.T) {
 		{
 			block:      newBlock(header1, commitAtH10),
 			parts:      validPartSet,
-			seenCommit: seenCommit,
+			seenCommit: seenCommit1,
 
 			corruptSeenCommitInDB: true,
 			wantPanic:             "error reading block seen commit",
@@ -188,7 +221,7 @@ func TestBlockStoreSaveLoadBlock(t *testing.T) {
 		{
 			block:      newBlock(header1, commitAtH10),
 			parts:      validPartSet,
-			seenCommit: seenCommit,
+			seenCommit: seenCommit1,
 
 			// Expecting no error and we want a nil back
 			eraseCommitInDB: true,
@@ -205,7 +238,7 @@ func TestBlockStoreSaveLoadBlock(t *testing.T) {
 
 	for i, tuple := range tuples {
 		tuple := tuple
-		bs, db := newInMemoryBlockStore()
+		bs, db := freshBlockStore()
 		// SaveBlock
 		res, err, panicErr := doFn(func() (interface{}, error) {
 			bs.SaveBlock(tuple.block, tuple.parts, tuple.seenCommit)
@@ -291,7 +324,7 @@ func TestLoadBaseMeta(t *testing.T) {
 		block := factory.MakeBlock(state, h, new(types.Commit))
 		partSet, err := block.MakePartSet(2)
 		require.NoError(t, err)
-		seenCommit := makeTestExtCommit(h, tmtime.Now())
+		seenCommit := makeTestCommit(h, tmtime.Now())
 		bs.SaveBlock(block, partSet, seenCommit)
 	}
 
@@ -305,19 +338,13 @@ func TestLoadBaseMeta(t *testing.T) {
 }
 
 func TestLoadBlockPart(t *testing.T) {
-	cfg, err := config.ResetTestRoot(t.TempDir(), "blockchain_reactor_test")
-	require.NoError(t, err)
-
-	bs, db := newInMemoryBlockStore()
+	bs, db := freshBlockStore()
 	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)
@@ -325,18 +352,13 @@ 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))
@@ -369,7 +391,7 @@ func TestPruneBlocks(t *testing.T) {
 		block := factory.MakeBlock(state, h, new(types.Commit))
 		partSet, err := block.MakePartSet(2)
 		require.NoError(t, err)
-		seenCommit := makeTestExtCommit(h, tmtime.Now())
+		seenCommit := makeTestCommit(h, tmtime.Now())
 		bs.SaveBlock(block, partSet, seenCommit)
 	}
 
@@ -430,7 +452,7 @@ func TestPruneBlocks(t *testing.T) {
 }
 
 func TestLoadBlockMeta(t *testing.T) {
-	bs, db := newInMemoryBlockStore()
+	bs, db := freshBlockStore()
 	height := int64(10)
 	loadMeta := func() (interface{}, error) {
 		meta := bs.LoadBlockMeta(height)
@@ -477,7 +499,7 @@ func TestBlockFetchAtHeight(t *testing.T) {
 
 	partSet, err := block.MakePartSet(2)
 	require.NoError(t, err)
-	seenCommit := makeTestExtCommit(block.Header.Height, tmtime.Now())
+	seenCommit := makeTestCommit(10, tmtime.Now())
 	bs.SaveBlock(block, partSet, seenCommit)
 	require.Equal(t, bs.Height(), block.Header.Height, "expecting the new height to be changed")
 
@@ -499,12 +521,9 @@ func TestBlockFetchAtHeight(t *testing.T) {
 }
 
 func TestSeenAndCanonicalCommit(t *testing.T) {
-	state, store, cleanup, err := makeStateAndBlockStore(t.TempDir())
-	defer cleanup()
-	require.NoError(t, err)
-
+	bs, _ := freshBlockStore()
 	loadCommit := func() (interface{}, error) {
-		meta := store.LoadSeenCommit()
+		meta := bs.LoadSeenCommit()
 		return meta, nil
 	}
 
@@ -517,19 +536,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 := makeTestExtCommit(h-1, tmtime.Now()).StripExtensions()
+		blockCommit := makeTestCommit(h-1, tmtime.Now())
 		block := factory.MakeBlock(state, h, blockCommit)
 		partSet, err := block.MakePartSet(2)
 		require.NoError(t, err)
-		seenCommit := makeTestExtCommit(h, tmtime.Now())
-		store.SaveBlock(block, partSet, seenCommit)
-		c3 := store.LoadSeenCommit()
+		seenCommit := makeTestCommit(h, tmtime.Now())
+		bs.SaveBlock(block, partSet, seenCommit)
+		c3 := bs.LoadSeenCommit()
 		require.NotNil(t, c3)
 		require.Equal(t, h, c3.Height)
-		require.Equal(t, seenCommit.StripExtensions().Hash(), c3.Hash())
-		c5 := store.LoadBlockCommit(h)
+		require.Equal(t, seenCommit.Hash(), c3.Hash())
+		c5 := bs.LoadBlockCommit(h)
 		require.Nil(t, c5)
-		c6 := store.LoadBlockCommit(h - 1)
+		c6 := bs.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 MakeExtendedCommit(ctx context.Context, blockID types.BlockID, height int64, round int32, voteSet *types.VoteSet, validators []types.PrivValidator, now time.Time) (*types.ExtendedCommit, error) {
+func MakeCommit(ctx context.Context, blockID types.BlockID, height int64, round int32, voteSet *types.VoteSet, validators []types.PrivValidator, now time.Time) (*types.Commit, error) {
 	// all sign
 	for i := 0; i < len(validators); i++ {
 		pubKey, err := validators[i].GetPubKey(ctx)
@@ -37,5 +37,5 @@ func MakeExtendedCommit(ctx context.Context, blockID types.BlockID, height int64
 		}
 	}
 
-	return voteSet.MakeExtendedCommit(), nil
+	return voteSet.MakeCommit(), nil
 }

node/node_test.go

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

proto/tendermint/abci/types.proto

@@ -424,10 +424,6 @@ 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,8 +116,7 @@ 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"`
-	ExtCommit *types.ExtendedCommit `protobuf:"bytes,2,opt,name=ext_commit,json=extCommit,proto3" json:"ext_commit,omitempty"`
+	Block *types.Block `protobuf:"bytes,1,opt,name=block,proto3" json:"block,omitempty"`
 }
 
 func (m *BlockResponse) Reset()         { *m = BlockResponse{} }
@@ -160,13 +159,6 @@ 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 {
 }
@@ -393,33 +385,30 @@ func init() {
 func init() { proto.RegisterFile("tendermint/blocksync/types.proto", fileDescriptor_19b397c236e0fa07) }
 
 var fileDescriptor_19b397c236e0fa07 = []byte{
-	// 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,
+	// 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,
 }
 
 func (m *BlockRequest) Marshal() (dAtA []byte, err error) {
@@ -498,18 +487,6 @@ 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])
@@ -763,10 +740,6 @@ 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
 }
 
@@ -1076,42 +1049,6 @@ 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,7 +4,6 @@ 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 {
@@ -20,7 +19,6 @@ 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,158 +726,6 @@ 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"`
@@ -892,7 +740,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{10}
+	return fileDescriptor_d3a6e55e2345de56, []int{8}
 }
 func (m *Proposal) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -979,7 +827,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{11}
+	return fileDescriptor_d3a6e55e2345de56, []int{9}
 }
 func (m *SignedHeader) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1031,7 +879,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{12}
+	return fileDescriptor_d3a6e55e2345de56, []int{10}
 }
 func (m *LightBlock) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1085,7 +933,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{13}
+	return fileDescriptor_d3a6e55e2345de56, []int{11}
 }
 func (m *BlockMeta) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1154,7 +1002,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{14}
+	return fileDescriptor_d3a6e55e2345de56, []int{12}
 }
 func (m *TxProof) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1215,8 +1063,6 @@ 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")
@@ -1227,95 +1073,91 @@ func init() {
 func init() { proto.RegisterFile("tendermint/types/types.proto", fileDescriptor_d3a6e55e2345de56) }
 
 var fileDescriptor_d3a6e55e2345de56 = []byte{
-	// 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,
+	// 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,
 }
 
 func (m *PartSetHeader) Marshal() (dAtA []byte, err error) {
@@ -1792,127 +1634,6 @@ 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)
@@ -1940,12 +1661,12 @@ func (m *Proposal) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i--
 		dAtA[i] = 0x3a
 	}
-	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
+	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
 	}
-	i -= n12
-	i = encodeVarintTypes(dAtA, i, uint64(n12))
+	i -= n10
+	i = encodeVarintTypes(dAtA, i, uint64(n10))
 	i--
 	dAtA[i] = 0x32
 	{
@@ -2396,59 +2117,6 @@ 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
@@ -4155,399 +3823,6 @@ 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,24 +142,6 @@ 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;

scripts/keymigrate/migrate.go

@@ -86,27 +86,30 @@ const (
 var prefixes = []struct {
 	prefix []byte
 	ktype  keyType
+	check  func(keyID) bool
 }{
-	{[]byte("consensusParamsKey:"), consensusParamsKey},
-	{[]byte("abciResponsesKey:"), abciResponsesKey},
-	{[]byte("validatorsKey:"), validatorsKey},
-	{[]byte("stateKey"), stateStoreKey},
-	{[]byte("H:"), blockMetaKey},
-	{[]byte("P:"), blockPartKey},
-	{[]byte("C:"), commitKey},
-	{[]byte("SC:"), seenCommitKey},
-	{[]byte("BH:"), blockHashKey},
-	{[]byte("size"), lightSizeKey},
-	{[]byte("lb/"), lightBlockKey},
-	{[]byte("\x00"), evidenceCommittedKey},
-	{[]byte("\x01"), evidencePendingKey},
+	{[]byte("consensusParamsKey:"), consensusParamsKey, nil},
+	{[]byte("abciResponsesKey:"), abciResponsesKey, nil},
+	{[]byte("validatorsKey:"), validatorsKey, nil},
+	{[]byte("stateKey"), stateStoreKey, nil},
+	{[]byte("H:"), blockMetaKey, nil},
+	{[]byte("P:"), blockPartKey, nil},
+	{[]byte("C:"), commitKey, nil},
+	{[]byte("SC:"), seenCommitKey, nil},
+	{[]byte("BH:"), blockHashKey, nil},
+	{[]byte("size"), lightSizeKey, nil},
+	{[]byte("lb/"), lightBlockKey, nil},
+	{[]byte("\x00"), evidenceCommittedKey, checkEvidenceKey},
+	{[]byte("\x01"), evidencePendingKey, checkEvidenceKey},
 }
 
 // checkKeyType classifies a candidate key based on its structure.
 func checkKeyType(key keyID) keyType {
 	for _, p := range prefixes {
 		if bytes.HasPrefix(key, p.prefix) {
-			return p.ktype
+			if p.check == nil || p.check(key) {
+				return p.ktype
+			}
 		}
 	}
 
@@ -342,6 +345,35 @@ func convertEvidence(key keyID, newPrefix int64) ([]byte, error) {
 	return orderedcode.Append(nil, newPrefix, binary.BigEndian.Uint64(hb), string(evidenceHash))
 }
 
+// checkEvidenceKey reports whether a candidate key with one of the legacy
+// evidence prefixes has the correct structure for a legacy evidence key.
+//
+// This check is needed because transaction hashes are stored without a prefix,
+// so checking the one-byte prefix alone is not enough to distinguish them.
+// Legacy evidence keys are suffixed with a string of the format:
+//
+//     "%0.16X/%X"
+//
+// where the first element is the height and the second is the hash.  Thus, we
+// check
+func checkEvidenceKey(key keyID) bool {
+	parts := bytes.SplitN(key[1:], []byte("/"), 2)
+	if len(parts) != 2 || len(parts[0]) != 16 || !isHex(parts[0]) || !isHex(parts[1]) {
+		return false
+	}
+	return true
+}
+
+func isHex(data []byte) bool {
+	for _, b := range data {
+		if ('0' <= b && b <= '9') || ('a' <= b && b <= 'f') || ('A' <= b && b <= 'F') {
+			continue
+		}
+		return false
+	}
+	return len(data) != 0
+}
+
 func replaceKey(db dbm.DB, key keyID, gooseFn migrateFunc) error {
 	exists, err := db.Has(key)
 	if err != nil {

scripts/keymigrate/migrate_test.go

@@ -1,11 +1,11 @@
 package keymigrate
 
 import (
-	"bytes"
 	"context"
 	"errors"
 	"fmt"
 	"math"
+	"strings"
 	"testing"
 
 	"github.com/google/orderedcode"
@@ -21,6 +21,7 @@ func makeKey(t *testing.T, elems ...interface{}) []byte {
 }
 
 func getLegacyPrefixKeys(val int) map[string][]byte {
+	vstr := fmt.Sprintf("%02x", byte(val))
 	return map[string][]byte{
 		"Height":            []byte(fmt.Sprintf("H:%d", val)),
 		"BlockPart":         []byte(fmt.Sprintf("P:%d:%d", val, val)),
@@ -40,14 +41,19 @@ func getLegacyPrefixKeys(val int) map[string][]byte {
 		"UserKey1":          []byte(fmt.Sprintf("foo/bar/baz/%d/%d", val, val)),
 		"TxHeight":          []byte(fmt.Sprintf("tx.height/%s/%d/%d", fmt.Sprint(val), val, val)),
 		"TxHash": append(
-			bytes.Repeat([]byte{fmt.Sprint(val)[0]}, 16),
-			bytes.Repeat([]byte{fmt.Sprint(val)[len([]byte(fmt.Sprint(val)))-1]}, 16)...,
+			[]byte(strings.Repeat(vstr[:1], 16)),
+			[]byte(strings.Repeat(vstr[1:], 16))...,
 		),
+
+		// Transaction hashes that could be mistaken for evidence keys.
+		"TxHashMimic0": append([]byte{0}, []byte(strings.Repeat(vstr, 16)[:31])...),
+		"TxHashMimic1": append([]byte{1}, []byte(strings.Repeat(vstr, 16)[:31])...),
 	}
 }
 
 func getNewPrefixKeys(t *testing.T, val int) map[string][]byte {
 	t.Helper()
+	vstr := fmt.Sprintf("%02x", byte(val))
 	return map[string][]byte{
 		"Height":            makeKey(t, int64(0), int64(val)),
 		"BlockPart":         makeKey(t, int64(1), int64(val), int64(val)),
@@ -66,7 +72,9 @@ func getNewPrefixKeys(t *testing.T, val int) map[string][]byte {
 		"UserKey0":          makeKey(t, "foo", "bar", int64(val), int64(val)),
 		"UserKey1":          makeKey(t, "foo", "bar/baz", int64(val), int64(val)),
 		"TxHeight":          makeKey(t, "tx.height", fmt.Sprint(val), int64(val), int64(val+2), int64(val+val)),
-		"TxHash":            makeKey(t, "tx.hash", string(bytes.Repeat([]byte{[]byte(fmt.Sprint(val))[0]}, 32))),
+		"TxHash":            makeKey(t, "tx.hash", strings.Repeat(vstr, 16)),
+		"TxHashMimic0":      makeKey(t, "tx.hash", "\x00"+strings.Repeat(vstr, 16)[:31]),
+		"TxHashMimic1":      makeKey(t, "tx.hash", "\x01"+strings.Repeat(vstr, 16)[:31]),
 	}
 }
 

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.MakeExtendedCommit(ctx, blockID, forgedHeight, 0, voteSet, pv, forgedTime)
+	commit, err := factory.MakeCommit(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.StripExtensions(),
+				Commit: commit,
 			},
 			ValidatorSet: conflictingVals,
 		},

types/block.go

@@ -730,6 +730,7 @@ 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
@@ -740,160 +741,6 @@ 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 {
@@ -909,8 +756,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.
@@ -923,23 +770,28 @@ func NewCommit(height int64, round int32, blockID BlockID, commitSigs []CommitSi
 	}
 }
 
-// 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)
-// }
+// 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
+}
 
-// 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.
+// GetVote converts the CommitSig for the given valIdx to a Vote.
 // Returns nil if the precommit at valIdx is nil.
 // Panics if valIdx >= commit.Size().
 func (commit *Commit) GetVote(valIdx int32) *Vote {
@@ -972,21 +824,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.
@@ -999,30 +851,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.
@@ -1147,241 +999,7 @@ 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)
-	extCommit, err := makeExtCommit(ctx, lastID, h-1, 1, voteSet, vals, time.Now())
+	commit, err := makeCommit(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, extCommit.StripExtensions(), evList)
+	block := MakeBlock(h, txs, commit, 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)
-	extCommit, err := makeExtCommit(ctx, lastID, h-1, 1, voteSet, vals, time.Now())
+	commit, err := makeCommit(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,14 +153,15 @@ func TestBlockMakePartSetWithEvidence(t *testing.T) {
 	h := int64(3)
 
 	voteSet, _, vals := randVoteSet(ctx, t, h-1, 1, tmproto.PrecommitType, 10, 1)
-	extCommit, err := makeExtCommit(ctx, lastID, h-1, 1, voteSet, vals, time.Now())
+	commit, err := makeCommit(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")}, extCommit.StripExtensions(), evList).MakePartSet(512)
+	partSet, err := MakeBlock(h, []Tx{Tx("Hello World")}, commit, evList).MakePartSet(512)
 	require.NoError(t, err)
 
 	assert.NotNil(t, partSet)
@@ -177,14 +178,14 @@ func TestBlockHashesTo(t *testing.T) {
 	h := int64(3)
 
 	voteSet, valSet, vals := randVoteSet(ctx, t, h-1, 1, tmproto.PrecommitType, 10, 1)
-	extCommit, err := makeExtCommit(ctx, lastID, h-1, 1, voteSet, vals, time.Now())
+	commit, err := makeCommit(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")}, extCommit.StripExtensions(), evList)
+	block := MakeBlock(h, []Tx{Tx("Hello World")}, commit, evList)
 	block.ValidatorsHash = valSet.Hash()
 	assert.False(t, block.HashesTo([]byte{}))
 	assert.False(t, block.HashesTo([]byte("something else")))
@@ -259,7 +260,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 := makeExtCommit(ctx, lastID, h-1, 1, voteSet, vals, time.Now())
+	commit, err := makeCommit(ctx, lastID, h-1, 1, voteSet, vals, time.Now())
 	require.NoError(t, err)
 
 	assert.Equal(t, h-1, commit.Height)
@@ -272,7 +273,7 @@ func TestCommit(t *testing.T) {
 	require.NotNil(t, commit.BitArray())
 	assert.Equal(t, bits.NewBitArray(10).Size(), commit.BitArray().Size())
 
-	assert.Equal(t, voteSet.GetByIndex(0), commit.GetByIndex(0))
+	assert.Equal(t, voteWithoutExtension(voteSet.GetByIndex(0)), commit.GetByIndex(0))
 	assert.True(t, commit.IsCommit())
 }
 
@@ -476,11 +477,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 := makeExtCommit(ctx, lastID, h-1, 1, voteSet, vals, now)
+	commit, err := makeCommit(ctx, lastID, h-1, 1, voteSet, vals, now)
 
 	require.NoError(t, err)
 
-	return commit.StripExtensions()
+	return commit
 }
 
 func hexBytesFromString(t *testing.T, s string) bytes.HexBytes {
@@ -553,7 +554,7 @@ func TestBlockMaxDataBytesNoEvidence(t *testing.T) {
 	}
 }
 
-func TestExtendedCommitToVoteSet(t *testing.T) {
+func TestCommitToVoteSet(t *testing.T) {
 	lastID := makeBlockIDRandom()
 	h := int64(3)
 
@@ -561,16 +562,17 @@ func TestExtendedCommitToVoteSet(t *testing.T) {
 	defer cancel()
 
 	voteSet, valSet, vals := randVoteSet(ctx, t, h-1, 1, tmproto.PrecommitType, 10, 1)
-	extCommit, err := makeExtCommit(ctx, lastID, h-1, 1, voteSet, vals, time.Now())
+	commit, err := makeCommit(ctx, lastID, h-1, 1, voteSet, vals, time.Now())
+
 	assert.NoError(t, err)
 
 	chainID := voteSet.ChainID()
-	voteSet2 := extCommit.ToVoteSet(chainID, valSet)
+	voteSet2 := CommitToVoteSet(chainID, commit, valSet)
 
 	for i := int32(0); int(i) < len(vals); i++ {
-		vote1 := voteSet.GetByIndex(i)
+		vote1 := voteWithoutExtension(voteSet.GetByIndex(i))
 		vote2 := voteSet2.GetByIndex(i)
-		vote3 := extCommit.GetExtendedVote(i)
+		vote3 := commit.GetVote(i)
 
 		vote1bz, err := vote1.ToProto().Marshal()
 		require.NoError(t, err)
@@ -632,12 +634,12 @@ func TestCommitToVoteSetWithVotesForNilBlock(t *testing.T) {
 		}
 
 		if tc.valid {
-			extCommit := voteSet.MakeExtendedCommit() // panics without > 2/3 valid votes
-			assert.NotNil(t, extCommit)
-			err := valSet.VerifyCommit(voteSet.ChainID(), blockID, height-1, extCommit.StripExtensions())
+			commit := voteSet.MakeCommit() // panics without > 2/3 valid votes
+			assert.NotNil(t, commit)
+			err := valSet.VerifyCommit(voteSet.ChainID(), blockID, height-1, commit)
 			assert.NoError(t, err)
 		} else {
-			assert.Panics(t, func() { voteSet.MakeExtendedCommit() })
+			assert.Panics(t, func() { voteSet.MakeCommit() })
 		}
 	}
 }

types/evidence_test.go

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

types/test_util.go

@@ -8,8 +8,8 @@ import (
 	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
 )
 
-func makeExtCommit(ctx context.Context, blockID BlockID, height int64, round int32,
-	voteSet *VoteSet, validators []PrivValidator, now time.Time) (*ExtendedCommit, error) {
+func makeCommit(ctx context.Context, blockID BlockID, height int64, round int32,
+	voteSet *VoteSet, validators []PrivValidator, now time.Time) (*Commit, error) {
 
 	// all sign
 	for i := 0; i < len(validators); i++ {
@@ -33,7 +33,7 @@ func makeExtCommit(ctx context.Context, blockID BlockID, height int64, round int
 		}
 	}
 
-	return voteSet.MakeExtendedCommit(), nil
+	return voteSet.MakeCommit(), nil
 }
 
 func signAddVote(ctx context.Context, privVal PrivValidator, vote *Vote, voteSet *VoteSet) (signed bool, err error) {
@@ -46,3 +46,13 @@ 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,10 +146,9 @@ func TestValidatorSet_VerifyCommit_CheckAllSignatures(t *testing.T) {
 	defer cancel()
 
 	voteSet, valSet, vals := randVoteSet(ctx, t, h, 0, tmproto.PrecommitType, 4, 10)
-	extCommit, err := makeExtCommit(ctx, blockID, h, 0, voteSet, vals, time.Now())
-	require.NoError(t, err)
-	commit := extCommit.StripExtensions()
+	commit, err := makeCommit(ctx, blockID, h, 0, voteSet, vals, time.Now())
 
+	require.NoError(t, err)
 	require.NoError(t, valSet.VerifyCommit(chainID, blockID, h, commit))
 
 	// malleate 4th signature
@@ -177,10 +176,9 @@ func TestValidatorSet_VerifyCommitLight_ReturnsAsSoonAsMajorityOfVotingPowerSign
 	defer cancel()
 
 	voteSet, valSet, vals := randVoteSet(ctx, t, h, 0, tmproto.PrecommitType, 4, 10)
-	extCommit, err := makeExtCommit(ctx, blockID, h, 0, voteSet, vals, time.Now())
-	require.NoError(t, err)
-	commit := extCommit.StripExtensions()
+	commit, err := makeCommit(ctx, blockID, h, 0, voteSet, vals, time.Now())
 
+	require.NoError(t, err)
 	require.NoError(t, valSet.VerifyCommit(chainID, blockID, h, commit))
 
 	// malleate 4th signature (3 signatures are enough for 2/3+)
@@ -205,10 +203,9 @@ func TestValidatorSet_VerifyCommitLightTrusting_ReturnsAsSoonAsTrustLevelOfVotin
 	defer cancel()
 
 	voteSet, valSet, vals := randVoteSet(ctx, t, h, 0, tmproto.PrecommitType, 4, 10)
-	extCommit, err := makeExtCommit(ctx, blockID, h, 0, voteSet, vals, time.Now())
-	require.NoError(t, err)
-	commit := extCommit.StripExtensions()
+	commit, err := makeCommit(ctx, blockID, h, 0, voteSet, vals, time.Now())
 
+	require.NoError(t, err)
 	require.NoError(t, valSet.VerifyCommit(chainID, blockID, h, commit))
 
 	// malleate 3rd signature (2 signatures are enough for 1/3+ trust level)
@@ -230,11 +227,10 @@ func TestValidatorSet_VerifyCommitLightTrusting(t *testing.T) {
 	var (
 		blockID                       = makeBlockIDRandom()
 		voteSet, originalValset, vals = randVoteSet(ctx, t, 1, 1, tmproto.PrecommitType, 6, 1)
-		extCommit, err                = makeExtCommit(ctx, blockID, 1, 1, voteSet, vals, time.Now())
+		commit, err                   = makeCommit(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
@@ -275,11 +271,11 @@ func TestValidatorSet_VerifyCommitLightTrustingErrorsOnOverflow(t *testing.T) {
 	var (
 		blockID               = makeBlockIDRandom()
 		voteSet, valSet, vals = randVoteSet(ctx, t, 1, 1, tmproto.PrecommitType, 1, MaxTotalVotingPower)
-		extCommit, err        = makeExtCommit(ctx, blockID, 1, 1, voteSet, vals, time.Now())
+		commit, err           = makeCommit(ctx, blockID, 1, 1, voteSet, vals, time.Now())
 	)
 	require.NoError(t, err)
 
-	err = valSet.VerifyCommitLightTrusting("test_chain_id", extCommit.StripExtensions(),
+	err = valSet.VerifyCommitLightTrusting("test_chain_id", commit,
 		tmmath.Fraction{Numerator: 25, Denominator: 55})
 	if assert.Error(t, err) {
 		assert.Contains(t, err.Error(), "int64 overflow")

types/validator_set_test.go

@@ -1539,9 +1539,8 @@ 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
-			extCommit, err := makeExtCommit(ctx, blockID, h, 0, voteSet, vals, time.Now())
+			commit, err := makeCommit(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)
@@ -1568,9 +1567,8 @@ 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
-			extCommit, err := makeExtCommit(ctx, blockID, h, 0, voteSet, vals, time.Now())
+			commit, err := makeCommit(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)
@@ -1596,9 +1594,8 @@ 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
-			extCommit, err := makeExtCommit(ctx, blockID, h, 0, voteSet, vals, time.Now())
+			commit, err := makeCommit(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,37 +109,6 @@ 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.
 //
@@ -250,7 +219,9 @@ 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)
-		if !pubKey.VerifySignature(extSignBytes, vote.ExtensionSignature) {
+		// 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) {
 			return ErrVoteInvalidSignature
 		}
 	}
@@ -325,7 +296,10 @@ func (vote *Vote) ValidateWithExtension() error {
 
 	// We should always see vote extension signatures in precommits
 	if vote.Type == tmproto.PrecommitType {
-		if len(vote.ExtensionSignature) == 0 {
+		// 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 {
 			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
 
-// MakeExtendedCommit constructs a Commit from the VoteSet. It only includes
-// precommits for the block, which has 2/3+ majority, and nil.
+// MakeCommit 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) MakeExtendedCommit() *ExtendedCommit {
+func (voteSet *VoteSet) MakeCommit() *Commit {
 	if voteSet.signedMsgType != tmproto.PrecommitType {
-		panic("Cannot MakeExtendCommit() unless VoteSet.Type is PrecommitType")
+		panic("Cannot MakeCommit() 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 MakeExtendCommit() unless a blockhash has +2/3")
+		panic("Cannot MakeCommit() unless a blockhash has +2/3")
 	}
 
-	// For every validator, get the precommit with extensions
-	extCommitSigs := make([]ExtendedCommitSig, len(voteSet.votes))
+	// For every validator, get the precommit
+	commitSigs := make([]CommitSig, len(voteSet.votes))
 	for i, v := range voteSet.votes {
-		extCommitSig := v.ExtendedCommitSig()
+		commitSig := v.CommitSig()
 		// if block ID exists but doesn't match, exclude sig
-		if extCommitSig.ForBlock() && !v.BlockID.Equals(*voteSet.maj23) {
-			extCommitSig = NewExtendedCommitSigAbsent()
+		if commitSig.ForBlock() && !v.BlockID.Equals(*voteSet.maj23) {
+			commitSig = NewCommitSigAbsent()
 		}
 
-		extCommitSigs[i] = extCommitSig
+		commitSigs[i] = commitSig
 	}
 
-	return NewExtendedCommit(voteSet.GetHeight(), voteSet.GetRound(), *voteSet.maj23, extCommitSigs)
+	return NewCommit(voteSet.GetHeight(), voteSet.GetRound(), *voteSet.maj23, commitSigs)
 }
 
 //--------------------------------------------------------------------------------

types/vote_set_test.go

@@ -450,7 +450,7 @@ func TestVoteSet_MakeCommit(t *testing.T) {
 	}
 
 	// MakeCommit should fail.
-	assert.Panics(t, func() { voteSet.MakeExtendedCommit() }, "Doesn't have +2/3 majority")
+	assert.Panics(t, func() { voteSet.MakeCommit() }, "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)
 	}
 
-	extCommit := voteSet.MakeExtendedCommit()
+	commit := voteSet.MakeCommit()
 
 	// Commit should have 10 elements
-	assert.Equal(t, 10, len(extCommit.ExtendedSignatures))
+	assert.Equal(t, 10, len(commit.Signatures))
 
 	// Ensure that Commit is good.
-	if err := extCommit.ValidateBasic(); err != nil {
+	if err := commit.ValidateBasic(); err != nil {
 		t.Errorf("error in Commit.ValidateBasic(): %v", err)
 	}
 }

types/vote_test.go

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