client

type AggregateAttestationProvider interface {
	// AggregateAttestation fetches the aggregate attestation for the given options.
	AggregateAttestation(ctx context.Context,
		opts *api.AggregateAttestationOpts,
	) (
		*api.Response[*spec.VersionedAttestation],
		error,
	)
}

type AggregateAttestationsSubmitter interface {
	// SubmitAggregateAttestations submits aggregate attestations.
	SubmitAggregateAttestations(ctx context.Context, opts *api.SubmitAggregateAttestationsOpts) error
}

type AttestationDataProvider interface {
	// AttestationData fetches the attestation data for the given options.
	AttestationData(ctx context.Context,
		opts *api.AttestationDataOpts,
	) (
		*api.Response[*phase0.AttestationData],
		error,
	)
}

type AttestationPoolProvider interface {
	// AttestationPool fetches the attestation pool for the given options.
	AttestationPool(ctx context.Context,
		opts *api.AttestationPoolOpts,
	) (
		*api.Response[[]*spec.VersionedAttestation],
		error,
	)
}

type AttestationRewardsProvider interface {
	// AttestationRewards provides rewards to the given validators for attesting.
	AttestationRewards(ctx context.Context,
		opts *api.AttestationRewardsOpts,
	) (
		*api.Response[*apiv1.AttestationRewards],
		error,
	)
}

type AttestationsSubmitter interface {
	// SubmitAttestations submits attestations.
	SubmitAttestations(ctx context.Context, opts *api.SubmitAttestationsOpts) error
}

type AttesterDutiesProvider interface {
	// AttesterDuties obtains attester duties.
	AttesterDuties(ctx context.Context,
		opts *api.AttesterDutiesOpts,
	) (
		*api.Response[[]*apiv1.AttesterDuty],
		error,
	)
}

type AttesterSlashingSubmitter interface {
	// SubmitAttesterSlashing submits an attester slashing
	SubmitAttesterSlashing(ctx context.Context, slashing *phase0.AttesterSlashing) error
}

type BLSToExecutionChangesSubmitter interface {
	// SubmitBLSToExecutionChanges submits BLS to execution address change operations.
	SubmitBLSToExecutionChanges(ctx context.Context, blsToExecutionChanges []*capella.SignedBLSToExecutionChange) error
}

type BeaconBlockHeadersProvider interface {
	// BeaconBlockHeader provides the block header of a given block ID.
	BeaconBlockHeader(ctx context.Context,
		opts *api.BeaconBlockHeaderOpts,
	) (
		*api.Response[*apiv1.BeaconBlockHeader],
		error,
	)
}

type BeaconBlockRootProvider interface {
	// BeaconBlockRoot fetches a block's root given a set of options.
	BeaconBlockRoot(ctx context.Context,
		opts *api.BeaconBlockRootOpts,
	) (
		*api.Response[*phase0.Root],
		error,
	)
}

type BeaconBlockSubmitter interface {
	// SubmitBeaconBlock submits a beacon block.
	//
	// Deprecated: this will not work as of the deneb hard-fork.  Use ProposalSubmitter.SubmitProposal() instead.
	SubmitBeaconBlock(ctx context.Context, block *spec.VersionedSignedBeaconBlock) error
}

type BeaconCommitteeSubscriptionsSubmitter interface {
	// SubmitBeaconCommitteeSubscriptions subscribes to beacon committees.
	SubmitBeaconCommitteeSubscriptions(ctx context.Context, subscriptions []*apiv1.BeaconCommitteeSubscription) error
}

type BeaconCommitteesProvider interface {
	// BeaconCommittees fetches all beacon committees for the given options.
	BeaconCommittees(ctx context.Context,
		opts *api.BeaconCommitteesOpts,
	) (*api.Response[[]*apiv1.BeaconCommittee],
		error,
	)
}

type BeaconStateProvider interface {
	// BeaconState fetches a beacon state given a state ID.
	BeaconState(ctx context.Context,
		opts *api.BeaconStateOpts,
	) (*api.Response[*spec.VersionedBeaconState],
		error,
	)
}

type BeaconStateRandaoProvider interface {
	// BeaconStateRandao fetches a beacon state RANDAO given a state ID.
	BeaconStateRandao(ctx context.Context,
		opts *api.BeaconStateRandaoOpts,
	) (
		*api.Response[*phase0.Root],
		error,
	)
}

