calls

type CallMessage struct {
	// From represents a core.Message's from parameter (sender), indicating who sent a transaction/message to the
	// Ethereum core to apply a state update.
	From common.Address `json:"from"`

	// To represents the receiving address for a given core.Message.
	To *common.Address `json:"to"`

	// Nonce represents the core.Message sender's nonce
	Nonce uint64 `json:"nonce"`

	// Value represents ETH value to be sent to the receiver of the message.
	Value *big.Int `json:"value"`

	// GasLimit represents the maximum amount of gas the sender is willing to spend to cover the cost of executing the
	// message or transaction.
	GasLimit uint64 `json:"gasLimit"`

	// GasPrice represents the price which the sender is willing to pay for each unit of gas used during execution
	// of the message.
	GasPrice *big.Int `json:"gasPrice"`

	// GasFeeCap represents the maximum fee to enforce for gas related costs (related to 1559 transaction executed).
	// The use of nil here indicates that the gas price oracle should be relied on instead.
	GasFeeCap *big.Int `json:"gasFeeCap"`

	// GasTipCap represents the fee cap to use for 1559 transaction. The use of nil here indicates that the gas price
	// oracle should be relied on instead.
	GasTipCap *big.Int `json:"gasTipCap"`

	// Data represents the underlying message data to be sent to the receiver. If the receiver is a smart contract,
	// this will likely house your call parameters and other serialized data. If MsgDataAbiValues is non-nil, this
	// value is not used.
	Data []byte `json:"data,omitempty"`

	// DataAbiValues represents the underlying message data to be sent to the receiver. If the receiver is a smart
	// contract, this will likely house your call parameters and other serialized data. This overrides Data if it is
	// set, allowing Data to be sourced from method ABI input arguments instead.
	DataAbiValues *CallMessageDataAbiValues `json:"dataAbiValues,omitempty"`

	// AccessList represents a core.Message's AccessList parameter which represents the storage slots and contracts
	// that will be accessed during the execution of this message.
	AccessList coreTypes.AccessList

	// SkipAccountChecks represents a core.Message's SkipAccountChecks. If it is set to true, then the message nonce
	// is not checked against the account nonce in state and will not verify if the sender is an EOA.
	SkipAccountChecks bool
}

type CallMessageDataAbiValues struct {
	// Method defines the ABI method definition used to pack input argument values.
	Method *abi.Method

	// InputValues represents the ABI packable input argument values to use alongside the Method to produce the call
	// data.
	InputValues []any
	// contains filtered or unexported fields
}

type CallSequence []*CallSequenceElement

type CallSequenceElement struct {
	// Contract describes the contract which was targeted by a transaction.
	Contract *fuzzingTypes.Contract `json:"-"`

	// Call represents the underlying message call.
	Call *CallMessage `json:"call"`

	// BlockNumberDelay defines how much the block number should advance when executing this transaction, compared to
	// the last executed transaction. If zero, this indicates the call should be included in the current pending block.
	// This number is *suggestive*: if delay specifies we should add a tx to a block which is full, it will be added to
	// a new block instead. If BlockNumberDelay is greater than BlockTimestampDelay and both are non-zero (we want to
	// create a new block), BlockNumberDelay will be capped to BlockTimestampDelay, as each block must have a unique
	// time stamp for chain semantics.
	BlockNumberDelay uint64 `json:"blockNumberDelay"`

	// BlockTimestampDelay defines how much the block timestamp should advance when executing this transaction,
	// compared to the last executed transaction.
	// This number is *suggestive*: if BlockNumberDelay is non-zero (indicating to add to the existing block), this
	// value will not be used.
	BlockTimestampDelay uint64 `json:"blockTimestampDelay"`

	// ChainReference describes the inclusion of the Call as a transaction in a block. This block may not yet be
	// committed to its underlying chain if this is a CallSequenceElement was just executed. Additional transactions
	// may be included before the block is committed. This reference will remain compatible after the block finalizes.
	ChainReference *CallSequenceElementChainReference `json:"-"`

	// ExecutionTrace represents a verbose execution trace collected. Nil if an execution trace was not collected.
	ExecutionTrace *executiontracer.ExecutionTrace `json:"-"`
}

type CallSequenceElementChainReference struct {
	// Block describes the block the CallSequenceElement.Call was included in as a transaction. This block may be
	// pending commitment to the chain, or already committed.
	Block *chainTypes.Block

	// TransactionIndex describes the index at which the transaction was included into the Block.
	TransactionIndex int
}

type ExecuteCallSequenceExecutionCheckFunc func(currentExecutedSequence CallSequence) (bool, error)

type ExecuteCallSequenceFetchElementFunc func(index int) (*CallSequenceElement, error)