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.
214 lines
6.7 KiB
214 lines
6.7 KiB
package types
|
|
|
|
import (
|
|
"time"
|
|
|
|
"github.com/pkg/errors"
|
|
|
|
abci "github.com/tendermint/tendermint/abci/types"
|
|
"github.com/tendermint/tendermint/crypto/tmhash"
|
|
tmstrings "github.com/tendermint/tendermint/libs/strings"
|
|
)
|
|
|
|
const (
|
|
// MaxBlockSizeBytes is the maximum permitted size of the blocks.
|
|
MaxBlockSizeBytes = 104857600 // 100MB
|
|
|
|
// BlockPartSizeBytes is the size of one block part.
|
|
BlockPartSizeBytes = 65536 // 64kB
|
|
|
|
// MaxBlockPartsCount is the maximum number of block parts.
|
|
MaxBlockPartsCount = (MaxBlockSizeBytes / BlockPartSizeBytes) + 1
|
|
)
|
|
|
|
// ConsensusParams contains consensus critical parameters that determine the
|
|
// validity of blocks.
|
|
type ConsensusParams struct {
|
|
Block BlockParams `json:"block"`
|
|
Evidence EvidenceParams `json:"evidence"`
|
|
Validator ValidatorParams `json:"validator"`
|
|
}
|
|
|
|
// HashedParams is a subset of ConsensusParams.
|
|
// It is amino encoded and hashed into the Header.ConsensusHash.
|
|
type HashedParams struct {
|
|
BlockMaxBytes int64
|
|
BlockMaxGas int64
|
|
}
|
|
|
|
// BlockParams defines limits on the block size and gas plus minimum time
|
|
// between blocks.
|
|
type BlockParams struct {
|
|
MaxBytes int64 `json:"max_bytes"`
|
|
MaxGas int64 `json:"max_gas"`
|
|
// Minimum time increment between consecutive blocks (in milliseconds)
|
|
// Not exposed to the application.
|
|
TimeIotaMs int64 `json:"time_iota_ms"`
|
|
}
|
|
|
|
// EvidenceParams determines how we handle evidence of malfeasance.
|
|
//
|
|
// Evidence older than MaxAgeNumBlocks && MaxAgeDuration is considered
|
|
// stale and ignored.
|
|
//
|
|
// In Cosmos-SDK based blockchains, MaxAgeDuration is usually equal to the
|
|
// unbonding period. MaxAgeNumBlocks is calculated by dividing the unboding
|
|
// period by the average block time (e.g. 2 weeks / 6s per block = 2d8h).
|
|
type EvidenceParams struct {
|
|
// Max age of evidence, in blocks.
|
|
//
|
|
// The basic formula for calculating this is: MaxAgeDuration / {average block
|
|
// time}.
|
|
MaxAgeNumBlocks int64 `json:"max_age_num_blocks"`
|
|
|
|
// Max age of evidence, in time.
|
|
//
|
|
// It should correspond with an app's "unbonding period" or other similar
|
|
// mechanism for handling [Nothing-At-Stake
|
|
// attacks](https://github.com/ethereum/wiki/wiki/Proof-of-Stake-FAQ#what-is-the-nothing-at-stake-problem-and-how-can-it-be-fixed).
|
|
MaxAgeDuration time.Duration `json:"max_age_duration"`
|
|
}
|
|
|
|
// ValidatorParams restrict the public key types validators can use.
|
|
// NOTE: uses ABCI pubkey naming, not Amino names.
|
|
type ValidatorParams struct {
|
|
PubKeyTypes []string `json:"pub_key_types"`
|
|
}
|
|
|
|
// DefaultConsensusParams returns a default ConsensusParams.
|
|
func DefaultConsensusParams() *ConsensusParams {
|
|
return &ConsensusParams{
|
|
DefaultBlockParams(),
|
|
DefaultEvidenceParams(),
|
|
DefaultValidatorParams(),
|
|
}
|
|
}
|
|
|
|
// DefaultBlockParams returns a default BlockParams.
|
|
func DefaultBlockParams() BlockParams {
|
|
return BlockParams{
|
|
MaxBytes: 22020096, // 21MB
|
|
MaxGas: -1,
|
|
TimeIotaMs: 1000, // 1s
|
|
}
|
|
}
|
|
|
|
// DefaultEvidenceParams returns a default EvidenceParams.
|
|
func DefaultEvidenceParams() EvidenceParams {
|
|
return EvidenceParams{
|
|
MaxAgeNumBlocks: 100000, // 27.8 hrs at 1block/s
|
|
MaxAgeDuration: 48 * time.Hour,
|
|
}
|
|
}
|
|
|
|
// DefaultValidatorParams returns a default ValidatorParams, which allows
|
|
// only ed25519 pubkeys.
|
|
func DefaultValidatorParams() ValidatorParams {
|
|
return ValidatorParams{[]string{ABCIPubKeyTypeEd25519}}
|
|
}
|
|
|
|
func (params *ValidatorParams) IsValidPubkeyType(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 (params *ConsensusParams) Validate() error {
|
|
if params.Block.MaxBytes <= 0 {
|
|
return errors.Errorf("block.MaxBytes must be greater than 0. Got %d",
|
|
params.Block.MaxBytes)
|
|
}
|
|
if params.Block.MaxBytes > MaxBlockSizeBytes {
|
|
return errors.Errorf("block.MaxBytes is too big. %d > %d",
|
|
params.Block.MaxBytes, MaxBlockSizeBytes)
|
|
}
|
|
|
|
if params.Block.MaxGas < -1 {
|
|
return errors.Errorf("block.MaxGas must be greater or equal to -1. Got %d",
|
|
params.Block.MaxGas)
|
|
}
|
|
|
|
if params.Block.TimeIotaMs <= 0 {
|
|
return errors.Errorf("block.TimeIotaMs must be greater than 0. Got %v",
|
|
params.Block.TimeIotaMs)
|
|
}
|
|
|
|
if params.Evidence.MaxAgeNumBlocks <= 0 {
|
|
return errors.Errorf("evidenceParams.MaxAgeNumBlocks must be greater than 0. Got %d",
|
|
params.Evidence.MaxAgeNumBlocks)
|
|
}
|
|
|
|
if params.Evidence.MaxAgeDuration <= 0 {
|
|
return errors.Errorf("evidenceParams.MaxAgeDuration must be grater than 0 if provided, Got %v",
|
|
params.Evidence.MaxAgeDuration)
|
|
}
|
|
|
|
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 errors.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 (params *ConsensusParams) Hash() []byte {
|
|
hasher := tmhash.New()
|
|
bz := cdcEncode(HashedParams{
|
|
params.Block.MaxBytes,
|
|
params.Block.MaxGas,
|
|
})
|
|
if bz == nil {
|
|
panic("cannot fail to encode ConsensusParams")
|
|
}
|
|
hasher.Write(bz)
|
|
return hasher.Sum(nil)
|
|
}
|
|
|
|
func (params *ConsensusParams) Equals(params2 *ConsensusParams) bool {
|
|
return params.Block == params2.Block &&
|
|
params.Evidence == params2.Evidence &&
|
|
tmstrings.StringSliceEqual(params.Validator.PubKeyTypes, params2.Validator.PubKeyTypes)
|
|
}
|
|
|
|
// Update returns a copy of the params with updates from the non-zero fields of p2.
|
|
// NOTE: note: must not modify the original
|
|
func (params ConsensusParams) Update(params2 *abci.ConsensusParams) 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
|
|
}
|
|
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
|
|
}
|