client

README

FORK to support pre-fork version of ssv-spec.

Documentation

Index

• type AggregateAttestationProvider
• type AggregateAttestationsSubmitter
• type AttestationDataProvider
• type AttestationPoolProvider
• type AttestationsSubmitter
• type AttesterDutiesProvider
• type AttesterSlashingSubmitter
• type BLSToExecutionChangesSubmitter
• type BeaconBlockHeadersProvider
• type BeaconBlockRootProvider
• type BeaconBlockSubmitter
• type BeaconCommitteeSubscriptionsSubmitter
• type BeaconCommitteesProvider
• type BeaconStateProvider
• type BeaconStateRandaoProvider
• type BeaconStateRootProvider
• type BlindedBeaconBlockSubmitter
• type BlindedProposalProvider
• type BlindedProposalSubmitter
• type BlobSidecarsProvider
• type DepositContractProvider
• type DomainProvider
• type EpochFromStateIDProvider
• type EventHandlerFunc
• type EventsProvider
• type FarFutureEpochProvider
• type FinalityProvider
• type ForkChoiceProvider
• type ForkProvider
• type ForkScheduleProvider
• type GenesisProvider
• type GenesisTimeProvider
• type NodeClientProvider
• type NodePeersProvider
• type NodeSyncingProvider
• type NodeVersionProvider
• type ProposalPreparationsSubmitter
• type ProposalProvider
• type ProposalSlashingSubmitter
• type ProposalSubmitter
• type ProposerDutiesProvider
• type Service
• type SignedBeaconBlockProvider
• type SlotDurationProvider
• type SlotFromStateIDProvider
• type SlotsPerEpochProvider
• type SpecProvider
• type SyncCommitteeContributionProvider
• type SyncCommitteeContributionsSubmitter
• type SyncCommitteeDutiesProvider
• type SyncCommitteeMessagesSubmitter
• type SyncCommitteeSubscriptionsSubmitter
• type SyncCommitteesProvider
• type SyncStateProvider
• type TargetAggregatorsPerCommitteeProvider
• type V3ProposalProvider
• type ValidatorBalancesProvider
• type ValidatorIDProvider
• type ValidatorIndexProvider
• type ValidatorPubKeyProvider
• type ValidatorRegistrationsSubmitter
• type ValidatorsProvider
• type VoluntaryExitPoolProvider
• type VoluntaryExitSubmitter

Types

type AggregateAttestationProvider

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

AggregateAttestationProvider is the interface for providing aggregate attestations.

type AggregateAttestationsSubmitter

type AggregateAttestationsSubmitter interface {
	// SubmitAggregateAttestations submits aggregate attestations.
	SubmitAggregateAttestations(ctx context.Context, aggregateAndProofs []*phase0.SignedAggregateAndProof) error
}

AggregateAttestationsSubmitter is the interface for submitting aggregate attestations.

type AttestationDataProvider

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

AttestationDataProvider is the interface for providing attestation data.

type AttestationPoolProvider

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

AttestationPoolProvider is the interface for providing attestation pools.

type AttestationsSubmitter

type AttestationsSubmitter interface {
	// SubmitAttestations submits attestations.
	SubmitAttestations(ctx context.Context, attestations []*phase0.Attestation) error
}

AttestationsSubmitter is the interface for submitting attestations.

type AttesterDutiesProvider

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

AttesterDutiesProvider is the interface for providing attester duties.

type AttesterSlashingSubmitter

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

AttesterSlashingSubmitter is the interface for submitting attester slashings.

type BLSToExecutionChangesSubmitter

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

BLSToExecutionChangesSubmitter is the interface for submitting BLS to execution address changes.

type BeaconBlockHeadersProvider

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)
}

BeaconBlockHeadersProvider is the interface for providing beacon block headers.

type BeaconBlockRootProvider

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)
}

BeaconBlockRootProvider is the interface for providing beacon block roots.

type BeaconBlockSubmitter

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

BeaconBlockSubmitter is the interface for submitting beacon blocks.

type BeaconCommitteeSubscriptionsSubmitter

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

BeaconCommitteeSubscriptionsSubmitter is the interface for submitting beacon committee subnet subscription requests.

type BeaconCommitteesProvider

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

BeaconCommitteesProvider is the interface for providing beacon committees.

type BeaconStateProvider

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

BeaconStateProvider is the interface for providing beacon state.

type BeaconStateRandaoProvider

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)
}

BeaconStateRandaoProvider is the interface for providing beacon state RANDAOs.

type BeaconStateRootProvider

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)
}

BeaconStateRootProvider is the interface for providing beacon state roots.

type BlindedBeaconBlockSubmitter

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

BlindedBeaconBlockSubmitter is the interface for submitting blinded beacon blocks.

type BlindedProposalProvider

type BlindedProposalProvider interface {
	// BlindedProposal fetches a blinded proposed beacon block for signing.
	BlindedProposal(ctx context.Context, opts *api.BlindedProposalOpts) (*api.Response[*api.VersionedBlindedProposal], error)
}

BlindedProposalProvider is the interface for providing blinded beacon block proposals.

type BlindedProposalSubmitter

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

BlindedProposalSubmitter is the interface for submitting blinded proposals.

type BlobSidecarsProvider

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

BlobSidecarsProvider is the interface for providing blobs for a given beacon block.

type DepositContractProvider

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)
}

