types: add new consensus params from proto (#7354)

This change adds the new TimingParams proto messages. These new messages were build using the wb/proposer-based-timestamps branch on the spec repo. This change also adds validation that these values are positive when parsed and adds the new parameters into the existing tests.
2026-02-12 23:01:30 +00:00 · 2021-12-05 19:20:37 -05:00
parent a9aab99b41
commit a9b2bbd70d
11 changed files with 658 additions and 136 deletions
--- a/config/toml.go
+++ b/config/toml.go
@@ -569,6 +569,10 @@ var testGenesisFmt = `{
 			"max_gas": "-1",
 			"time_iota_ms": "10"
 		},
+		"timing": {
+			"message_delay": "200",
+			"precision": "50"
+		},
 		"evidence": {
 			"max_age_num_blocks": "100000",
 			"max_age_duration": "172800000000000",
--- a/internal/consensus/pbts_test.go
+++ b/internal/consensus/pbts_test.go
@@ -58,7 +58,7 @@ type pbtsTestHarness struct {

 type pbtsTestConfiguration struct {
 	// The timestamp consensus parameters to be used by the state machine under test.
-	timestampParams types.TimestampParams
+	timingParams types.TimingParams

 	// The setting to use for the TimeoutPropose configuration parameter.
 	timeoutPropose time.Duration
@@ -80,7 +80,7 @@ func newPBTSTestHarness(ctx context.Context, t *testing.T, tc pbtsTestConfigurat
 	clock := new(tmtimemocks.Source)
 	cfg.Consensus.TimeoutPropose = tc.timeoutPropose
 	consensusParams := types.DefaultConsensusParams()
-	consensusParams.Timestamp = tc.timestampParams
+	consensusParams.Timing = tc.timingParams

 	state, privVals := makeGenesisState(cfg, genesisStateArgs{
 		Params:     consensusParams,
@@ -240,9 +240,9 @@ func TestReceiveProposalWaitsForPreviousBlockTime(t *testing.T) {
 	defer cancel()
 	initialTime := time.Now().Add(50 * time.Millisecond)
 	cfg := pbtsTestConfiguration{
-		timestampParams: types.TimestampParams{
-			Precision: 100 * time.Millisecond,
-			MsgDelay:  500 * time.Millisecond,
+		timingParams: types.TimingParams{
+			Precision:    100 * time.Millisecond,
+			MessageDelay: 500 * time.Millisecond,
 		},
 		timeoutPropose:             50 * time.Millisecond,
 		genesisTime:                initialTime,
@@ -256,7 +256,7 @@ func TestReceiveProposalWaitsForPreviousBlockTime(t *testing.T) {
 	// Check that the validator waited until after the proposer-based timestamp
 	// waitingTime bound.
 	assert.True(t, results.height2.prevoteIssuedAt.After(cfg.height2ProposalDeliverTime))
-	maxWaitingTime := cfg.genesisTime.Add(cfg.timestampParams.Precision).Add(cfg.timestampParams.MsgDelay)
+	maxWaitingTime := cfg.genesisTime.Add(cfg.timingParams.Precision).Add(cfg.timingParams.MessageDelay)
 	assert.True(t, results.height2.prevoteIssuedAt.Before(maxWaitingTime))

 	// Check that the validator did not prevote for nil.
@@ -275,9 +275,9 @@ func TestReceiveProposalTimesOutOnSlowDelivery(t *testing.T) {
 	defer cancel()
 	initialTime := time.Now()
 	cfg := pbtsTestConfiguration{
-		timestampParams: types.TimestampParams{
-			Precision: 100 * time.Millisecond,
-			MsgDelay:  500 * time.Millisecond,
+		timingParams: types.TimingParams{
+			Precision:    100 * time.Millisecond,
+			MessageDelay: 500 * time.Millisecond,
 		},
 		timeoutPropose:             50 * time.Millisecond,
 		genesisTime:                initialTime,
@@ -290,7 +290,7 @@ func TestReceiveProposalTimesOutOnSlowDelivery(t *testing.T) {

 	// Check that the validator waited until after the proposer-based timestamp
 	// waitinTime bound.
-	maxWaitingTime := initialTime.Add(cfg.timestampParams.Precision).Add(cfg.timestampParams.MsgDelay)
+	maxWaitingTime := initialTime.Add(cfg.timingParams.Precision).Add(cfg.timingParams.MessageDelay)
 	assert.True(t, results.height2.prevoteIssuedAt.After(maxWaitingTime))

 	// Ensure that the validator issued a prevote for nil.
@@ -378,9 +378,9 @@ func TestProposalTimeout(t *testing.T) {
 			mockSource := new(tmtimemocks.Source)
 			mockSource.On("Now").Return(testCase.localTime)

-			tp := types.TimestampParams{
-				Precision: testCase.precision,
-				MsgDelay:  testCase.msgDelay,
+			tp := types.TimingParams{
+				Precision:    testCase.precision,
+				MessageDelay: testCase.msgDelay,
 			}

 			ti := proposalStepWaitingTime(mockSource, testCase.previousBlockTime, tp)
--- a/internal/consensus/replay_test.go
+++ b/internal/consensus/replay_test.go
@@ -816,7 +816,8 @@ func testHandshakeReplay(
 	}

 	// now start the app using the handshake - it should sync
-	genDoc, _ := sm.MakeGenesisDocFromFile(cfg.GenesisFile())
+	genDoc, err := sm.MakeGenesisDocFromFile(cfg.GenesisFile())
+	require.NoError(t, err)
 	handshaker := NewHandshaker(logger, stateStore, state, store, eventbus.NopEventBus{}, genDoc)
 	proxyApp := proxy.NewAppConns(clientCreator2, logger, proxy.NopMetrics())
 	if err := proxyApp.Start(ctx); err != nil {
@@ -825,7 +826,7 @@ func testHandshakeReplay(

 	t.Cleanup(func() { cancel(); proxyApp.Wait() })

-	err := handshaker.Handshake(ctx, proxyApp)
+	err = handshaker.Handshake(ctx, proxyApp)
 	if expectError {
 		require.Error(t, err)
 		return
@@ -1004,7 +1005,8 @@ func TestHandshakePanicsIfAppReturnsWrongAppHash(t *testing.T) {
 	require.NoError(t, err)
 	stateDB, state, store := stateAndStore(cfg, pubKey, appVersion)
 	stateStore := sm.NewStore(stateDB)
-	genDoc, _ := sm.MakeGenesisDocFromFile(cfg.GenesisFile())
+	genDoc, err := sm.MakeGenesisDocFromFile(cfg.GenesisFile())
+	require.NoError(t, err)
 	state.LastValidators = state.Validators.Copy()
 	// mode = 0 for committing all the blocks
 	blocks := sf.MakeBlocks(3, &state, privVal)
--- a/internal/consensus/state.go
+++ b/internal/consensus/state.go
@@ -1119,8 +1119,7 @@ func (cs *State) enterPropose(height int64, round int32) {
 		}
 	}()

-	//nolint: lll
-	waitingTime := proposalStepWaitingTime(tmtime.DefaultSource{}, cs.state.LastBlockTime, cs.state.ConsensusParams.Timestamp)
+	waitingTime := proposalStepWaitingTime(tmtime.DefaultSource{}, cs.state.LastBlockTime, cs.state.ConsensusParams.Timing) // nolint: lll
 	proposalTimeout := maxDuration(cs.config.Propose(round), waitingTime)

 	// If we don't get the proposal and all block parts quick enough, enterPrevote
@@ -2448,9 +2447,9 @@ func proposerWaitTime(lt tmtime.Source, bt time.Time) time.Duration {
 // The result of proposalStepWaitingTime is compared with the configured `timeout-propose` duration,
 // and the validator waits for whichever duration is larger before advancing to the next step
 // and prevoting nil.
-func proposalStepWaitingTime(lt tmtime.Source, bt time.Time, tp types.TimestampParams) time.Duration {
+func proposalStepWaitingTime(lt tmtime.Source, bt time.Time, tp types.TimingParams) time.Duration {
 	t := lt.Now()
-	wt := bt.Add(tp.Precision).Add(tp.MsgDelay)
+	wt := bt.Add(tp.Precision).Add(tp.MessageDelay)
 	if t.After(wt) {
 		return 0
 	}
--- a/proto/tendermint/statesync/message_test.go
+++ b/proto/tendermint/statesync/message_test.go
@@ -7,9 +7,9 @@ import (
 	"github.com/gogo/protobuf/proto"
 	"github.com/stretchr/testify/require"

+	"github.com/tendermint/tendermint/crypto/ed25519"
 	ssproto "github.com/tendermint/tendermint/proto/tendermint/statesync"
 	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
-	"github.com/tendermint/tendermint/types"
 )

 func TestValidateMsg(t *testing.T) {
@@ -186,10 +186,30 @@ func TestStateSyncVectors(t *testing.T) {
 		{
 			"ParamsResponse",
 			&ssproto.ParamsResponse{
-				Height:          9001,
-				ConsensusParams: types.DefaultConsensusParams().ToProto(),
+				Height: 9001,
+				ConsensusParams: tmproto.ConsensusParams{
+					Block: &tmproto.BlockParams{
+						MaxBytes: 10,
+						MaxGas:   20,
+					},
+					Evidence: &tmproto.EvidenceParams{
+						MaxAgeNumBlocks: 10,
+						MaxAgeDuration:  300,
+						MaxBytes:        100,
+					},
+					Validator: &tmproto.ValidatorParams{
+						PubKeyTypes: []string{ed25519.KeyType},
+					},
+					Version: &tmproto.VersionParams{
+						AppVersion: 11,
+					},
+					Timing: &tmproto.TimingParams{
+						MessageDelay: 550,
+						Precision:    90,
+					},
+				},
 			},
-			"423408a946122f0a10088080c00a10ffffffffffffffffff01120e08a08d0612040880c60a188080401a090a07656432353531392200",
+			"423008a946122b0a04080a10141209080a120310ac0218641a090a07656432353531392202080b2a090a0310a6041202105a",
 		},
 	}

--- a/proto/tendermint/types/params.pb.go
+++ b/proto/tendermint/types/params.pb.go
@@ -34,6 +34,7 @@ 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"`
+	Timing    *TimingParams    `protobuf:"bytes,5,opt,name=timing,proto3" json:"timing,omitempty"`
 }

 func (m *ConsensusParams) Reset()         { *m = ConsensusParams{} }
