@lodestar/api/lib/beacon/routes/validator.d.ts

A Typescript REST client for the Ethereum Consensus API

import { ContainerType, Type, ValueOf } from "@chainsafe/ssz";
import { ChainForkConfig } from "@lodestar/config";
import { Attestation, BLSSignature, BeaconBlockOrContents, BlindedBeaconBlock, CommitteeIndex, Epoch, ProducedBlockSource, Root, Slot, UintBn64, ValidatorIndex, altair, phase0 } from "@lodestar/types";
import { EmptyMeta, EmptyResponseData } from "../../utils/codecs.js";
import { Endpoint, RouteDefinitions } from "../../utils/index.js";
import { ExecutionOptimisticAndDependentRootMeta, ExecutionOptimisticMeta, MetaHeader, VersionMeta } from "../../utils/metadata.js";
export declare enum BuilderSelection {
    Default = "default",
    BuilderAlways = "builderalways",
    ExecutionAlways = "executionalways",
    MaxProfit = "maxprofit",
    /** Only activate builder flow for DVT block proposal protocols */
    BuilderOnly = "builderonly",
    /** Only builds execution block*/
    ExecutionOnly = "executiononly"
}
/** Lodestar-specific (non-standardized) options */
export type ExtraProduceBlockOpts = {
    feeRecipient?: string;
    builderSelection?: BuilderSelection;
    strictFeeRecipientCheck?: boolean;
    blindedLocal?: boolean;
};
export declare const ProduceBlockV3MetaType: ContainerType<{
    /** Specifies whether the response contains full or blinded block */
    executionPayloadBlinded: import("@chainsafe/ssz").BooleanType;
    /** Execution payload value in Wei */
    executionPayloadValue: import("@chainsafe/ssz").UintBigintType;
    /** Consensus rewards paid to the proposer for this block, in Wei */
    consensusBlockValue: import("@chainsafe/ssz").UintBigintType;
    version: import("@lodestar/types").StringType<import("@lodestar/params").ForkName>;
}>;
export type ProduceBlockV3Meta = ValueOf<typeof ProduceBlockV3MetaType> & {
    /** Lodestar-specific (non-standardized) value */
    executionPayloadSource: ProducedBlockSource;
};
export declare const AttesterDutyType: ContainerType<{
    /** The validator's public key, uniquely identifying them */
    pubkey: import("@chainsafe/ssz").ByteVectorType;
    /** Index of validator in validator registry */
    validatorIndex: import("@chainsafe/ssz").UintNumberType;
    /** Index of the committee */
    committeeIndex: import("@chainsafe/ssz").UintNumberType;
    /** Number of validators in committee */
    committeeLength: import("@chainsafe/ssz").UintNumberType;
    /** Number of committees at the provided slot */
    committeesAtSlot: import("@chainsafe/ssz").UintNumberType;
    /** Index of validator in committee */
    validatorCommitteeIndex: import("@chainsafe/ssz").UintNumberType;
    /** The slot at which the validator must attest */
    slot: import("@chainsafe/ssz").UintNumberType;
}>;
export declare const ProposerDutyType: ContainerType<{
    slot: import("@chainsafe/ssz").UintNumberType;
    validatorIndex: import("@chainsafe/ssz").UintNumberType;
    pubkey: import("@chainsafe/ssz").ByteVectorType;
}>;
/**
 * From https://github.com/ethereum/beacon-APIs/pull/134
 */
export declare const SyncDutyType: ContainerType<{
    pubkey: import("@chainsafe/ssz").ByteVectorType;
    /** Index of validator in validator registry. */
    validatorIndex: import("@chainsafe/ssz").UintNumberType;
    /** The indices of the validator in the sync committee. */
    validatorSyncCommitteeIndices: import("@chainsafe/ssz").ArrayType<Type<number>, unknown, unknown>;
}>;
export declare const BeaconCommitteeSubscriptionType: ContainerType<{
    validatorIndex: import("@chainsafe/ssz").UintNumberType;
    committeeIndex: import("@chainsafe/ssz").UintNumberType;
    committeesAtSlot: import("@chainsafe/ssz").UintNumberType;
    slot: import("@chainsafe/ssz").UintNumberType;
    isAggregator: import("@chainsafe/ssz").BooleanType;
}>;
/**
 * From https://github.com/ethereum/beacon-APIs/pull/136
 */
