api

type AggregateAttestationOpts struct {
	Common CommonOpts

	// Slot is the slot for which the data is obtained.
	Slot phase0.Slot
	// AttestationDataRoot is the root for which the data is obtained.
	AttestationDataRoot phase0.Root
	// CommitteeIndex is the committee index the attestation data belongs to.
	CommitteeIndex phase0.CommitteeIndex
}

type AttestationDataOpts struct {
	Common CommonOpts

	// Slot is the slot for which the data is obtained.
	Slot phase0.Slot
	// CommitteeIndex is the committee index for which the data is obtained.
	CommitteeIndex phase0.CommitteeIndex
}

type AttestationEventHandlerFunc func(context.Context, *spec.VersionedAttestation)

type AttestationPoolOpts struct {
	Common CommonOpts

	// Slot is the slot for which the data is obtained.  If not present then
	// data for all slots will be obtained.
	Slot *phase0.Slot

	// CommitteeIndex is the committee index for which the data is obtained.
	// If not present then data for all committee indices will be obtained.
	CommitteeIndex *phase0.CommitteeIndex
}

type AttestationRewardsOpts struct {
	Common CommonOpts

	// Epoch is the epoch for which the data is obtained.
	Epoch phase0.Epoch
	// Indices is a list of validator indices to restrict the returned values.
	// If no indices are supplied then no filter will be applied.
	Indices []phase0.ValidatorIndex
	// PubKeys is a list of validator public keys to restrict the returned values.
	// If no public keys are supplied then no filter will be applied.
	PubKeys []phase0.BLSPubKey
}

type AttesterDutiesOpts struct {
	Common CommonOpts

	// Epoch is the epoch for which the data is obtained.
	Epoch phase0.Epoch
	// Indices is a list of validators for which to obtain the duties.
	Indices []phase0.ValidatorIndex
}

type AttesterSlashingEventHandlerFunc func(context.Context, *electra.AttesterSlashing)

type BLSToExecutionChangeEventHandlerFunc func(context.Context, *capella.SignedBLSToExecutionChange)

type BeaconBlockHeaderOpts struct {
	Common CommonOpts

	// Block is the ID of the block which the data is obtained.
	Block string
}

type BeaconBlockRootOpts struct {
	Common CommonOpts

	// Block is the ID of the block which the data is obtained.
	Block string
}

type BeaconCommitteeSelectionsOpts struct {
	Common CommonOpts

	// Beacon Committee Selections are the selections which the DV should resolve.
	Selections []*apiv1.BeaconCommitteeSelection
}

type BeaconCommitteesOpts struct {
	Common CommonOpts

	// State is the state at which the data is obtained.
	// It can be a slot number or state root, or one of the special values "genesis", "head", "justified" or "finalized".
	State string
	// Epoch is the epoch for which the data is obtained.
	// This is optional; if not supplied it will obtain the data at the epoch relating to the state.
	Epoch *phase0.Epoch
}

type BeaconStateOpts struct {
	Common CommonOpts

	// State is the state at which the data is obtained.
	// It can be a slot number or state root, or one of the special values "genesis", "head", "justified" or "finalized".
	State string
}

type BeaconStateRandaoOpts struct {
	Common CommonOpts

	// State is the state at which the data is obtained.
	// It can be a slot number or state root, or one of the special values "genesis", "head", "justified" or "finalized".
	State string
}

type BeaconStateRootOpts struct {
	Common CommonOpts

	// State is the state at which the data is obtained.
	// It can be a slot number or state root, or one of the special values "genesis", "head", "justified" or "finalized".
	State string
}

type BlindedProposalOpts struct {
	Common CommonOpts

	// Slot is the slot for which the proposal should be fetched.
	Slot phase0.Slot
	// RandaoReveal is the RANDAO reveal for the proposal.
	RandaoReveal phase0.BLSSignature
	// Graffiti is the graffiti to be included in the beacon block body.
	Graffiti [32]byte
	// SkipRandaoVerification is true if we do not want the server to verify our RANDAO reveal.
	// If this is set then the RANDAO reveal should be passed as the point at infinity (0xc0…00)
	SkipRandaoVerification bool
}

