eth

type APIBeaconBlobsResponse struct {
	Data []*Blob `json:"data"`
}

type APIBlobSidecar struct {
	Index             Uint64String            `json:"index"`
	Blob              Blob                    `json:"blob"`
	KZGCommitment     Bytes48                 `json:"kzg_commitment"`
	KZGProof          Bytes48                 `json:"kzg_proof"`
	SignedBlockHeader SignedBeaconBlockHeader `json:"signed_block_header"`
	InclusionProof    []Bytes32               `json:"kzg_commitment_inclusion_proof"`
}

type APIConfigResponse struct {
	Data ReducedConfigData `json:"data"`
}

type APIGenesisResponse struct {
	Data ReducedGenesisData `json:"data"`
}

type APIGetBlobSidecarsResponse struct {
	Data []*APIBlobSidecar `json:"data"`
}

type APIVersionResponse struct {
	Data VersionInformation `json:"data"`
}

type AccountResult struct {
	AccountProof []hexutil.Bytes `json:"accountProof"`

	Address     common.Address `json:"address"`
	Balance     *hexutil.Big   `json:"balance"`
	CodeHash    common.Hash    `json:"codeHash"`
	Nonce       hexutil.Uint64 `json:"nonce"`
	StorageHash common.Hash    `json:"storageHash"`

	// Optional
	StorageProof []StorageProofEntry `json:"storageProof,omitempty"`
}

type BeaconBlockHeader struct {
	Slot          Uint64String `json:"slot"`
	ProposerIndex Uint64String `json:"proposer_index"`
	ParentRoot    Bytes32      `json:"parent_root"`
	StateRoot     Bytes32      `json:"state_root"`
	BodyRoot      Bytes32      `json:"body_root"`
}

type Blob [BlobSize]byte

type BlobSidecar struct {
	Blob          Blob         `json:"blob"`
	Index         Uint64String `json:"index"`
	KZGCommitment Bytes48      `json:"kzg_commitment"`
	KZGProof      Bytes48      `json:"kzg_proof"`
}

type BlockID struct {
	Hash   common.Hash `json:"hash"`
	Number uint64      `json:"number"`
}

type BlockInfo interface {
	Hash() common.Hash
	ParentHash() common.Hash
	Coinbase() common.Address
	Root() common.Hash // state-root
	NumberU64() uint64
	Time() uint64
	// MixDigest field, reused for randomness after The Merge (Bellatrix hardfork)
	MixDigest() common.Hash
	BaseFee() *big.Int
	// BlobBaseFee returns the result of computing the blob fee from excessDataGas, or nil if the
	// block isn't a Dencun (4844 capable) block
	BlobBaseFee(chainConfig *params.ChainConfig) *big.Int
	ExcessBlobGas() *uint64
	ReceiptHash() common.Hash
	GasUsed() uint64
	BlobGasUsed() *uint64
	GasLimit() uint64
	ParentBeaconRoot() *common.Hash // Dencun extension
	WithdrawalsRoot() *common.Hash  // Isthmus extension

	// HeaderRLP returns the RLP of the block header as per consensus rules
	// Returns an error if the header RLP could not be written
	HeaderRLP() ([]byte, error)
	Header() *types.Header
}

type BlockLabel string

type BlockRef = L1BlockRef

type BlockVersion int

type Bytes8 [8]byte

type Bytes32 [32]byte

type Bytes48 [48]byte

type Bytes65 [65]byte

type Bytes96 [96]byte

type Bytes256 [256]byte

type BytesMax32 []byte

type ChainID uint256.Int

type ChainIDAndOutput struct {
	ChainID ChainID
	Output  Bytes32
}

