protocol

type AccountState func(StateReader, address.Address) (*state.Account, error)

type ActionCtx struct {
	// Caller is the address of whom issues this action
	Caller address.Address
	// ActionHash is the hash of the action with the sealed envelope
	ActionHash hash.Hash256
	// GasPrice is the action gas price
	GasPrice *big.Int
	// IntrinsicGas is the action intrinsic gas
	IntrinsicGas uint64
	// Nonce is the nonce of the action
	Nonce uint64
}

type ActionHandler interface {
	Handle(context.Context, action.Action, StateManager) (*action.Receipt, error)
}

type ActionValidator interface {
	Validate(context.Context, action.Action, StateReader) error
}

type BlockCtx struct {
	// height of block containing those actions
	BlockHeight uint64
	// timestamp of block containing those actions
	BlockTimeStamp time.Time
	// gas Limit for perform those actions
	GasLimit uint64
	// Producer is the address of whom composes the block containing this action
	Producer address.Address
}

type BlockchainCtx struct {
	// Tip is the information of tip block
	Tip TipInfo
	//ChainID of the node
	ChainID uint32
}

type CheckFunc func(height uint64) bool

type Committer interface {
	Commit(context.Context, StateManager) error
}

type Dock interface {
	ProtocolDirty(string) bool
	Load(string, string, interface{}) error
	Unload(string, string, interface{}) error
	Reset()
}

type FeatureCtx struct {
	FixDoubleChargeGas          bool
	SystemWideActionGasLimit    bool
	NotFixTopicCopyBug          bool
	SetRevertMessageToReceipt   bool
	FixGetHashFnHeight          bool
	UsePendingNonceOption       bool
	AsyncContractTrie           bool
	AddOutOfGasToTransactionLog bool
	AddChainIDToConfig          bool
	UseV2Storage                bool
	CannotUnstakeAgain          bool
	SkipStakingIndexer          bool
	ReturnFetchError            bool
	CannotTranferToSelf         bool
	NewStakingReceiptFormat     bool
	UpdateBlockMeta             bool
	CurrentEpochProductivity    bool
	FixSnapshotOrder            bool
	AllowCorrectDefaultChainID  bool
	CorrectGetHashFn            bool
	CorrectTxLogIndex           bool
	RevertLog                   bool
}

type FeatureWithHeightCtx struct {
	GetUnproductiveDelegates CheckFunc
	ReadStateFromDB          CheckFunc
	UseV2Staking             CheckFunc
	EnableNativeStaking      CheckFunc
	StakingCorrectGas        CheckFunc
	CalculateProbationList   CheckFunc
	LoadCandidatesLegacy     CheckFunc
}

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

type GenesisStateCreator interface {
	CreateGenesisStates(context.Context, StateManager) error
}

type PostSystemActionsCreator interface {
	CreatePostSystemActions(context.Context, StateReader) ([]action.Envelope, error)
}

type PreStatesCreator interface {
	CreatePreStates(context.Context, StateManager) error
}

type Protocol interface {
	ActionHandler
	ReadState(context.Context, StateReader, []byte, ...[]byte) ([]byte, uint64, error)
	Register(*Registry) error
	ForceRegister(*Registry) error
	Name() string
}

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

type SerializableBytes []byte

type Starter interface {
	Start(context.Context, StateReader) (interface{}, error)
}

type StateConfig struct {
	Namespace string // namespace used by state's storage
	Key       []byte
	MinKey    []byte
	MaxKey    []byte
	Cond      db.Condition
}

type StateManager interface {
	StateReader
	// Accounts
	Snapshot() int
	Revert(int) error
	// General state
	PutState(interface{}, ...StateOption) (uint64, error)
	DelState(...StateOption) (uint64, error)
	WriteView(string, interface{}) error
	Dock
}

type StateOption func(*StateConfig) error

type StateReader interface {
	Height() (uint64, error)
	State(interface{}, ...StateOption) (uint64, error)
	States(...StateOption) (uint64, state.Iterator, error)
	ReadView(string) (interface{}, error)
}

type TipInfo struct {
	Height    uint64
	Hash      hash.Hash256
	Timestamp time.Time
}

type View map[string]interface{}