type BeaconStateRootProvider interface {
	// BeaconStateRoot fetches a beacon state root given a state ID.
	BeaconStateRoot(ctx context.Context,
		opts *api.BeaconStateRootOpts,
	) (
		*api.Response[*phase0.Root],
		error,
	)
}

type BlindedBeaconBlockSubmitter interface {
	// SubmitBlindedBeaconBlock submits a beacon block.
	//
	// Deprecated: this will not work as of the deneb hard-fork.  Use BlindedProposalSubmitter.SubmitBlindedProposal() instead.
	SubmitBlindedBeaconBlock(ctx context.Context, block *api.VersionedSignedBlindedBeaconBlock) error
}

type BlindedProposalSubmitter interface {
	// SubmitBlindedProposal submits a beacon block.
	SubmitBlindedProposal(ctx context.Context,
		opts *api.SubmitBlindedProposalOpts,
	) error
}

type BlobSidecarsProvider interface {
	// BlobSidecars fetches the blobs given a block ID.
	BlobSidecars(ctx context.Context,
		opts *api.BlobSidecarsOpts,
	) (
		*api.Response[[]*deneb.BlobSidecar],
		error)
}

type BlobsProvider interface {
	// Blobs fetches the blobs given a block ID.
	Blobs(ctx context.Context,
		opts *api.BlobsOpts,
	) (
		*api.Response[apiv1.Blobs],
		error)
}

type BlockRewardsProvider interface {
	// BlockRewards provides rewards for proposing a block.
	BlockRewards(ctx context.Context,
		opts *api.BlockRewardsOpts,
	) (
		*api.Response[*apiv1.BlockRewards],
		error,
	)
}

type DepositContractProvider interface {
	// DepositContract provides details of the execution deposit contract for the chain.
	DepositContract(ctx context.Context,
		opts *api.DepositContractOpts,
	) (
		*api.Response[*apiv1.DepositContract],
		error,
	)
}

type DomainProvider interface {
	// Domain provides a domain for a given domain type at a given epoch.
	Domain(ctx context.Context, domainType phase0.DomainType, epoch phase0.Epoch) (phase0.Domain, error)

	// GenesisDomain returns the domain for the given domain type at genesis.
	// N.B. this is not always the same as the domain at epoch 0.  It is possible
	// for a chain's fork schedule to have multiple forks at genesis.  In this situation,
	// GenesisDomain() will return the first, and Domain() will return the last.
	GenesisDomain(ctx context.Context, domainType phase0.DomainType) (phase0.Domain, error)
}

type EpochFromStateIDProvider interface {
	// EpochFromStateID converts a state ID to its epoch.
	//
	// Deprecated: will be removed in a future release.
	EpochFromStateID(ctx context.Context, stateID string) (phase0.Epoch, error)
}

type EventsProvider interface {
	// Events feeds requested events with the given topics to the supplied handler.
	Events(ctx context.Context, opts *api.EventsOpts) error
}

type FarFutureEpochProvider interface {
	// FarFutureEpoch provides the far future epoch of the chain.
	FarFutureEpoch(ctx context.Context) (phase0.Epoch, error)
}

type FinalityProvider interface {
	// Finality provides the finality given a state ID.
	Finality(ctx context.Context,
		opts *api.FinalityOpts,
	) (
		*api.Response[*apiv1.Finality],
		error,
	)
}

type ForkChoiceProvider interface {
	// Fork fetches all current fork choice context.
	ForkChoice(ctx context.Context,
		opts *api.ForkChoiceOpts,
	) (
		*api.Response[*apiv1.ForkChoice],
		error,
	)
}

type ForkProvider interface {
	// Fork fetches fork information for the given state.
	Fork(ctx context.Context,
		opts *api.ForkOpts,
	) (
		*api.Response[*phase0.Fork],
		error,
	)
}

type ForkScheduleProvider interface {
	// ForkSchedule provides details of past and future changes in the chain's fork version.
	ForkSchedule(ctx context.Context,
		opts *api.ForkScheduleOpts,
	) (
		*api.Response[[]*phase0.Fork],
		error,
	)
}

type GenesisProvider interface {
	// Genesis fetches genesis information for the chain.
	Genesis(ctx context.Context,
		opts *api.GenesisOpts,
	) (
		*api.Response[*apiv1.Genesis],
		error,
	)
}

type NodeClientProvider interface {
	// NodeClient provides the client for the node.
	NodeClient(ctx context.Context) (*api.Response[string], error)
}