type ChainRootInfo struct {
	ChainID ChainID `json:"chainID"`
	// Canonical is the output root of the latest canonical block at a particular Timestamp.
	Canonical Bytes32 `json:"canonical"`
	// Pending is the output root preimage for the latest block at a particular Timestamp prior to validation of
	// executing messages. If the original block was valid, this will be the preimage of the
	// output root from the Canonical array. If it was invalid, it will be the output root preimage from the
	// Optimistic Block Deposited Transaction added to the deposit-only block.
	Pending []byte `json:"pending"`
}

type Data = hexutil.Bytes

type ELSyncPolicy interface {
	ELSyncStatus(num uint64) ExecutePayloadStatus
}

type ETH uint256.Int

type EcotoneScalars struct {
	BlobBaseFeeScalar uint32
	BaseFeeScalar     uint32
}

type EngineAPIMethod string

type ErrorCode int

type ExecutePayloadStatus string

type ExecutionPayload struct {
	ParentHash    common.Hash     `json:"parentHash"`
	FeeRecipient  common.Address  `json:"feeRecipient"`
	StateRoot     Bytes32         `json:"stateRoot"`
	ReceiptsRoot  Bytes32         `json:"receiptsRoot"`
	LogsBloom     Bytes256        `json:"logsBloom"`
	PrevRandao    Bytes32         `json:"prevRandao"`
	BlockNumber   Uint64Quantity  `json:"blockNumber"`
	GasLimit      Uint64Quantity  `json:"gasLimit"`
	GasUsed       Uint64Quantity  `json:"gasUsed"`
	Timestamp     Uint64Quantity  `json:"timestamp"`
	ExtraData     BytesMax32      `json:"extraData"`
	BaseFeePerGas Uint256Quantity `json:"baseFeePerGas"`
	BlockHash     common.Hash     `json:"blockHash"`
	// Array of transaction objects, each object is a byte list (DATA) representing
	// TransactionType || TransactionPayload or LegacyTransaction as defined in EIP-2718
	Transactions []Data `json:"transactions"`
	// Nil if not present (Bedrock)
	Withdrawals *types.Withdrawals `json:"withdrawals,omitempty"`
	// Nil if not present (Bedrock, Canyon, Delta)
	BlobGasUsed *Uint64Quantity `json:"blobGasUsed,omitempty"`
	// Nil if not present (Bedrock, Canyon, Delta)
	ExcessBlobGas *Uint64Quantity `json:"excessBlobGas,omitempty"`
	// Nil if not present (Bedrock, Canyon, Delta, Ecotone, Fjord, Granite, Holocene)
	WithdrawalsRoot *common.Hash `json:"withdrawalsRoot,omitempty"`
}

type ExecutionPayloadEnvelope struct {
	ParentBeaconBlockRoot *common.Hash      `json:"parentBeaconBlockRoot,omitempty"`
	ExecutionPayload      *ExecutionPayload `json:"executionPayload"`
}

type ExecutionWitness struct {
	Keys  []hexutil.Bytes `json:"keys"`
	Codes []hexutil.Bytes `json:"codes"`
	State []hexutil.Bytes `json:"state"`
}

type FCUState struct {
	Latest    uint64 `json:"latest"`
	Safe      uint64 `json:"safe"`
	Finalized uint64 `json:"finalized"`
}

type ForkchoiceState struct {
	// block hash of the head of the canonical chain
	HeadBlockHash common.Hash `json:"headBlockHash"`
	// safe block hash in the canonical chain
	SafeBlockHash common.Hash `json:"safeBlockHash"`
	// block hash of the most recent finalized block
	FinalizedBlockHash common.Hash `json:"finalizedBlockHash"`
}

type ForkchoiceUpdatedResult struct {
	// the result of the payload execution
	PayloadStatus PayloadStatusV1 `json:"payloadStatus"`
	// the payload id if requested
	PayloadID *PayloadID `json:"payloadId"`
}

type HeadSignalFn func(ctx context.Context, sig L1BlockRef)

type IndexedBlobHash struct {
	Index uint64      // absolute index in the block, a.k.a. position in sidecar blobs array
	Hash  common.Hash // hash of the blob, used for consistency checks
}