DepositContractProvider is the interface for providing details about the deposit contract.

type DomainProvider

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)
}

DomainProvider provides a domain for a given domain type at an epoch.

type EpochFromStateIDProvider

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)
}

EpochFromStateIDProvider is the interface for providing epochs from state IDs.

type EventHandlerFunc

type EventHandlerFunc func(*apiv1.Event)

EventHandlerFunc is the handler for events.

type EventsProvider

type EventsProvider interface {
	// Events feeds requested events with the given topics to the supplied handler.
	Events(ctx context.Context, topics []string, handler EventHandlerFunc) error
}

EventsProvider is the interface for providing events.

type FarFutureEpochProvider

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

FarFutureEpochProvider is the interface for providing the far future epoch of a chain.

type FinalityProvider

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

FinalityProvider is the interface for providing finality information.

type ForkChoiceProvider

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

ForkChoiceProvider is the interface for providing fork choice information.

type ForkProvider

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

ForkProvider is the interface for providing fork information.

type ForkScheduleProvider

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)
}

ForkScheduleProvider is the interface for providing fork schedule data.

type GenesisProvider

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

GenesisProvider is the interface for providing genesis information.

type GenesisTimeProvider

type GenesisTimeProvider interface {
	// GenesisTime provides the genesis time of the chain.
	GenesisTime(ctx context.Context) (time.Time, error)
}

GenesisTimeProvider is the interface for providing the genesis time of a chain.

Deprecated: use Genesis().

type NodeClientProvider

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

NodeClientProvider provides the client for the node.

type NodePeersProvider

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

NodePeersProvider is the interface for providing peer information.

type NodeSyncingProvider

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)
}

NodeSyncingProvider is the interface for providing synchronization state.

type NodeVersionProvider

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

NodeVersionProvider is the interface for providing the node version.

type ProposalPreparationsSubmitter

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
}

ProposalPreparationsSubmitter is the interface for submitting proposal preparations.

type ProposalProvider

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

ProposalProvider is the interface for providing proposals.

type ProposalSlashingSubmitter

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

ProposalSlashingSubmitter is the interface for submitting proposal slashings.

type ProposalSubmitter

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

ProposalSubmitter is the interface for submitting proposals.

type ProposerDutiesProvider

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

ProposerDutiesProvider is the interface for providing proposer duties.

type Service

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

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

Service is the service providing a connection to an Ethereum 2 client.

type SignedBeaconBlockProvider

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)
}

SignedBeaconBlockProvider is the interface for providing beacon blocks.

type SlotDurationProvider

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

SlotDurationProvider is the interface for providing the duration of each slot of a chain.

type SlotFromStateIDProvider

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)
}

SlotFromStateIDProvider is the interface for providing slots from state IDs.

type SlotsPerEpochProvider

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

SlotsPerEpochProvider is the interface for providing the number of slots in each epoch of a chain.

type SpecProvider

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

SpecProvider is the interface for providing spec data.

type SyncCommitteeContributionProvider

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

SyncCommitteeContributionProvider is the interface for providing sync committee contributions.

type SyncCommitteeContributionsSubmitter

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

SyncCommitteeContributionsSubmitter is the interface for submitting sync committee contributions.

type SyncCommitteeDutiesProvider

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

SyncCommitteeDutiesProvider is the interface for providing sync committee duties.

type SyncCommitteeMessagesSubmitter

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

SyncCommitteeMessagesSubmitter is the interface for submitting sync committee messages.

type SyncCommitteeSubscriptionsSubmitter

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

SyncCommitteeSubscriptionsSubmitter is the interface for submitting sync committee subnet subscription requests.

type SyncCommitteesProvider

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

SyncCommitteesProvider is the interface for providing sync committees.

type SyncStateProvider

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)
}

SyncStateProvider is the interface for providing synchronization state.

type TargetAggregatorsPerCommitteeProvider

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

TargetAggregatorsPerCommitteeProvider is the interface for providing the target number of aggregators in each attestation committee.

type V3ProposalProvider

type V3ProposalProvider interface {
	// BlindedProposal fetches a blinded proposed beacon block for signing.
	V3Proposal(ctx context.Context, opts *api.V3ProposalOpts) (*api.Response[*api.VersionedV3Proposal], error)
}

V3ProposalProvider is the interface for providing v3 beacon block proposals.

type ValidatorBalancesProvider

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)
}

ValidatorBalancesProvider is the interface for providing validator balances.

type ValidatorIDProvider

type ValidatorIDProvider interface {
	ValidatorIndexProvider
	ValidatorPubKeyProvider
}

ValidatorIDProvider is the interface that provides the identifiers (pubkey, index) of a validator.

type ValidatorIndexProvider

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

ValidatorIndexProvider is the interface for entities that can provide the index of a validator.

type ValidatorPubKeyProvider

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

ValidatorPubKeyProvider is the interface for entities that can provide the public key of a validator.

type ValidatorRegistrationsSubmitter

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

ValidatorRegistrationsSubmitter is the interface for submitting validator registrations.

type ValidatorsProvider

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)
}

ValidatorsProvider is the interface for providing validator information.

type VoluntaryExitPoolProvider

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

VoluntaryExitPoolProvider is the interface for providing voluntary exit pools.

type VoluntaryExitSubmitter

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

VoluntaryExitSubmitter is the interface for submitting voluntary exits.