type BlobSidecarEventHandlerFunc func(context.Context, *apiv1.BlobSidecarEvent)

type BlobSidecars struct {
	Sidecars []*deneb.BlobSidecar `ssz-max:"72"`
}

type BlobSidecarsOpts struct {
	Common CommonOpts

	// Block is the ID of the block for which the data is obtained.
	Block string
}

type BlobsOpts struct {
	Common CommonOpts

	// Block is the ID of the block for which the data is obtained.
	Block string
}

type BlockEventHandlerFunc func(context.Context, *apiv1.BlockEvent)

type BlockGossipEventHandlerFunc func(context.Context, *apiv1.BlockGossipEvent)

type BlockRewardsOpts struct {
	Common CommonOpts

	// Block is the ID of the block which the data is obtained.
	Block string
}

type ChainReorgEventHandlerFunc func(context.Context, *apiv1.ChainReorgEvent)

type CommonOpts struct {
	// Timeout is a specific timeout for this call.
	// If 0 then the default timeout is used.
	Timeout time.Duration
}

type ContributionAndProofEventHandlerFunc func(context.Context, *altair.SignedContributionAndProof)

type DataColumnSidecarEventHandlerFunc func(context.Context, *apiv1.DataColumnSidecarEvent)

type DepositContractOpts struct {
	Common CommonOpts
}

type EPBSProposalOpts struct {
	Common CommonOpts

	// Slot is the slot for which the proposal should be fetched.
	Slot phase0.Slot
	// RandaoReveal is the RANDAO reveal for the proposal.
	RandaoReveal phase0.BLSSignature
	// Graffiti is the graffiti to be included in the beacon block body.
	Graffiti [32]byte
	// SkipRandaoVerification is true if we do not want the server to verify our RANDAO reveal.
	// If this is set then the RANDAO reveal should be passed as the point at infinity (0xc0…00)
	SkipRandaoVerification bool
	// BuilderConfig supplies the required P2P and direct-builder bid policy.
	BuilderConfig *gloas.BuilderConfig
	// IncludePayload selects whether a self-built proposal carries its execution
	// payload envelope and blobs.
	//
	// True asks a self-building node for the stateless form: everything needed to
	// publish travels in the response, so any beacon node can publish the block.
	// This is what multiple-beacon-node, distributed-validator and failover setups
	// require.  It is a request rather than a guarantee: a block built on an
	// external builder's bid comes back with
	// VersionedEPBSProposal.ExecutionPayloadIncluded false whatever was asked for,
	// because the node does not hold the builder's payload, so those setups must
	// read that field rather than assume this one describes what arrived.
	//
	// False is stateful: the producing node caches the envelope and blobs, so the
	// block must be published via that same node, and the envelope retrieved from
	// it with ExecutionPayloadEnvelope() — but only when the node self-built the
	// block. An external builder's bid comes back excluded regardless of what was
	// asked for, and the response alone does not say which case occurred; that is
	// operational context the caller must already know.
	//
	// The spec marks this parameter required with no default, and the two choices
	// carry materially different operational constraints, so it is a pointer:
	// there is no safe value to assume on the caller's behalf, and leaving it
	// unset is rejected rather than silently resolved to the constraining mode.
	IncludePayload *bool
}

type Error struct {
	Method     string
	Endpoint   string
	StatusCode int
	Data       []byte
}

type EventHandlerFunc func(*apiv1.Event)

