types: add TimeoutParams into ConsensusParams structs (#8177)

types/genesis_test.go

@@ -72,6 +72,14 @@ func TestBasicGenesisDoc(t *testing.T) {
 			"app_state":{"account_owner": "Bob"},
 			"consensus_params": {
 				"synchrony":  {"precision": "1", "message_delay": "10"},
+				"timeout": {
+					"propose": "30000000000",
+					"propose_delta": "50000000",
+					"vote": "30000000000",
+					"vote_delta": "50000000",
+					"commit": "10000000000",
+					"bypass_commit_timeout": false
+				},
 				"validator": {"pub_key_types":["ed25519"]},
 				"block": {"max_bytes": "100"},
 				"evidence": {"max_age_num_blocks": "100", "max_age_duration": "10"}

types/params.go

@@ -42,6 +42,7 @@ type ConsensusParams struct {
 	Validator ValidatorParams `json:"validator"`
 	Version   VersionParams   `json:"version"`
 	Synchrony SynchronyParams `json:"synchrony"`
+	Timeout   TimeoutParams   `json:"timeout"`
 }
 
 // HashedParams is a subset of ConsensusParams.
@@ -85,6 +86,16 @@ type SynchronyParams struct {
 	MessageDelay time.Duration `json:"message_delay,string"`
 }
 
+// TimeoutParams configure the timings of the steps of the Tendermint consensus algorithm.
+type TimeoutParams struct {
+	Propose             time.Duration `json:"propose,string"`
+	ProposeDelta        time.Duration `json:"propose_delta,string"`
+	Vote                time.Duration `json:"vote,string"`
+	VoteDelta           time.Duration `json:"vote_delta,string"`
+	Commit              time.Duration `json:"commit,string"`
+	BypassCommitTimeout bool          `json:"bypass_commit_timeout"`
+}
+
 // DefaultConsensusParams returns a default ConsensusParams.
 func DefaultConsensusParams() *ConsensusParams {
 	return &ConsensusParams{
@@ -93,6 +104,7 @@ func DefaultConsensusParams() *ConsensusParams {
 		Validator: DefaultValidatorParams(),
 		Version:   DefaultVersionParams(),
 		Synchrony: DefaultSynchronyParams(),
+		Timeout:   DefaultTimeoutParams(),
 	}
 }
 
@@ -135,6 +147,18 @@ func DefaultSynchronyParams() SynchronyParams {
 		Precision:    505 * time.Millisecond,
 		MessageDelay: 12 * time.Second,
 	}
+
+}
+
+func DefaultTimeoutParams() TimeoutParams {
+	return TimeoutParams{
+		Propose:             3000 * time.Millisecond,
+		ProposeDelta:        500 * time.Millisecond,
+		Vote:                1000 * time.Millisecond,
+		VoteDelta:           500 * time.Millisecond,
+		Commit:              1000 * time.Millisecond,
+		BypassCommitTimeout: false,
+	}
 }
 
 func (val *ValidatorParams) IsValidPubkeyType(pubkeyType string) bool {
@@ -150,6 +174,9 @@ func (params *ConsensusParams) Complete() {
 	if params.Synchrony == (SynchronyParams{}) {
 		params.Synchrony = DefaultSynchronyParams()
 	}
+	if params.Timeout == (TimeoutParams{}) {
+		params.Timeout = DefaultTimeoutParams()
+	}
 }
 
 // Validate validates the ConsensusParams to ensure all values are within their
@@ -199,6 +226,26 @@ func (params ConsensusParams) ValidateConsensusParams() error {
 			params.Synchrony.Precision)
 	}
 
+	if params.Timeout.Propose < 0 {
+		return fmt.Errorf("timeout.ProposeDelta must not be negative. Got: %d", params.Timeout.Propose)
+	}
+
+	if params.Timeout.ProposeDelta < 0 {
+		return fmt.Errorf("timeout.ProposeDelta must not be negative. Got: %d", params.Timeout.ProposeDelta)
+	}
+
+	if params.Timeout.Vote < 0 {
+		return fmt.Errorf("timeout.Vote must not be negative. Got: %d", params.Timeout.Vote)
+	}
+
+	if params.Timeout.VoteDelta < 0 {
+		return fmt.Errorf("timeout.VoteDelta must not be negative. Got: %d", params.Timeout.VoteDelta)
+	}
+
+	if params.Timeout.Commit < 0 {
+		return fmt.Errorf("timeout.Commit must not be negative. Got: %d", params.Timeout.Commit)
+	}
+
 	if len(params.Validator.PubKeyTypes) == 0 {
 		return errors.New("len(Validator.PubKeyTypes) must be greater than 0")
 	}
@@ -244,6 +291,7 @@ func (params *ConsensusParams) Equals(params2 *ConsensusParams) bool {
 		params.Evidence == params2.Evidence &&
 		params.Version == params2.Version &&
 		params.Synchrony == params2.Synchrony &&
+		params.Timeout == params2.Timeout &&
 		tmstrings.StringSliceEqual(params.Validator.PubKeyTypes, params2.Validator.PubKeyTypes)
 }
 
@@ -282,6 +330,24 @@ func (params ConsensusParams) UpdateConsensusParams(params2 *tmproto.ConsensusPa
 			res.Synchrony.Precision = *params2.Synchrony.GetPrecision()
 		}
 	}
+	if params2.Timeout != nil {
+		if params2.Timeout.Propose != nil {
+			res.Timeout.Propose = *params2.Timeout.GetPropose()
+		}
+		if params2.Timeout.ProposeDelta != nil {
+			res.Timeout.ProposeDelta = *params2.Timeout.GetProposeDelta()
+		}
+		if params2.Timeout.Vote != nil {
+			res.Timeout.Vote = *params2.Timeout.GetVote()
+		}
+		if params2.Timeout.VoteDelta != nil {
+			res.Timeout.VoteDelta = *params2.Timeout.GetVoteDelta()
+		}
+		if params2.Timeout.Commit != nil {
+			res.Timeout.Commit = *params2.Timeout.GetCommit()
+		}
+		res.Timeout.BypassCommitTimeout = params2.Timeout.GetBypassCommitTimeout()
+	}
 	return res
 }
 
@@ -306,6 +372,14 @@ func (params *ConsensusParams) ToProto() tmproto.ConsensusParams {
 			MessageDelay: &params.Synchrony.MessageDelay,
 			Precision:    &params.Synchrony.Precision,
 		},
+		Timeout: &tmproto.TimeoutParams{
+			Propose:             &params.Timeout.Propose,
+			ProposeDelta:        &params.Timeout.ProposeDelta,
+			Vote:                &params.Timeout.Vote,
+			VoteDelta:           &params.Timeout.VoteDelta,
+			Commit:              &params.Timeout.Commit,
+			BypassCommitTimeout: params.Timeout.BypassCommitTimeout,
+		},
 	}
 }
 
