protocol

type AccountState func(context.Context, 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
	// ReadOnly indicates two scenarios: eth_estimateGas and eth_call
	ReadOnly bool
}

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

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

type BaseStateContext struct {
	Parameter *Parameters
	Method    *abi.Method
}

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
	// AccumTips is the accumulated tips of the block
	AccumulatedTips big.Int
	// BaseFee is the base fee of the block
	BaseFee *big.Int
	// ExcessBlobGas is the excess blob gas of the block
	ExcessBlobGas uint64
	// SkipSidecarValidation dictates to validate sidecar (for blob tx) or not
	SkipSidecarValidation bool
	// Simulate is used for read-only APIs
	Simulate bool
}

type BlockchainCtx struct {
	// Tip is the information of tip block
	Tip TipInfo
	//ChainID is the native chain ID
	ChainID uint32
	// EvmNetworkID is the EVM network ID
	EvmNetworkID uint32
	// GetBlockHash is the function to get block hash by height
	GetBlockHash func(uint64) (hash.Hash256, error)
	// GetBlockTime is the function to get block time by height
	GetBlockTime func(uint64) (time.Time, error)
}

type CheckFunc func(height uint64) bool

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

type DepositGas func(context.Context, StateManager, *big.Int, ...DepositOption) ([]*action.TransactionLog, error)

type DepositOption func(*DepositOptionCfg)

type DepositOptionCfg struct {
	PriorityFee *big.Int
	BlobGasFee  *big.Int
}