type EventsOpts struct {
	Common CommonOpts

	// Topics are the topics of events to which we want to listen.
	Topics []string

	// Handler is a generic handler function to which to send all events.
	// In general, it is better to use event-specific handlers as they avoid casting, and also provide a context.
	Handler EventHandlerFunc

	// AttestationHandler is a handler for the attestation event.
	AttestationHandler AttestationEventHandlerFunc
	// AttesterSlashingHandler is a handler for the attester_slashing event.
	AttesterSlashingHandler AttesterSlashingEventHandlerFunc
	// BlobSidecarHandler is a handler for the blob_sidecar event.
	BlobSidecarHandler BlobSidecarEventHandlerFunc
	// BlockHandler is a handler for the block event.
	BlockHandler BlockEventHandlerFunc
	// BlockGossipHandler is a handler for the block_gossip event.
	BlockGossipHandler BlockGossipEventHandlerFunc
	// BLSToExecutionChangeHandler is a handler for the bls_to_execution_change event.
	BLSToExecutionChangeHandler BLSToExecutionChangeEventHandlerFunc
	// ChainReorgHandler is a handler for the chain_reorg event.
	ChainReorgHandler ChainReorgEventHandlerFunc
	// ContributionAndProofHandler is a handler for the contribution_and_proof event.
	ContributionAndProofHandler ContributionAndProofEventHandlerFunc
	// DataColumnSidecarHandler is a handler for the data_column_sidecar event.
	DataColumnSidecarHandler DataColumnSidecarEventHandlerFunc
	// ExecutionPayloadHandler is a handler for the execution_payload event
	// (SignedExecutionPayloadEnvelope successfully imported on the fork-choice).
	ExecutionPayloadHandler ExecutionPayloadEventHandlerFunc
	// ExecutionPayloadAvailableHandler is a handler for the execution_payload_available event.
	ExecutionPayloadAvailableHandler ExecutionPayloadAvailableEventHandlerFunc
	// ExecutionPayloadBidHandler is a handler for the execution_payload_bid event.
	ExecutionPayloadBidHandler ExecutionPayloadBidEventHandlerFunc
	// ExecutionPayloadGossipHandler is a handler for the execution_payload_gossip event
	// (SignedExecutionPayloadEnvelope passed gossip validation).
	ExecutionPayloadGossipHandler ExecutionPayloadGossipEventHandlerFunc
	// FastConfirmationHandler is a handler for the fast_confirmation event.
	FastConfirmationHandler FastConfirmationEventHandlerFunc
	// FinalizedCheckpointHandler is a handler for the finalized_checkpoint event.
	FinalizedCheckpointHandler FinalizedCheckpointEventHandlerFunc
	// HeadHandler is a handler for the head event.
	HeadHandler HeadEventHandlerFunc
	// HeadV2Handler is a handler for the head_v2 event.
	HeadV2Handler HeadV2EventHandlerFunc
	// PayloadAttestationMessageHandler is a handler for the payload_attestation_message event.
	PayloadAttestationMessageHandler PayloadAttestationMessageEventHandlerFunc
	// PayloadAttributesHandler is a handler for the payload_attributes event.
	PayloadAttributesHandler PayloadAttributesEventHandlerFunc
	// ProposerPreferencesHandler is a handler for the proposer_preferences event.
	ProposerPreferencesHandler ProposerPreferencesEventHandlerFunc
	// ProposerSlashingHandler is a handler for the proposer_slashing event.
	ProposerSlashingHandler ProposerSlashingEventHandlerFunc
	// SingleAttestationHandler is a handler for the single_attestation event.
	SingleAttestationHandler SingleAttestationEventHandlerFunc
	// VoluntaryExitHandler is a handler for the voluntary_exit event.
	VoluntaryExitHandler VoluntaryExitEventHandlerFunc
}

type ExecutionPayloadAvailableEventHandlerFunc func(context.Context, *apiv1.ExecutionPayloadAvailableEvent)

type ExecutionPayloadBidEventHandlerFunc func(context.Context, *gloas.SignedExecutionPayloadBid)

type ExecutionPayloadEnvelopeOpts struct {
	Common CommonOpts

	// Slot is the slot for which the envelope was built.
	Slot phase0.Slot
	// BeaconBlockRoot is the root of the beacon block the envelope commits to.
	//
	// Passing it makes the lookup re-org resistant: if a re-org happens between
	// producing the block and retrieving the envelope, the caller gets nothing
	// rather than an envelope committed to a block that is no longer on the
	// chain.  The node is expected to check the cached envelope against it, and
	// the returned envelope's own root is checked against it again here, so a
	// node that does not is caught rather than trusted.
	BeaconBlockRoot phase0.Root
}

type ExecutionPayloadEventHandlerFunc func(context.Context, *apiv1.ExecutionPayloadEvent)

type ExecutionPayloadGossipEventHandlerFunc func(context.Context, *apiv1.ExecutionPayloadGossipEvent)