type InputError struct {
	Inner error
	Code  ErrorCode
}

type L1BlockRef struct {
	Hash       common.Hash `json:"hash"`
	Number     uint64      `json:"number"`
	ParentHash common.Hash `json:"parentHash"`
	Time       uint64      `json:"timestamp"`
}

type L1BlockRefsSource interface {
	L1BlockRefByLabel(ctx context.Context, label BlockLabel) (L1BlockRef, error)
}

type L1Client interface {
	HeaderByNumber(ctx context.Context, number *big.Int) (*types.Header, error)
	NonceAt(ctx context.Context, account common.Address, blockNumber *big.Int) (uint64, error)
}

type L2BlockRef struct {
	Hash           common.Hash `json:"hash"`
	Number         uint64      `json:"number"`
	ParentHash     common.Hash `json:"parentHash"`
	Time           uint64      `json:"timestamp"`
	L1Origin       BlockID     `json:"l1origin"`
	SequenceNumber uint64      `json:"sequenceNumber"` // distance to first block of epoch
}

type NewHeadSource interface {
	SubscribeNewHead(ctx context.Context, ch chan<- *types.Header) (ethereum.Subscription, error)
}

type NumberAndHash interface {
	Hash() common.Hash
	NumberU64() uint64
}

type OperatorFeeParams struct {
	Scalar   uint32
	Constant uint64
}

type Output interface {
	// Version returns the version of the L2 output
	Version() Bytes32

	// Marshal a L2 output into a byte slice for hashing
	Marshal() []byte
}

type OutputResponse struct {
	Version               Bytes32     `json:"version"`
	OutputRoot            Bytes32     `json:"outputRoot"`
	BlockRef              L2BlockRef  `json:"blockRef"`
	WithdrawalStorageRoot common.Hash `json:"withdrawalStorageRoot"`
	StateRoot             common.Hash `json:"stateRoot"`
	Status                *SyncStatus `json:"syncStatus"`
}

type OutputV0 struct {
	StateRoot                Bytes32     `json:"stateRoot"`
	MessagePasserStorageRoot Bytes32     `json:"messagePasserStorageRoot"`
	BlockHash                common.Hash `json:"blockHash"`
}

type OutputWithRequiredL1 struct {
	Output     *OutputV0 `json:"output"`
	OutputRoot Bytes32   `json:"output_root"`
	RequiredL1 BlockID   `json:"required_l1"`
}

type PayloadAttributes struct {
	// value for the timestamp field of the new payload
	Timestamp Uint64Quantity `json:"timestamp"`
	// value for the random field of the new payload
	PrevRandao Bytes32 `json:"prevRandao"`
	// suggested value for the coinbase field of the new payload
	SuggestedFeeRecipient common.Address `json:"suggestedFeeRecipient"`
	// Withdrawals to include into the block -- should be nil or empty depending on Shanghai enablement
	Withdrawals *types.Withdrawals `json:"withdrawals,omitempty"`
	// parentBeaconBlockRoot optional extension in Dencun
	ParentBeaconBlockRoot *common.Hash `json:"parentBeaconBlockRoot,omitempty"`

	// Transactions to force into the block (always at the start of the transactions list).
	Transactions []Data `json:"transactions,omitempty"`
	// NoTxPool to disable adding any transactions from the transaction-pool.
	NoTxPool bool `json:"noTxPool,omitempty"`
	// GasLimit override
	GasLimit *Uint64Quantity `json:"gasLimit,omitempty"`
	// EIP-1559 parameters, to be specified only post-Holocene
	EIP1559Params *Bytes8 `json:"eip1559Params,omitempty"`
	// MinBaseFee is the minimum base fee, to be specified only post-Jovian
	MinBaseFee *uint64 `json:"minBaseFee,omitempty"`
}

type PayloadID = engine.PayloadID

