nolint lll

internal/consensus/common_test.go

@@ -512,6 +512,15 @@ func ensureNoNewRoundStep(t *testing.T, stepCh <-chan tmpubsub.Message) {
 		"We should be stuck waiting, not receiving NewRoundStep event")
 }
 
+func ensureNoNewUnlock(t *testing.T, unlockCh <-chan tmpubsub.Message) {
+	t.Helper()
+	ensureNoNewEvent(
+		t,
+		unlockCh,
+		ensureTimeout,
+		"We should be stuck waiting, not receiving Unlock event")
+}
+
 func ensureNoNewTimeout(t *testing.T, stepCh <-chan tmpubsub.Message, timeout int64) {
 	t.Helper()
 	timeoutDuration := time.Duration(timeout*10) * time.Nanosecond
@@ -522,7 +531,7 @@ func ensureNoNewTimeout(t *testing.T, stepCh <-chan tmpubsub.Message, timeout in
 		"We should be stuck waiting, not receiving NewTimeout event")
 }
 
-func ensureNewEvent(t *testing.T, ch <-chan tmpubsub.Message, height int64, round int32, timeout time.Duration, errorMessage string) { // nolint: lll
+func ensureNewEvent(t *testing.T, ch <-chan tmpubsub.Message, height int64, round int32, timeout time.Duration, errorMessage string) { //nolint: lll
 	t.Helper()
 	select {
 	case <-time.After(timeout):
@@ -631,16 +640,10 @@ func ensureNewBlockHeader(t *testing.T, blockCh <-chan tmpubsub.Message, height
 	}
 }
 
-func ensureLock(t *testing.T, lockCh <-chan tmpubsub.Message, height int64, round int32) {
+func ensureNewUnlock(t *testing.T, unlockCh <-chan tmpubsub.Message, height int64, round int32) {
 	t.Helper()
-	ensureNewEvent(t, lockCh, height, round, ensureTimeout,
-		"Timeout expired while waiting for LockValue event")
-}
-
-func ensureRelock(t *testing.T, relockCh <-chan tmpubsub.Message, height int64, round int32) {
-	t.Helper()
-	ensureNewEvent(t, relockCh, height, round, ensureTimeout,
-		"Timeout expired while waiting for RelockValue event")
+	ensureNewEvent(t, unlockCh, height, round, ensureTimeout,
+		"Timeout expired while waiting for NewUnlock event")
 }
 
 func ensureProposal(t *testing.T, proposalCh <-chan tmpubsub.Message, height int64, round int32, propID types.BlockID) {

internal/consensus/state.go

@@ -1361,6 +1361,7 @@ func (cs *State) enterPrevoteWait(height int64, round int32) {
 // Enter: `timeoutPrecommit` after any +2/3 precommits.
 // Enter: +2/3 precomits for block or nil.
 // Lock & precommit the ProposalBlock if we have enough prevotes for it (a POL in this round)
+// else, unlock an existing lock and precommit nil if +2/3 of prevotes were nil,
 // else, precommit nil otherwise.
 func (cs *State) enterPrecommit(height int64, round int32) {
 	logger := cs.Logger.With("height", height, "round", round)
@@ -1407,9 +1408,21 @@ func (cs *State) enterPrecommit(height int64, round int32) {
 		panic(fmt.Sprintf("this POLRound should be %v but got %v", round, polRound))
 	}
 
-	// +2/3 prevoted nil. Precommit nil.
-	if blockID.IsNil() {
-		logger.Debug("precommit step; +2/3 prevoted for nil")
+	// +2/3 prevoted nil. Unlock and precommit nil.
+	if len(blockID.Hash) == 0 {
+		if cs.LockedBlock == nil {
+			logger.Debug("precommit step; +2/3 prevoted for nil")
+		} else {
+			logger.Debug("precommit step; +2/3 prevoted for nil; unlocking")
+			cs.LockedRound = -1
+			cs.LockedBlock = nil
+			cs.LockedBlockParts = nil
+
+			if err := cs.eventBus.PublishEventUnlock(cs.RoundStateEvent()); err != nil {
+				logger.Error("failed publishing event unlock", "err", err)
+			}
+		}
+
 		cs.signAddVote(tmproto.PrecommitType, nil, types.PartSetHeader{})
 		return
 	}
@@ -1429,9 +1442,7 @@ func (cs *State) enterPrecommit(height int64, round int32) {
 		return
 	}
 
-	// If greater than 2/3 of the voting power on the network prevoted for
-	// the proposed block, update our locked block to this block and issue a
-	// precommit vote for it.
+	// If +2/3 prevoted for proposal block, stage and precommit it
 	if cs.ProposalBlock.HashesTo(blockID.Hash) {
 		logger.Debug("precommit step; +2/3 prevoted proposal block; locking", "hash", blockID.Hash)
 
@@ -1453,14 +1464,23 @@ func (cs *State) enterPrecommit(height int64, round int32) {
 	}
 
 	// There was a polka in this round for a block we don't have.
-	// Fetch that block, and precommit nil.
+	// Fetch that block, unlock, and precommit nil.
+	// The +2/3 prevotes for this round is the POL for our unlock.
 	logger.Debug("precommit step; +2/3 prevotes for a block we do not have; voting nil", "block_id", blockID)
 
+	cs.LockedRound = -1
+	cs.LockedBlock = nil
+	cs.LockedBlockParts = nil
+
 	if !cs.ProposalBlockParts.HasHeader(blockID.PartSetHeader) {
 		cs.ProposalBlock = nil
 		cs.ProposalBlockParts = types.NewPartSetFromHeader(blockID.PartSetHeader)
 	}
 
+	if err := cs.eventBus.PublishEventUnlock(cs.RoundStateEvent()); err != nil {
+		logger.Error("failed publishing event unlock", "err", err)
+	}
+
 	cs.signAddVote(tmproto.PrecommitType, nil, types.PartSetHeader{})
 }
 
@@ -1568,7 +1588,7 @@ func (cs *State) tryFinalizeCommit(height int64) {
 	}
 
 	blockID, ok := cs.Votes.Precommits(cs.CommitRound).TwoThirdsMajority()
-	if !ok || blockID.IsNil() {
+	if !ok || len(blockID.Hash) == 0 {
 		logger.Error("failed attempt to finalize commit; there was no +2/3 majority or +2/3 was for nil")
 		return
 	}
@@ -1901,7 +1921,7 @@ func (cs *State) addProposalBlockPart(msg *BlockPartMessage, peerID types.NodeID
 		// Update Valid* if we can.
 		prevotes := cs.Votes.Prevotes(cs.Round)
 		blockID, hasTwoThirds := prevotes.TwoThirdsMajority()
-		if hasTwoThirds && !blockID.IsNil() && (cs.ValidRound < cs.Round) {
+		if hasTwoThirds && !blockID.IsZero() && (cs.ValidRound < cs.Round) {
 			if cs.ProposalBlock.HashesTo(blockID.Hash) {
 				cs.Logger.Debug(
 					"updating valid block to new proposal block",
@@ -2050,13 +2070,33 @@ func (cs *State) addVote(vote *types.Vote, peerID types.NodeID) (added bool, err
 		prevotes := cs.Votes.Prevotes(vote.Round)
 		cs.Logger.Debug("added vote to prevote", "vote", vote, "prevotes", prevotes.StringShort())
 
-		// Check to see if >2/3 of the voting power on the network voted for any non-nil block.
-		if blockID, ok := prevotes.TwoThirdsMajority(); ok && !blockID.IsNil() {
-			// Greater than 2/3 of the voting power on the network voted for some
-			// non-nil block
+		// If +2/3 prevotes for a block or nil for *any* round:
+		if blockID, ok := prevotes.TwoThirdsMajority(); ok {
+			// There was a polka!
+			// If we're locked but this is a recent polka, unlock.
+			// If it matches our ProposalBlock, update the ValidBlock
+
+			// Unlock if `cs.LockedRound < vote.Round <= cs.Round`
+			// NOTE: If vote.Round > cs.Round, we'll deal with it when we get to vote.Round
+			if (cs.LockedBlock != nil) &&
+				(cs.LockedRound < vote.Round) &&
+				(vote.Round <= cs.Round) &&
+				!cs.LockedBlock.HashesTo(blockID.Hash) {
+
+				cs.Logger.Debug("unlocking because of POL", "locked_round", cs.LockedRound, "pol_round", vote.Round)
+
+				cs.LockedRound = -1
+				cs.LockedBlock = nil
+				cs.LockedBlockParts = nil
+
+				if err := cs.eventBus.PublishEventUnlock(cs.RoundStateEvent()); err != nil {
+					return added, err
+				}
+			}
 
 			// Update Valid* if we can.
-			if cs.ValidRound < vote.Round && vote.Round == cs.Round {
+			// NOTE: our proposal block may be nil or not what received a polka..
+			if len(blockID.Hash) != 0 && (cs.ValidRound < vote.Round) && (vote.Round == cs.Round) {
 				if cs.ProposalBlock.HashesTo(blockID.Hash) {
 					cs.Logger.Debug("updating valid block because of POL", "valid_round", cs.ValidRound, "pol_round", vote.Round)
 					cs.ValidRound = vote.Round
@@ -2092,7 +2132,7 @@ func (cs *State) addVote(vote *types.Vote, peerID types.NodeID) (added bool, err
 
 		case cs.Round == vote.Round && cstypes.RoundStepPrevote <= cs.Step: // current round
 			blockID, ok := prevotes.TwoThirdsMajority()
-			if ok && (cs.isProposalComplete() || blockID.IsNil()) {
+			if ok && (cs.isProposalComplete() || len(blockID.Hash) == 0) {
 				cs.enterPrecommit(height, vote.Round)
 			} else if prevotes.HasTwoThirdsAny() {
 				cs.enterPrevoteWait(height, vote.Round)
@@ -2120,7 +2160,7 @@ func (cs *State) addVote(vote *types.Vote, peerID types.NodeID) (added bool, err
 			cs.enterNewRound(height, vote.Round)
 			cs.enterPrecommit(height, vote.Round)
 
-			if !blockID.IsNil() {
+			if len(blockID.Hash) != 0 {
 				cs.enterCommit(height, vote.Round)
 				if cs.config.SkipTimeoutCommit && precommits.HasAll() {
 					cs.enterNewRound(cs.Height, 0)

internal/consensus/state_test.go

@@ -35,22 +35,16 @@ x * TestFullRound1 - 1 val, full successful round
 x * TestFullRoundNil - 1 val, full round of nil
 x * TestFullRound2 - 2 vals, both required for full round
 LockSuite
-x * TestStateLock_NoPOL - 2 vals, 4 rounds. one val locked, precommits nil every round except first.
-x * TestStateLock_POLUpdateLock - 4 vals, one precommits,
-other 3 polka at next round, so we unlock and precomit the polka
-x * TestStateLock_POLRelock - 4 vals, polka in round 1 and polka in round 2.
-Ensure validator updates locked round.
-x_*_TestStateLock_POLDoesNotUnlock 4 vals, one precommits, other 3 polka nil at
-next round, so we precommit nil but maintain lock
-x * TestStateLock_MissingProposalWhenPOLSeenDoesNotUpdateLock - 4 vals, 1 misses proposal but sees POL.
-x * TestStateLock_MissingProposalWhenPOLSeenDoesNotUnlock - 4 vals, 1 misses proposal but sees POL.
-x * TestStateLock_POLSafety1 - 4 vals. We shouldn't change lock based on polka at earlier round
-x * TestStateLock_POLSafety2 - 4 vals. After unlocking, we shouldn't relock based on polka at earlier round
+x * TestLockNoPOL - 2 vals, 4 rounds. one val locked, precommits nil every round except first.
+x * TestLockPOLRelock - 4 vals, one precommits, other 3 polka at next round, so we unlock and precomit the polka
+x * TestLockPOLUnlock - 4 vals, one precommits, other 3 polka nil at next round, so we unlock and precomit nil
+x * TestLockPOLSafety1 - 4 vals. We shouldn't change lock based on polka at earlier round
+x * TestLockPOLSafety2 - 4 vals. After unlocking, we shouldn't relock based on polka at earlier round
   * TestNetworkLock - once +1/3 precommits, network should be locked
   * TestNetworkLockPOL - once +1/3 precommits, the block with more recent polka is committed
 SlashingSuite
-x * TestStateSlashing_Prevotes - a validator prevoting twice in a round gets slashed
-x * TestStateSlashing_Precommits - a validator precomitting twice in a round gets slashed
+x * TestSlashingPrevotes - a validator prevoting twice in a round gets slashed
+x * TestSlashingPrecommits - a validator precomitting twice in a round gets slashed
 CatchupSuite
   * TestCatchup - if we might be behind and we've seen any 2/3 prevotes, round skip to new round, precommit, or prevote
 HaltSuite
@@ -133,7 +127,8 @@ func TestStateProposerSelection2(t *testing.T) {
 				prop.Address))
 		}
 
-		signAddVotes(config, cs1, tmproto.PrecommitType, nil, types.PartSetHeader{}, vss[1:]...)
+		rs := cs1.GetRoundState()
+		signAddVotes(config, cs1, tmproto.PrecommitType, nil, rs.ProposalBlockParts.Header(), vss[1:]...)
 		ensureNewRound(t, newRoundCh, height, i+round+1) // wait for the new round event each round
 		incrementRound(vss[1:]...)
 	}
@@ -422,7 +417,7 @@ func TestStateFullRound2(t *testing.T) {
 
 // two validators, 4 rounds.
 // two vals take turns proposing. val1 locks on first one, precommits nil on everything else
-func TestStateLock_NoPOL(t *testing.T) {
+func TestStateLockNoPOL(t *testing.T) {
 	config := configSetup(t)
 
 	cs1, vss := randState(config, 2)
@@ -608,12 +603,11 @@ func TestStateLock_NoPOL(t *testing.T) {
 	ensurePrecommit(t, voteCh, height, round)
 }
 
-// TestStateLock_POLUpdateLock tests that a validator maintains updates its locked
-// block if the following conditions are met within a round:
-// 1. The validator received a valid proposal for the block
-// 2. The validator received prevotes representing greater than 2/3 of the voting
-// power on the network for the block.
-func TestStateLock_POLUpdateLock(t *testing.T) {
+// 4 vals in two rounds,
+// in round one: v1 precommits, other 3 only prevote so the block isn't committed
+// in round two: v1 prevotes the same block that the node is locked on
+// the others prevote a new block hence v1 changes lock and precommits the new block with the others
+func TestStateLockPOLRelock(t *testing.T) {
 	config := configSetup(t)
 
 	cs1, vss := randState(config, 4)
@@ -628,19 +622,18 @@ func TestStateLock_POLUpdateLock(t *testing.T) {
 	require.NoError(t, err)
 	addr := pv1.Address()
 	voteCh := subscribeToVoter(cs1, addr)
-	lockCh := subscribe(cs1.eventBus, types.EventQueryLock)
 	newRoundCh := subscribe(cs1.eventBus, types.EventQueryNewRound)
+	newBlockCh := subscribe(cs1.eventBus, types.EventQueryNewBlockHeader)
+
+	// everything done from perspective of cs1
 
 	/*
-		Round 0:
-		cs1 creates a proposal for block B.
-		Send a prevote for B from each of the validators to cs1.
-		Send a precommit for nil from all of the validators to cs1.
+		Round1 (cs1, B) // B B B B// B nil B nil
 
-		This ensures that cs1 will lock on B in this round but not precommit it.
+		eg. vs2 and vs4 didn't see the 2/3 prevotes
 	*/
-	t.Log("### Starting Round 0")
 
+	// start round and wait for propose and prevote
 	startTestRound(cs1, height, round)
 
 	ensureNewRound(t, newRoundCh, height, round)
@@ -649,206 +642,94 @@ func TestStateLock_POLUpdateLock(t *testing.T) {
 	theBlockHash := rs.ProposalBlock.Hash()
 	theBlockParts := rs.ProposalBlockParts.Header()
 
-	ensurePrevote(t, voteCh, height, round)
+	ensurePrevote(t, voteCh, height, round) // prevote
 
 	signAddVotes(config, cs1, tmproto.PrevoteType, theBlockHash, theBlockParts, vs2, vs3, vs4)
 
-	// check that the validator generates a Lock event.
-	ensureLock(t, lockCh, height, round)
-
-	// the proposed block should now be locked and our precommit added.
-	ensurePrecommit(t, voteCh, height, round)
+	ensurePrecommit(t, voteCh, height, round) // our precommit
+	// the proposed block should now be locked and our precommit added
 	validatePrecommit(t, cs1, round, round, vss[0], theBlockHash, theBlockHash)
 
-	// add precommits from the rest of the validators.
+	// add precommits from the rest
 	signAddVotes(config, cs1, tmproto.PrecommitType, nil, types.PartSetHeader{}, vs2, vs3, vs4)
 
-	// timeout to new round.
-	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.config.Precommit(round).Nanoseconds())
-
-	/*
-		Round 1:
-		Create a block, D and send a proposal for it to cs1
-		Send a prevote for D from each of the validators to cs1.
-		Send a precommit for nil from all of the validtors to cs1.
-
-		Check that cs1 is now locked on the new block, D and no longer on the old block.
-	*/
-	t.Log("### Starting Round 1")
-	incrementRound(vs2, vs3, vs4)
-	round++
-
-	// Generate a new proposal block.
+	// before we timeout to the new round set the new proposal
 	cs2 := newState(cs1.state, vs2, kvstore.NewApplication())
-	propR1, propBlockR1 := decideProposal(t, cs2, vs2, vs2.Height, vs2.Round)
-	propBlockR1Parts := propBlockR1.MakePartSet(partSize)
-	propBlockR1Hash := propBlockR1.Hash()
-	require.NotEqual(t, propBlockR1Hash, theBlockHash)
-	if err := cs1.SetProposalAndBlock(propR1, propBlockR1, propBlockR1Parts, "some peer"); err != nil {
-		t.Fatal(err)
+	prop, propBlock := decideProposal(t, cs2, vs2, vs2.Height, vs2.Round+1)
+	if prop == nil || propBlock == nil {
+		t.Fatal("Failed to create proposal block with vs2")
 	}
+	propBlockParts := propBlock.MakePartSet(partSize)
+	propBlockHash := propBlock.Hash()
+	require.NotEqual(t, propBlockHash, theBlockHash)
 
-	ensureNewRound(t, newRoundCh, height, round)
+	incrementRound(vs2, vs3, vs4)
 
-	// ensure that the validator receives the proposal.
-	ensureNewProposal(t, proposalCh, height, round)
-
-	// Prevote our locked block.
-	// TODO: Ensure we prevote for the proposal if it is valid and from a round greater than
-	// the valid round: https://github.com/tendermint/tendermint/issues/6850.
-	ensurePrevote(t, voteCh, height, round)
-	validatePrevote(t, cs1, round, vss[0], theBlockHash)
-
-	// Add prevotes from the remainder of the validators for the new locked block.
-	signAddVotes(config, cs1, tmproto.PrevoteType, propBlockR1Hash, propBlockR1Parts.Header(), vs2, vs3, vs4)
-
-	// Check that we lock on a new block.
-	ensureLock(t, lockCh, height, round)
-
-	ensurePrecommit(t, voteCh, height, round)
-
-	// We should now be locked on the new block and prevote it since we saw a sufficient amount
-	// prevote for the block.
-	validatePrecommit(t, cs1, round, round, vss[0], propBlockR1Hash, propBlockR1Hash)
-}
-
-// TestStateLock_POLRelock tests that a validator updates its locked round if
-// it receives votes representing over 2/3 of the voting power on the network
-// for a block that it is already locked in.
-func TestStateLock_POLRelock(t *testing.T) {
-	config := configSetup(t)
-
-	cs1, vss := randState(config, 4)
-	vs2, vs3, vs4 := vss[1], vss[2], vss[3]
-	height, round := cs1.Height, cs1.Round
-
-	timeoutWaitCh := subscribe(cs1.eventBus, types.EventQueryTimeoutWait)
-	proposalCh := subscribe(cs1.eventBus, types.EventQueryCompleteProposal)
-	pv1, err := cs1.privValidator.GetPubKey(context.Background())
-	require.NoError(t, err)
-	addr := pv1.Address()
-	voteCh := subscribeToVoter(cs1, addr)
-	lockCh := subscribe(cs1.eventBus, types.EventQueryLock)
-	relockCh := subscribe(cs1.eventBus, types.EventQueryRelock)
-	newRoundCh := subscribe(cs1.eventBus, types.EventQueryNewRound)
-
-	/*
-		Round 0:
-		cs1 creates a proposal for block B.
-		Send a prevote for B from each of the validators to cs1.
-		Send a precommit for nil from all of the validators to cs1.
-
-		This ensures that cs1 will lock on B in this round but not precommit it.
-	*/
-	t.Log("### Starting Round 0")
-
-	startTestRound(cs1, height, round)
-
-	ensureNewRound(t, newRoundCh, height, round)
-	ensureNewProposal(t, proposalCh, height, round)
-	rs := cs1.GetRoundState()
-	theBlock := rs.ProposalBlock
-	theBlockHash := rs.ProposalBlock.Hash()
-	theBlockParts := rs.ProposalBlockParts
-
-	ensurePrevote(t, voteCh, height, round)
-
-	signAddVotes(config, cs1, tmproto.PrevoteType, theBlockHash, theBlockParts.Header(), vs2, vs3, vs4)
-
-	// check that the validator generates a Lock event.
-	ensureLock(t, lockCh, height, round)
-
-	// the proposed block should now be locked and our precommit added.
-	ensurePrecommit(t, voteCh, height, round)
-	validatePrecommit(t, cs1, round, round, vss[0], theBlockHash, theBlockHash)
-
-	// add precommits from the rest of the validators.
-	signAddVotes(config, cs1, tmproto.PrecommitType, nil, types.PartSetHeader{}, vs2, vs3, vs4)
-
-	// timeout to new round.
+	// timeout to new round
 	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.config.Precommit(round).Nanoseconds())
 
-	/*
-		Round 1:
-		Create a proposal for block B, the same block from round 1.
-		Send a prevote for B from each of the validators to cs1.
-		Send a precommit for nil from all of the validtors to cs1.
-
-		Check that cs1 updates its 'locked round' value to the current round.
-	*/
-	t.Log("### Starting Round 1")
-	incrementRound(vs2, vs3, vs4)
-	round++
-	propBlockID := types.BlockID{Hash: theBlockHash, PartSetHeader: theBlockParts.Header()}
-	propR1 := types.NewProposal(height, round, cs1.ValidRound, propBlockID)
-	p := propR1.ToProto()
-	if err := vs2.SignProposal(context.Background(), cs1.state.ChainID, p); err != nil {
-		t.Fatalf("error signing proposal: %s", err)
-	}
-	propR1.Signature = p.Signature
-	if err := cs1.SetProposalAndBlock(propR1, theBlock, theBlockParts, ""); err != nil {
+	round++ // moving to the next round
+	//XXX: this isnt guaranteed to get there before the timeoutPropose ...
+	if err := cs1.SetProposalAndBlock(prop, propBlock, propBlockParts, "some peer"); err != nil {
 		t.Fatal(err)
 	}
 
 	ensureNewRound(t, newRoundCh, height, round)
+	t.Log("### ONTO ROUND 1")
 
-	// ensure that the validator receives the proposal.
+	/*
+		Round2 (vs2, C) // B C C C // C C C _)
+
+		cs1 changes lock!
+	*/
+
+	// now we're on a new round and not the proposer
+	// but we should receive the proposal
 	ensureNewProposal(t, proposalCh, height, round)
 
-	// Prevote our locked block.
-	// TODO: Ensure we prevote for the proposal if it is valid and from a round greater than
-	// the valid round: https://github.com/tendermint/tendermint/issues/6850.
+	// go to prevote, node should prevote for locked block (not the new proposal) - this is relocking
 	ensurePrevote(t, voteCh, height, round)
 	validatePrevote(t, cs1, round, vss[0], theBlockHash)
 
-	// Add prevotes from the remainder of the validators for the locked block.
-	signAddVotes(config, cs1, tmproto.PrevoteType, theBlockHash, theBlockParts.Header(), vs2, vs3, vs4)
-
-	// Check that we relock.
-	ensureRelock(t, relockCh, height, round)
+	// now lets add prevotes from everyone else for the new block
+	signAddVotes(config, cs1, tmproto.PrevoteType, propBlockHash, propBlockParts.Header(), vs2, vs3, vs4)
 
 	ensurePrecommit(t, voteCh, height, round)
+	// we should have unlocked and locked on the new block, sending a precommit for this new block
+	validatePrecommit(t, cs1, round, round, vss[0], propBlockHash, propBlockHash)
 
-	// We should now be locked on the same block but with an updated locked round.
-	validatePrecommit(t, cs1, round, round, vss[0], theBlockHash, theBlockHash)
+	// more prevote creating a majority on the new block and this is then committed
+	signAddVotes(config, cs1, tmproto.PrecommitType, propBlockHash, propBlockParts.Header(), vs2, vs3)
+	ensureNewBlockHeader(t, newBlockCh, height, propBlockHash)
+
+	ensureNewRound(t, newRoundCh, height+1, 0)
 }
 
-// TestStateLock_POLDoesNotUnlock tests that a validator maintains its locked block
-// despite receiving +2/3 nil prevotes and nil precommits from other validators.
-// Tendermint used to 'unlock' its locked block when greater than 2/3 prevotes
-// for a nil block were seen. This behavior has been removed and this test ensures
-// that it has been completely removed.
-func TestStateLock_POLDoesNotUnlock(t *testing.T) {
+// 4 vals, one precommits, other 3 polka at next round, so we unlock and precomit the polka
+func TestStateLockPOLUnlock(t *testing.T) {
 	config := configSetup(t)
-	/*
-		All of the assertions in this test occur on the `cs1` validator.
-		The test sends signed votes from the other validators to cs1 and
-		cs1's state is then examined to verify that it now matches the expected
-		state.
-	*/
 
 	cs1, vss := randState(config, 4)
 	vs2, vs3, vs4 := vss[1], vss[2], vss[3]
 	height, round := cs1.Height, cs1.Round
 
+	partSize := types.BlockPartSizeBytes
+
 	proposalCh := subscribe(cs1.eventBus, types.EventQueryCompleteProposal)
 	timeoutWaitCh := subscribe(cs1.eventBus, types.EventQueryTimeoutWait)
 	newRoundCh := subscribe(cs1.eventBus, types.EventQueryNewRound)
-	lockCh := subscribe(cs1.eventBus, types.EventQueryLock)
+	unlockCh := subscribe(cs1.eventBus, types.EventQueryUnlock)
 	pv1, err := cs1.privValidator.GetPubKey(context.Background())
 	require.NoError(t, err)
 	addr := pv1.Address()
 	voteCh := subscribeToVoter(cs1, addr)
 
-	/*
-		Round 0:
-		Create a block, B
-		Send a prevote for B from each of the validators to `cs1`.
-		Send a precommit for B from one of the validtors to `cs1`.
+	// everything done from perspective of cs1
 
-		This ensures that cs1 will lock on B in this round.
+	/*
+		Round1 (cs1, B) // B B B B // B nil B nil
+		eg. didn't see the 2/3 prevotes
 	*/
-	t.Log("#### ONTO ROUND 0")
 
 	// start round and wait for propose and prevote
 	startTestRound(cs1, height, round)
@@ -864,96 +745,62 @@ func TestStateLock_POLDoesNotUnlock(t *testing.T) {
 
 	signAddVotes(config, cs1, tmproto.PrevoteType, theBlockHash, theBlockParts, vs2, vs3, vs4)
 
-	// the validator should have locked a block in this round.
-	ensureLock(t, lockCh, height, round)
-
 	ensurePrecommit(t, voteCh, height, round)
-	// the proposed block should now be locked and our should be for this locked block.
-
+	// the proposed block should now be locked and our precommit added
 	validatePrecommit(t, cs1, round, round, vss[0], theBlockHash, theBlockHash)
 
-	// Add precommits from the other validators.
-	// We only issue 1/2 Precommits for the block in this round.
-	// This ensures that the validator being tested does not commit the block.
-	// We do not want the validator to commit the block because we want the test
-	// test to proceeds to the next consensus round.
+	// add precommits from the rest
 	signAddVotes(config, cs1, tmproto.PrecommitType, nil, types.PartSetHeader{}, vs2, vs4)
 	signAddVotes(config, cs1, tmproto.PrecommitType, theBlockHash, theBlockParts, vs3)
 
+	// before we time out into new round, set next proposal block
+	prop, propBlock := decideProposal(t, cs1, vs2, vs2.Height, vs2.Round+1)
+	propBlockParts := propBlock.MakePartSet(partSize)
+
 	// timeout to new round
 	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.config.Precommit(round).Nanoseconds())
+	rs = cs1.GetRoundState()
+	lockedBlockHash := rs.LockedBlock.Hash()
 
-	/*
-		Round 1:
-		Send a prevote for nil from >2/3 of the validators to `cs1`.
-		Check that cs1 maintains its lock on B but precommits nil.
-		Send a precommit for nil from >2/3 of the validators to `cs1`.
-	*/
+	incrementRound(vs2, vs3, vs4)
+	round++ // moving to the next round
+
+	ensureNewRound(t, newRoundCh, height, round)
 	t.Log("#### ONTO ROUND 1")
-	round++
-	incrementRound(vs2, vs3, vs4)
-	prop, propBlock := decideProposal(t, cs1, vs2, vs2.Height, vs2.Round)
-	propBlockParts := propBlock.MakePartSet(types.BlockPartSizeBytes)
-	if err := cs1.SetProposalAndBlock(prop, propBlock, propBlockParts, ""); err != nil {
-		t.Fatal(err)
-	}
-
-	ensureNewRound(t, newRoundCh, height, round)
-
-	ensureNewProposal(t, proposalCh, height, round)
-
-	// prevote for the locked block. We do not currently prevote for the
-	// proposal.
-	// TODO: do not prevote the locked block if it does not match the proposal.
-	// (https://github.com/tendermint/tendermint/issues/6850)
-	ensurePrevote(t, voteCh, height, round)
-	validatePrevote(t, cs1, round, vss[0], theBlockHash)
-	// add >2/3 prevotes for nil from all other validators
-	signAddVotes(config, cs1, tmproto.PrevoteType, nil, types.PartSetHeader{}, vs2, vs3, vs4)
-
-	ensurePrecommit(t, voteCh, height, round)
-
-	// verify that we haven't update our locked block since the first round
-	validatePrecommit(t, cs1, round, 0, vss[0], nil, theBlockHash)
-
-	signAddVotes(config, cs1, tmproto.PrecommitType, nil, types.PartSetHeader{}, vs2, vs3, vs4)
-	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.config.Precommit(round).Nanoseconds())
-
 	/*
-		Round 2:
-		The validator cs1 saw >2/3 precommits for nil in the previous round.
-		Send the validator >2/3 prevotes for nil and ensure that it did not
-		unlock its block at the end of the previous round.
+		Round2 (vs2, C) // B nil nil nil // nil nil nil _
+		cs1 unlocks!
 	*/
-	t.Log("#### ONTO ROUND 2")
-	round++
-	incrementRound(vs2, vs3, vs4)
-	prop, propBlock = decideProposal(t, cs1, vs3, vs3.Height, vs3.Round)
-	propBlockParts = propBlock.MakePartSet(types.BlockPartSizeBytes)
-	if err := cs1.SetProposalAndBlock(prop, propBlock, propBlockParts, ""); err != nil {
+	//XXX: this isnt guaranteed to get there before the timeoutPropose ...
+	if err := cs1.SetProposalAndBlock(prop, propBlock, propBlockParts, "some peer"); err != nil {
 		t.Fatal(err)
 	}
 
-	ensureNewRound(t, newRoundCh, height, round)
-
 	ensureNewProposal(t, proposalCh, height, round)
 
+	// go to prevote, prevote for locked block (not proposal)
 	ensurePrevote(t, voteCh, height, round)
-	validatePrevote(t, cs1, round, vss[0], theBlockHash)
-
+	validatePrevote(t, cs1, round, vss[0], lockedBlockHash)
+	// now lets add prevotes from everyone else for nil (a polka!)
 	signAddVotes(config, cs1, tmproto.PrevoteType, nil, types.PartSetHeader{}, vs2, vs3, vs4)
 
+	// the polka makes us unlock and precommit nil
+	ensureNewUnlock(t, unlockCh, height, round)
 	ensurePrecommit(t, voteCh, height, round)
 
-	// verify that we haven't update our locked block since the first round
-	validatePrecommit(t, cs1, round, 0, vss[0], nil, theBlockHash)
+	// we should have unlocked and committed nil
+	// NOTE: since we don't relock on nil, the lock round is -1
+	validatePrecommit(t, cs1, round, -1, vss[0], nil, nil)
 
+	signAddVotes(config, cs1, tmproto.PrecommitType, nil, types.PartSetHeader{}, vs2, vs3)
+	ensureNewRound(t, newRoundCh, height, round+1)
 }
 
-// TestStateLock_MissingProposalWhenPOLSeenDoesNotUnlock tests that observing
-// a two thirds majority for a block does not cause a validator to upate its lock on the
-// new block if a proposal was not seen for that block.
-func TestStateLock_MissingProposalWhenPOLSeenDoesNotUpdateLock(t *testing.T) {
+// 4 vals, v1 locks on proposed block in the first round but the other validators only prevote
+// In the second round, v1 misses the proposal but sees a majority prevote an unknown block so
+// v1 should unlock and precommit nil. In the third round another block is proposed, all vals
+// prevote and now v1 can lock onto the third block and precommit that
+func TestStateLockPOLUnlockOnUnknownBlock(t *testing.T) {
 	config := configSetup(t)
 
 	cs1, vss := randState(config, 4)
@@ -969,15 +816,13 @@ func TestStateLock_MissingProposalWhenPOLSeenDoesNotUpdateLock(t *testing.T) {
 	addr := pv1.Address()
 	voteCh := subscribeToVoter(cs1, addr)
 	newRoundCh := subscribe(cs1.eventBus, types.EventQueryNewRound)
-	/*
-		Round 0:
-		cs1 creates a proposal for block B.
-		Send a prevote for B from each of the validators to cs1.
-		Send a precommit for nil from all of the validators to cs1.
+	// everything done from perspective of cs1
 
-		This ensures that cs1 will lock on B in this round but not precommit it.
+	/*
+		Round0 (cs1, A) // A A A A// A nil nil nil
 	*/
-	t.Log("### Starting Round 0")
+
+	// start round and wait for propose and prevote
 	startTestRound(cs1, height, round)
 
 	ensureNewRound(t, newRoundCh, height, round)
@@ -997,21 +842,9 @@ func TestStateLock_MissingProposalWhenPOLSeenDoesNotUpdateLock(t *testing.T) {
 	// add precommits from the rest
 	signAddVotes(config, cs1, tmproto.PrecommitType, nil, types.PartSetHeader{}, vs2, vs3, vs4)
 
-	// timeout to new round
-	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.config.Precommit(round).Nanoseconds())
-
-	/*
-		Round 1:
-		Create a new block, D but do not send it to cs1.
-		Send a prevote for D from each of the validators to cs1.
-
-		Check that cs1 does not update its locked block to this missed block D.
-	*/
-	t.Log("### Starting Round 1")
-	incrementRound(vs2, vs3, vs4)
-	round++
+	// before we timeout to the new round set the new proposal
 	cs2 := newState(cs1.state, vs2, kvstore.NewApplication())
-	prop, propBlock := decideProposal(t, cs2, vs2, vs2.Height, vs2.Round)
+	prop, propBlock := decideProposal(t, cs2, vs2, vs2.Height, vs2.Round+1)
 	if prop == nil || propBlock == nil {
 		t.Fatal("Failed to create proposal block with vs2")
 	}
@@ -1019,7 +852,21 @@ func TestStateLock_MissingProposalWhenPOLSeenDoesNotUpdateLock(t *testing.T) {
 	secondBlockHash := propBlock.Hash()
 	require.NotEqual(t, secondBlockHash, firstBlockHash)
 
+	incrementRound(vs2, vs3, vs4)
+
+	// timeout to new round
+	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.config.Precommit(round).Nanoseconds())
+
+	round++ // moving to the next round
+
 	ensureNewRound(t, newRoundCh, height, round)
+	t.Log("### ONTO ROUND 1")
+
+	/*
+		Round1 (vs2, B) // A B B B // nil nil nil nil)
+	*/
+
+	// now we're on a new round but v1 misses the proposal
 
 	// go to prevote, node should prevote for locked block (not the new proposal) - this is relocking
 	ensurePrevote(t, voteCh, height, round)
@@ -1029,88 +876,59 @@ func TestStateLock_MissingProposalWhenPOLSeenDoesNotUpdateLock(t *testing.T) {
 	signAddVotes(config, cs1, tmproto.PrevoteType, secondBlockHash, secondBlockParts.Header(), vs2, vs3, vs4)
 
 	ensurePrecommit(t, voteCh, height, round)
-	validatePrecommit(t, cs1, round, 0, vss[0], nil, firstBlockHash)
-}
-
-// TestStateLock_DoesNotLockOnOldProposal tests that observing
-// a two thirds majority for a block does not cause a validator to lock on the
-// block if a proposal was not seen for that block in the current round, but
-// was seen in a previous round.
-func TestStateLock_DoesNotLockOnOldProposal(t *testing.T) {
-	config := configSetup(t)
-
-	cs1, vss := randState(config, 4)
-	vs2, vs3, vs4 := vss[1], vss[2], vss[3]
-	height, round := cs1.Height, cs1.Round
-
-	timeoutWaitCh := subscribe(cs1.eventBus, types.EventQueryTimeoutWait)
-	proposalCh := subscribe(cs1.eventBus, types.EventQueryCompleteProposal)
-	pv1, err := cs1.privValidator.GetPubKey(context.Background())
-	require.NoError(t, err)
-	addr := pv1.Address()
-	voteCh := subscribeToVoter(cs1, addr)
-	newRoundCh := subscribe(cs1.eventBus, types.EventQueryNewRound)
-	/*
-		Round 0:
-		cs1 creates a proposal for block B.
-		Send a prevote for nil from each of the validators to cs1.
-		Send a precommit for nil from all of the validators to cs1.
-
-		This ensures that cs1 will not lock on B.
-	*/
-	t.Log("### Starting Round 0")
-	startTestRound(cs1, height, round)
-
-	ensureNewRound(t, newRoundCh, height, round)
-	ensureNewProposal(t, proposalCh, height, round)
-	rs := cs1.GetRoundState()
-	firstBlockHash := rs.ProposalBlock.Hash()
-	firstBlockParts := rs.ProposalBlockParts.Header()
-
-	ensurePrevote(t, voteCh, height, round)
-
-	signAddVotes(config, cs1, tmproto.PrevoteType, nil, types.PartSetHeader{}, vs2, vs3, vs4)
-
-	// The proposed block should not have been locked.
-	ensurePrecommit(t, voteCh, height, round)
+	// we should have unlocked and locked on the new block, sending a precommit for this new block
 	validatePrecommit(t, cs1, round, -1, vss[0], nil, nil)
 
+	if err := cs1.SetProposalAndBlock(prop, propBlock, secondBlockParts, "some peer"); err != nil {
+		t.Fatal(err)
+	}
+
+	// more prevote creating a majority on the new block and this is then committed
 	signAddVotes(config, cs1, tmproto.PrecommitType, nil, types.PartSetHeader{}, vs2, vs3, vs4)
 
+	// before we timeout to the new round set the new proposal
+	cs3 := newState(cs1.state, vs3, kvstore.NewApplication())
+	prop, propBlock = decideProposal(t, cs3, vs3, vs3.Height, vs3.Round+1)
+	if prop == nil || propBlock == nil {
+		t.Fatal("Failed to create proposal block with vs2")
+	}
+	thirdPropBlockParts := propBlock.MakePartSet(partSize)
+	thirdPropBlockHash := propBlock.Hash()
+	require.NotEqual(t, secondBlockHash, thirdPropBlockHash)
+
 	incrementRound(vs2, vs3, vs4)
 
 	// timeout to new round
 	ensureNewTimeout(t, timeoutWaitCh, height, round, cs1.config.Precommit(round).Nanoseconds())
 
-	/*
-		Round 1:
-		No proposal new proposal is created.
-		Send a prevote for B, the block from round 0, from each of the validators to cs1.
-		Send a precommit for nil from all of the validators to cs1.
-
-		cs1 saw a POL for the block it saw in round 0. We ensure that it does not
-		lock on this block, since it did not see a proposal for it in this round.
-	*/
-	t.Log("### Starting Round 1")
-	round++
+	round++ // moving to the next round
 	ensureNewRound(t, newRoundCh, height, round)
+	t.Log("### ONTO ROUND 2")
+
+	/*
+		Round2 (vs3, C) // C C C C // C nil nil nil)
+	*/
+
+	if err := cs1.SetProposalAndBlock(prop, propBlock, thirdPropBlockParts, "some peer"); err != nil {
+		t.Fatal(err)
+	}
 
 	ensurePrevote(t, voteCh, height, round)
-	validatePrevote(t, cs1, round, vss[0], nil)
+	// we are no longer locked to the first block so we should be able to prevote
+	validatePrevote(t, cs1, round, vss[0], thirdPropBlockHash)
 
-	// All validators prevote for the old block.
-	signAddVotes(config, cs1, tmproto.PrevoteType, firstBlockHash, firstBlockParts, vs2, vs3, vs4)
+	signAddVotes(config, cs1, tmproto.PrevoteType, thirdPropBlockHash, thirdPropBlockParts.Header(), vs2, vs3, vs4)
 
-	// Make sure that cs1 did not lock on the block since it did not receive a proposal for it.
 	ensurePrecommit(t, voteCh, height, round)
-	validatePrecommit(t, cs1, round, -1, vss[0], nil, nil)
+	// we have a majority, now vs1 can change lock to the third block
+	validatePrecommit(t, cs1, round, round, vss[0], thirdPropBlockHash, thirdPropBlockHash)
 }
 
 // 4 vals
 // a polka at round 1 but we miss it
 // then a polka at round 2 that we lock on
 // then we see the polka from round 1 but shouldn't unlock
-func TestStateLock_POLSafety1(t *testing.T) {
+func TestStateLockPOLSafety1(t *testing.T) {
 	config := configSetup(t)
 
 	cs1, vss := randState(config, 4)
@@ -1233,7 +1051,7 @@ func TestStateLock_POLSafety1(t *testing.T) {
 
 // What we want:
 // dont see P0, lock on P1 at R1, dont unlock using P0 at R2
-func TestStateLock_POLSafety2(t *testing.T) {
+func TestStateLockPOLSafety2(t *testing.T) {
 	config := configSetup(t)
 
 	cs1, vss := randState(config, 4)
@@ -1245,6 +1063,7 @@ func TestStateLock_POLSafety2(t *testing.T) {
 	proposalCh := subscribe(cs1.eventBus, types.EventQueryCompleteProposal)
 	timeoutWaitCh := subscribe(cs1.eventBus, types.EventQueryTimeoutWait)
 	newRoundCh := subscribe(cs1.eventBus, types.EventQueryNewRound)
+	unlockCh := subscribe(cs1.eventBus, types.EventQueryUnlock)
 	pv1, err := cs1.privValidator.GetPubKey(context.Background())
 	require.NoError(t, err)
 	addr := pv1.Address()
@@ -1320,13 +1139,14 @@ func TestStateLock_POLSafety2(t *testing.T) {
 	*/
 	ensureNewProposal(t, proposalCh, height, round)
 
+	ensureNoNewUnlock(t, unlockCh)
 	ensurePrevote(t, voteCh, height, round)
 	validatePrevote(t, cs1, round, vss[0], propBlockHash1)
 
 }
 
 // 4 vals.
-// polka P0 at R0 for B0. We lock B0 on P0 at R0.
+// polka P0 at R0 for B0. We lock B0 on P0 at R0. P0 unlocks value at R1.
 
 // What we want:
 // P0 proposes B0 at R3.
@@ -1343,6 +1163,7 @@ func TestProposeValidBlock(t *testing.T) {
 	timeoutWaitCh := subscribe(cs1.eventBus, types.EventQueryTimeoutWait)
 	timeoutProposeCh := subscribe(cs1.eventBus, types.EventQueryTimeoutPropose)
 	newRoundCh := subscribe(cs1.eventBus, types.EventQueryNewRound)
+	unlockCh := subscribe(cs1.eventBus, types.EventQueryUnlock)
 	pv1, err := cs1.privValidator.GetPubKey(context.Background())
 	require.NoError(t, err)
 	addr := pv1.Address()
@@ -1364,8 +1185,7 @@ func TestProposeValidBlock(t *testing.T) {
 	signAddVotes(config, cs1, tmproto.PrevoteType, propBlockHash, propBlock.MakePartSet(partSize).Header(), vs2, vs3, vs4)
 
 	ensurePrecommit(t, voteCh, height, round)
-	// we should have precommitted the proposed block in this round.
-
+	// we should have precommitted
 	validatePrecommit(t, cs1, round, round, vss[0], propBlockHash, propBlockHash)
 
 	signAddVotes(config, cs1, tmproto.PrecommitType, nil, types.PartSetHeader{}, vs2, vs3, vs4)
@@ -1376,7 +1196,8 @@ func TestProposeValidBlock(t *testing.T) {
 	round++ // moving to the next round
 
 	ensureNewRound(t, newRoundCh, height, round)
-	t.Log("### ONTO ROUND 1")
+
+	t.Log("### ONTO ROUND 2")
 
 	// timeout of propose
 	ensureNewTimeout(t, timeoutProposeCh, height, round, cs1.config.Propose(round).Nanoseconds())
@@ -1384,19 +1205,20 @@ func TestProposeValidBlock(t *testing.T) {
 	ensurePrevote(t, voteCh, height, round)
 	validatePrevote(t, cs1, round, vss[0], propBlockHash)
 
-	signAddVotes(config, cs1, tmproto.PrecommitType, nil, types.PartSetHeader{}, vs2, vs3, vs4)
+	signAddVotes(config, cs1, tmproto.PrevoteType, nil, types.PartSetHeader{}, vs2, vs3, vs4)
+
+	ensureNewUnlock(t, unlockCh, height, round)
 
 	ensurePrecommit(t, voteCh, height, round)
-	// we should have precommitted nil during this round because we received
-	// >2/3 precommits for nil from the other validators.
-	validatePrecommit(t, cs1, round, 0, vss[0], nil, propBlockHash)
+	// we should have precommitted
+	validatePrecommit(t, cs1, round, -1, vss[0], nil, nil)
 
 	incrementRound(vs2, vs3, vs4)
 	incrementRound(vs2, vs3, vs4)
 
 	signAddVotes(config, cs1, tmproto.PrecommitType, nil, types.PartSetHeader{}, vs2, vs3, vs4)
 
-	round += 2 // increment by multiple rounds
+	round += 2 // moving to the next round
 
 	ensureNewRound(t, newRoundCh, height, round)
 	t.Log("### ONTO ROUND 3")
@@ -1407,6 +1229,8 @@ func TestProposeValidBlock(t *testing.T) {
 
 	ensureNewRound(t, newRoundCh, height, round)
 
+	t.Log("### ONTO ROUND 4")
+
 	ensureNewProposal(t, proposalCh, height, round)
 
 	rs = cs1.GetRoundState()
@@ -1886,7 +1710,7 @@ func TestResetTimeoutPrecommitUponNewHeight(t *testing.T) {
 // TODO: Slashing
 
 /*
-func TestStateSlashing_Prevotes(t *testing.T) {
+func TestStateSlashingPrevotes(t *testing.T) {
 	cs1, vss := randState(2)
 	vs2 := vss[1]
 
@@ -1921,7 +1745,7 @@ func TestStateSlashing_Prevotes(t *testing.T) {
 	// XXX: Check for existence of Dupeout info
 }
 
-func TestStateSlashing_Precommits(t *testing.T) {
+func TestStateSlashingPrecommits(t *testing.T) {
 	cs1, vss := randState(2)
 	vs2 := vss[1]
 

internal/test/factory/block.go

@@ -55,7 +55,7 @@ func MakeHeader(h *types.Header) (*types.Header, error) {
 	if h.Height == 0 {
 		h.Height = 1
 	}
-	if h.LastBlockID.IsNil() {
+	if h.LastBlockID.IsZero() {
 		h.LastBlockID = MakeBlockID()
 	}
 	if h.ChainID == "" {

proto/tendermint/types/params.pb.go

@@ -34,7 +34,6 @@ type ConsensusParams struct {
 	Evidence  *EvidenceParams  `protobuf:"bytes,2,opt,name=evidence,proto3" json:"evidence,omitempty"`
 	Validator *ValidatorParams `protobuf:"bytes,3,opt,name=validator,proto3" json:"validator,omitempty"`
 	Version   *VersionParams   `protobuf:"bytes,4,opt,name=version,proto3" json:"version,omitempty"`
-	Timestamp *TimestampParams `protobuf:"bytes,5,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
 }
 
 func (m *ConsensusParams) Reset()         { *m = ConsensusParams{} }
@@ -98,13 +97,6 @@ func (m *ConsensusParams) GetVersion() *VersionParams {
 	return nil
 }
 
-func (m *ConsensusParams) GetTimestamp() *TimestampParams {
-	if m != nil {
-		return m.Timestamp
-	}
-	return nil
-}
-
 // BlockParams contains limits on the block size.
 type BlockParams struct {
 	// Max block size, in bytes.
@@ -326,66 +318,6 @@ func (m *VersionParams) GetAppVersion() uint64 {
 	return 0
 }
 
-type TimestampParams struct {
-	Accuracy     time.Duration `protobuf:"bytes,1,opt,name=accuracy,proto3,stdduration" json:"accuracy"`
-	Precision    time.Duration `protobuf:"bytes,2,opt,name=precision,proto3,stdduration" json:"precision"`
-	MessageDelay time.Duration `protobuf:"bytes,3,opt,name=message_delay,json=messageDelay,proto3,stdduration" json:"message_delay"`
-}
-
-func (m *TimestampParams) Reset()         { *m = TimestampParams{} }
-func (m *TimestampParams) String() string { return proto.CompactTextString(m) }
-func (*TimestampParams) ProtoMessage()    {}
-func (*TimestampParams) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e12598271a686f57, []int{5}
-}
-func (m *TimestampParams) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *TimestampParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_TimestampParams.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 *TimestampParams) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_TimestampParams.Merge(m, src)
-}
-func (m *TimestampParams) XXX_Size() int {
-	return m.Size()
-}
-func (m *TimestampParams) XXX_DiscardUnknown() {
-	xxx_messageInfo_TimestampParams.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_TimestampParams proto.InternalMessageInfo
-
-func (m *TimestampParams) GetAccuracy() time.Duration {
-	if m != nil {
-		return m.Accuracy
-	}
-	return 0
-}
-
-func (m *TimestampParams) GetPrecision() time.Duration {
-	if m != nil {
-		return m.Precision
-	}
-	return 0
-}
-
-func (m *TimestampParams) GetMessageDelay() time.Duration {
-	if m != nil {
-		return m.MessageDelay
-	}
-	return 0
-}
-
 // HashedParams is a subset of ConsensusParams.
 //
 // It is hashed into the Header.ConsensusHash.
@@ -398,7 +330,7 @@ func (m *HashedParams) Reset()         { *m = HashedParams{} }
 func (m *HashedParams) String() string { return proto.CompactTextString(m) }
 func (*HashedParams) ProtoMessage()    {}
 func (*HashedParams) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e12598271a686f57, []int{6}
+	return fileDescriptor_e12598271a686f57, []int{5}
 }
 func (m *HashedParams) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -447,51 +379,45 @@ func init() {
 	proto.RegisterType((*EvidenceParams)(nil), "tendermint.types.EvidenceParams")
 	proto.RegisterType((*ValidatorParams)(nil), "tendermint.types.ValidatorParams")
 	proto.RegisterType((*VersionParams)(nil), "tendermint.types.VersionParams")
-	proto.RegisterType((*TimestampParams)(nil), "tendermint.types.TimestampParams")
 	proto.RegisterType((*HashedParams)(nil), "tendermint.types.HashedParams")
 }
 
 func init() { proto.RegisterFile("tendermint/types/params.proto", fileDescriptor_e12598271a686f57) }
 
 var fileDescriptor_e12598271a686f57 = []byte{
-	// 577 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x94, 0x4f, 0x6b, 0xd4, 0x40,
-	0x18, 0xc6, 0x37, 0xdd, 0xfe, 0xd9, 0x7d, 0xb7, 0xdb, 0x2d, 0x83, 0x60, 0xac, 0x34, 0x5b, 0x73,
-	0x90, 0x82, 0x90, 0x88, 0x45, 0x44, 0x10, 0x4a, 0xb7, 0x95, 0x16, 0xa4, 0x22, 0xa1, 0x7a, 0xe8,
-	0x25, 0x4c, 0xb2, 0x63, 0x1a, 0xba, 0x93, 0x19, 0x32, 0x49, 0xd9, 0x7c, 0x0b, 0x8f, 0x7e, 0x04,
-	0xfd, 0x18, 0xde, 0x7a, 0xec, 0xd1, 0x93, 0x95, 0xed, 0x17, 0x91, 0x4c, 0x66, 0x36, 0xdd, 0xad,
-	0x42, 0xbd, 0x25, 0xf3, 0x3e, 0xbf, 0x79, 0x79, 0x9f, 0xf7, 0x61, 0x60, 0x33, 0x23, 0xc9, 0x90,
-	0xa4, 0x34, 0x4e, 0x32, 0x37, 0x2b, 0x38, 0x11, 0x2e, 0xc7, 0x29, 0xa6, 0xc2, 0xe1, 0x29, 0xcb,
-	0x18, 0x5a, 0xaf, 0xcb, 0x8e, 0x2c, 0x6f, 0x3c, 0x88, 0x58, 0xc4, 0x64, 0xd1, 0x2d, 0xbf, 0x2a,
-	0xdd, 0x86, 0x15, 0x31, 0x16, 0x8d, 0x88, 0x2b, 0xff, 0x82, 0xfc, 0xb3, 0x3b, 0xcc, 0x53, 0x9c,
-	0xc5, 0x2c, 0xa9, 0xea, 0xf6, 0x8f, 0x05, 0xe8, 0xed, 0xb3, 0x44, 0x90, 0x44, 0xe4, 0xe2, 0x83,
-	0xec, 0x80, 0x76, 0x60, 0x29, 0x18, 0xb1, 0xf0, 0xdc, 0x34, 0xb6, 0x8c, 0xed, 0xce, 0x8b, 0x4d,
-	0x67, 0xbe, 0x97, 0x33, 0x28, 0xcb, 0x95, 0xda, 0xab, 0xb4, 0xe8, 0x0d, 0xb4, 0xc8, 0x45, 0x3c,
-	0x24, 0x49, 0x48, 0xcc, 0x05, 0xc9, 0x6d, 0xdd, 0xe5, 0xde, 0x2a, 0x85, 0x42, 0xa7, 0x04, 0xda,
-	0x85, 0xf6, 0x05, 0x1e, 0xc5, 0x43, 0x9c, 0xb1, 0xd4, 0x6c, 0x4a, 0xfc, 0xc9, 0x5d, 0xfc, 0x93,
-	0x96, 0x28, 0xbe, 0x66, 0xd0, 0x6b, 0x58, 0xb9, 0x20, 0xa9, 0x88, 0x59, 0x62, 0x2e, 0x4a, 0xbc,
-	0xff, 0x17, 0xbc, 0x12, 0x28, 0x58, 0xeb, 0xcb, 0xde, 0x59, 0x4c, 0x89, 0xc8, 0x30, 0xe5, 0xe6,
-	0xd2, 0xbf, 0x7a, 0x9f, 0x68, 0x89, 0xee, 0x3d, 0x65, 0xec, 0x7d, 0xe8, 0xdc, 0x32, 0x04, 0x3d,
-	0x86, 0x36, 0xc5, 0x63, 0x3f, 0x28, 0x32, 0x22, 0xa4, 0x85, 0x4d, 0xaf, 0x45, 0xf1, 0x78, 0x50,
-	0xfe, 0xa3, 0x87, 0xb0, 0x52, 0x16, 0x23, 0x2c, 0xa4, 0x4b, 0x4d, 0x6f, 0x99, 0xe2, 0xf1, 0x21,
-	0x16, 0xf6, 0x77, 0x03, 0xd6, 0x66, 0xed, 0x41, 0xcf, 0x00, 0x95, 0x5a, 0x1c, 0x11, 0x3f, 0xc9,
-	0xa9, 0x2f, 0x7d, 0xd6, 0x37, 0xf6, 0x28, 0x1e, 0xef, 0x45, 0xe4, 0x7d, 0x4e, 0x65, 0x6b, 0x81,
-	0x8e, 0x61, 0x5d, 0x8b, 0xf5, 0x8a, 0xd5, 0x1e, 0x1e, 0x39, 0x55, 0x06, 0x1c, 0x9d, 0x01, 0xe7,
-	0x40, 0x09, 0x06, 0xad, 0xcb, 0x5f, 0xfd, 0xc6, 0xd7, 0xeb, 0xbe, 0xe1, 0xad, 0x55, 0xf7, 0xe9,
-	0xca, 0xec, 0x10, 0xcd, 0xd9, 0x21, 0xec, 0x97, 0xd0, 0x9b, 0x5b, 0x05, 0xb2, 0xa1, 0xcb, 0xf3,
-	0xc0, 0x3f, 0x27, 0x85, 0x2f, 0xfd, 0x32, 0x8d, 0xad, 0xe6, 0x76, 0xdb, 0xeb, 0xf0, 0x3c, 0x78,
-	0x47, 0x8a, 0x93, 0xf2, 0xc8, 0x7e, 0x0e, 0xdd, 0x99, 0x15, 0xa0, 0x3e, 0x74, 0x30, 0xe7, 0xbe,
-	0x5e, 0x5c, 0x39, 0xd9, 0xa2, 0x07, 0x98, 0x73, 0x25, 0xb3, 0xaf, 0x0d, 0xe8, 0xcd, 0x19, 0x8f,
-	0x76, 0xa1, 0x85, 0xc3, 0x30, 0x4f, 0x71, 0x58, 0xa8, 0x80, 0xde, 0x6b, 0xc0, 0x29, 0x84, 0xf6,
-	0xa0, 0xcd, 0x53, 0x12, 0xc6, 0xe2, 0x3f, 0x2d, 0xaa, 0x29, 0x74, 0x04, 0x5d, 0x4a, 0x84, 0x90,
-	0x66, 0x93, 0x11, 0x2e, 0x54, 0x64, 0xef, 0x75, 0xcd, 0xaa, 0x22, 0x0f, 0x4a, 0xd0, 0x3e, 0x85,
-	0xd5, 0x23, 0x2c, 0xce, 0xc8, 0x50, 0x4d, 0xf7, 0x14, 0x7a, 0x72, 0xcf, 0xfe, 0x7c, 0x84, 0xba,
-	0xf2, 0xf8, 0x58, 0xe7, 0xc8, 0x86, 0x6e, 0xad, 0xab, 0xd3, 0xd4, 0xd1, 0xaa, 0x43, 0x2c, 0x06,
-	0x1f, 0xbf, 0x4d, 0x2c, 0xe3, 0x72, 0x62, 0x19, 0x57, 0x13, 0xcb, 0xf8, 0x3d, 0xb1, 0x8c, 0x2f,
-	0x37, 0x56, 0xe3, 0xea, 0xc6, 0x6a, 0xfc, 0xbc, 0xb1, 0x1a, 0xa7, 0xaf, 0xa2, 0x38, 0x3b, 0xcb,
-	0x03, 0x27, 0x64, 0xd4, 0xbd, 0xfd, 0xd6, 0xd4, 0x9f, 0xd5, 0x63, 0x32, 0xff, 0x0e, 0x05, 0xcb,
-	0xf2, 0x7c, 0xe7, 0x4f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x6e, 0x64, 0xc1, 0x5d, 0xa2, 0x04, 0x00,
-	0x00,
+	// 498 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x93, 0xc1, 0x6a, 0xd4, 0x40,
+	0x1c, 0xc6, 0x77, 0x9a, 0xda, 0xee, 0xfe, 0xe3, 0x76, 0xcb, 0x20, 0x18, 0x2b, 0xcd, 0xae, 0x39,
+	0x48, 0x41, 0x48, 0xc4, 0x22, 0x22, 0x08, 0xe2, 0x56, 0xa9, 0x20, 0x15, 0x09, 0xea, 0xa1, 0x97,
+	0x30, 0xd9, 0x8c, 0x69, 0xe8, 0x4e, 0x66, 0xc8, 0x24, 0xcb, 0xee, 0xcd, 0x47, 0xf0, 0xe8, 0x23,
+	0xe8, 0x9b, 0xf4, 0xd8, 0xa3, 0x27, 0x95, 0xdd, 0x17, 0x91, 0x4c, 0x32, 0xa6, 0x9b, 0xf6, 0x36,
+	0x33, 0xdf, 0xef, 0x9b, 0xe1, 0xfb, 0x86, 0x3f, 0xec, 0xe7, 0x34, 0x8d, 0x68, 0xc6, 0x92, 0x34,
+	0xf7, 0xf2, 0x85, 0xa0, 0xd2, 0x13, 0x24, 0x23, 0x4c, 0xba, 0x22, 0xe3, 0x39, 0xc7, 0xbb, 0x8d,
+	0xec, 0x2a, 0x79, 0xef, 0x4e, 0xcc, 0x63, 0xae, 0x44, 0xaf, 0x5c, 0x55, 0xdc, 0x9e, 0x1d, 0x73,
+	0x1e, 0x4f, 0xa9, 0xa7, 0x76, 0x61, 0xf1, 0xc5, 0x8b, 0x8a, 0x8c, 0xe4, 0x09, 0x4f, 0x2b, 0xdd,
+	0xf9, 0xba, 0x01, 0x83, 0x23, 0x9e, 0x4a, 0x9a, 0xca, 0x42, 0x7e, 0x50, 0x2f, 0xe0, 0x43, 0xb8,
+	0x15, 0x4e, 0xf9, 0xe4, 0xdc, 0x42, 0x23, 0x74, 0x60, 0x3e, 0xd9, 0x77, 0xdb, 0x6f, 0xb9, 0xe3,
+	0x52, 0xae, 0x68, 0xbf, 0x62, 0xf1, 0x0b, 0xe8, 0xd2, 0x59, 0x12, 0xd1, 0x74, 0x42, 0xad, 0x0d,
+	0xe5, 0x1b, 0x5d, 0xf7, 0xbd, 0xa9, 0x89, 0xda, 0xfa, 0xdf, 0x81, 0x5f, 0x42, 0x6f, 0x46, 0xa6,
+	0x49, 0x44, 0x72, 0x9e, 0x59, 0x86, 0xb2, 0x3f, 0xb8, 0x6e, 0xff, 0xac, 0x91, 0xda, 0xdf, 0x78,
+	0xf0, 0x73, 0xd8, 0x9e, 0xd1, 0x4c, 0x26, 0x3c, 0xb5, 0x36, 0x95, 0x7d, 0x78, 0x83, 0xbd, 0x02,
+	0x6a, 0xb3, 0xe6, 0x9d, 0x23, 0x30, 0xaf, 0xe4, 0xc1, 0xf7, 0xa1, 0xc7, 0xc8, 0x3c, 0x08, 0x17,
+	0x39, 0x95, 0xaa, 0x01, 0xc3, 0xef, 0x32, 0x32, 0x1f, 0x97, 0x7b, 0x7c, 0x17, 0xb6, 0x4b, 0x31,
+	0x26, 0x52, 0x85, 0x34, 0xfc, 0x2d, 0x46, 0xe6, 0xc7, 0x44, 0x3a, 0x3f, 0x11, 0xec, 0xac, 0xa7,
+	0xc3, 0x8f, 0x00, 0x97, 0x2c, 0x89, 0x69, 0x90, 0x16, 0x2c, 0x50, 0x35, 0xe9, 0x1b, 0x07, 0x8c,
+	0xcc, 0x5f, 0xc5, 0xf4, 0x7d, 0xc1, 0xd4, 0xd3, 0x12, 0x9f, 0xc0, 0xae, 0x86, 0xf5, 0x0f, 0xd5,
+	0x35, 0xde, 0x73, 0xab, 0x2f, 0x74, 0xf5, 0x17, 0xba, 0xaf, 0x6b, 0x60, 0xdc, 0xbd, 0xf8, 0x3d,
+	0xec, 0x7c, 0xff, 0x33, 0x44, 0xfe, 0x4e, 0x75, 0x9f, 0x56, 0xd6, 0x43, 0x18, 0xeb, 0x21, 0x9c,
+	0xa7, 0x30, 0x68, 0x35, 0x89, 0x1d, 0xe8, 0x8b, 0x22, 0x0c, 0xce, 0xe9, 0x22, 0x50, 0x5d, 0x59,
+	0x68, 0x64, 0x1c, 0xf4, 0x7c, 0x53, 0x14, 0xe1, 0x3b, 0xba, 0xf8, 0x58, 0x1e, 0x39, 0x8f, 0xa1,
+	0xbf, 0xd6, 0x20, 0x1e, 0x82, 0x49, 0x84, 0x08, 0x74, 0xef, 0x65, 0xb2, 0x4d, 0x1f, 0x88, 0x10,
+	0x35, 0xe6, 0x9c, 0xc2, 0xed, 0xb7, 0x44, 0x9e, 0xd1, 0xa8, 0x36, 0x3c, 0x84, 0x81, 0x6a, 0x21,
+	0x68, 0x17, 0xdc, 0x57, 0xc7, 0x27, 0xba, 0x65, 0x07, 0xfa, 0x0d, 0xd7, 0x74, 0x6d, 0x6a, 0xea,
+	0x98, 0xc8, 0xf1, 0xa7, 0x1f, 0x4b, 0x1b, 0x5d, 0x2c, 0x6d, 0x74, 0xb9, 0xb4, 0xd1, 0xdf, 0xa5,
+	0x8d, 0xbe, 0xad, 0xec, 0xce, 0xe5, 0xca, 0xee, 0xfc, 0x5a, 0xd9, 0x9d, 0xd3, 0x67, 0x71, 0x92,
+	0x9f, 0x15, 0xa1, 0x3b, 0xe1, 0xcc, 0xbb, 0x3a, 0x48, 0xcd, 0xb2, 0x9a, 0x94, 0xf6, 0x90, 0x85,
+	0x5b, 0xea, 0xfc, 0xf0, 0x5f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x18, 0x54, 0x4f, 0xe1, 0x7f, 0x03,
+	0x00, 0x00,
 }
 
 func (this *ConsensusParams) Equal(that interface{}) bool {
@@ -525,9 +451,6 @@ func (this *ConsensusParams) Equal(that interface{}) bool {
 	if !this.Version.Equal(that1.Version) {
 		return false
 	}
-	if !this.Timestamp.Equal(that1.Timestamp) {
-		return false
-	}
 	return true
 }
 func (this *BlockParams) Equal(that interface{}) bool {
@@ -640,36 +563,6 @@ func (this *VersionParams) Equal(that interface{}) bool {
 	}
 	return true
 }
-func (this *TimestampParams) Equal(that interface{}) bool {
-	if that == nil {
-		return this == nil
-	}
-
-	that1, ok := that.(*TimestampParams)
-	if !ok {
-		that2, ok := that.(TimestampParams)
-		if ok {
-			that1 = &that2
-		} else {
-			return false
-		}
-	}
-	if that1 == nil {
-		return this == nil
-	} else if this == nil {
-		return false
-	}
-	if this.Accuracy != that1.Accuracy {
-		return false
-	}
-	if this.Precision != that1.Precision {
-		return false
-	}
-	if this.MessageDelay != that1.MessageDelay {
-		return false
-	}
-	return true
-}
 func (this *HashedParams) Equal(that interface{}) bool {
 	if that == nil {
 		return this == nil
@@ -717,18 +610,6 @@ func (m *ConsensusParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
-	if m.Timestamp != nil {
-		{
-			size, err := m.Timestamp.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintParams(dAtA, i, uint64(size))
-		}
-		i--
-		dAtA[i] = 0x2a
-	}
 	if m.Version != nil {
 		{
 			size, err := m.Version.MarshalToSizedBuffer(dAtA[:i])
@@ -838,12 +719,12 @@ func (m *EvidenceParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i--
 		dAtA[i] = 0x18
 	}
-	n6, err6 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.MaxAgeDuration, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.MaxAgeDuration):])
-	if err6 != nil {
-		return 0, err6
+	n5, err5 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.MaxAgeDuration, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.MaxAgeDuration):])
+	if err5 != nil {
+		return 0, err5
 	}
-	i -= n6
-	i = encodeVarintParams(dAtA, i, uint64(n6))
+	i -= n5
+	i = encodeVarintParams(dAtA, i, uint64(n5))
 	i--
 	dAtA[i] = 0x12
 	if m.MaxAgeNumBlocks != 0 {
@@ -914,53 +795,6 @@ func (m *VersionParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
-func (m *TimestampParams) 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 *TimestampParams) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *TimestampParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	n7, err7 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.MessageDelay, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.MessageDelay):])
-	if err7 != nil {
-		return 0, err7
-	}
-	i -= n7
-	i = encodeVarintParams(dAtA, i, uint64(n7))
-	i--
-	dAtA[i] = 0x1a
-	n8, err8 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.Precision, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.Precision):])
-	if err8 != nil {
-		return 0, err8
-	}
-	i -= n8
-	i = encodeVarintParams(dAtA, i, uint64(n8))
-	i--
-	dAtA[i] = 0x12
-	n9, err9 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.Accuracy, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.Accuracy):])
-	if err9 != nil {
-		return 0, err9
-	}
-	i -= n9
-	i = encodeVarintParams(dAtA, i, uint64(n9))
-	i--
-	dAtA[i] = 0xa
-	return len(dAtA) - i, nil
-}
-
 func (m *HashedParams) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -1027,10 +861,6 @@ func (m *ConsensusParams) Size() (n int) {
 		l = m.Version.Size()
 		n += 1 + l + sovParams(uint64(l))
 	}
-	if m.Timestamp != nil {
-		l = m.Timestamp.Size()
-		n += 1 + l + sovParams(uint64(l))
-	}
 	return n
 }
 
@@ -1093,21 +923,6 @@ func (m *VersionParams) Size() (n int) {
 	return n
 }
 
-func (m *TimestampParams) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.Accuracy)
-	n += 1 + l + sovParams(uint64(l))
-	l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.Precision)
-	n += 1 + l + sovParams(uint64(l))
-	l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.MessageDelay)
-	n += 1 + l + sovParams(uint64(l))
-	return n
-}
-
 func (m *HashedParams) Size() (n int) {
 	if m == nil {
 		return 0
@@ -1302,42 +1117,6 @@ func (m *ConsensusParams) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
-		case 5:
-			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 ErrIntOverflowParams
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthParams
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthParams
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if m.Timestamp == nil {
-				m.Timestamp = &TimestampParams{}
-			}
-			if err := m.Timestamp.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipParams(dAtA[iNdEx:])
@@ -1719,155 +1498,6 @@ func (m *VersionParams) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *TimestampParams) 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 ErrIntOverflowParams
-			}
-			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: TimestampParams: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: TimestampParams: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Accuracy", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowParams
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthParams
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthParams
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.Accuracy, dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Precision", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowParams
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthParams
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthParams
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.Precision, dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 3:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field MessageDelay", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowParams
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthParams
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthParams
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(&m.MessageDelay, dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipParams(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthParams
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
 func (m *HashedParams) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0

proto/tendermint/types/params.proto

@@ -15,7 +15,6 @@ message ConsensusParams {
   EvidenceParams  evidence  = 2;
   ValidatorParams validator = 3;
   VersionParams   version   = 4;
-  TimestampParams timestamp = 5;
 }
 
 // BlockParams contains limits on the block size.
@@ -61,15 +60,6 @@ message VersionParams {
   uint64 app_version = 1;
 }
 
-message TimestampParams {
-  google.protobuf.Duration accuracy = 1
-      [(gogoproto.nullable) = false, (gogoproto.stdduration) = true];
-  google.protobuf.Duration precision = 2
-      [(gogoproto.nullable) = false, (gogoproto.stdduration) = true];
-  google.protobuf.Duration message_delay = 3
-      [(gogoproto.nullable) = false, (gogoproto.stdduration) = true];
-}
-
 // HashedParams is a subset of ConsensusParams.
 //
 // It is hashed into the Header.ConsensusHash.

types/block.go

@@ -883,7 +883,7 @@ func (commit *Commit) ValidateBasic() error {
 	}
 
 	if commit.Height >= 1 {
-		if commit.BlockID.IsNil() {
+		if commit.BlockID.IsZero() {
 			return errors.New("commit cannot be for nil block")
 		}
 
@@ -1204,8 +1204,8 @@ func (blockID BlockID) ValidateBasic() error {
 	return nil
 }
 
-// IsNil returns true if this is the BlockID of a nil block.
-func (blockID BlockID) IsNil() bool {
+// IsZero returns true if this is the BlockID of a nil block.
+func (blockID BlockID) IsZero() bool {
 	return len(blockID.Hash) == 0 &&
 		blockID.PartSetHeader.IsZero()
 }

types/canonical.go

@@ -21,7 +21,7 @@ func CanonicalizeBlockID(bid tmproto.BlockID) *tmproto.CanonicalBlockID {
 		panic(err)
 	}
 	var cbid *tmproto.CanonicalBlockID
-	if rbid == nil || rbid.IsNil() {
+	if rbid == nil || rbid.IsZero() {
 		cbid = nil
 	} else {
 		cbid = &tmproto.CanonicalBlockID{

types/event_bus.go

@@ -221,6 +221,10 @@ func (b *EventBus) PublishEventPolka(data EventDataRoundState) error {
 	return b.Publish(EventPolkaValue, data)
 }
 
+func (b *EventBus) PublishEventUnlock(data EventDataRoundState) error {
+	return b.Publish(EventUnlockValue, data)
+}
+
 func (b *EventBus) PublishEventRelock(data EventDataRoundState) error {
 	return b.Publish(EventRelockValue, data)
 }
@@ -297,6 +301,10 @@ func (NopEventBus) PublishEventPolka(data EventDataRoundState) error {
 	return nil
 }
 
+func (NopEventBus) PublishEventUnlock(data EventDataRoundState) error {
+	return nil
+}
+
 func (NopEventBus) PublishEventRelock(data EventDataRoundState) error {
 	return nil
 }

types/event_bus_test.go

@@ -362,6 +362,8 @@ func TestEventBusPublish(t *testing.T) {
 	require.NoError(t, err)
 	err = eventBus.PublishEventPolka(EventDataRoundState{})
 	require.NoError(t, err)
+	err = eventBus.PublishEventUnlock(EventDataRoundState{})
+	require.NoError(t, err)
 	err = eventBus.PublishEventRelock(EventDataRoundState{})
 	require.NoError(t, err)
 	err = eventBus.PublishEventLock(EventDataRoundState{})
@@ -473,6 +475,7 @@ var events = []string{
 	EventTimeoutProposeValue,
 	EventCompleteProposalValue,
 	EventPolkaValue,
+	EventUnlockValue,
 	EventLockValue,
 	EventRelockValue,
 	EventTimeoutWaitValue,
@@ -494,6 +497,7 @@ var queries = []tmpubsub.Query{
 	EventQueryTimeoutPropose,
 	EventQueryCompleteProposal,
 	EventQueryPolka,
+	EventQueryUnlock,
 	EventQueryLock,
 	EventQueryRelock,
 	EventQueryTimeoutWait,

types/events.go

@@ -38,6 +38,7 @@ const (
 	EventStateSyncStatusValue = "StateSyncStatus"
 	EventTimeoutProposeValue  = "TimeoutPropose"
 	EventTimeoutWaitValue     = "TimeoutWait"
+	EventUnlockValue          = "Unlock"
 	EventValidBlockValue      = "ValidBlock"
 	EventVoteValue            = "Vote"
 )
@@ -222,6 +223,7 @@ var (
 	EventQueryTimeoutPropose      = QueryForEvent(EventTimeoutProposeValue)
 	EventQueryTimeoutWait         = QueryForEvent(EventTimeoutWaitValue)
 	EventQueryTx                  = QueryForEvent(EventTxValue)
+	EventQueryUnlock              = QueryForEvent(EventUnlockValue)
 	EventQueryValidatorSetUpdates = QueryForEvent(EventValidatorSetUpdatesValue)
 	EventQueryValidBlock          = QueryForEvent(EventValidBlockValue)
 	EventQueryVote                = QueryForEvent(EventVoteValue)

types/params.go

@@ -41,7 +41,6 @@ type ConsensusParams struct {
 	Evidence  EvidenceParams  `json:"evidence"`
 	Validator ValidatorParams `json:"validator"`
 	Version   VersionParams   `json:"version"`
-	Timestamp TimestampParams `json:"timestamp"`
 }
 
 // HashedParams is a subset of ConsensusParams.
@@ -66,14 +65,6 @@ type EvidenceParams struct {
 	MaxBytes        int64         `json:"max_bytes"`
 }
 
-// TimestampParams define the acceptable amount of clock skew among different
-// validators on a network.
-type TimestampParams struct {
-	Accuracy     time.Duration `json:"accuracy"`
-	Precision    time.Duration `json:"precision"`
-	MessageDelay time.Duration `json:"message_delay"`
-}
-
 // ValidatorParams restrict the public key types validators can use.
 // NOTE: uses ABCI pubkey naming, not Amino names.
 type ValidatorParams struct {
@@ -244,11 +235,6 @@ func (params ConsensusParams) UpdateConsensusParams(params2 *tmproto.ConsensusPa
 	if params2.Version != nil {
 		res.Version.AppVersion = params2.Version.AppVersion
 	}
-	if params2.Timestamp != nil {
-		res.Timestamp.Accuracy = params2.Timestamp.Accuracy
-		res.Timestamp.Precision = params2.Timestamp.Precision
-		res.Timestamp.MessageDelay = params2.Timestamp.MessageDelay
-	}
 	return res
 }
 
@@ -269,11 +255,6 @@ func (params *ConsensusParams) ToProto() tmproto.ConsensusParams {
 		Version: &tmproto.VersionParams{
 			AppVersion: params.Version.AppVersion,
 		},
-		Timestamp: &tmproto.TimestampParams{
-			Accuracy:     params.Timestamp.Accuracy,
-			Precision:    params.Timestamp.Precision,
-			MessageDelay: params.Timestamp.MessageDelay,
-		},
 	}
 }
 
@@ -294,10 +275,5 @@ func ConsensusParamsFromProto(pbParams tmproto.ConsensusParams) ConsensusParams
 		Version: VersionParams{
 			AppVersion: pbParams.Version.AppVersion,
 		},
-		Timestamp: TimestampParams{
-			Accuracy:     pbParams.Timestamp.Accuracy,
-			Precision:    pbParams.Timestamp.Precision,
-			MessageDelay: pbParams.Timestamp.MessageDelay,
-		},
 	}
 }

types/vote.go

@@ -68,7 +68,7 @@ func (vote *Vote) CommitSig() CommitSig {
 	switch {
 	case vote.BlockID.IsComplete():
 		blockIDFlag = BlockIDFlagCommit
-	case vote.BlockID.IsNil():
+	case vote.BlockID.IsZero():
 		blockIDFlag = BlockIDFlagNil
 	default:
 		panic(fmt.Sprintf("Invalid vote %v - expected BlockID to be either empty or complete", vote))
@@ -177,7 +177,7 @@ func (vote *Vote) ValidateBasic() error {
 
 	// BlockID.ValidateBasic would not err if we for instance have an empty hash but a
 	// non-empty PartsSetHeader:
-	if !vote.BlockID.IsNil() && !vote.BlockID.IsComplete() {
+	if !vote.BlockID.IsZero() && !vote.BlockID.IsComplete() {
 		return fmt.Errorf("blockID must be either empty or complete, got: %v", vote.BlockID)
 	}
 

types/vote_set_test.go

@@ -27,7 +27,7 @@ func TestVoteSet_AddVote_Good(t *testing.T) {
 	assert.Nil(t, voteSet.GetByAddress(val0Addr))
 	assert.False(t, voteSet.BitArray().GetIndex(0))
 	blockID, ok := voteSet.TwoThirdsMajority()
-	assert.False(t, ok || !blockID.IsNil(), "there should be no 2/3 majority")
+	assert.False(t, ok || !blockID.IsZero(), "there should be no 2/3 majority")
 
 	vote := &Vote{
 		ValidatorAddress: val0Addr,
@@ -44,7 +44,7 @@ func TestVoteSet_AddVote_Good(t *testing.T) {
 	assert.NotNil(t, voteSet.GetByAddress(val0Addr))
 	assert.True(t, voteSet.BitArray().GetIndex(0))
 	blockID, ok = voteSet.TwoThirdsMajority()
-	assert.False(t, ok || !blockID.IsNil(), "there should be no 2/3 majority")
+	assert.False(t, ok || !blockID.IsZero(), "there should be no 2/3 majority")
 }
 
 func TestVoteSet_AddVote_Bad(t *testing.T) {
@@ -145,7 +145,7 @@ func TestVoteSet_2_3Majority(t *testing.T) {
 		require.NoError(t, err)
 	}
 	blockID, ok := voteSet.TwoThirdsMajority()
-	assert.False(t, ok || !blockID.IsNil(), "there should be no 2/3 majority")
+	assert.False(t, ok || !blockID.IsZero(), "there should be no 2/3 majority")
 
 	// 7th validator voted for some blockhash
 	{
@@ -156,7 +156,7 @@ func TestVoteSet_2_3Majority(t *testing.T) {
 		_, err = signAddVote(privValidators[6], withBlockHash(vote, tmrand.Bytes(32)), voteSet)
 		require.NoError(t, err)
 		blockID, ok = voteSet.TwoThirdsMajority()
-		assert.False(t, ok || !blockID.IsNil(), "there should be no 2/3 majority")
+		assert.False(t, ok || !blockID.IsZero(), "there should be no 2/3 majority")
 	}
 
 	// 8th validator voted for nil.
@@ -168,7 +168,7 @@ func TestVoteSet_2_3Majority(t *testing.T) {
 		_, err = signAddVote(privValidators[7], vote, voteSet)
 		require.NoError(t, err)
 		blockID, ok = voteSet.TwoThirdsMajority()
-		assert.True(t, ok || blockID.IsNil(), "there should be 2/3 majority for nil")
+		assert.True(t, ok || blockID.IsZero(), "there should be 2/3 majority for nil")
 	}
 }
 
@@ -200,7 +200,7 @@ func TestVoteSet_2_3MajorityRedux(t *testing.T) {
 		require.NoError(t, err)
 	}
 	blockID, ok := voteSet.TwoThirdsMajority()
-	assert.False(t, ok || !blockID.IsNil(),
+	assert.False(t, ok || !blockID.IsZero(),
 		"there should be no 2/3 majority")
 
 	// 67th validator voted for nil
@@ -212,7 +212,7 @@ func TestVoteSet_2_3MajorityRedux(t *testing.T) {
 		_, err = signAddVote(privValidators[66], withBlockHash(vote, nil), voteSet)
 		require.NoError(t, err)
 		blockID, ok = voteSet.TwoThirdsMajority()
-		assert.False(t, ok || !blockID.IsNil(),
+		assert.False(t, ok || !blockID.IsZero(),
 			"there should be no 2/3 majority: last vote added was nil")
 	}
 
@@ -226,7 +226,7 @@ func TestVoteSet_2_3MajorityRedux(t *testing.T) {
 		_, err = signAddVote(privValidators[67], withBlockPartSetHeader(vote, blockPartsHeader), voteSet)
 		require.NoError(t, err)
 		blockID, ok = voteSet.TwoThirdsMajority()
-		assert.False(t, ok || !blockID.IsNil(),
+		assert.False(t, ok || !blockID.IsZero(),
 			"there should be no 2/3 majority: last vote added had different PartSetHeader Hash")
 	}
 
@@ -240,7 +240,7 @@ func TestVoteSet_2_3MajorityRedux(t *testing.T) {
 		_, err = signAddVote(privValidators[68], withBlockPartSetHeader(vote, blockPartsHeader), voteSet)
 		require.NoError(t, err)
 		blockID, ok = voteSet.TwoThirdsMajority()
-		assert.False(t, ok || !blockID.IsNil(),
+		assert.False(t, ok || !blockID.IsZero(),
 			"there should be no 2/3 majority: last vote added had different PartSetHeader Total")
 	}
 
@@ -253,7 +253,7 @@ func TestVoteSet_2_3MajorityRedux(t *testing.T) {
 		_, err = signAddVote(privValidators[69], withBlockHash(vote, tmrand.Bytes(32)), voteSet)
 		require.NoError(t, err)
 		blockID, ok = voteSet.TwoThirdsMajority()
-		assert.False(t, ok || !blockID.IsNil(),
+		assert.False(t, ok || !blockID.IsZero(),
 			"there should be no 2/3 majority: last vote added had different BlockHash")
 	}