type FastConfirmationEventHandlerFunc func(context.Context, *apiv1.FastConfirmationEvent)

type FinalityOpts struct {
	Common CommonOpts

	// State is the state at which the data is obtained.
	// It can be a slot number or state root, or one of the special values "genesis", "head", "justified" or "finalized".
	State string
}

type FinalizedCheckpointEventHandlerFunc func(context.Context, *apiv1.FinalizedCheckpointEvent)

type ForkChoiceOpts struct {
	Common CommonOpts
}

type ForkOpts struct {
	Common CommonOpts

	// State is the state at which the data is obtained.
	// It can be a slot number or state root, or one of the special values "genesis", "head", "justified" or "finalized".
	State string
}

type ForkScheduleOpts struct {
	Common CommonOpts
}

type GenesisOpts struct {
	Common CommonOpts
}

type HeadEventHandlerFunc func(context.Context, *apiv1.HeadEvent)

type HeadV2EventHandlerFunc func(context.Context, *apiv1.HeadEventV2)

type NodePeersOpts struct {
	Common CommonOpts

	// State of the connection (disconnected, connecting, connected, disconnecting)
	State []string
	// Direction of the connection (inbound, outbound)
	Direction []string
}

type NodeSyncingOpts struct {
	Common CommonOpts
}

type NodeVersionOpts struct {
	Common CommonOpts
}

type PTCDutiesOpts struct {
	Common CommonOpts

	// Epoch is the epoch for which the data is obtained.
	Epoch phase0.Epoch
	// Indices is a list of validators for which to obtain the duties.
	Indices []phase0.ValidatorIndex
}

type PayloadAttestationDataOpts struct {
	Common CommonOpts

	// Slot is the slot for which the data is obtained.
	Slot phase0.Slot
}

type PayloadAttestationMessageEventHandlerFunc func(context.Context, *gloas.PayloadAttestationMessage)

type PayloadAttestationPoolOpts struct {
	Common CommonOpts

	// Slot is the slot for which the data is obtained.  If not present then
	// data for all slots will be obtained.  Note that some beacon nodes
	// require a slot and will reject a request without one.
	Slot *phase0.Slot
}

type PayloadAttributesEventHandlerFunc func(context.Context, *apiv1.PayloadAttributesEvent)

type PendingConsolidationsOpts struct {
	Common CommonOpts

	// State is the state at which the data is obtained.
	// It can be a slot number or state root, or one of the special values "genesis", "head", "justified" or "finalized".
	State string
}

type PendingDepositsOpts struct {
	Common CommonOpts

	// State is the state at which the data is obtained.
	// It can be a slot number or state root, or one of the special values "genesis", "head", "justified" or "finalized".
	State string
}

type PendingPartialWithdrawalsOpts struct {
	Common CommonOpts

	// State is the state at which the data is obtained.
	// It can be a slot number or state root, or one of the special values "genesis", "head", "justified" or "finalized".
	State string
}

type ProposalOpts struct {
	Common CommonOpts

	// Slot is the slot for which the proposal should be fetched.
	Slot phase0.Slot
	// RandaoReveal is the RANDAO reveal for the proposal.
	RandaoReveal phase0.BLSSignature
	// Graffiti is the graffiti to be included in the beacon block body.
	Graffiti [32]byte
	// SkipRandaoVerification is true if we do not want the server to verify our RANDAO reveal.
	// If this is set then the RANDAO reveal should be passed as the point at infinity (0xc0…00)
	SkipRandaoVerification bool
	// BuilderBoostFactor is the relative weight of the builder payload versus a locally-produced
	// payload, as per https://ethereum.github.io/beacon-APIs/#/Validator/produceBlockV3
	// This is optional; if not supplied it will use the default value of 100.
	BuilderBoostFactor *uint64
}

type ProposerDutiesOpts struct {
	Common CommonOpts

	// Epoch is the epoch for which the data is obtained.
	Epoch phase0.Epoch
	// Indices is a list of validators to restrict the returned values.
	// If no indices are supplied then no filter will be applied.
	Indices []phase0.ValidatorIndex
}