type NodePeersProvider interface {
	// NodePeers provides the peers of the node.
	NodePeers(ctx context.Context,
		opts *api.NodePeersOpts,
	) (
		*api.Response[[]*apiv1.Peer],
		error,
	)
}

type NodeSyncingProvider interface {
	// NodeSyncing provides the state of the node's synchronization with the chain.
	NodeSyncing(ctx context.Context,
		opts *api.NodeSyncingOpts,
	) (
		*api.Response[*apiv1.SyncState],
		error,
	)
}

type NodeVersionProvider interface {
	// NodeVersion returns a free-text string with the node version.
	NodeVersion(ctx context.Context,
		opts *api.NodeVersionOpts,
	) (
		*api.Response[string],
		error,
	)
}

type PendingConsolidationsProvider interface {
	// PendingConsolidations provides the pending consolidations for a given state.
	PendingConsolidations(ctx context.Context,
		opts *api.PendingConsolidationsOpts,
	) (
		*api.Response[[]*electra.PendingConsolidation],
		error,
	)
}

type PendingDepositProvider interface {
	// PendingDeposits provides the pending deposits for a given state.
	PendingDeposits(ctx context.Context,
		opts *api.PendingDepositsOpts,
	) (
		*api.Response[[]*electra.PendingDeposit],
		error,
	)
}

type PendingPartialWithdrawalsProvider interface {
	// PendingPartialWithdrawals provides the pending partial withdrawals for a given state.
	PendingPartialWithdrawals(ctx context.Context,
		opts *api.PendingPartialWithdrawalsOpts,
	) (
		*api.Response[[]*electra.PendingPartialWithdrawal],
		error,
	)
}

type ProposalPreparationsSubmitter interface {
	// SubmitProposalPreparations provides the beacon node with information required if a proposal for the given validators
	// shows up in the next epoch.
	SubmitProposalPreparations(ctx context.Context, preparations []*apiv1.ProposalPreparation) error
}

type ProposalProvider interface {
	// Proposal fetches a proposal for signing.
	Proposal(ctx context.Context,
		opts *api.ProposalOpts,
	) (
		*api.Response[*api.VersionedProposal],
		error,
	)
}

type ProposalSlashingSubmitter interface {
	SubmitProposalSlashing(ctx context.Context, slashing *phase0.ProposerSlashing) error
}

type ProposalSubmitter interface {
	// SubmitProposal submits a proposal.
	SubmitProposal(ctx context.Context,
		opts *api.SubmitProposalOpts,
	) error
}

type ProposerDutiesProvider interface {
	// ProposerDuties obtains proposer duties for the given options.
	ProposerDuties(ctx context.Context,
		opts *api.ProposerDutiesOpts,
	) (
		*api.Response[[]*apiv1.ProposerDuty],
		error,
	)
}

type Service interface {
	// Name returns the name of the client implementation.
	Name() string

	// Address returns the address of the client.
	Address() string

	// IsActive returns true if the client is active.
	IsActive() bool

	// IsSynced returns true if the client is synced.
	IsSynced() bool
}

type SignedBeaconBlockProvider interface {
	// SignedBeaconBlock fetches a signed beacon block given a block ID.
	SignedBeaconBlock(ctx context.Context,
		opts *api.SignedBeaconBlockOpts,
	) (
		*api.Response[*spec.VersionedSignedBeaconBlock],
		error,
	)
}

type SlotDurationProvider interface {
	// SlotDuration provides the duration of a slot of the chain.
	//
	// Deprecated: use Spec()
	SlotDuration(ctx context.Context) (time.Duration, error)
}

type SlotFromStateIDProvider interface {
	// SlotFromStateID converts a state ID to its slot.
	//
	// Deprecated: will be removed in a future release.
	SlotFromStateID(ctx context.Context, stateID string) (phase0.Slot, error)
}

type SlotsPerEpochProvider interface {
	// SlotsPerEpoch provides the slots per epoch of the chain.
	//
	// Deprecated: use Spec()
	SlotsPerEpoch(ctx context.Context) (uint64, error)
}

type SpecProvider interface {
	// Spec provides the spec information of the chain.
	Spec(ctx context.Context,
		opts *api.SpecOpts,
	) (
		*api.Response[map[string]any],
		error,
	)
}

type SyncCommitteeContributionProvider interface {
	// SyncCommitteeContribution provides a sync committee contribution.
	SyncCommitteeContribution(ctx context.Context,
		opts *api.SyncCommitteeContributionOpts,
	) (
		*api.Response[*altair.SyncCommitteeContribution],
		error,
	)
}