type FeatureCtx struct {
	FixDoubleChargeGas                      bool
	SystemWideActionGasLimit                bool
	NotFixTopicCopyBug                      bool
	SetRevertMessageToReceipt               bool
	FixGetHashFnHeight                      bool
	FixSortCacheContractsAndUsePendingNonce 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
	TolerateLegacyAddress                   bool
	CreateLegacyNonceAccount                bool
	FixGasAndNonceUpdate                    bool
	FixUnproductiveDelegates                bool
	CorrectGasRefund                        bool
	SufficentBalanceGuarantee               bool
	TolerateEmptyCandidateName              bool
	SkipSystemActionNonce                   bool
	ValidateSystemAction                    bool
	AllowCorrectChainIDOnly                 bool
	AddContractStakingVotes                 bool
	FixContractStakingWeightedVotes         bool
	ExecutionSizeLimit32KB                  bool
	UseZeroNonceForFreshAccount             bool
	CandidateRegisterMustWithStake          bool
	DisableDelegateEndorsement              bool
	RefactorFreshAccountConversion          bool
	SuicideTxLogMismatchPanic               bool
	PanicUnrecoverableError                 bool
	CandidateIdentifiedByOwner              bool
	LimitedStakingContract                  bool
	MigrateNativeStake                      bool
	AddClaimRewardAddress                   bool
	EnforceLegacyEndorsement                bool
	EnableDynamicFeeTx                      bool
	EnableBlobTransaction                   bool
	EnableCancunEVM                         bool
	CorrectValidationOrder                  bool
	UnstakedButNotClearSelfStakeAmount      bool
	CheckStakingDurationUpperLimit          bool
	FixRevertSnapshot                       bool
	TimestampedStakingContract              bool
	PreStateSystemAction                    bool
	CreatePostActionStates                  bool
	NotSlashUnproductiveDelegates           bool
	CandidateBLSPublicKey                   bool
	NotUseMinSelfStakeToBeActive            bool
	StoreVoteOfNFTBucketIntoView            bool
	CandidateSlashByOwner                   bool
	CandidateBLSPublicKeyNotCopied          bool
	OnlyOwnerCanUpdateBLSPublicKey          bool
	PrePectraEVM                            bool
	// AlwaysWriteCachedContract if true, CommitContracts writes back all cached
	// contracts regardless of whether they were modified; if false, only dirty
	// contracts are committed and written back
	AlwaysWriteCachedContract     bool
	NoCandidateExitQueue          bool
	FixInContractTransferLogTopic bool
	// CorrectPrestateForAbsentKeys, when true, makes contract.GetCommittedState
	// return the true tx-start prestate value (zero, via trie.ErrNotExist) for
	// storage slots that were absent in the pre-tx trie. Prior to this gate the
	// contract-level committed[] cache was populated with post-mutation values
	// for such slots, causing EIP-2200 SSTORE dynamic gas to misclassify
	// dirty in-place writes as SSTORE_RESET (100 → 2900 gas overcharge per hit).
	CorrectPrestateForAbsentKeys bool
	// NoVoterRewardDistribution gates IIP-59's protocol-native voter reward
	// distribution. Pre-fork (true) the poll layer does NOT freeze the
	// per-candidate CandidateRewardSnapshot and rewarding stays on the legacy
	// Hermes path. Post-fork (false) the snapshot is written at every
	// PutPollResult and rewarding consumes it. Bound to
	// !g.IsZanzibar(height): default zero-value = active after fork.
	NoVoterRewardDistribution bool
	// FixEpochSettlementFaultHandling corrects how faults raised during
	// epoch settlement are classified, in three places:
	//
	//   - the auto-deposit lookup and the compound bucket read no longer
	//     reroute a voter's share on a fault only some nodes saw; an absent
	//     or withdrawn bucket, which every node reads identically, still
	//     degrades to a direct credit;
	//   - an era boundary reached with no copy-on-write window skips the
	//     drain cursor instead of failing the whole epoch grant, which used
	//     to take that epoch's commissions, foundation bonus and sentinel
	//     down with it;
	//   - a GrantEpochReward error settles a Failure receipt only when it
	//     is derivable from committed state; the rest fail the block rather
	//     than let one node commit "this epoch paid nobody" against
	//     everyone else's full grant.
	//
	// Deliberately separate from NoVoterRewardDistribution. That gate is
	// what turns IIP-59 on, so a chain where it has already activated is
	// executing the pre-correction behaviour; changing it in place would
	// alter blocks that chain has already committed. This flag therefore
	// needs its own height, one fork later than the gate above:
	// Zanzibar Beta.
	FixEpochSettlementFaultHandling bool
	// RequireProfileForHermesMigration makes the activation-block Hermes
	// opt-in migration skip candidates whose DelegateProfile portions are
	// missing or only half set, leaving them on the off-chain Hermes payout
	// instead of moving them into an on-chain path that freezes them at
	// 100% commission and pays their voters nothing.
	//
	// Separate from NoVoterRewardDistribution because the migration is a
	// one-shot that runs in the single block that gate turns on at. A chain
	// where it has already fired has that block committed; changing what it
	// did would alter the block's receipt root and fork any node replaying
	// history. Carried by Zanzibar Beta.
	//
	// Because that migration is a one-shot in the block Zanzibar activates
	// at, this flag only ever has an effect where Zanzibar Beta is not
	// scheduled after Zanzibar. On a chain that activated Zanzibar first
	// the migration has already run unguarded and cannot be re-run, so the
	// flag is inert there by construction -- it exists to protect a chain
	// that activates both together. See ZanzibarBetaBlockHeight.
	RequireProfileForHermesMigration bool
	// EmitEraFreezeLog makes the era freeze emit one DelegateRewardFrozen
	// log per frozen delegate.
	//
	// Freezing is otherwise silent: the freeze block and its neighbours
	// carry the same single untopiced block-reward log, so an event-driven
	// indexer cannot tell an era was frozen, which delegates are in it, or
	// what commission each was frozen at.
	//
	// Receipt logs are part of the receipt root, so this needs its own
	// height rather than riding on the gate that turns IIP-59 on: a chain
	// that has already produced freeze blocks without these logs would
	// recompute different roots for them. Carried by Zanzibar Beta.
	EmitEraFreezeLog bool
	// EnforceBLSPoP gates the BLS proof-of-possession requirement at
	// candidate register / update. The staking handler validates
	// blsPubKey only with BLS12381PublicKeyFromBytes (format +
	// subgroup); without a possession proof, IIP-52's planned
	// FastAggregateVerify path is vulnerable to a rogue-key
	// aggregate-forgery attack (a registered candidate could publish
	// pk_rogue = g^x − Σ(other pubkeys) and, once aggregation goes
	// live, forge a 2/3+ quorum certificate with a single signature).
	// Activating EnforceBLSPoP BEFORE the BLS aggregation fork closes
	// the window for collecting un-attested pubkeys.
	EnforceBLSPoP bool
	// OptionalCandidateBLSPublicKey relaxes the Xingu-era rule that every
	// candidate register / update must carry a BLS public key. Post-fork
	// the key is optional -- nothing consumes it until IIP-52 aggregation
	// activates -- but a proof-of-possession may not arrive without one.
	// An update that omits both leaves any previously registered key
	// untouched.
	OptionalCandidateBLSPublicKey bool
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type Parameters struct {
	MethodName []byte
	Arguments  [][]byte
}

type PostActionHandler interface {
	HandleReceipt(ctx context.Context, elp action.Envelope, sm StateManager, receipt *action.Receipt) error
}

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

type PreCommitter interface {
	PreCommit(context.Context, StateManager) 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 SimulateOption func(*SimulateOptionConfig)

type SimulateOptionConfig struct {
	PreOpt     func(StateManager) error
	Nonce, Gas uint64
	GasPrice   *big.Int
}

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

type StateConfig struct {
	Namespace       string // namespace used by state's storage
	Key             []byte
	Keys            [][]byte
	Object          any    // object used by state's storage
	ErigonStoreOnly bool   // whether only read/write from/to erigon store
	ErigonStoreKey  []byte // erigon store key used by state's storage. If nil, use Key field
	// RangeMin/RangeMax bound an ordered States() scan over the half-open
	// interval [RangeMin, RangeMax); nil means unbounded on that side. Limit
	// caps the number of results (<= 0 means unlimited). All three are unset by
	// default, in which case States() behaves exactly as it always has.
	RangeMin []byte
	RangeMax []byte
	Limit    int
}

type StateContext interface {
	Parameters() *Parameters
	EncodeToEth(*iotexapi.ReadStateResponse) (string, error)
}

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

type StateManagerWithCloser interface {
	StateManager
	Close()
}

type StateOption func(*StateConfig) error

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

type TipInfo struct {
	Height        uint64
	GasUsed       uint64
	Hash          hash.Hash256
	Timestamp     time.Time
	BaseFee       *big.Int
	BlobGasUsed   uint64
	ExcessBlobGas uint64
}

type View interface {
	Fork() View
	Snapshot() int
	Revert(int) error
	Commit(context.Context, StateManager) error
}

type Views interface {
	Snapshot() int
	Revert(id int) error
	Fork() Views
	Commit(ctx context.Context, sm StateManager) error
	Read(name string) (View, error)
	Write(name string, v View)
}