@@ -335,5 +409,23 @@ func ConsensusParamsFromProto(pbParams tmproto.ConsensusParams) ConsensusParams
 			c.Synchrony.Precision = *pbParams.Synchrony.GetPrecision()
 		}
 	}
+	if pbParams.Timeout != nil {
+		if pbParams.Timeout.Propose != nil {
+			c.Timeout.Propose = *pbParams.Timeout.GetPropose()
+		}
+		if pbParams.Timeout.ProposeDelta != nil {
+			c.Timeout.ProposeDelta = *pbParams.Timeout.GetProposeDelta()
+		}
+		if pbParams.Timeout.Vote != nil {
+			c.Timeout.Vote = *pbParams.Timeout.GetVote()
+		}
+		if pbParams.Timeout.VoteDelta != nil {
+			c.Timeout.VoteDelta = *pbParams.Timeout.GetVoteDelta()
+		}
+		if pbParams.Timeout.Commit != nil {
+			c.Timeout.Commit = *pbParams.Timeout.GetCommit()
+		}
+		c.Timeout.BypassCommitTimeout = pbParams.Timeout.BypassCommitTimeout
+	}
 	return c
 }

types/params_test.go

@@ -168,13 +168,19 @@ func TestConsensusParamsValidation(t *testing.T) {
 }
 
 type makeParamsArgs struct {
-	blockBytes       int64
-	blockGas         int64
-	evidenceAge      int64
-	maxEvidenceBytes int64
-	pubkeyTypes      []string
-	precision        time.Duration
-	messageDelay     time.Duration
+	blockBytes          int64
+	blockGas            int64
+	evidenceAge         int64
+	maxEvidenceBytes    int64
+	pubkeyTypes         []string
+	precision           time.Duration
+	messageDelay        time.Duration
+	propose             time.Duration
+	proposeDelta        time.Duration
+	vote                time.Duration
+	voteDelta           time.Duration
+	commit              time.Duration
+	bypassCommitTimeout bool
 }
 
 func makeParams(args makeParamsArgs) ConsensusParams {
@@ -198,8 +204,15 @@ func makeParams(args makeParamsArgs) ConsensusParams {
 			Precision:    args.precision,
 			MessageDelay: args.messageDelay,
 		},
+		Timeout: TimeoutParams{
+			Propose:             args.propose,
+			ProposeDelta:        args.proposeDelta,
+			Vote:                args.vote,
+			VoteDelta:           args.voteDelta,
+			Commit:              args.commit,
+			BypassCommitTimeout: args.bypassCommitTimeout,
+		},
 	}
-
 }
 
 func TestConsensusParamsHash(t *testing.T) {
@@ -252,6 +265,35 @@ func TestConsensusParamsUpdate(t *testing.T) {
 			},
 			updatedParams: makeParams(makeParamsArgs{evidenceAge: 3, precision: 2 * time.Second, messageDelay: 4 * time.Second}),
 		},
+		{
+			// update timeout params
+			intialParams: makeParams(makeParamsArgs{
+				propose:             3 * time.Second,
+				proposeDelta:        500 * time.Millisecond,
+				vote:                time.Second,
+				voteDelta:           500 * time.Millisecond,
+				commit:              time.Second,
+				bypassCommitTimeout: false,
+			}),
+			updates: &tmproto.ConsensusParams{
+				Timeout: &tmproto.TimeoutParams{
+					Propose:             durationPtr(2 * time.Second),
+					ProposeDelta:        durationPtr(400 * time.Millisecond),
+					Vote:                durationPtr(5 * time.Second),
+					VoteDelta:           durationPtr(400 * time.Millisecond),
+					Commit:              durationPtr(time.Minute),
+					BypassCommitTimeout: true,
+				},
+			},
+			updatedParams: makeParams(makeParamsArgs{
+				propose:             2 * time.Second,
+				proposeDelta:        400 * time.Millisecond,
+				vote:                5 * time.Second,
+				voteDelta:           400 * time.Millisecond,
+				commit:              time.Minute,
+				bypassCommitTimeout: true,
+			}),
+		},
 		// fine updates
 		{
 			intialParams: makeParams(makeParamsArgs{blockBytes: 1, blockGas: 2, evidenceAge: 3}),