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/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(), } } // DefaultBlockParams returns a default BlockParams. func DefaultBlockParams() tmproto.BlockParams { return tmproto.BlockParams{ MaxBytes: 22020096, // 21MB MaxGas: -1, TimeIotaMs: 1000, // 1s } } // DefaultEvidenceParams Params 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 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 := ABCIPubKeyTypesToAminoNames[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...) } return res }