type ProposerPreferencesEventHandlerFunc func(context.Context, *gloas.SignedProposerPreferences)

type ProposerSlashingEventHandlerFunc func(context.Context, *phase0.ProposerSlashing)

type Response[T any] struct {
	Data     T
	Metadata map[string]any
}

type SignedBeaconBlockOpts struct {
	Common CommonOpts

	// Block is the ID of the block which the data is obtained.
	Block string
}

type SignedExecutionPayloadEnvelopeOpts struct {
	Common CommonOpts

	// Block is the ID of the block which the data is obtained.
	Block string
}

type SingleAttestationEventHandlerFunc func(context.Context, *electra.SingleAttestation)

type SpecOpts struct {
	Common CommonOpts
}

type SubmitAggregateAttestationsOpts struct {
	Common CommonOpts

	// SignedAggregateAndProofs are the aggregate and proofs to submit.
	SignedAggregateAndProofs []*spec.VersionedSignedAggregateAndProof
}

type SubmitAttestationsOpts struct {
	Common CommonOpts

	// Attestations are the attestations to submit.
	Attestations []*spec.VersionedAttestation
}

type SubmitBlindedProposalOpts struct {
	Common CommonOpts

	// Proposal is the proposal to submit.
	Proposal *VersionedSignedBlindedProposal

	// BroadcastValidation is the validation required of the consensus node before broadcasting the proposal.
	BroadcastValidation *apiv2.BroadcastValidation
}

type SubmitExecutionPayloadBidOpts struct {
	Common CommonOpts

	// SignedExecutionPayloadBid is the signed bid to publish. Its Version
	// selects the wire schema and the consensus version header.
	SignedExecutionPayloadBid *spec.VersionedSignedExecutionPayloadBid
}

type SubmitExecutionPayloadEnvelopeOpts struct {
	Common CommonOpts

	// SignedExecutionPayloadEnvelope is the signed envelope to publish.
	// Its Version selects the wire schema and the consensus version header.
	SignedExecutionPayloadEnvelope *spec.VersionedSignedExecutionPayloadEnvelope

	// KZGProofs are the cell KZG proofs for the blobs committed to by the
	// envelope's payload.
	KZGProofs []deneb.KZGProof

	// Blobs are the blobs committed to by the envelope's payload.
	Blobs []deneb.Blob

	// BroadcastValidation is the validation required of the consensus node
	// before broadcasting the envelope.
	BroadcastValidation *apiv2.BroadcastValidation
}

type SubmitPayloadAttestationMessagesOpts struct {
	Common CommonOpts

	// Messages are the payload attestation messages to submit.  They must all
	// be of the same version.
	Messages []*spec.VersionedPayloadAttestationMessage
}

type SubmitProposalOpts struct {
	Common CommonOpts

	// Proposal is the proposal to submit.
	Proposal *VersionedSignedProposal

	// BroadcastValidation is the validation required of the consensus node before broadcasting the proposal.
	BroadcastValidation *apiv2.BroadcastValidation

	// BuilderURL is the optional direct-builder route returned by block production.
	BuilderURL string
}

type SubmitProposerPreferencesOpts struct {
	Common CommonOpts

	// Preferences are the signed proposer preferences to submit.  Proposer
	// preferences exist only from Gloas onwards, so they are unversioned.  An
	// empty list is a valid submission.
	Preferences []*gloas.SignedProposerPreferences
}

type SyncCommitteeContributionOpts struct {
	Common CommonOpts

	// Slot is the slot for which the data is obtained.
	Slot phase0.Slot
	// SubcommitteeIndex is the index of the sync subcommittee for which the data is obtained.
	SubcommitteeIndex uint64
	// BeaconBlockRoot is the root of the beacon block for which the data is obtained.
	BeaconBlockRoot phase0.Root
}

type SyncCommitteeDutiesOpts struct {
	Common CommonOpts

	// Epoch is the epoch for which the data is obtained.
	Epoch phase0.Epoch
	// Indices is a list of validators for which to obtain the duties.
	Indices []phase0.ValidatorIndex
}

