You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
185 lines
5.6 KiB
185 lines
5.6 KiB
package types
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"time"
|
|
|
|
abci "github.com/tendermint/tendermint/abci/types"
|
|
"github.com/tendermint/tendermint/crypto/tmhash"
|
|
tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
|
|
)
|
|
|
|
const (
|
|
// MaxBlockSizeBytes is the maximum permitted size of the blocks.
|
|
MaxBlockSizeBytes = 104857600 // 100MB
|
|
|
|
// BlockPartSizeBytes is the size of one block part.
|
|
BlockPartSizeBytes uint32 = 65536 // 64kB
|
|
|
|
// MaxBlockPartsCount is the maximum number of block parts.
|
|
MaxBlockPartsCount = (MaxBlockSizeBytes / BlockPartSizeBytes) + 1
|
|
|
|
// Restrict the upper bound of the amount of evidence (uses uint16 for safe conversion)
|
|
MaxEvidencePerBlock = 65535
|
|
)
|
|
|
|
// DefaultConsensusParams returns a default ConsensusParams.
|
|
func DefaultConsensusParams() *tmproto.ConsensusParams {
|
|
return &tmproto.ConsensusParams{
|
|
Block: DefaultBlockParams(),
|
|
Evidence: DefaultEvidenceParams(),
|
|
Validator: DefaultValidatorParams(),
|
|
Version: DefaultVersionParams(),
|
|
}
|
|
}
|
|
|
|
// DefaultBlockParams returns a default BlockParams.
|
|
func DefaultBlockParams() tmproto.BlockParams {
|
|
return tmproto.BlockParams{
|
|
MaxBytes: 22020096, // 21MB
|
|
MaxGas: -1,
|
|
TimeIotaMs: 1000, // 1s
|
|
}
|
|
}
|
|
|
|
// DefaultEvidenceParams returns a default EvidenceParams.
|
|
func DefaultEvidenceParams() tmproto.EvidenceParams {
|
|
return tmproto.EvidenceParams{
|
|
MaxAgeNumBlocks: 100000, // 27.8 hrs at 1block/s
|
|
MaxAgeDuration: 48 * time.Hour,
|
|
MaxNum: 50,
|
|
}
|
|
}
|
|
|
|
// DefaultValidatorParams returns a default ValidatorParams, which allows
|
|
// only ed25519 pubkeys.
|
|
func DefaultValidatorParams() tmproto.ValidatorParams {
|
|
return tmproto.ValidatorParams{
|
|
PubKeyTypes: []string{ABCIPubKeyTypeEd25519},
|
|
}
|
|
}
|
|
|
|
func DefaultVersionParams() tmproto.VersionParams {
|
|
return tmproto.VersionParams{
|
|
AppVersion: 0,
|
|
}
|
|
}
|
|
|
|
func IsValidPubkeyType(params tmproto.ValidatorParams, pubkeyType string) bool {
|
|
for i := 0; i < len(params.PubKeyTypes); i++ {
|
|
if params.PubKeyTypes[i] == pubkeyType {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
// Validate validates the ConsensusParams to ensure all values are within their
|
|
// allowed limits, and returns an error if they are not.
|
|
func ValidateConsensusParams(params tmproto.ConsensusParams) error {
|
|
if params.Block.MaxBytes <= 0 {
|
|
return fmt.Errorf("block.MaxBytes must be greater than 0. Got %d",
|
|
params.Block.MaxBytes)
|
|
}
|
|
if params.Block.MaxBytes > MaxBlockSizeBytes {
|
|
return fmt.Errorf("block.MaxBytes is too big. %d > %d",
|
|
params.Block.MaxBytes, MaxBlockSizeBytes)
|
|
}
|
|
|
|
if params.Block.MaxGas < -1 {
|
|
return fmt.Errorf("block.MaxGas must be greater or equal to -1. Got %d",
|
|
params.Block.MaxGas)
|
|
}
|
|
|
|
if params.Block.TimeIotaMs <= 0 {
|
|
return fmt.Errorf("block.TimeIotaMs must be greater than 0. Got %v",
|
|
params.Block.TimeIotaMs)
|
|
}
|
|
|
|
if params.Evidence.MaxAgeNumBlocks <= 0 {
|
|
return fmt.Errorf("evidenceParams.MaxAgeNumBlocks must be greater than 0. Got %d",
|
|
params.Evidence.MaxAgeNumBlocks)
|
|
}
|
|
|
|
if params.Evidence.MaxAgeDuration <= 0 {
|
|
return fmt.Errorf("evidenceParams.MaxAgeDuration must be grater than 0 if provided, Got %v",
|
|
params.Evidence.MaxAgeDuration)
|
|
}
|
|
|
|
if params.Evidence.MaxNum > MaxEvidencePerBlock {
|
|
return fmt.Errorf("evidenceParams.MaxNumEvidence is greater than upper bound, %d > %d",
|
|
params.Evidence.MaxNum, MaxEvidencePerBlock)
|
|
}
|
|
|
|
if int64(params.Evidence.MaxNum)*MaxEvidenceBytes > params.Block.MaxBytes {
|
|
return fmt.Errorf("total possible evidence size is bigger than block.MaxBytes, %d > %d",
|
|
int64(params.Evidence.MaxNum)*MaxEvidenceBytes, params.Block.MaxBytes)
|
|
}
|
|
|
|
if len(params.Validator.PubKeyTypes) == 0 {
|
|
return errors.New("len(Validator.PubKeyTypes) must be greater than 0")
|
|
}
|
|
|
|
// Check if keyType is a known ABCIPubKeyType
|
|
for i := 0; i < len(params.Validator.PubKeyTypes); i++ {
|
|
keyType := params.Validator.PubKeyTypes[i]
|
|
if _, ok := ABCIPubKeyTypesToNames[keyType]; !ok {
|
|
return fmt.Errorf("params.Validator.PubKeyTypes[%d], %s, is an unknown pubkey type",
|
|
i, keyType)
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// Hash returns a hash of a subset of the parameters to store in the block header.
|
|
// Only the Block.MaxBytes and Block.MaxGas are included in the hash.
|
|
// This allows the ConsensusParams to evolve more without breaking the block
|
|
// protocol. No need for a Merkle tree here, just a small struct to hash.
|
|
func HashConsensusParams(params tmproto.ConsensusParams) []byte {
|
|
hasher := tmhash.New()
|
|
|
|
hp := tmproto.HashedParams{
|
|
BlockMaxBytes: params.Block.MaxBytes,
|
|
BlockMaxGas: params.Block.MaxGas,
|
|
}
|
|
|
|
bz, err := hp.Marshal()
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
hasher.Write(bz)
|
|
return hasher.Sum(nil)
|
|
}
|
|
|
|
// Update returns a copy of the params with updates from the non-zero fields of p2.
|
|
// NOTE: note: must not modify the original
|
|
func UpdateConsensusParams(params tmproto.ConsensusParams, params2 *abci.ConsensusParams) tmproto.ConsensusParams {
|
|
res := params // explicit copy
|
|
|
|
if params2 == nil {
|
|
return res
|
|
}
|
|
|
|
// we must defensively consider any structs may be nil
|
|
if params2.Block != nil {
|
|
res.Block.MaxBytes = params2.Block.MaxBytes
|
|
res.Block.MaxGas = params2.Block.MaxGas
|
|
}
|
|
if params2.Evidence != nil {
|
|
res.Evidence.MaxAgeNumBlocks = params2.Evidence.MaxAgeNumBlocks
|
|
res.Evidence.MaxAgeDuration = params2.Evidence.MaxAgeDuration
|
|
res.Evidence.MaxNum = params2.Evidence.MaxNum
|
|
}
|
|
if params2.Validator != nil {
|
|
// Copy params2.Validator.PubkeyTypes, and set result's value to the copy.
|
|
// This avoids having to initialize the slice to 0 values, and then write to it again.
|
|
res.Validator.PubKeyTypes = append([]string{}, params2.Validator.PubKeyTypes...)
|
|
}
|
|
if params2.Version != nil {
|
|
res.Version.AppVersion = params2.Version.AppVersion
|
|
}
|
|
return res
|
|
}
|