state

type BlockExecutor struct {
	// contains filtered or unexported fields
}

type BlockStore interface {
	Base() int64
	Height() int64
	CoreChainLockedHeight() uint32
	Size() int64

	LoadBaseMeta() *types.BlockMeta
	LoadBlockMeta(height int64) *types.BlockMeta
	LoadBlock(height int64) *types.Block

	SaveBlock(block *types.Block, blockParts *types.PartSet, seenCommit *types.Commit)

	PruneBlocks(height int64) (uint64, error)

	LoadBlockByHash(hash []byte) *types.Block
	LoadBlockMetaByHash(hash []byte) *types.BlockMeta
	LoadBlockPart(height int64, index int) *types.Part

	LoadBlockCommit(height int64) *types.Commit
	LoadSeenCommit() *types.Commit
	LoadSeenCommitAt(height int64) *types.Commit
}

type CurrentRoundState struct {
	// Base state for the changes
	Base State

	// Round at which we are right now
	Round int32

	ProTxHash types.ProTxHash

	// AppHash of current block
	AppHash tmbytes.HexBytes `json:"app_hash"`

	// TxResults for current block
	TxResults []*abci.ExecTxResult `json:"tx_results"`
	// ResultsHash of current block
	ResultsHash []byte `json:"results_hash"`

	CoreChainLock *types.CoreChainLock

	NextConsensusParams              types.ConsensusParams
	LastHeightConsensusParamsChanged int64

	NextValidators              *types.ValidatorSet
	LastHeightValidatorsChanged int64

	Params RoundParams
}

type EmptyEvidencePool struct{}

type ErrAppBlockHeightTooHigh struct {
	CoreHeight int64
	AppHeight  int64
}

type ErrAppBlockHeightTooLow struct {
	AppHeight int64
	StoreBase int64
}

type ErrBlockHashMismatch struct {
	CoreHash []byte
	AppHash  []byte
	Height   int64
}

type ErrInvalidBlock struct {
	// contains filtered or unexported fields
}

type ErrLastStateMismatch struct {
	Height int64
	Core   []byte
	App    []byte
}

type ErrNoABCIResponsesForHeight struct {
	Height int64
}

type ErrNoConsensusParamsForHeight struct {
	Height int64
}

type ErrNoFinalizeBlockResponsesForHeight struct {
	Height int64
}

type ErrNoValSetForHeight struct {
	Height int64
	Err    error
}

type ErrProxyAppConn error

type ErrStateMismatch struct {
	Got      *State
	Expected *State
}

type ErrUnknownBlock struct {
	Height int64
}

type EventSet struct {
	NewBlock           *types.EventDataNewBlock
	NewBlockHeader     *types.EventDataNewBlockHeader
	NewEvidence        []types.EventDataNewEvidence
	Txs                []types.EventDataTx
	ValidatorSetUpdate *types.EventDataValidatorSetUpdate
}

type EvidencePool interface {
	PendingEvidence(maxBytes int64) (ev []types.Evidence, size int64)
	AddEvidence(context.Context, types.Evidence) error
	Update(context.Context, State, types.EvidenceList)
	CheckEvidence(context.Context, types.EvidenceList) error
}

type Executor interface {
	VoteExtender
	CreateProposalBlock(
		ctx context.Context,
		height int64,
		round int32,
		state State,
		commit *types.Commit,
		proposerProTxHash []byte,
		proposedAppVersion uint64,
	) (*types.Block, CurrentRoundState, error)

	ProcessProposal(
		ctx context.Context,
		block *types.Block,
		round int32,
		state State,
		verify bool,
		lastCommit types.VerifiedCommit,
	) (CurrentRoundState, error)

	// ValidateBlock, ValidateBlockWithRoundState, FinalizeBlock, ApplyBlock and
	// ProcessProposal (used only when verify is set) take lastCommit,
	// block.LastCommit with the proof of its verification if
	// the caller holds one. The proof spares the threshold verification only
	// when it covers exactly the verification the block's validation would run;
	// anything else, including a VerifiedCommit without proof, is verified in
	// full. block.LastCommit is always what is verified: the commit lastCommit
	// holds is never read in its place.
	ValidateBlock(ctx context.Context, state State, block *types.Block, lastCommit types.VerifiedCommit) error

	// VerifyCommit checks that commit is state.Validators' commit for the block
	// blockID at height. On success it returns commit with the proof of that
	// verification, which the caller can offer back as lastCommit when commit
	// reappears as the next block's LastCommit.
	VerifyCommit(
		state State,
		blockID types.BlockID,
		height int64,
		commit *types.Commit,
	) (types.VerifiedCommit, error)

	ValidateBlockWithRoundState(
		ctx context.Context,
		state State,
		uncommittedState CurrentRoundState,
		block *types.Block,
		lastCommit types.VerifiedCommit,
	) error

	// FinalizeBlock commits the block to the application and returns the new
	// state together with the application's ResponseFinalizeBlock, whose hints
	// that are not part of the state (propose_next_block_immediately) the
	// consensus engine acts on.
	FinalizeBlock(
		ctx context.Context,
		state State,
		uncommittedState CurrentRoundState,
		blockID types.BlockID,
		block *types.Block,
		commit *types.Commit,
		lastCommit types.VerifiedCommit,
	) (State, *abci.ResponseFinalizeBlock, error)

	ApplyBlock(
		ctx context.Context,
		state State,
		blockID types.BlockID,
		block *types.Block,
		commit *types.Commit,
		lastCommit types.VerifiedCommit,
	) (State, error)

	VerifyVoteExtension(ctx context.Context, vote *types.Vote) error
}