type PayloadInfo struct {
	ID        PayloadID `json:"id"`
	Timestamp uint64    `json:"timestamp"`
}

type PayloadStatusV1 struct {
	// the result of the payload execution
	Status ExecutePayloadStatus `json:"status"`
	// the hash of the most recent valid block in the branch defined by payload and its ancestors (optional field)
	LatestValidHash *common.Hash `json:"latestValidHash,omitempty"`
	// additional details on the result (optional field)
	ValidationError *string `json:"validationError,omitempty"`
}

type ReducedConfigData struct {
	SecondsPerSlot Uint64String `json:"SECONDS_PER_SLOT"`
}

type ReducedGenesisData struct {
	GenesisTime Uint64String `json:"genesis_time"`
}

type SafeHeadResponse struct {
	L1Block  BlockID `json:"l1Block"`
	SafeHead BlockID `json:"safeHead"`
}

type SignedBeaconBlockHeader struct {
	Message   BeaconBlockHeader `json:"message"`
	Signature hexutil.Bytes     `json:"signature"`
}

type StorageKey []byte

type StorageProofEntry struct {
	Key   StorageKey      `json:"key"`
	Value hexutil.Big     `json:"value"`
	Proof []hexutil.Bytes `json:"proof"`
}

type Super interface {
	Version() byte
	Marshal() []byte
}

type SuperNodeSyncStatusResponse struct {
	// Chains contains the per-chain op-node sync status.
	Chains map[ChainID]SyncStatus `json:"chains"`

	// ChainIDs are the chain IDs in the dependency set, sorted ascending.
	ChainIDs []ChainID `json:"chain_ids"`

	// CurrentL1 is the highest L1 block ID that has been fully derived and verified by all chains.
	// This value is derived from the minimum per-chain current L1 block IDs, including validators.
	CurrentL1 BlockID `json:"current_l1"`

	// SafeTimestamp is the highest L2 timestamp that is safe across the dependency set at the CurrentL1.
	// This value is derived from the minimum per-chain safe L2 head timestamp.
	SafeTimestamp uint64 `json:"safe_timestamp"`

	// LocalSafeTimestamp is the highest L2 timestamp that is local-safe across the dependency set at the CurrentL1.
	// This value is derived from the minimum per-chain local safe L2 head timestamp.
	LocalSafeTimestamp uint64 `json:"local_safe_timestamp"`

	// FinalizedTimestamp is the highest L2 timestamp that is finalized across the dependency set at the CurrentL1.
	// This value is derived from the minimum per-chain finalized L2 head timestamp.
	FinalizedTimestamp uint64 `json:"finalized_timestamp"`
}

type SuperRootAtTimestampResponse struct {
	// CurrentL1 is the highest L1 block that has been fully derived and verified by all chains.
	CurrentL1 BlockID `json:"current_l1"`

	// CurrentSafeTimestamp is the highest L2 timestamp that is safe across the dependency set at the CurrentL1.
	// This value is derived from the minimum per-chain safe L2 head timestamp.
	CurrentSafeTimestamp uint64 `json:"safe_timestamp"`

	// CurrentSafeTimestamp is the highest L2 timestamp that is safe across the dependency set at the CurrentL1.
	// This value is derived from the minimum per-chain local-safe L2 head timestamp.
	CurrentLocalSafeTimestamp uint64 `json:"local_safe_timestamp"`

	// CurrentFinalizedTimestamp is the highest L2 timestamp that is finalized across the dependency set at the CurrentL1.
	// This value is derived from the minimum per-chain finalized L2 head timestamp.
	CurrentFinalizedTimestamp uint64 `json:"finalized_timestamp"`

	// OptimisticAtTimestamp is the L2 block that would be applied if verification were assumed to be successful,
	// and the minimum L1 block required to derive them. If Data is nil, some chains may be absent from this map,
	// indicating that there is no optimistic block for the chain at the requested timestamp that can be derived
	// from the L1 data currently processed.
	OptimisticAtTimestamp map[ChainID]OutputWithRequiredL1 `json:"optimistic_at_timestamp"`

	// ChainIDs are the chain IDs in the dependency set at the requested timestamp, sorted ascending.
	ChainIDs []ChainID `json:"chain_ids"`

	// Data provides information about the super root at the requested timestamp if present. If block data at the
	// requested timestamp is not present, the data will be nil.
	Data *SuperRootResponseData `json:"data,omitempty"`
}