export declare const SyncCommitteeSubscriptionType: ContainerType<{
    validatorIndex: import("@chainsafe/ssz").UintNumberType;
    syncCommitteeIndices: import("@chainsafe/ssz").ArrayType<Type<number>, unknown, unknown>;
    untilEpoch: import("@chainsafe/ssz").UintNumberType;
}>;
export declare const ProposerPreparationDataType: ContainerType<{
    validatorIndex: import("@chainsafe/ssz").UintNumberType;
    feeRecipient: import("@lodestar/types").StringType<string>;
}>;
/**
 * From https://github.com/ethereum/beacon-APIs/pull/224
 */
export declare const BeaconCommitteeSelectionType: ContainerType<{
    /** Index of the validator */
    validatorIndex: import("@chainsafe/ssz").UintNumberType;
    /** The slot at which a validator is assigned to attest */
    slot: import("@chainsafe/ssz").UintNumberType;
    /** The `slot_signature` calculated by the validator for the upcoming attestation slot */
    selectionProof: import("@chainsafe/ssz").ByteVectorType;
}>;
/**
 * From https://github.com/ethereum/beacon-APIs/pull/224
 */
export declare const SyncCommitteeSelectionType: ContainerType<{
    /** Index of the validator */
    validatorIndex: import("@chainsafe/ssz").UintNumberType;
    /** The slot at which validator is assigned to produce a sync committee contribution */
    slot: import("@chainsafe/ssz").UintNumberType;
    /** SubcommitteeIndex to which the validator is assigned */
    subcommitteeIndex: import("@chainsafe/ssz").UintNumberType;
    /** The `slot_signature` calculated by the validator for the upcoming sync committee slot */
    selectionProof: import("@chainsafe/ssz").ByteVectorType;
}>;
export declare const LivenessResponseDataType: ContainerType<{
    index: import("@chainsafe/ssz").UintNumberType;
    isLive: import("@chainsafe/ssz").BooleanType;
}>;
export declare const ValidatorIndicesType: import("@chainsafe/ssz").ArrayType<Type<number>, unknown, unknown>;
export declare const AttesterDutyListType: import("@chainsafe/ssz").ArrayType<Type<import("@chainsafe/ssz").ValueOfFields<{
    /** The validator's public key, uniquely identifying them */
    pubkey: import("@chainsafe/ssz").ByteVectorType;
    /** Index of validator in validator registry */
    validatorIndex: import("@chainsafe/ssz").UintNumberType;
    /** Index of the committee */
    committeeIndex: import("@chainsafe/ssz").UintNumberType;
    /** Number of validators in committee */
    committeeLength: import("@chainsafe/ssz").UintNumberType;
    /** Number of committees at the provided slot */
    committeesAtSlot: import("@chainsafe/ssz").UintNumberType;
    /** Index of validator in committee */
    validatorCommitteeIndex: import("@chainsafe/ssz").UintNumberType;
    /** The slot at which the validator must attest */
    slot: import("@chainsafe/ssz").UintNumberType;
}>>, unknown, unknown>;
export declare const ProposerDutyListType: import("@chainsafe/ssz").ArrayType<Type<import("@chainsafe/ssz").ValueOfFields<{
    slot: import("@chainsafe/ssz").UintNumberType;
    validatorIndex: import("@chainsafe/ssz").UintNumberType;
    pubkey: import("@chainsafe/ssz").ByteVectorType;
}>>, unknown, unknown>;
export declare const SyncDutyListType: import("@chainsafe/ssz").ArrayType<Type<import("@chainsafe/ssz").ValueOfFields<{
    pubkey: import("@chainsafe/ssz").ByteVectorType;
    /** Index of validator in validator registry. */
    validatorIndex: import("@chainsafe/ssz").UintNumberType;
    /** The indices of the validator in the sync committee. */
    validatorSyncCommitteeIndices: import("@chainsafe/ssz").ArrayType<Type<number>, unknown, unknown>;
}>>, unknown, unknown>;
export declare const SignedAggregateAndProofListPhase0Type: import("@chainsafe/ssz").ArrayType<Type<import("@chainsafe/ssz").ValueOfFields<{
    message: ContainerType<{
        aggregatorIndex: import("@chainsafe/ssz").UintNumberType;
        aggregate: ContainerType<{
            aggregationBits: import("@chainsafe/ssz").BitListType;
            data: ContainerType<{
                slot: import("@chainsafe/ssz").UintNumberType;
                index: import("@chainsafe/ssz").UintNumberType;
                beaconBlockRoot: import("@chainsafe/ssz").ByteVectorType;
                source: ContainerType<{
                    epoch: import("@chainsafe/ssz").UintNumberType;
                    root: import("@chainsafe/ssz").ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: import("@chainsafe/ssz").UintNumberType;
                    root: import("@chainsafe/ssz").ByteVectorType;
                }>;
            }>;
            signature: import("@chainsafe/ssz").ByteVectorType;
        }>;
        selectionProof: import("@chainsafe/ssz").ByteVectorType;
    }>;
    signature: import("@chainsafe/ssz").ByteVectorType;
}>>, unknown, unknown>;
export declare const SignedAggregateAndProofListElectraType: import("@chainsafe/ssz").ArrayType<Type<import("@chainsafe/ssz").ValueOfFields<{
    message: ContainerType<{
        aggregatorIndex: import("@chainsafe/ssz").UintNumberType;
        aggregate: ContainerType<{
            aggregationBits: import("@chainsafe/ssz").BitListType;
            data: ContainerType<{
                slot: import("@chainsafe/ssz").UintNumberType;
                index: import("@chainsafe/ssz").UintNumberType;
                beaconBlockRoot: import("@chainsafe/ssz").ByteVectorType;
                source: ContainerType<{
                    epoch: import("@chainsafe/ssz").UintNumberType;
                    root: import("@chainsafe/ssz").ByteVectorType;
                }>;
                target: ContainerType<{
                    epoch: import("@chainsafe/ssz").UintNumberType;
                    root: import("@chainsafe/ssz").ByteVectorType;
                }>;
            }>;
            signature: import("@chainsafe/ssz").ByteVectorType;
            committeeBits: import("@chainsafe/ssz").BitVectorType;
        }>;
        selectionProof: import("@chainsafe/ssz").ByteVectorType;
    }>;
    signature: import("@chainsafe/ssz").ByteVectorType;
}>>, unknown, unknown>;
export declare const SignedContributionAndProofListType: import("@chainsafe/ssz").ArrayType<Type<import("@chainsafe/ssz").ValueOfFields<{
    message: ContainerType<{
        aggregatorIndex: import("@chainsafe/ssz").UintNumberType;
        contribution: ContainerType<{
            slot: import("@chainsafe/ssz").UintNumberType;
            beaconBlockRoot: import("@chainsafe/ssz").ByteVectorType;
            subcommitteeIndex: import("@chainsafe/ssz").UintNumberType;
            aggregationBits: import("@chainsafe/ssz").BitVectorType;
            signature: import("@chainsafe/ssz").ByteVectorType;
        }>;
        selectionProof: import("@chainsafe/ssz").ByteVectorType;
    }>;
    signature: import("@chainsafe/ssz").ByteVectorType;
}>>, unknown, unknown>;
export declare const BeaconCommitteeSubscriptionListType: import("@chainsafe/ssz").ArrayType<Type<import("@chainsafe/ssz").ValueOfFields<{
    validatorIndex: import("@chainsafe/ssz").UintNumberType;
    committeeIndex: import("@chainsafe/ssz").UintNumberType;
    committeesAtSlot: import("@chainsafe/ssz").UintNumberType;
    slot: import("@chainsafe/ssz").UintNumberType;
    isAggregator: import("@chainsafe/ssz").BooleanType;
}>>, unknown, unknown>;
export declare const SyncCommitteeSubscriptionListType: import("@chainsafe/ssz").ArrayType<Type<import("@chainsafe/ssz").ValueOfFields<{
    validatorIndex: import("@chainsafe/ssz").UintNumberType;
    syncCommitteeIndices: import("@chainsafe/ssz").ArrayType<Type<number>, unknown, unknown>;
    untilEpoch: import("@chainsafe/ssz").UintNumberType;
}>>, unknown, unknown>;
export declare const ProposerPreparationDataListType: import("@chainsafe/ssz").ArrayType<Type<import("@chainsafe/ssz").ValueOfFields<{
    validatorIndex: import("@chainsafe/ssz").UintNumberType;
    feeRecipient: import("@lodestar/types").StringType<string>;
}>>, unknown, unknown>;
export declare const BeaconCommitteeSelectionListType: import("@chainsafe/ssz").ArrayType<Type<import("@chainsafe/ssz").ValueOfFields<{
    /** Index of the validator */
    validatorIndex: import("@chainsafe/ssz").UintNumberType;
    /** The slot at which a validator is assigned to attest */
    slot: import("@chainsafe/ssz").UintNumberType;
    /** The `slot_signature` calculated by the validator for the upcoming attestation slot */
    selectionProof: import("@chainsafe/ssz").ByteVectorType;
}>>, unknown, unknown>;
export declare const SyncCommitteeSelectionListType: import("@chainsafe/ssz").ArrayType<Type<import("@chainsafe/ssz").ValueOfFields<{
    /** Index of the validator */
    validatorIndex: import("@chainsafe/ssz").UintNumberType;
    /** The slot at which validator is assigned to produce a sync committee contribution */
    slot: import("@chainsafe/ssz").UintNumberType;
    /** SubcommitteeIndex to which the validator is assigned */
    subcommitteeIndex: import("@chainsafe/ssz").UintNumberType;
    /** The `slot_signature` calculated by the validator for the upcoming sync committee slot */
    selectionProof: import("@chainsafe/ssz").ByteVectorType;
}>>, unknown, unknown>;
export declare const LivenessResponseDataListType: import("@chainsafe/ssz").ArrayType<Type<import("@chainsafe/ssz").ValueOfFields<{
    index: import("@chainsafe/ssz").UintNumberType;
    isLive: import("@chainsafe/ssz").BooleanType;
}>>, unknown, unknown>;
export declare const SignedValidatorRegistrationV1ListType: import("@chainsafe/ssz").ArrayType<Type<import("@chainsafe/ssz").ValueOfFields<{
    message: ContainerType<{
        feeRecipient: import("@lodestar/types/lib/utils/executionAddress.js").ExecutionAddressType;
        gasLimit: import("@chainsafe/ssz").UintNumberType;
        timestamp: import("@chainsafe/ssz").UintNumberType;
        pubkey: import("@chainsafe/ssz").ByteVectorType;
    }>;
    signature: import("@chainsafe/ssz").ByteVectorType;
}>>, unknown, unknown>;
export type ValidatorIndices = ValueOf<typeof ValidatorIndicesType>;
export type AttesterDuty = ValueOf<typeof AttesterDutyType>;
export type AttesterDutyList = ValueOf<typeof AttesterDutyListType>;
export type ProposerDuty = ValueOf<typeof ProposerDutyType>;
export type ProposerDutyList = ValueOf<typeof ProposerDutyListType>;
export type SyncDuty = ValueOf<typeof SyncDutyType>;
export type SyncDutyList = ValueOf<typeof SyncDutyListType>;
export type SignedAggregateAndProofListPhase0 = ValueOf<typeof SignedAggregateAndProofListPhase0Type>;
export type SignedAggregateAndProofListElectra = ValueOf<typeof SignedAggregateAndProofListElectraType>;
export type SignedAggregateAndProofList = SignedAggregateAndProofListPhase0 | SignedAggregateAndProofListElectra;
export type SignedContributionAndProofList = ValueOf<typeof SignedContributionAndProofListType>;
export type BeaconCommitteeSubscription = ValueOf<typeof BeaconCommitteeSubscriptionType>;
export type BeaconCommitteeSubscriptionList = ValueOf<typeof BeaconCommitteeSubscriptionListType>;
export type SyncCommitteeSubscription = ValueOf<typeof SyncCommitteeSubscriptionType>;
export type SyncCommitteeSubscriptionList = ValueOf<typeof SyncCommitteeSubscriptionListType>;
export type ProposerPreparationData = ValueOf<typeof ProposerPreparationDataType>;
export type ProposerPreparationDataList = ValueOf<typeof ProposerPreparationDataListType>;
export type BeaconCommitteeSelection = ValueOf<typeof BeaconCommitteeSelectionType>;
export type BeaconCommitteeSelectionList = ValueOf<typeof BeaconCommitteeSelectionListType>;
export type SyncCommitteeSelection = ValueOf<typeof SyncCommitteeSelectionType>;
export type SyncCommitteeSelectionList = ValueOf<typeof SyncCommitteeSelectionListType>;
export type LivenessResponseData = ValueOf<typeof LivenessResponseDataType>;
export type LivenessResponseDataList = ValueOf<typeof LivenessResponseDataListType>;
export type SignedValidatorRegistrationV1List = ValueOf<typeof SignedValidatorRegistrationV1ListType>;
export type Endpoints = {
    /**
     * Get attester duties
     * Requests the beacon node to provide a set of attestation duties, which should be performed by validators, for a particular epoch.
     * Duties should only need to be checked once per epoch, however a chain reorganization (of > MIN_SEED_LOOKAHEAD epochs) could occur, resulting in a change of duties. For full safety, you should monitor head events and confirm the dependent root in this response matches:
     * - event.previous_duty_dependent_root when `compute_epoch_at_slot(event.slot) == epoch`
     * - event.current_duty_dependent_root when `compute_epoch_at_slot(event.slot) + 1 == epoch`
     * - event.block otherwise
     * The dependent_root value is `get_block_root_at_slot(state, compute_start_slot_at_epoch(epoch - 1) - 1)` or the genesis block root in the case of underflow.
     */
    getAttesterDuties: Endpoint<"POST", {
        /** Should only be allowed 1 epoch ahead */
        epoch: Epoch;
        /** An array of the validator indices for which to obtain the duties */
        indices: ValidatorIndices;
    }, {
        params: {
            epoch: Epoch;
        };
        body: unknown;
    }, AttesterDutyList, ExecutionOptimisticAndDependentRootMeta>;
    /**
     * Get block proposers duties
     * Request beacon node to provide all validators that are scheduled to propose a block in the given epoch.
     * Duties should only need to be checked once per epoch, however a chain reorganization could occur that results in a change of duties. For full safety, you should monitor head events and confirm the dependent root in this response matches:
     * - event.current_duty_dependent_root when `compute_epoch_at_slot(event.slot) == epoch`
     * - event.block otherwise
     * The dependent_root value is `get_block_root_at_slot(state, compute_start_slot_at_epoch(epoch) - 1)` or the genesis block root in the case of underflow.
     */
    getProposerDuties: Endpoint<"GET", {
        epoch: Epoch;
    }, {
        params: {
            epoch: Epoch;
        };
    }, ProposerDutyList, ExecutionOptimisticAndDependentRootMeta>;
    getSyncCommitteeDuties: Endpoint<"POST", {
        epoch: number;
        indices: ValidatorIndices;
    }, {
        params: {
            epoch: Epoch;
        };
        body: unknown;
    }, SyncDutyList, ExecutionOptimisticMeta>;
    /**
     * Requests a beacon node to produce a valid block, which can then be signed by a validator.
     * Metadata in the response indicates the type of block produced, and the supported types of block
     * will be added to as forks progress.
     */
    produceBlockV2: Endpoint<"GET", {
        /** The slot for which the block should be proposed */
        slot: Slot;
        /** The validator's randao reveal value */
        randaoReveal: BLSSignature;
        /** Arbitrary data validator wants to include in block */
        graffiti?: string;
    } & Omit<ExtraProduceBlockOpts, "blindedLocal">, {
        params: {
            slot: number;
        };
        query: {
            randao_reveal: string;
            graffiti?: string;
            fee_recipient?: string;
            builder_selection?: string;
            strict_fee_recipient_check?: boolean;
        };
    }, BeaconBlockOrContents, VersionMeta>;
    /**
     * Requests a beacon node to produce a valid block, which can then be signed by a validator.
     * Metadata in the response indicates the type of block produced, and the supported types of block
     * will be added to as forks progress.
     */
    produceBlockV3: Endpoint<"GET", {
        /** The slot for which the block should be proposed */
        slot: Slot;
        /** The validator's randao reveal value */
        randaoReveal: BLSSignature;
        /** Arbitrary data validator wants to include in block */
        graffiti?: string;
        skipRandaoVerification?: boolean;
        builderBoostFactor?: UintBn64;
    } & ExtraProduceBlockOpts, {
        params: {
            slot: number;
        };
        query: {
            randao_reveal: string;
            graffiti?: string;
            skip_randao_verification?: string;
            fee_recipient?: string;
            builder_selection?: string;
            builder_boost_factor?: string;
            strict_fee_recipient_check?: boolean;
            blinded_local?: boolean;
        };
    }, BeaconBlockOrContents | BlindedBeaconBlock, ProduceBlockV3Meta>;
    produceBlindedBlock: Endpoint<"GET", {
        slot: Slot;
        randaoReveal: BLSSignature;
        graffiti?: string;
    }, {
        params: {
            slot: number;
        };
        query: {
            randao_reveal: string;
            graffiti?: string;
        };
    }, BlindedBeaconBlock, VersionMeta>;
    /**
     * Produce an attestation data
     * Requests that the beacon node produce an AttestationData.
     */
    produceAttestationData: Endpoint<"GET", {
        /** The committee index for which an attestation data should be created */
        committeeIndex: CommitteeIndex;
        /** The slot for which an attestation data should be created */
        slot: Slot;
    }, {
        query: {
            slot: number;
            committee_index: number;
        };
    }, phase0.AttestationData, EmptyMeta>;
    produceSyncCommitteeContribution: Endpoint<"GET", {
        slot: Slot;
        subcommitteeIndex: number;
        beaconBlockRoot: Root;
    }, {
        query: {
            slot: number;
            subcommittee_index: number;
            beacon_block_root: string;
        };
    }, altair.SyncCommitteeContribution, EmptyMeta>;
    /**
     * Get aggregated attestation
     * Aggregates all attestations matching given attestation data root and slot
     * Returns an aggregated `Attestation` object with same `AttestationData` root.
     */
    getAggregatedAttestation: Endpoint<"GET", {
        /** HashTreeRoot of AttestationData that validator want's aggregated */
        attestationDataRoot: Root;
        slot: Slot;
    }, {
        query: {
            attestation_data_root: string;
            slot: number;
        };
    }, phase0.Attestation, EmptyMeta>;
    /**
     * Get aggregated attestation
     * Aggregates all attestations matching given attestation data root, slot and committee index
     * Returns an aggregated `Attestation` object with same `AttestationData` root.
     */
    getAggregatedAttestationV2: Endpoint<"GET", {
        /** HashTreeRoot of AttestationData that validator want's aggregated */
        attestationDataRoot: Root;
        slot: Slot;
        committeeIndex: number;
    }, {
        query: {
            attestation_data_root: string;
            slot: number;
            committee_index: number;
        };
    }, Attestation, VersionMeta>;
    /**
     * Publish multiple aggregate and proofs
     * Verifies given aggregate and proofs and publishes them on appropriate gossipsub topic.
     */
    publishAggregateAndProofs: Endpoint<"POST", {
        signedAggregateAndProofs: SignedAggregateAndProofListPhase0;
    }, {
        body: unknown;
    }, EmptyResponseData, EmptyMeta>;
    /**
     * Publish multiple aggregate and proofs
     * Verifies given aggregate and proofs and publishes them on appropriate gossipsub topic.
     */
    publishAggregateAndProofsV2: Endpoint<"POST", {
        signedAggregateAndProofs: SignedAggregateAndProofList;
    }, {
        body: unknown;
        headers: {
            [MetaHeader.Version]: string;
        };
    }, EmptyResponseData, EmptyMeta>;
    publishContributionAndProofs: Endpoint<"POST", {
        contributionAndProofs: SignedContributionAndProofList;
    }, {
        body: unknown;
    }, EmptyResponseData, EmptyMeta>;
    /**
     * Signal beacon node to prepare for a committee subnet
     * After beacon node receives this request,
     * search using discv5 for peers related to this subnet
     * and replace current peers with those ones if necessary
     * If validator `is_aggregator`, beacon node must:
     * - announce subnet topic subscription on gossipsub
     * - aggregate attestations received on that subnet
     *
     * Returns if slot signature is valid and beacon node has prepared the attestation subnet.
     *
     * Note that we cannot be certain the Beacon node will find peers for that subnet for various reasons.
     */
    prepareBeaconCommitteeSubnet: Endpoint<"POST", {
        subscriptions: BeaconCommitteeSubscriptionList;
    }, {
        body: unknown;
    }, EmptyResponseData, EmptyMeta>;
    prepareSyncCommitteeSubnets: Endpoint<"POST", {
        subscriptions: SyncCommitteeSubscriptionList;
    }, {
        body: unknown;
    }, EmptyResponseData, EmptyMeta>;
    prepareBeaconProposer: Endpoint<"POST", {
        proposers: ProposerPreparationDataList;
    }, {
        body: unknown;
    }, EmptyResponseData, EmptyMeta>;
    /**
     * Determine if a distributed validator has been selected to aggregate attestations
     *
     * This endpoint is implemented by a distributed validator middleware client to exchange
     * partial beacon committee selection proofs for combined/aggregated selection proofs to allow
     * a validator client to correctly determine if one of its validators has been selected to
     * perform an aggregation duty in this slot.
     *
     * Note that this endpoint is not implemented by the beacon node and will return a 501 error
     *
     * Returns an array of threshold aggregated beacon committee selection proofs
     */
    submitBeaconCommitteeSelections: Endpoint<"POST", {
        /** An array of partial beacon committee selection proofs */
        selections: BeaconCommitteeSelectionList;
    }, {
        body: unknown;
    }, BeaconCommitteeSelectionList, EmptyMeta>;
    /**
     * Determine if a distributed validator has been selected to make a sync committee contribution
     *
     * This endpoint is implemented by a distributed validator middleware client to exchange
     * partial sync committee selection proofs for combined/aggregated selection proofs to allow
     * a validator client to correctly determine if one of its validators has been selected to
     * perform a sync committee contribution (sync aggregation) duty in this slot.
     *
     * Note that this endpoint is not implemented by the beacon node and will return a 501 error
     *
     * Returns an array of threshold aggregated sync committee selection proofs
     */
    submitSyncCommitteeSelections: Endpoint<"POST", {
        /** An array of partial sync committee selection proofs */
        selections: SyncCommitteeSelectionList;
    }, {
        body: unknown;
    }, SyncCommitteeSelectionList, EmptyMeta>;
    /** Returns validator indices that have been observed to be active on the network */
    getLiveness: Endpoint<"POST", {
        epoch: Epoch;
        indices: ValidatorIndex[];
    }, {
        params: {
            epoch: Epoch;
        };
        body: unknown;
    }, LivenessResponseDataList, EmptyMeta>;
    registerValidator: Endpoint<"POST", {
        registrations: SignedValidatorRegistrationV1List;
    }, {
        body: unknown;
    }, EmptyResponseData, EmptyMeta>;
};
export declare function getDefinitions(config: ChainForkConfig): RouteDefinitions<Endpoints>;
//# sourceMappingURL=validator.d.ts.map