@@ -97,6 +98,13 @@ func (m *ConsensusParams) GetVersion() *VersionParams {
 	return nil
 }

+func (m *ConsensusParams) GetTiming() *TimingParams {
+	if m != nil {
+		return m.Timing
+	}
+	return nil
+}
+
 // BlockParams contains limits on the block size.
 type BlockParams struct {
 	// Max block size, in bytes.
@@ -373,6 +381,58 @@ func (m *HashedParams) GetBlockMaxGas() int64 {
 	return 0
 }

+type TimingParams struct {
+	MessageDelay time.Duration `protobuf:"bytes,1,opt,name=message_delay,json=messageDelay,proto3,stdduration" json:"message_delay"`
+	Precision    time.Duration `protobuf:"bytes,2,opt,name=precision,proto3,stdduration" json:"precision"`
+}
+
+func (m *TimingParams) Reset()         { *m = TimingParams{} }
+func (m *TimingParams) String() string { return proto.CompactTextString(m) }
+func (*TimingParams) ProtoMessage()    {}
+func (*TimingParams) Descriptor() ([]byte, []int) {
+	return fileDescriptor_e12598271a686f57, []int{6}
+}
+func (m *TimingParams) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *TimingParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_TimingParams.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 *TimingParams) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_TimingParams.Merge(m, src)
+}
+func (m *TimingParams) XXX_Size() int {
+	return m.Size()
+}
+func (m *TimingParams) XXX_DiscardUnknown() {
+	xxx_messageInfo_TimingParams.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_TimingParams proto.InternalMessageInfo
+
+func (m *TimingParams) GetMessageDelay() time.Duration {
+	if m != nil {
+		return m.MessageDelay
+	}
+	return 0
+}
+
+func (m *TimingParams) GetPrecision() time.Duration {
+	if m != nil {
+		return m.Precision
+	}
+	return 0
+}
+
 func init() {
 	proto.RegisterType((*ConsensusParams)(nil), "tendermint.types.ConsensusParams")
 	proto.RegisterType((*BlockParams)(nil), "tendermint.types.BlockParams")
@@ -380,44 +440,48 @@ func init() {
 	proto.RegisterType((*ValidatorParams)(nil), "tendermint.types.ValidatorParams")
 	proto.RegisterType((*VersionParams)(nil), "tendermint.types.VersionParams")
 	proto.RegisterType((*HashedParams)(nil), "tendermint.types.HashedParams")
+	proto.RegisterType((*TimingParams)(nil), "tendermint.types.TimingParams")
 }

 func init() { proto.RegisterFile("tendermint/types/params.proto", fileDescriptor_e12598271a686f57) }

 var fileDescriptor_e12598271a686f57 = []byte{
-	// 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,
+	// 559 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x94, 0xcf, 0x6e, 0xd3, 0x30,
+	0x1c, 0xc7, 0x9b, 0x75, 0xeb, 0xda, 0x5f, 0xdb, 0x75, 0xb2, 0x90, 0x08, 0x43, 0x4b, 0x4b, 0x0e,
+	0x68, 0x12, 0x52, 0x82, 0x98, 0x00, 0x21, 0x21, 0xa1, 0x75, 0x43, 0x4c, 0x42, 0x43, 0x28, 0x1a,
+	0x1c, 0x76, 0x89, 0x9c, 0xd6, 0x64, 0xd1, 0xea, 0xd8, 0x8a, 0x93, 0xaa, 0x7d, 0x0b, 0x8e, 0x48,
+	0xbc, 0x00, 0xbc, 0x01, 0x8f, 0xb0, 0xe3, 0x8e, 0x9c, 0x00, 0xb5, 0x2f, 0x82, 0xe2, 0xd8, 0xa4,
+	0x7f, 0x38, 0xc0, 0x2d, 0xf1, 0xf7, 0xfb, 0x89, 0xe5, 0xcf, 0xaf, 0x35, 0xec, 0xa7, 0x24, 0x1e,
+	0x92, 0x84, 0x46, 0x71, 0xea, 0xa6, 0x53, 0x4e, 0x84, 0xcb, 0x71, 0x82, 0xa9, 0x70, 0x78, 0xc2,
+	0x52, 0x86, 0x76, 0xcb, 0xd8, 0x91, 0xf1, 0xde, 0xad, 0x90, 0x85, 0x4c, 0x86, 0x6e, 0xfe, 0x54,
+	0xf4, 0xf6, 0xac, 0x90, 0xb1, 0x70, 0x44, 0x5c, 0xf9, 0x16, 0x64, 0x1f, 0xdc, 0x61, 0x96, 0xe0,
+	0x34, 0x62, 0x71, 0x91, 0xdb, 0xdf, 0x36, 0xa0, 0x73, 0xcc, 0x62, 0x41, 0x62, 0x91, 0x89, 0xb7,
+	0x72, 0x07, 0x74, 0x08, 0x5b, 0xc1, 0x88, 0x0d, 0xae, 0x4c, 0xa3, 0x67, 0x1c, 0x34, 0x1f, 0xed,
+	0x3b, 0xab, 0x7b, 0x39, 0xfd, 0x3c, 0x2e, 0xda, 0x5e, 0xd1, 0x45, 0xcf, 0xa1, 0x4e, 0xc6, 0xd1,
+	0x90, 0xc4, 0x03, 0x62, 0x6e, 0x48, 0xae, 0xb7, 0xce, 0xbd, 0x54, 0x0d, 0x85, 0xfe, 0x21, 0xd0,
+	0x0b, 0x68, 0x8c, 0xf1, 0x28, 0x1a, 0xe2, 0x94, 0x25, 0x66, 0x55, 0xe2, 0xf7, 0xd6, 0xf1, 0xf7,
+	0xba, 0xa2, 0xf8, 0x92, 0x41, 0xcf, 0x60, 0x7b, 0x4c, 0x12, 0x11, 0xb1, 0xd8, 0xdc, 0x94, 0x78,
+	0xf7, 0x2f, 0x78, 0x51, 0x50, 0xb0, 0xee, 0xa3, 0x27, 0x50, 0x4b, 0x23, 0x1a, 0xc5, 0xa1, 0xb9,
+	0x25, 0x49, 0x6b, 0x9d, 0x3c, 0x97, 0xb9, 0x02, 0x55, 0xdb, 0x3e, 0x86, 0xe6, 0x82, 0x07, 0x74,
+	0x17, 0x1a, 0x14, 0x4f, 0xfc, 0x60, 0x9a, 0x12, 0x21, 0xcd, 0x55, 0xbd, 0x3a, 0xc5, 0x93, 0x7e,
+	0xfe, 0x8e, 0x6e, 0xc3, 0x76, 0x1e, 0x86, 0x58, 0x48, 0x39, 0x55, 0xaf, 0x46, 0xf1, 0xe4, 0x15,
+	0x16, 0xf6, 0x57, 0x03, 0x76, 0x96, 0xad, 0xa0, 0x07, 0x80, 0xf2, 0x2e, 0x0e, 0x89, 0x1f, 0x67,
+	0xd4, 0x97, 0x7a, 0xf5, 0x17, 0x3b, 0x14, 0x4f, 0x8e, 0x42, 0xf2, 0x26, 0xa3, 0x72, 0x6b, 0x81,
+	0xce, 0x60, 0x57, 0x97, 0xf5, 0x64, 0x95, 0xfe, 0x3b, 0x4e, 0x31, 0x7a, 0x47, 0x8f, 0xde, 0x39,
+	0x51, 0x85, 0x7e, 0xfd, 0xfa, 0x47, 0xb7, 0xf2, 0xe9, 0x67, 0xd7, 0xf0, 0x76, 0x8a, 0xef, 0xe9,
+	0x64, 0xf9, 0x10, 0xd5, 0xe5, 0x43, 0xd8, 0x8f, 0xa1, 0xb3, 0x32, 0x01, 0x64, 0x43, 0x9b, 0x67,
+	0x81, 0x7f, 0x45, 0xa6, 0xbe, 0x34, 0x65, 0x1a, 0xbd, 0xea, 0x41, 0xc3, 0x6b, 0xf2, 0x2c, 0x78,
+	0x4d, 0xa6, 0xe7, 0xf9, 0x92, 0xfd, 0x10, 0xda, 0x4b, 0xe6, 0x51, 0x17, 0x9a, 0x98, 0x73, 0x5f,
+	0xcf, 0x2b, 0x3f, 0xd9, 0xa6, 0x07, 0x98, 0x73, 0x55, 0xb3, 0x2f, 0xa0, 0x75, 0x8a, 0xc5, 0x25,
+	0x19, 0x2a, 0xe0, 0x3e, 0x74, 0xa4, 0x05, 0x7f, 0x55, 0x70, 0x5b, 0x2e, 0x9f, 0x69, 0xcb, 0x36,
+	0xb4, 0xcb, 0x5e, 0xe9, 0xba, 0xa9, 0x5b, 0xb9, 0xf0, 0xcf, 0x06, 0xb4, 0x16, 0xc7, 0x89, 0x4e,
+	0xa1, 0x4d, 0x89, 0x10, 0xd2, 0x20, 0x19, 0xe1, 0xa9, 0xfa, 0xd5, 0xff, 0x93, 0xbe, 0x96, 0x22,
+	0x4f, 0x72, 0x10, 0x1d, 0x41, 0x83, 0x27, 0x64, 0x10, 0x89, 0xff, 0x1c, 0x42, 0x49, 0xf5, 0xdf,
+	0x7d, 0x99, 0x59, 0xc6, 0xf5, 0xcc, 0x32, 0x6e, 0x66, 0x96, 0xf1, 0x6b, 0x66, 0x19, 0x1f, 0xe7,
+	0x56, 0xe5, 0x66, 0x6e, 0x55, 0xbe, 0xcf, 0xad, 0xca, 0xc5, 0xd3, 0x30, 0x4a, 0x2f, 0xb3, 0xc0,
+	0x19, 0x30, 0xea, 0x2e, 0x5e, 0x0f, 0xe5, 0x63, 0xf1, 0xff, 0x5f, 0xbd, 0x3a, 0x82, 0x9a, 0x5c,
+	0x3f, 0xfc, 0x1d, 0x00, 0x00, 0xff, 0xff, 0xf4, 0x57, 0x2d, 0xa2, 0x55, 0x04, 0x00, 0x00,
 }

 func (this *ConsensusParams) Equal(that interface{}) bool {
@@ -451,6 +515,9 @@ func (this *ConsensusParams) Equal(that interface{}) bool {
 	if !this.Version.Equal(that1.Version) {
 		return false
 	}
+	if !this.Timing.Equal(that1.Timing) {
+		return false
+	}
 	return true
 }
 func (this *BlockParams) Equal(that interface{}) bool {
@@ -590,6 +657,33 @@ func (this *HashedParams) Equal(that interface{}) bool {
 	}
 	return true
 }
+func (this *TimingParams) Equal(that interface{}) bool {
+	if that == nil {
+		return this == nil
+	}
+
+	that1, ok := that.(*TimingParams)
+	if !ok {
+		that2, ok := that.(TimingParams)
+		if ok {
+			that1 = &that2
+		} else {
+			return false
+		}
+	}
+	if that1 == nil {
+		return this == nil
+	} else if this == nil {
+		return false
+	}
+	if this.MessageDelay != that1.MessageDelay {
+		return false
+	}
+	if this.Precision != that1.Precision {
+		return false
+	}
+	return true
+}
 func (m *ConsensusParams) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -610,6 +704,18 @@ func (m *ConsensusParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
+	if m.Timing != nil {
+		{
+			size, err := m.Timing.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])
@@ -719,12 +825,12 @@ func (m *EvidenceParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i--
 		dAtA[i] = 0x18
 	}
-	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
+	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
 	}
-	i -= n5
-	i = encodeVarintParams(dAtA, i, uint64(n5))
+	i -= n6
+	i = encodeVarintParams(dAtA, i, uint64(n6))
 	i--
 	dAtA[i] = 0x12
 	if m.MaxAgeNumBlocks != 0 {
@@ -828,6 +934,45 @@ func (m *HashedParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }

+func (m *TimingParams) 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 *TimingParams) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *TimingParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	n7, err7 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.Precision, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.Precision):])
+	if err7 != nil {
+		return 0, err7
+	}
+	i -= n7
+	i = encodeVarintParams(dAtA, i, uint64(n7))
+	i--
+	dAtA[i] = 0x12
+	n8, err8 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.MessageDelay, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.MessageDelay):])
+	if err8 != nil {
+		return 0, err8
+	}
+	i -= n8
+	i = encodeVarintParams(dAtA, i, uint64(n8))
+	i--
+	dAtA[i] = 0xa
+	return len(dAtA) - i, nil
+}
+
 func encodeVarintParams(dAtA []byte, offset int, v uint64) int {
 	offset -= sovParams(v)
 	base := offset
@@ -861,6 +1006,10 @@ func (m *ConsensusParams) Size() (n int) {
 		l = m.Version.Size()
 		n += 1 + l + sovParams(uint64(l))
 	}
+	if m.Timing != nil {
+		l = m.Timing.Size()
+		n += 1 + l + sovParams(uint64(l))
+	}
 	return n
 }