type SyncCommitteeOpts struct {
	Common CommonOpts

	// State is the state at which the data is obtained.
	// It can be a slot number or state root, or one of the special values "genesis", "head", "justified" or "finalized".
	State string
	// Epoch is the epoch for which the data is obtained.
	// This is optional; if not supplied it will obtain the data at the epoch relating to the state.
	Epoch *phase0.Epoch
}

type SyncCommitteeRewardsOpts struct {
	Common CommonOpts

	// Block is the ID of the block which the data is obtained.
	Block string
	// Indices is a list of validator indices to restrict the returned values.
	// If no indices are supplied then no filter will be applied.
	Indices []phase0.ValidatorIndex
	// PubKeys is a list of validator public keys to restrict the returned values.
	// If no public keys are supplied then no filter will be applied.
	PubKeys []phase0.BLSPubKey
}

type ValidatorBalancesOpts struct {
	Common CommonOpts

	// State is the state at which the data is obtained.
	// It can be a slot number or state root, or one of the special values "genesis", "head", "justified" or "finalized".
	State string
	// Indices is a list of validator indices to restrict the returned values.
	// If no indices are supplied then no filter will be applied.
	Indices []phase0.ValidatorIndex
	// PubKeys is a list of validator public keys to restrict the returned values.
	// If no public keys are supplied then no filter will be applied.
	PubKeys []phase0.BLSPubKey
}

type ValidatorLivenessOpts struct {
	Common CommonOpts

	// Epoch is the epoch for which the data is obtained.
	Epoch phase0.Epoch
	// Indices is a list of validators for which to obtain the duties.
	Indices []phase0.ValidatorIndex
}

type ValidatorsOpts struct {
	Common CommonOpts

	// State is the state at which the data is obtained.
	// It can be a slot number or state root, or one of the special values "genesis", "head", "justified" or "finalized".
	State string
	// Indices is a list of validator indices to restrict the returned values.
	// If no indices are supplied then no filter will be applied.
	Indices []phase0.ValidatorIndex
	// PubKeys is a list of validator public keys to restrict the returned values.
	// If no public keys are supplied then no filter will be applied.
	PubKeys []phase0.BLSPubKey
	// ValidatorStates is a list of validator states to restrict the returned values.
	// If no validator states are supplied then no filter will be applied.
	ValidatorStates []apiv1.ValidatorState
}

type VersionedBlindedBeaconBlock struct {
	Version   spec.DataVersion
	Bellatrix *apiv1bellatrix.BlindedBeaconBlock
	Capella   *apiv1capella.BlindedBeaconBlock
	Deneb     *apiv1deneb.BlindedBeaconBlock
	Electra   *apiv1electra.BlindedBeaconBlock
	Fulu      *apiv1electra.BlindedBeaconBlock
}

type VersionedBlindedProposal struct {
	Version   spec.DataVersion
	Bellatrix *apiv1bellatrix.BlindedBeaconBlock
	Capella   *apiv1capella.BlindedBeaconBlock
	Deneb     *apiv1deneb.BlindedBeaconBlock
	Electra   *apiv1electra.BlindedBeaconBlock
	Fulu      *apiv1electra.BlindedBeaconBlock
}

type VersionedBlockRequest struct {
	Version   spec.DataVersion
	Bellatrix *bellatrix.SignedBeaconBlock
	Capella   *capella.SignedBeaconBlock
	Deneb     *deneb.SignedBeaconBlock
	Electra   *electra.SignedBeaconBlock
	Fulu      *electra.SignedBeaconBlock
}