type SuperRootResponse struct {
	CrossSafeDerivedFrom BlockID `json:"crossSafeDerivedFrom"`
	Timestamp            uint64  `json:"timestamp"`
	SuperRoot            Bytes32 `json:"superRoot"`
	Version              byte    `json:"version"`
	// Chains is the list of ChainRootInfo for each chain in the dependency set.
	// It represents the state of the chain at or before the Timestamp.
	Chains []ChainRootInfo `json:"chains"`
}

type SuperRootResponseData struct {

	// VerifiedRequiredL1 is the minimum L1 block including the required data to fully verify all blocks at this timestamp
	VerifiedRequiredL1 BlockID `json:"verified_required_l1"`

	// Super is the unhashed data for the superroot at the given timestamp after all verification is applied.
	Super Super `json:"super"`

	// SuperRoot is the superroot at the given timestamp after all verification is applied.
	SuperRoot Bytes32 `json:"super_root"`
}

type SuperV1 struct {
	Timestamp uint64
	Chains    []ChainIDAndOutput
}

type SupervisorChainSyncStatus struct {
	// LocalUnsafe is the latest L2 block that has been processed by the supervisor.
	LocalUnsafe BlockRef `json:"localUnsafe"`
	LocalSafe   BlockID  `json:"localSafe"`
	CrossUnsafe BlockID  `json:"crossUnsafe"`
	// Some fault-proof releases may already depend on `safe`, so we keep JSON field name as `safe`.
	CrossSafe BlockID `json:"safe"`
	Finalized BlockID `json:"finalized"`
}

type SupervisorSyncStatus struct {
	// MinSyncedL1 is the highest L1 block that has been processed by all supervisor nodes.
	// This is not the same as the latest L1 block known to the supervisor,
	// but rather the L1 block view of the supervisor nodes.
	// This L1 block may not be fully derived into L2 data on all nodes yet.
	MinSyncedL1        L1BlockRef                             `json:"minSyncedL1"`
	SafeTimestamp      uint64                                 `json:"safeTimestamp"`
	FinalizedTimestamp uint64                                 `json:"finalizedTimestamp"`
	Chains             map[ChainID]*SupervisorChainSyncStatus `json:"chains"`
}