@@ -938,6 +1087,19 @@ func (m *HashedParams) Size() (n int) {
 	return n
 }

+func (m *TimingParams) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.MessageDelay)
+	n += 1 + l + sovParams(uint64(l))
+	l = github_com_gogo_protobuf_types.SizeOfStdDuration(m.Precision)
+	n += 1 + l + sovParams(uint64(l))
+	return n
+}
+
 func sovParams(x uint64) (n int) {
 	return (math_bits.Len64(x|1) + 6) / 7
 }
@@ -1117,6 +1279,42 @@ 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 Timing", 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.Timing == nil {
+				m.Timing = &TimingParams{}
+			}
+			if err := m.Timing.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipParams(dAtA[iNdEx:])
@@ -1586,6 +1784,122 @@ func (m *HashedParams) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *TimingParams) 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: TimingParams: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: TimingParams: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			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
+		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
+		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 skipParams(dAtA []byte) (n int, err error) {
 	l := len(dAtA)
 	iNdEx := 0
--- a/types/genesis_test.go
+++ b/types/genesis_test.go
@@ -56,21 +56,26 @@ func TestGenesisBad(t *testing.T) {
 	}
 }

-func TestGenesisGood(t *testing.T) {
+func TestBasicGenesisDoc(t *testing.T) {
 	// test a good one by raw json
 	genDocBytes := []byte(
 		`{
 			"genesis_time": "0001-01-01T00:00:00Z",
 			"chain_id": "test-chain-QDKdJr",
 			"initial_height": "1000",
-			"consensus_params": null,
 			"validators": [{
 				"pub_key":{"type":"tendermint/PubKeyEd25519","value":"AT/+aaL1eB0477Mud9JMm8Sh8BIvOYlPGC9KkIUmFaE="},
 				"power":"10",
 				"name":""
 			}],
 			"app_hash":"",
-			"app_state":{"account_owner": "Bob"}
+			"app_state":{"account_owner": "Bob"},
+			"consensus_params": {
+				"timing":  {"precision": "1", "message_delay": "10"},
+				"validator": {"pub_key_types":["ed25519"]},
+				"block": {"max_bytes": "100"},
+				"evidence": {"max_age_num_blocks": "100", "max_age_duration": "10"}
+			}
 		}`,
 	)
 	_, err := GenesisDocFromJSON(genDocBytes)
@@ -97,12 +102,12 @@ func TestGenesisGood(t *testing.T) {
 	genDocBytes, err = tmjson.Marshal(genDoc)
 	assert.NoError(t, err, "error marshaling genDoc")
 	genDoc, err = GenesisDocFromJSON(genDocBytes)
-	assert.NoError(t, err, "expected no error for valid genDoc json")
+	require.NoError(t, err, "expected no error for valid genDoc json")

 	// test with invalid consensus params
 	genDoc.ConsensusParams.Block.MaxBytes = 0
 	genDocBytes, err = tmjson.Marshal(genDoc)
-	assert.NoError(t, err, "error marshaling genDoc")
+	require.NoError(t, err, "error marshaling genDoc")
 	_, err = GenesisDocFromJSON(genDocBytes)
 	assert.Error(t, err, "expected error for genDoc json with block size of 0")

--- a/types/params.go
+++ b/types/params.go
@@ -41,7 +41,7 @@ type ConsensusParams struct {
 	Evidence  EvidenceParams  `json:"evidence"`
 	Validator ValidatorParams `json:"validator"`
 	Version   VersionParams   `json:"version"`
-	Timestamp TimestampParams `json:"timestamp"`
+	Timing    TimingParams    `json:"timing"`
 }

 // HashedParams is a subset of ConsensusParams.
@@ -76,11 +76,11 @@ type VersionParams struct {
 	AppVersion uint64 `json:"app_version"`
 }

-// TimestampParams influence the validity of block timestamps.
+// TimingParams influence the validity of block timestamps.
 // TODO (@wbanfield): add link to proposer-based timestamp spec when completed.
-type TimestampParams struct {
-	Precision time.Duration `json:"precision"`
-	MsgDelay  time.Duration `json:"msg_delay"`
+type TimingParams struct {
+	Precision    time.Duration `json:"precision"`
+	MessageDelay time.Duration `json:"message_delay"`
 }

 // DefaultConsensusParams returns a default ConsensusParams.
@@ -90,6 +90,7 @@ func DefaultConsensusParams() *ConsensusParams {
 		Evidence:  DefaultEvidenceParams(),
 		Validator: DefaultValidatorParams(),
 		Version:   DefaultVersionParams(),
+		Timing:    DefaultTimingParams(),
 	}
 }

@@ -124,12 +125,12 @@ func DefaultVersionParams() VersionParams {
 	}
 }

-func DefaultTimestampParams() TimestampParams {
+func DefaultTimingParams() TimingParams {
 	// TODO(@wbanfield): Determine experimental values for these defaults
 	// https://github.com/tendermint/tendermint/issues/7202
-	return TimestampParams{
-		Precision: 2 * time.Second,
-		MsgDelay:  3 * time.Second,
+	return TimingParams{
+		Precision:    1 * time.Nanosecond,
+		MessageDelay: 1 * time.Nanosecond,
 	}
 }

@@ -165,7 +166,7 @@ func (params ConsensusParams) ValidateConsensusParams() error {
 	}

 	if params.Evidence.MaxAgeDuration <= 0 {
-		return fmt.Errorf("evidence.MaxAgeDuration must be grater than 0 if provided, Got %v",
+		return fmt.Errorf("evidence.MaxAgeDuration must be greater than 0 if provided, Got %v",
 			params.Evidence.MaxAgeDuration)
 	}

@@ -179,6 +180,16 @@ func (params ConsensusParams) ValidateConsensusParams() error {
 			params.Evidence.MaxBytes)
 	}

+	if params.Timing.MessageDelay <= 0 {
+		return fmt.Errorf("timing.MessageDelay must be greater than 0. Got: %d",
+			params.Timing.MessageDelay)
+	}
+
+	if params.Timing.Precision <= 0 {
+		return fmt.Errorf("timing.Precision must be greater than 0. Got: %d",
+			params.Timing.Precision)
+	}
+
 	if len(params.Validator.PubKeyTypes) == 0 {
 		return errors.New("len(Validator.PubKeyTypes) must be greater than 0")
 	}
@@ -222,6 +233,8 @@ func (params ConsensusParams) HashConsensusParams() []byte {
 func (params *ConsensusParams) Equals(params2 *ConsensusParams) bool {
 	return params.Block == params2.Block &&
 		params.Evidence == params2.Evidence &&
+		params.Version == params2.Version &&
+		params.Timing == params2.Timing &&
 		tmstrings.StringSliceEqual(params.Validator.PubKeyTypes, params2.Validator.PubKeyTypes)
 }

@@ -252,6 +265,10 @@ func (params ConsensusParams) UpdateConsensusParams(params2 *tmproto.ConsensusPa
 	if params2.Version != nil {
 		res.Version.AppVersion = params2.Version.AppVersion
 	}
+	if params2.Timing != nil {
+		res.Timing.Precision = params2.Timing.Precision
+		res.Timing.MessageDelay = params2.Timing.MessageDelay
+	}
 	return res
 }

@@ -272,6 +289,10 @@ func (params *ConsensusParams) ToProto() tmproto.ConsensusParams {
 		Version: &tmproto.VersionParams{
 			AppVersion: params.Version.AppVersion,
 		},
+		Timing: &tmproto.TimingParams{
+			MessageDelay: params.Timing.MessageDelay,
+			Precision:    params.Timing.Precision,
+		},
 	}
 }

@@ -292,5 +313,9 @@ func ConsensusParamsFromProto(pbParams tmproto.ConsensusParams) ConsensusParams
 		Version: VersionParams{
 			AppVersion: pbParams.Version.AppVersion,
 		},
+		Timing: TimingParams{
+			MessageDelay: pbParams.Timing.MessageDelay,
+			Precision:    pbParams.Timing.Precision,
+		},
 	}
 }
--- a/types/params_test.go
+++ b/types/params_test.go
@@ -23,23 +23,140 @@ func TestConsensusParamsValidation(t *testing.T) {
 		valid  bool
 	}{
 		// test block params
-		0: {makeParams(1, 0, 2, 0, valEd25519), true},
-		1: {makeParams(0, 0, 2, 0, valEd25519), false},
-		2: {makeParams(47*1024*1024, 0, 2, 0, valEd25519), true},
-		3: {makeParams(10, 0, 2, 0, valEd25519), true},
-		4: {makeParams(100*1024*1024, 0, 2, 0, valEd25519), true},
-		5: {makeParams(101*1024*1024, 0, 2, 0, valEd25519), false},
-		6: {makeParams(1024*1024*1024, 0, 2, 0, valEd25519), false},
-		7: {makeParams(1024*1024*1024, 0, -1, 0, valEd25519), false},
+		{
+			params: makeParams(makeParamsArgs{
+				blockBytes:   1,
+				evidenceAge:  2,
+				precision:    1,
+				messageDelay: 1}),
+			valid: true,
+		},
+		{
+			params: makeParams(makeParamsArgs{
+				blockBytes:   0,
+				evidenceAge:  2,
+				precision:    1,
+				messageDelay: 1}),
+			valid: false,
+		},
+		{
+			params: makeParams(makeParamsArgs{
+				blockBytes:   47 * 1024 * 1024,
+				evidenceAge:  2,
+				precision:    1,
+				messageDelay: 1}),
+			valid: true,
+		},
+		{
+			params: makeParams(makeParamsArgs{
+				blockBytes:   10,
+				evidenceAge:  2,
+				precision:    1,
+				messageDelay: 1}),
+			valid: true,
+		},
+		{
+			params: makeParams(makeParamsArgs{
+				blockBytes:   100 * 1024 * 1024,
+				evidenceAge:  2,
+				precision:    1,
+				messageDelay: 1}),
+			valid: true,
+		},
+		{
+			params: makeParams(makeParamsArgs{
+				blockBytes:   101 * 1024 * 1024,
+				evidenceAge:  2,
+				precision:    1,
+				messageDelay: 1}),
+			valid: false,
+		},
+		{
+			params: makeParams(makeParamsArgs{
+				blockBytes:   1024 * 1024 * 1024,
+				evidenceAge:  2,
+				precision:    1,
+				messageDelay: 1}),
+			valid: false,
+		},
+		{
+			params: makeParams(makeParamsArgs{
+				blockBytes:   1024 * 1024 * 1024,
+				evidenceAge:  2,
+				precision:    1,
+				messageDelay: 1}),
+			valid: false,
+		},
 		// test evidence params
-		8:  {makeParams(1, 0, 0, 0, valEd25519), false},
-		9:  {makeParams(1, 0, 2, 2, valEd25519), false},
-		10: {makeParams(1000, 0, 2, 1, valEd25519), true},
-		11: {makeParams(1, 0, -1, 0, valEd25519), false},
+		{
+			params: makeParams(makeParamsArgs{
+				blockBytes:       1,
+				evidenceAge:      0,
+				maxEvidenceBytes: 0,
+				precision:        1,
+				messageDelay:     1}),
+			valid: false,
+		},
+		{
+			params: makeParams(makeParamsArgs{
+				blockBytes:       1,
+				evidenceAge:      2,
+				maxEvidenceBytes: 2,
+				precision:        1,
+				messageDelay:     1}),
+			valid: false,
+		},
+		{
+			params: makeParams(makeParamsArgs{
+				blockBytes:       1000,
+				evidenceAge:      2,
+				maxEvidenceBytes: 1,
+				precision:        1,
+				messageDelay:     1}),
+			valid: true,
+		},
+		{
+			params: makeParams(makeParamsArgs{
+				blockBytes:       1,
+				evidenceAge:      -1,
+				maxEvidenceBytes: 0,
+				precision:        1,
+				messageDelay:     1}),
+			valid: false,
+		},
 		// test no pubkey type provided
-		12: {makeParams(1, 0, 2, 0, []string{}), false},
+		{
+			params: makeParams(makeParamsArgs{
+				evidenceAge:  2,
+				pubkeyTypes:  []string{},
+				precision:    1,
+				messageDelay: 1}),
+			valid: false,
+		},
 		// test invalid pubkey type provided
-		13: {makeParams(1, 0, 2, 0, []string{"potatoes make good pubkeys"}), false},
+		{
+			params: makeParams(makeParamsArgs{
+				evidenceAge:  2,
+				pubkeyTypes:  []string{"potatoes make good pubkeys"},
+				precision:    1,
+				messageDelay: 1}),
+			valid: false,
+		},
+		// test invalid pubkey type provided
+		{
+			params: makeParams(makeParamsArgs{
+				evidenceAge:  2,
+				precision:    1,
+				messageDelay: -1}),
+			valid: false,
+		},
+		{
+			params: makeParams(makeParamsArgs{
+				evidenceAge:  2,
+				precision:    -1,
+				messageDelay: 1}),
+			valid: false,
+		},
 	}
 	for i, tc := range testCases {
 		if tc.valid {
@@ -50,38 +167,51 @@ func TestConsensusParamsValidation(t *testing.T) {
 	}
 }

-func makeParams(
-	blockBytes, blockGas int64,
-	evidenceAge int64,
-	maxEvidenceBytes int64,
-	pubkeyTypes []string,
-) ConsensusParams {
+type makeParamsArgs struct {
+	blockBytes       int64
+	blockGas         int64
+	evidenceAge      int64
+	maxEvidenceBytes int64
+	pubkeyTypes      []string
+	precision        time.Duration
+	messageDelay     time.Duration
+}
+
+func makeParams(args makeParamsArgs) ConsensusParams {
+	if args.pubkeyTypes == nil {
+		args.pubkeyTypes = valEd25519
+	}
 	return ConsensusParams{
 		Block: BlockParams{
-			MaxBytes: blockBytes,
-			MaxGas:   blockGas,
+			MaxBytes: args.blockBytes,
+			MaxGas:   args.blockGas,
 		},
 		Evidence: EvidenceParams{
-			MaxAgeNumBlocks: evidenceAge,
-			MaxAgeDuration:  time.Duration(evidenceAge),
-			MaxBytes:        maxEvidenceBytes,
+			MaxAgeNumBlocks: args.evidenceAge,
+			MaxAgeDuration:  time.Duration(args.evidenceAge),
+			MaxBytes:        args.maxEvidenceBytes,
 		},
 		Validator: ValidatorParams{
-			PubKeyTypes: pubkeyTypes,
+			PubKeyTypes: args.pubkeyTypes,
+		},
+		Timing: TimingParams{
+			Precision:    args.precision,
+			MessageDelay: args.messageDelay,
 		},
 	}
+
 }

 func TestConsensusParamsHash(t *testing.T) {
 	params := []ConsensusParams{
-		makeParams(4, 2, 3, 1, valEd25519),
-		makeParams(1, 4, 3, 1, valEd25519),
-		makeParams(1, 2, 4, 1, valEd25519),
-		makeParams(2, 5, 7, 1, valEd25519),
-		makeParams(1, 7, 6, 1, valEd25519),
-		makeParams(9, 5, 4, 1, valEd25519),
-		makeParams(7, 8, 9, 1, valEd25519),
-		makeParams(4, 6, 5, 1, valEd25519),
+		makeParams(makeParamsArgs{blockBytes: 4, blockGas: 2, evidenceAge: 3, maxEvidenceBytes: 1}),
+		makeParams(makeParamsArgs{blockBytes: 1, blockGas: 4, evidenceAge: 3, maxEvidenceBytes: 1}),
+		makeParams(makeParamsArgs{blockBytes: 1, blockGas: 2, evidenceAge: 4, maxEvidenceBytes: 1}),
+		makeParams(makeParamsArgs{blockBytes: 2, blockGas: 5, evidenceAge: 7, maxEvidenceBytes: 1}),
+		makeParams(makeParamsArgs{blockBytes: 1, blockGas: 7, evidenceAge: 6, maxEvidenceBytes: 1}),
+		makeParams(makeParamsArgs{blockBytes: 9, blockGas: 5, evidenceAge: 4, maxEvidenceBytes: 1}),
+		makeParams(makeParamsArgs{blockBytes: 7, blockGas: 8, evidenceAge: 9, maxEvidenceBytes: 1}),
+		makeParams(makeParamsArgs{blockBytes: 4, blockGas: 6, evidenceAge: 5, maxEvidenceBytes: 1}),
 	}

 	hashes := make([][]byte, len(params))
@@ -101,20 +231,31 @@ func TestConsensusParamsHash(t *testing.T) {

 func TestConsensusParamsUpdate(t *testing.T) {
 	testCases := []struct {
-		params        ConsensusParams
+		intialParams  ConsensusParams
 		updates       *tmproto.ConsensusParams
 		updatedParams ConsensusParams
 	}{
 		// empty updates
 		{
-			makeParams(1, 2, 3, 0, valEd25519),
-			&tmproto.ConsensusParams{},
-			makeParams(1, 2, 3, 0, valEd25519),
+			intialParams:  makeParams(makeParamsArgs{blockBytes: 1, blockGas: 2, evidenceAge: 3}),
+			updates:       &tmproto.ConsensusParams{},
+			updatedParams: makeParams(makeParamsArgs{blockBytes: 1, blockGas: 2, evidenceAge: 3}),
+		},
+		{
+			// update timing params
+			intialParams: makeParams(makeParamsArgs{evidenceAge: 3, precision: time.Second, messageDelay: 3 * time.Second}),
+			updates: &tmproto.ConsensusParams{
+				Timing: &tmproto.TimingParams{
+					Precision:    time.Second * 2,
+					MessageDelay: time.Second * 4,
+				},
+			},
+			updatedParams: makeParams(makeParamsArgs{evidenceAge: 3, precision: 2 * time.Second, messageDelay: 4 * time.Second}),
 		},
 		// fine updates
 		{
-			makeParams(1, 2, 3, 0, valEd25519),
-			&tmproto.ConsensusParams{
+			intialParams: makeParams(makeParamsArgs{blockBytes: 1, blockGas: 2, evidenceAge: 3}),
+			updates: &tmproto.ConsensusParams{
 				Block: &tmproto.BlockParams{
 					MaxBytes: 100,
 					MaxGas:   200,
@@ -128,11 +269,15 @@ func TestConsensusParamsUpdate(t *testing.T) {
 					PubKeyTypes: valSecp256k1,
 				},
 			},
-			makeParams(100, 200, 300, 50, valSecp256k1),
+			updatedParams: makeParams(makeParamsArgs{
+				blockBytes: 100, blockGas: 200,
+				evidenceAge:      300,
+				maxEvidenceBytes: 50,
+				pubkeyTypes:      valSecp256k1}),
 		},
 		{
-			makeParams(1, 2, 3, 0, valEd25519),
-			&tmproto.ConsensusParams{
+			intialParams: makeParams(makeParamsArgs{blockBytes: 1, blockGas: 2, evidenceAge: 3}),
+			updates: &tmproto.ConsensusParams{
 				Block: &tmproto.BlockParams{
 					MaxBytes: 100,
 					MaxGas:   200,
@@ -145,17 +290,23 @@ func TestConsensusParamsUpdate(t *testing.T) {
 				Validator: &tmproto.ValidatorParams{
 					PubKeyTypes: valSr25519,
 				},
-			}, makeParams(100, 200, 300, 50, valSr25519),
+			},
+			updatedParams: makeParams(makeParamsArgs{
+				blockBytes:       100,
+				blockGas:         200,
+				evidenceAge:      300,
+				maxEvidenceBytes: 50,
+				pubkeyTypes:      valSr25519}),
 		},
 	}

 	for _, tc := range testCases {
-		assert.Equal(t, tc.updatedParams, tc.params.UpdateConsensusParams(tc.updates))
+		assert.Equal(t, tc.updatedParams, tc.intialParams.UpdateConsensusParams(tc.updates))
 	}
 }

 func TestConsensusParamsUpdate_AppVersion(t *testing.T) {
-	params := makeParams(1, 2, 3, 0, valEd25519)
+	params := makeParams(makeParamsArgs{blockBytes: 1, blockGas: 2, evidenceAge: 3})

 	assert.EqualValues(t, 0, params.Version.AppVersion)

@@ -167,14 +318,16 @@ func TestConsensusParamsUpdate_AppVersion(t *testing.T) {

 func TestProto(t *testing.T) {
 	params := []ConsensusParams{
-		makeParams(4, 2, 3, 1, valEd25519),
-		makeParams(1, 4, 3, 1, valEd25519),
-		makeParams(1, 2, 4, 1, valEd25519),
-		makeParams(2, 5, 7, 1, valEd25519),
-		makeParams(1, 7, 6, 1, valEd25519),
-		makeParams(9, 5, 4, 1, valEd25519),
-		makeParams(7, 8, 9, 1, valEd25519),
-		makeParams(4, 6, 5, 1, valEd25519),
+		makeParams(makeParamsArgs{blockBytes: 4, blockGas: 2, evidenceAge: 3, maxEvidenceBytes: 1}),
+		makeParams(makeParamsArgs{blockBytes: 1, blockGas: 4, evidenceAge: 3, maxEvidenceBytes: 1}),
+		makeParams(makeParamsArgs{blockBytes: 1, blockGas: 2, evidenceAge: 4, maxEvidenceBytes: 1}),
+		makeParams(makeParamsArgs{blockBytes: 2, blockGas: 5, evidenceAge: 7, maxEvidenceBytes: 1}),
+		makeParams(makeParamsArgs{blockBytes: 1, blockGas: 7, evidenceAge: 6, maxEvidenceBytes: 1}),
+		makeParams(makeParamsArgs{blockBytes: 9, blockGas: 5, evidenceAge: 4, maxEvidenceBytes: 1}),
+		makeParams(makeParamsArgs{blockBytes: 7, blockGas: 8, evidenceAge: 9, maxEvidenceBytes: 1}),
+		makeParams(makeParamsArgs{blockBytes: 4, blockGas: 6, evidenceAge: 5, maxEvidenceBytes: 1}),
+		makeParams(makeParamsArgs{precision: time.Second, messageDelay: time.Minute}),
+		makeParams(makeParamsArgs{precision: time.Nanosecond, messageDelay: time.Millisecond}),
 	}

 	for i := range params {
--- a/types/proposal.go
+++ b/types/proposal.go
@@ -88,10 +88,10 @@ func (p *Proposal) ValidateBasic() error {
 //
 // For more information on the meaning of 'timely', see the proposer-based timestamp specification:
 // https://github.com/tendermint/spec/tree/master/spec/consensus/proposer-based-timestamp
-func (p *Proposal) IsTimely(clock tmtime.Source, tp TimestampParams) bool {
+func (p *Proposal) IsTimely(clock tmtime.Source, tp TimingParams) bool {
 	lt := clock.Now()
 	lhs := lt.Add(-tp.Precision)
-	rhs := lt.Add(tp.Precision).Add(tp.MsgDelay)
+	rhs := lt.Add(tp.Precision).Add(tp.MessageDelay)
 	if lhs.Before(p.Timestamp) && rhs.After(p.Timestamp) {
 		return true
 	}
--- a/types/proposal_test.go
+++ b/types/proposal_test.go
@@ -241,9 +241,9 @@ func TestIsTimely(t *testing.T) {
 				Timestamp: testCase.proposalTime,
 			}

-			tp := TimestampParams{
-				Precision: testCase.precision,
-				MsgDelay:  testCase.msgDelay,
+			tp := TimingParams{
+				Precision:    testCase.precision,
+				MessageDelay: testCase.msgDelay,
 			}

 			mockSource := new(tmtimemocks.Source)