type VersionedEPBSProposal struct {
	Version spec.DataVersion
	// ExecutionPayloadIncluded selects which arm below carries the proposal.
	ExecutionPayloadIncluded bool
	BuilderIndex             *gloas.BuilderIndex
	ConsensusValue           *big.Int
	ExecutionValue           *big.Int
	// Gloas is the proposal when the execution payload is not included.
	Gloas *gloas.BeaconBlock
	// GloasContents is the proposal when the execution payload is included.
	GloasContents *apiv1gloas.BlockContents
	// BeaconBlockBodyRoot is the hash tree root of the proposal's beacon block
	// body, calculated with the codec that decoded the proposal -- the one
	// aware of whatever preset the connected node actually runs.  The
	// generated HashTreeRoot methods on the gloas types inline mainnet preset
	// sizes (for example a 512-bit sync committee bitvector) as Go literals
	// and never consult that codec, so they compute the wrong root on any
	// other preset.  A beacon block's own root has no preset-dependent field
	// of its own: it merkleizes slot, proposer index, parent root, state root
	// and this body root, exactly like phase0.BeaconBlockHeader.  The body
	// root is therefore the only preset-sensitive quantity in a block, and
	// whatever obtains the proposal is responsible for setting this field
	// with the spec-aware root.  BodyRoot errors when it is unset rather than
	// falling back to the generated, potentially wrong, Body.HashTreeRoot().
	BeaconBlockBodyRoot *phase0.Root
}

type VersionedProposal struct {
	Version          spec.DataVersion
	Blinded          bool
	ConsensusValue   *big.Int
	ExecutionValue   *big.Int
	Phase0           *phase0.BeaconBlock
	Altair           *altair.BeaconBlock
	Bellatrix        *bellatrix.BeaconBlock
	BellatrixBlinded *apiv1bellatrix.BlindedBeaconBlock
	Capella          *capella.BeaconBlock
	CapellaBlinded   *apiv1capella.BlindedBeaconBlock
	Deneb            *apiv1deneb.BlockContents
	DenebBlinded     *apiv1deneb.BlindedBeaconBlock
	Electra          *apiv1electra.BlockContents
	ElectraBlinded   *apiv1electra.BlindedBeaconBlock
	Fulu             *apiv1fulu.BlockContents
	FuluBlinded      *apiv1electra.BlindedBeaconBlock
}

type VersionedSignedBlindedBeaconBlock struct {
	Version   spec.DataVersion
	Bellatrix *apiv1bellatrix.SignedBlindedBeaconBlock
	Capella   *apiv1capella.SignedBlindedBeaconBlock
	Deneb     *apiv1deneb.SignedBlindedBeaconBlock
	Electra   *apiv1electra.SignedBlindedBeaconBlock
	Fulu      *apiv1electra.SignedBlindedBeaconBlock
}

type VersionedSignedBlindedProposal struct {
	Version   spec.DataVersion
	Bellatrix *apiv1bellatrix.SignedBlindedBeaconBlock
	Capella   *apiv1capella.SignedBlindedBeaconBlock
	Deneb     *apiv1deneb.SignedBlindedBeaconBlock
	Electra   *apiv1electra.SignedBlindedBeaconBlock
	Fulu      *apiv1electra.SignedBlindedBeaconBlock
}

type VersionedSignedProposal struct {
	Version          spec.DataVersion
	Blinded          bool
	ConsensusValue   *big.Int
	ExecutionValue   *big.Int
	Phase0           *phase0.SignedBeaconBlock
	Altair           *altair.SignedBeaconBlock
	Bellatrix        *bellatrix.SignedBeaconBlock
	BellatrixBlinded *apiv1bellatrix.SignedBlindedBeaconBlock
	Capella          *capella.SignedBeaconBlock
	CapellaBlinded   *apiv1capella.SignedBlindedBeaconBlock
	Deneb            *apiv1deneb.SignedBlockContents
	DenebBlinded     *apiv1deneb.SignedBlindedBeaconBlock
	Electra          *apiv1electra.SignedBlockContents
	ElectraBlinded   *apiv1electra.SignedBlindedBeaconBlock
	Fulu             *apiv1fulu.SignedBlockContents
	FuluBlinded      *apiv1electra.SignedBlindedBeaconBlock
	Gloas            *gloas.SignedBeaconBlock
}

type VersionedSignedValidatorRegistration struct {
	Version spec.BuilderVersion                `json:"version"`
	V1      *apiv1.SignedValidatorRegistration `json:"v1"`
}

type VersionedValidatorRegistration struct {
	Version spec.BuilderVersion
	V1      *apiv1.ValidatorRegistration
}

type VoluntaryExitEventHandlerFunc func(context.Context, *phase0.SignedVoluntaryExit)

type VoluntaryExitPoolOpts struct {
	Common CommonOpts
}