type Metrics struct {
	// Time between BeginBlock and EndBlock.
	BlockProcessingTime metrics.Histogram `metrics_buckettype:"lin" metrics_bucketsizes:"1,10,10"`

	// ConsensusParamUpdates is the total number of times the application has
	// udated the consensus params since process start.
	//metrics:Number of consensus parameter updates returned by the application since process start.
	ConsensusParamUpdates metrics.Counter

	// ValidatorSetUpdates is the total number of times the application has
	// udated the validator set since process start.
	//metrics:Number of validator set updates returned by the application since process start.
	ValidatorSetUpdates metrics.Counter

	// LastCommitVerificationSkipped counts the LastCommit threshold verifications
	// that were skipped because VerifyCommit had already verified the identical
	// commit against the identical inputs. During block sync this should track
	// the block rate; in consensus it stays flat.
	//metrics:Number of LastCommit threshold verifications skipped because the same commit was already verified.
	LastCommitVerificationSkipped metrics.Counter

	// BlockApplyStageDuration is the wall-clock cost of each stage a committed
	// block goes through in ProcessProposal and FinalizeBlock. During block sync
	// those stages are most of a block; this says which one a slow sync is in.
	//metrics:Time spent in each stage of applying a committed block, in milliseconds.
	BlockApplyStageDuration metrics.Histogram `metrics_labels:"stage" metrics_buckettype:"exprange" metrics_bucketsizes:"0.01, 1000, 12"`
}

type RoundParams struct {
	AppHash               tmbytes.HexBytes
	TxResults             []*abci.ExecTxResult
	ConsensusParamUpdates *tmtypes.ConsensusParams
	ValidatorSetUpdate    *abci.ValidatorSetUpdate
	CoreChainLock         *types.CoreChainLock
	Source                string
	Round                 int32
}

type State struct {
	// FIXME: This can be removed as TMVersion is a constant, and version.Consensus should
	// eventually be replaced by VersionParams in ConsensusParams
	Version Version

	// immutable
	ChainID       string
	InitialHeight int64 // should be 1, not 0, when starting from height 1

	// LastBlockHeight=0 at genesis (ie. block(H=0) does not exist)
	LastBlockHeight int64
	LastBlockRound  int32
	LastBlockID     types.BlockID
	LastBlockTime   time.Time

	// Last Chain Lock is the last known chain locked height in consensus
	// It does not go to 0 if a block had no chain lock and should stay the same as the previous block
	LastCoreChainLockedBlockHeight uint32

	// LastValidators is used to validate block.LastPrecommits.
	// Validators are persisted to the database separately every time they change,
	// so we can query for historical validator sets.
	// Note that if s.LastBlockHeight causes a valset change,
	// we set s.LastHeightValidatorsChanged = s.LastBlockHeight + 1 + 1
	// Extra +1 due to nextValSet delay.
	Validators                  *types.ValidatorSet
	LastValidators              *types.ValidatorSet
	LastHeightValidatorsChanged int64

	// Consensus parameters used for validating blocks.
	// Changes returned by FinalizeBlock and updated after Commit.
	ConsensusParams                  types.ConsensusParams
	LastHeightConsensusParamsChanged int64

	// Merkle root of the results from executing prev block
	LastResultsHash tmbytes.HexBytes

	// the latest LastAppHash we've received from calling abci.Commit()
	LastAppHash tmbytes.HexBytes
}

type Store interface {
	// Load loads the current state of the blockchain
	Load() (State, error)
	// LoadValidators loads the validator set that is used to validate the given height
	LoadValidators(int64, selectproposer.BlockStore) (*types.ValidatorSet, error)
	// LoadABCIResponses loads the abciResponse for a given height
	LoadABCIResponses(int64) (*tmstate.ABCIResponses, error)
	// LoadConsensusParams loads the consensus params for a given height
	LoadConsensusParams(int64) (types.ConsensusParams, error)
	// Save overwrites the previous state with the updated one
	Save(State) error
	// SaveABCIResponses saves ABCIResponses for a given height
	SaveABCIResponses(int64, tmstate.ABCIResponses) error
	// SaveValidatorSet saves the validator set at a given height
	SaveValidatorSets(int64, int64, *types.ValidatorSet) error
	// Bootstrap is used for bootstrapping state when not starting from a initial height.
	Bootstrap(State) error
	// PruneStates takes the height from which to prune up to (exclusive)
	PruneStates(int64) error
	// Close closes the connection with the database
	Close() error
}

type StoreOption func(*dbStore)

type Version struct {
	Consensus version.Consensus ` json:"consensus"`
	Software  string            ` json:"software"`
}

type VoteExtender interface {
	ExtendVote(ctx context.Context, vote *types.Vote)
}