engineprimitives

type BlobsBundle interface {
	// GetCommitments returns the commitments in the blobs bundle.
	GetCommitments() []eip4844.KZGCommitment
	// GetProofs returns the proofs in the blobs bundle.
	GetProofs() []eip4844.KZGProof
	// GetBlobs returns the blobs in the blobs bundle.
	GetBlobs() []*eip4844.Blob
}

type BlobsBundleV1[
	C, P ~[48]byte, B ~[131072]byte,
] struct {
	// Commitments are the KZG commitments included in the bundle.
	Commitments []C `json:"commitments"`
	// Proofs are the KZG proofs corresponding to the commitments.
	Proofs []P `json:"proofs"`
	// Blobs are arbitrary data blobs included in the bundle.
	Blobs []*B `json:"blobs"`
}

type Block = coretypes.Block

type BuiltExecutionPayloadEnv interface {
	// GetExecutionPayload retrieves the associated execution payload.
	GetExecutionPayload() ExecutionPayload
	// GetValue returns the Wei value of the block in the execution payload.
	GetValue() math.Wei
	// GetBlobsBundle fetches the associated BlobsBundleV1 if available.
	GetBlobsBundle() BlobsBundle
	// ShouldOverrideBuilder indicates if the builder should be overridden.
	ShouldOverrideBuilder() bool
}

type ClientVersionV1 = engine.ClientVersionV1

type ExecutableData = engine.ExecutableData

type ExecutionPayload interface {
	ExecutionPayloadBody
	GetTransactions() [][]byte
	// TODO: decouple from consensus-types
	GetWithdrawals() []*Withdrawal
}

type ExecutionPayloadBody interface {
	ssz.Marshaler
	ssz.Unmarshaler
	ssz.HashRoot
	IsNil() bool
	Version() uint32
	IsBlinded() bool
	GetPrevRandao() primitives.Bytes32
	GetBlockHash() common.ExecutionHash
	GetParentHash() common.ExecutionHash
	GetNumber() math.U64
	GetGasLimit() math.U64
	GetGasUsed() math.U64
	GetTimestamp() math.U64
	GetExtraData() []byte
	GetBaseFeePerGas() math.Wei
	GetFeeRecipient() common.ExecutionAddress
	GetStateRoot() primitives.Bytes32
	GetReceiptsRoot() primitives.Bytes32
	GetLogsBloom() []byte
	GetBlobGasUsed() math.U64
	GetExcessBlobGas() math.U64
}

type ExecutionPayloadEnvelope[
	ExecutionPayloadT ExecutionPayload,
	BlobsBundleT BlobsBundle,
] struct {
	ExecutionPayload ExecutionPayloadT `json:"executionPayload"`
	BlockValue       math.Wei          `json:"blockValue"`
	BlobsBundle      BlobsBundleT      `json:"blobsBundle"`
	Override         bool              `json:"shouldOverrideBuilder"`
}

type ExecutionPayloadHeader interface {
	ExecutionPayloadBody
	GetTransactionsRoot() primitives.Root
	GetWithdrawalsRoot() primitives.Root
}

type ForkchoiceResponseV1 struct {
	// PayloadStatus is the payload status.
	PayloadStatus PayloadStatusV1 `json:"payloadStatus"`

	// PayloadID isthe identifier of the payload build process, it
	// can also be `nil`.
	PayloadID *PayloadID `json:"payloadId"`
}

type ForkchoiceStateV1 struct {
	// HeadBlockHash is the desired block hash of the head of the canonical
	// chain.
	HeadBlockHash common.ExecutionHash `json:"headBlockHash"`

	// SafeBlockHash is  the "safe" block hash of the canonical chain under
	// certain
	// synchrony and honesty assumptions. This value MUST be either equal to
	// or an ancestor of `HeadBlockHash`.
	SafeBlockHash common.ExecutionHash `json:"safeBlockHash"`

	// FinalizedBlockHash is the desired block hash of the most recent finalized
	// block
	FinalizedBlockHash common.ExecutionHash `json:"finalizedBlockHash"`
}

