types

type Block struct {
	// hash represents the block hash for this block.
	Hash common.Hash

	// header represents the block header for this current block.
	Header *types.Header

	// Messages represent internal EVM core.Message objects. Messages are derived from transactions after validation
	// of a transaction occurs and can be thought of as an internal EVM transaction. It contains typical transaction
	// fields plainly (e.g., no transaction signature is included, the sender is derived and simply supplied as a field
	// in a message).
	Messages []*core.Message

	// MessageResults represents the results recorded while executing transactions.
	MessageResults []*MessageResults
}

type DeployedContractBytecode struct {
	// Address represents the Ethereum address where the deployed contract containing the method exists.
	Address common.Address

	// InitBytecode describes the bytecode used to deploy the contract.
	InitBytecode []byte

	// RuntimeBytecode describes the bytecode which was deployed by the InitBytecode. This is expected to be non-nil.
	RuntimeBytecode []byte
}

type DeployedContractBytecodeChange struct {
	// Contract describes the contract address which was affected as well as the relevant init and runtime bytecode.
	// If this change represents a creation, this is the new bytecode information. If it represents destruction, this
	// is the destroyed bytecode information.
	Contract *DeployedContractBytecode

	// Creation indicates whether the change made was a contract creation. This cannot be true if SelfDestructed or
	// Destroyed are true.
	Creation bool

	// DynamicCreation indicates whether the change made was a _dynamic_ contract creation. This cannot be true if
	// Creation is false.
	DynamicCreation bool

	// SelfDestructed indicates whether the change made was due to a self-destruct instruction being executed. This
	// cannot be true if Creation is true.
	// Note: This may not be indicative of contract removal (as is the case with Destroyed), as proposed changes to
	// the `SELFDESTRUCT` instruction aim to not remove contract code.
	SelfDestructed bool

	// Destroyed indicates whether the contract was destroyed as a result of the operation, indicating the code
	// provided by Contract is no longer available.
	Destroyed bool
}

type GenericHookFunc func()

type GenericHookFuncs []GenericHookFunc

type MessageResults struct {
	// PreStateRoot refers to the state root hash prior to the execution of this transaction.
	PreStateRoot common.Hash

	// PostStateRoot refers to the state root hash after the execution of this transaction.
	PostStateRoot common.Hash

	// ExecutionResult describes the core.ExecutionResult returned after processing a given call.
	ExecutionResult *core.ExecutionResult

	// Receipt represents the transaction receipt
	Receipt *types.Receipt

	// ContractDeploymentChanges describes changes made to deployed contracts, such as creation and destruction.
	ContractDeploymentChanges []DeployedContractBytecodeChange

	// AdditionalResults represents results of arbitrary types which can be stored by any part of the application,
	// such as a tracers.
	AdditionalResults map[string]any

	// OnRevertHookFuncs refers hook functions that should be executed when this transaction is reverted.
	// This is to be used when a non-vm safe operation occurs, such as patching chain ID mid-execution, to ensure
	// that when the transaction is reverted, the value is also restored.
	// The hooks are executed as a stack (to support revert operations).
	OnRevertHookFuncs GenericHookFuncs
}