type SyncStatus struct {
	// CurrentL1 is the L1 block that the derivation process is last idled at.
	// This may not be fully derived into L2 data yet.
	// The safe L2 blocks were produced/included fully from the L1 chain up to _but excluding_ this L1 block.
	// If the node is synced, this matches the HeadL1, minus the verifier confirmation distance.
	CurrentL1 L1BlockRef `json:"current_l1"`
	// CurrentL1Finalized is a legacy sync-status attribute. This is deprecated.
	// A previous version of the L1 finalization-signal was updated only after the block was retrieved by number.
	// This attribute just matches FinalizedL1 now.
	CurrentL1Finalized L1BlockRef `json:"current_l1_finalized"`
	// HeadL1 is the perceived head of the L1 chain, no confirmation distance.
	// The head is not guaranteed to build on the other L1 sync status fields,
	// as the node may be in progress of resetting to adapt to a L1 reorg.
	HeadL1      L1BlockRef `json:"head_l1"`
	SafeL1      L1BlockRef `json:"safe_l1"`
	FinalizedL1 L1BlockRef `json:"finalized_l1"`
	// UnsafeL2 is the absolute tip of the L2 chain,
	// pointing to block data that has not been submitted to L1 yet.
	// The sequencer is building this, and verifiers may also be ahead of the
	// SafeL2 block if they sync blocks via p2p or other offchain sources.
	// This is considered to only be local-unsafe post-interop, see CrossUnsafe for cross-L2 guarantees.
	UnsafeL2 L2BlockRef `json:"unsafe_l2"`
	// SafeL2 points to the L2 block that was derived from the L1 chain.
	// This point may still reorg if the L1 chain reorgs.
	// This is considered to be cross-safe post-interop, see LocalSafe to ignore cross-L2 guarantees.
	SafeL2 L2BlockRef `json:"safe_l2"`
	// FinalizedL2 points to the L2 block that was derived fully from
	// finalized L1 information, thus irreversible.
	FinalizedL2 L2BlockRef `json:"finalized_l2"`
	// PendingSafeL2 points to the L2 block processed from the batch, but not consolidated to the safe block yet.
	PendingSafeL2 L2BlockRef `json:"pending_safe_l2"`
	// CrossUnsafeL2 is an unsafe L2 block, that has been verified to match cross-L2 dependencies.
	// Pre-interop every unsafe L2 block is also cross-unsafe.
	CrossUnsafeL2 L2BlockRef `json:"cross_unsafe_l2"`
	// LocalSafeL2 is an L2 block derived from L1, not yet verified to have valid cross-L2 dependencies.
	LocalSafeL2 L2BlockRef `json:"local_safe_l2"`
}

type SyncTesterSession struct {
	sync.Mutex

	SessionID string `json:"session_id"`

	// Non canonical view of the chain
	Validated uint64 `json:"validated"`
	// Canonical view of the chain
	CurrentState FCUState `json:"current_state"`
	// payloads
	Payloads map[PayloadID]*ExecutionPayloadEnvelope `json:"-"`

	ELSyncPolicy ELSyncPolicy `json:"-"`
	ELSyncActive bool         `json:"el_sync_active"`

	InitialState FCUState `json:"initial_state"`
}

type SystemConfig struct {
	// BatcherAddr identifies the batch-sender address used in batch-inbox data-transaction filtering.
	BatcherAddr common.Address `json:"batcherAddr"`
	// Overhead identifies the L1 fee overhead.
	// Pre-Ecotone this is passed as-is to the engine.
	// Post-Ecotone this is always zero, and not passed into the engine.
	Overhead Bytes32 `json:"overhead"`
	// Scalar identifies the L1 fee scalar
	// Pre-Ecotone this is passed as-is to the engine.
	// Post-Ecotone this encodes multiple pieces of scalar data.
	Scalar Bytes32 `json:"scalar"`
	// GasLimit identifies the L2 block gas limit
	GasLimit uint64 `json:"gasLimit"`
	// EIP1559Params contains the Holocene-encoded EIP-1559 parameters. This
	// value will be 0 if Holocene is not active, or if derivation has yet to
	// process any EIP_1559_PARAMS system config update events.
	EIP1559Params Bytes8 `json:"eip1559Params"`
	// OperatorFeeParams identifies the operator fee parameters.
	OperatorFeeParams Bytes32 `json:"operatorFeeParams"`
	// MinBaseFee identifies the minimum base fee.
	MinBaseFee uint64 `json:"minBaseFee"`
	// DAFootprintGasScalar identifies the DA footprint gas scalar.
	DAFootprintGasScalar uint16 `json:"daFootprintGasScalar"`

	// MarshalPreHolocene indicates whether or not this struct should be
	// marshaled in the pre-Holocene format. The pre-Holocene format does
	// not marshal the EIP1559Params field. The presence of this field in
	// pre-Holocene codebases causes the rollup config to be rejected.
	MarshalPreHolocene bool `json:"-"`
}

type Uint64Quantity = hexutil.Uint64

type Uint64String uint64

type Uint256Quantity = hexutil.U256

type VersionInformation struct {
	Version string `json:"version"`
}