type ForkchoiceUpdateRequest struct {
	// State is the forkchoice state.
	State *ForkchoiceStateV1
	// PayloadAttributes is the payload attributer.
	PayloadAttributes PayloadAttributer
	// ForkVersion is the fork version that we
	// are going to be submitting for.
	ForkVersion uint32
}

type GetPayloadRequest struct {
	// PayloadID is the payload ID.
	PayloadID PayloadID
	// ForkVersion is the fork version that we are
	// currently on.
	ForkVersion uint32
}

type Header = coretypes.Header

type Log = coretypes.Log

type NewPayloadRequest[
	ExecutionPayloadT interface {
		GetTransactions() [][]byte
		Version() uint32
	},
] struct {
	// ExecutionPayload is the payload to the execution client.
	ExecutionPayload ExecutionPayloadT
	// VersionedHashes is the versioned hashes of the execution payload.
	VersionedHashes []common.ExecutionHash
	// ParentBeaconBlockRoot is the root of the parent beacon block.
	ParentBeaconBlockRoot *primitives.Root
	// SkipIfExists is a flag that indicates if the payload should be skipped
	// if it alreadyexists in the database of the execution client.
	SkipIfExists bool
	// Optimistic is a flag that indicates if the payload should be
	// optimistically deemed valid. This is useful during syncing.
	Optimistic bool
}

type PayloadAttributer interface {
	// IsNil returns true if the PayloadAttributer is nil.
	IsNil() bool

	// Version returns the version of the PayloadAttributer.
	Version() uint32

	// Validate checks if the PayloadAttributer is valid and returns an error if
	// it is not.
	Validate() error

	// GetSuggestedFeeRecipient returns the suggested fee recipient for the
	// block.
	GetSuggestedFeeRecipient() common.ExecutionAddress
}

type PayloadAttributes[
	Withdrawal SSZMarshallable,
] struct {

	// Timestamp is the timestamp at which the block will be built at.
	Timestamp math.U64 `json:"timestamp"`
	// PrevRandao is the previous Randao value from the beacon chain as
	// per EIP-4399.
	PrevRandao primitives.Bytes32 `json:"prevRandao"`
	// SuggestedFeeRecipient is the suggested fee recipient for the block. If
	// the execution client has a different fee recipient, it will typically
	// ignore this value.
	SuggestedFeeRecipient common.ExecutionAddress `json:"suggestedFeeRecipient"`
	// Withdrawals is the list of withdrawals to be included in the block as per
	// EIP-4895
	Withdrawals []Withdrawal `json:"withdrawals"`
	// ParentBeaconBlockRoot is the root of the parent beacon block. (The block
	// prior)
	// to the block currently being processed. This field was added for
	// EIP-4788.
	ParentBeaconBlockRoot primitives.Root `json:"parentBeaconBlockRoot"`
	// contains filtered or unexported fields
}

type PayloadID = bytes.B8

type PayloadStatusStr = string

type PayloadStatusV1 struct {
	// Status string of the payload.
	Status string `json:"status"`

	// LatestValidHash is the hash of the most recent valid block
	// in the branch defined by payload and its ancestors
	LatestValidHash *common.ExecutionHash `json:"latestValidHash"`

	// ValidationError is a message providing additional details on
	// the validation error if the payload is classified as
	// INVALID or INVALID_BLOCK_HASH
	ValidationError *string `json:"validationError"`
}

type SSZMarshallable interface {
	// MarshalSSZTo marshals the object into the provided byte slice and returns
	// it along with any error.
	MarshalSSZTo([]byte) ([]byte, error)
	// MarshalSSZ marshals the object into a new byte slice and returns it along
	// with any error.
	MarshalSSZ() ([]byte, error)
	// UnmarshalSSZ unmarshals the object from the provided byte slice and
	// returns an error if the unmarshaling fails.
	UnmarshalSSZ([]byte) error
	// SizeSSZ returns the size in bytes that the object would take when
	// marshaled.
	SizeSSZ() int
}

type Transactions [][]byte

type Withdrawal struct {
	Index     math.U64                `json:"index"`
	Validator math.ValidatorIndex     `json:"validatorIndex"`
	Address   common.ExecutionAddress `json:"address"        ssz-size:"20"`
	Amount    math.Gwei               `json:"amount"`
}

type Withdrawals []*Withdrawal