type SyncCommitteeContributionsSubmitter interface {
	// SubmitSyncCommitteeContributions submits sync committee contributions.
	SubmitSyncCommitteeContributions(ctx context.Context, contributionAndProofs []*altair.SignedContributionAndProof) error
}

type SyncCommitteeDutiesProvider interface {
	// SyncCommitteeDuties obtains sync committee duties.
	// If validatorIndices is nil it will return all duties for the given epoch.
	SyncCommitteeDuties(ctx context.Context,
		opts *api.SyncCommitteeDutiesOpts,
	) (
		*api.Response[[]*apiv1.SyncCommitteeDuty],
		error,
	)
}

type SyncCommitteeMessagesSubmitter interface {
	// SubmitSyncCommitteeMessages submits sync committee messages.
	SubmitSyncCommitteeMessages(ctx context.Context, messages []*altair.SyncCommitteeMessage) error
}

type SyncCommitteeRewardsProvider interface {
	// SyncCommitteeRewards provides rewards to the given validators for being members of a sync committee.
	SyncCommitteeRewards(ctx context.Context,
		opts *api.SyncCommitteeRewardsOpts,
	) (
		*api.Response[[]*apiv1.SyncCommitteeReward],
		error,
	)
}

type SyncCommitteeSubscriptionsSubmitter interface {
	// SubmitSyncCommitteeSubscriptions subscribes to sync committees.
	SubmitSyncCommitteeSubscriptions(ctx context.Context, subscriptions []*apiv1.SyncCommitteeSubscription) error
}

type SyncCommitteesProvider interface {
	// SyncCommittee fetches the sync committee for the given state.
	SyncCommittee(ctx context.Context,
		opts *api.SyncCommitteeOpts,
	) (
		*api.Response[*apiv1.SyncCommittee],
		error,
	)
}

type SyncStateProvider interface {
	// SyncState provides the state of the node's synchronization with the chain.
	//
	// Deprecated: use NodeSyncing()
	SyncState(ctx context.Context) (*apiv1.SyncState, error)
}

type TargetAggregatorsPerCommitteeProvider interface {
	// TargetAggregatorsPerCommittee provides the target number of aggregators for each attestation committee.
	//
	// Deprecated: use Spec()
	TargetAggregatorsPerCommittee(ctx context.Context) (uint64, error)
}

type ValidatorBalancesProvider interface {
	// ValidatorBalances provides the validator balances for the given options.
	ValidatorBalances(ctx context.Context,
		opts *api.ValidatorBalancesOpts,
	) (
		*api.Response[map[phase0.ValidatorIndex]phase0.Gwei],
		error,
	)
}

type ValidatorIDProvider interface {
	ValidatorIndexProvider
	ValidatorPubKeyProvider
}

type ValidatorIndexProvider interface {
	// Index provides the index of the validator.
	Index(ctx context.Context) (phase0.ValidatorIndex, error)
}

type ValidatorLivenessProvider interface {
	// ValidatorLiveness provides the liveness data to the given validators.
	ValidatorLiveness(ctx context.Context,
		opts *api.ValidatorLivenessOpts,
	) (
		*api.Response[[]*apiv1.ValidatorLiveness],
		error,
	)
}

type ValidatorPubKeyProvider interface {
	// PubKey provides the public key of the validator.
	PubKey(ctx context.Context) (phase0.BLSPubKey, error)
}

type ValidatorRegistrationsSubmitter interface {
	// SubmitValidatorRegistrations submits a validator registration.
	SubmitValidatorRegistrations(ctx context.Context, registrations []*api.VersionedSignedValidatorRegistration) error
}

type ValidatorsProvider interface {
	// Validators provides the validators, with their balance and status, for the given options.
	Validators(ctx context.Context,
		opts *api.ValidatorsOpts,
	) (
		*api.Response[map[phase0.ValidatorIndex]*apiv1.Validator],
		error,
	)
}

type VoluntaryExitPoolProvider interface {
	// VoluntaryExitPool fetches the voluntary exit pool.
	VoluntaryExitPool(ctx context.Context,
		opts *api.VoluntaryExitPoolOpts,
	) (
		*api.Response[[]*phase0.SignedVoluntaryExit],
		error,
	)
}

type VoluntaryExitSubmitter interface {
	// SubmitVoluntaryExit submits a voluntary exit.
	SubmitVoluntaryExit(ctx context.Context, voluntaryExit *phase0.SignedVoluntaryExit) error
}