@lodestar/api 1.20.0-dev.14855ea72f → 1.20.0-dev.225e67a1e5

package/lib/beacon/routes/validator.js

@@ -1,10 +1,13 @@
+/* eslint-disable @typescript-eslint/naming-convention */
 import { ContainerType, fromHexString, toHexString } from "@chainsafe/ssz";
-import { ForkName, isForkBlobs, isForkExecution } from "@lodestar/params";
-import { ssz, StringType, ProducedBlockSource, } from "@lodestar/types";
-import { HttpStatusCode } from "../../utils/client/httpStatusCode.js";
-import { ArrayOf, Schema, WithVersion, WithBlockValues, reqOnlyBody, jsonType, ContainerDataExecutionOptimistic, ContainerData, } from "../../utils/index.js";
-import { fromU64Str, fromGraffitiHex, toU64Str, toGraffitiHex } from "../../utils/serdes.js";
-import { allForksBlockContentsResSerializer } from "../../utils/routes.js";
+import { isForkBlobs } from "@lodestar/params";
+import { ssz, ProducedBlockSource, stringType, } from "@lodestar/types";
+import { Schema } from "../../utils/index.js";
+import { fromGraffitiHex, toBoolean, toGraffitiHex } from "../../utils/serdes.js";
+import { getBlindedForkTypes, toForkName } from "../../utils/fork.js";
+import { ArrayOf, EmptyMetaCodec, EmptyResponseCodec, JsonOnlyReq, WithMeta, WithVersion, } from "../../utils/codecs.js";
+import { ExecutionOptimisticAndDependentRootCodec, ExecutionOptimisticCodec, MetaHeader, VersionCodec, VersionType, } from "../../utils/metadata.js";
+// See /packages/api/src/routes/index.ts for reasoning and instructions to add new routes
 export var BuilderSelection;
 (function (BuilderSelection) {
     BuilderSelection["Default"] = "default";
@@ -16,260 +19,538 @@ export var BuilderSelection;
     /** Only builds execution block*/
     BuilderSelection["ExecutionOnly"] = "executiononly";
 })(BuilderSelection || (BuilderSelection = {}));
+export const ProduceBlockV3MetaType = new ContainerType({
+    ...VersionType.fields,
+    /** Specifies whether the response contains full or blinded block */
+    executionPayloadBlinded: ssz.Boolean,
+    /** Execution payload value in Wei */
+    executionPayloadValue: ssz.UintBn64,
+    /** Consensus rewards paid to the proposer for this block, in Wei */
+    consensusBlockValue: ssz.UintBn64,
+}, { jsonCase: "eth2" });
+export const BlockContentsType = new ContainerType({
+    block: ssz.deneb.BeaconBlock,
+    kzgProofs: ssz.deneb.KZGProofs,
+    blobs: ssz.deneb.Blobs,
+}, { jsonCase: "eth2" });
+export const AttesterDutyType = new ContainerType({
+    /** The validator's public key, uniquely identifying them */
+    pubkey: ssz.BLSPubkey,
+    /** Index of validator in validator registry */
+    validatorIndex: ssz.ValidatorIndex,
+    /** Index of the committee */
+    committeeIndex: ssz.CommitteeIndex,
+    /** Number of validators in committee */
+    committeeLength: ssz.UintNum64,
+    /** Number of committees at the provided slot */
+    committeesAtSlot: ssz.UintNum64,
+    /** Index of validator in committee */
+    validatorCommitteeIndex: ssz.UintNum64,
+    /** The slot at which the validator must attest */
+    slot: ssz.Slot,
+}, { jsonCase: "eth2" });
+export const ProposerDutyType = new ContainerType({
+    slot: ssz.Slot,
+    validatorIndex: ssz.ValidatorIndex,
+    pubkey: ssz.BLSPubkey,
+}, { jsonCase: "eth2" });
+/**
+ * From https://github.com/ethereum/beacon-APIs/pull/134
+ */
+export const SyncDutyType = new ContainerType({
+    pubkey: ssz.BLSPubkey,
+    /** Index of validator in validator registry. */
+    validatorIndex: ssz.ValidatorIndex,
+    /** The indices of the validator in the sync committee. */
+    validatorSyncCommitteeIndices: ArrayOf(ssz.CommitteeIndex),
+}, { jsonCase: "eth2" });
+export const BeaconCommitteeSubscriptionType = new ContainerType({
+    validatorIndex: ssz.ValidatorIndex,
+    committeeIndex: ssz.CommitteeIndex,
+    committeesAtSlot: ssz.Slot,
+    slot: ssz.Slot,
+    isAggregator: ssz.Boolean,
+}, { jsonCase: "eth2" });
 /**
- * Define javascript values for each route
+ * From https://github.com/ethereum/beacon-APIs/pull/136
  */
-export const routesData = {
-    getAttesterDuties: { url: "/eth/v1/validator/duties/attester/{epoch}", method: "POST" },
-    getProposerDuties: { url: "/eth/v1/validator/duties/proposer/{epoch}", method: "GET" },
-    getSyncCommitteeDuties: { url: "/eth/v1/validator/duties/sync/{epoch}", method: "POST" },
-    produceBlock: { url: "/eth/v1/validator/blocks/{slot}", method: "GET" },
-    produceBlockV2: { url: "/eth/v2/validator/blocks/{slot}", method: "GET" },
-    produceBlockV3: { url: "/eth/v3/validator/blocks/{slot}", method: "GET" },
-    produceBlindedBlock: { url: "/eth/v1/validator/blinded_blocks/{slot}", method: "GET" },
-    produceAttestationData: { url: "/eth/v1/validator/attestation_data", method: "GET" },
-    produceSyncCommitteeContribution: { url: "/eth/v1/validator/sync_committee_contribution", method: "GET" },
-    getAggregatedAttestation: { url: "/eth/v1/validator/aggregate_attestation", method: "GET" },
-    publishAggregateAndProofs: { url: "/eth/v1/validator/aggregate_and_proofs", method: "POST" },
-    publishContributionAndProofs: { url: "/eth/v1/validator/contribution_and_proofs", method: "POST" },
-    prepareBeaconCommitteeSubnet: { url: "/eth/v1/validator/beacon_committee_subscriptions", method: "POST" },
-    prepareSyncCommitteeSubnets: { url: "/eth/v1/validator/sync_committee_subscriptions", method: "POST" },
-    prepareBeaconProposer: { url: "/eth/v1/validator/prepare_beacon_proposer", method: "POST" },
-    submitBeaconCommitteeSelections: { url: "/eth/v1/validator/beacon_committee_selections", method: "POST" },
-    submitSyncCommitteeSelections: { url: "/eth/v1/validator/sync_committee_selections", method: "POST" },
-    getLiveness: { url: "/eth/v1/validator/liveness/{epoch}", method: "POST" },
-    registerValidator: { url: "/eth/v1/validator/register_validator", method: "POST" },
-};
-const BeaconCommitteeSelection = new ContainerType({
+export const SyncCommitteeSubscriptionType = new ContainerType({
+    validatorIndex: ssz.ValidatorIndex,
+    syncCommitteeIndices: ArrayOf(ssz.CommitteeIndex),
+    untilEpoch: ssz.Epoch,
+}, { jsonCase: "eth2" });
+export const ProposerPreparationDataType = new ContainerType({
     validatorIndex: ssz.ValidatorIndex,
+    feeRecipient: stringType,
+}, { jsonCase: "eth2" });
+/**
+ * From https://github.com/ethereum/beacon-APIs/pull/224
+ */
+export const BeaconCommitteeSelectionType = new ContainerType({
+    /** Index of the validator */
+    validatorIndex: ssz.ValidatorIndex,
+    /** The slot at which a validator is assigned to attest */
     slot: ssz.Slot,
+    /** The `slot_signature` calculated by the validator for the upcoming attestation slot */
     selectionProof: ssz.BLSSignature,
 }, { jsonCase: "eth2" });
-const SyncCommitteeSelection = new ContainerType({
+/**
+ * From https://github.com/ethereum/beacon-APIs/pull/224
+ */
+export const SyncCommitteeSelectionType = new ContainerType({
+    /** Index of the validator */
     validatorIndex: ssz.ValidatorIndex,
+    /** The slot at which validator is assigned to produce a sync committee contribution */
     slot: ssz.Slot,
+    /** SubcommitteeIndex to which the validator is assigned */
     subcommitteeIndex: ssz.SubcommitteeIndex,
+    /** The `slot_signature` calculated by the validator for the upcoming sync committee slot */
     selectionProof: ssz.BLSSignature,
 }, { jsonCase: "eth2" });
-export function getReqSerializers() {
-    const BeaconCommitteeSubscription = new ContainerType({
-        validatorIndex: ssz.ValidatorIndex,
-        committeeIndex: ssz.CommitteeIndex,
-        committeesAtSlot: ssz.Slot,
-        slot: ssz.Slot,
-        isAggregator: ssz.Boolean,
-    }, { jsonCase: "eth2" });
-    const SyncCommitteeSubscription = new ContainerType({
-        validatorIndex: ssz.ValidatorIndex,
-        syncCommitteeIndices: ArrayOf(ssz.CommitteeIndex),
-        untilEpoch: ssz.Epoch,
-    }, { jsonCase: "eth2" });
-    const produceBlockV3 = {
-        writeReq: (slot, randaoReveal, graffiti, skipRandaoVerification, opts) => ({
-            params: { slot },
-            query: {
-                randao_reveal: toHexString(randaoReveal),
-                graffiti: toGraffitiHex(graffiti),
-                fee_recipient: opts?.feeRecipient,
-                ...(skipRandaoVerification && { skip_randao_verification: "" }),
-                builder_selection: opts?.builderSelection,
-                builder_boost_factor: opts?.builderBoostFactor?.toString(),
-                strict_fee_recipient_check: opts?.strictFeeRecipientCheck,
-                blinded_local: opts?.blindedLocal,
-            },
-        }),
-        parseReq: ({ params, query }) => [
-            params.slot,
-            fromHexString(query.randao_reveal),
-            fromGraffitiHex(query.graffiti),
-            parseSkipRandaoVerification(query.skip_randao_verification),
-            {
-                feeRecipient: query.fee_recipient,
-                builderSelection: query.builder_selection,
-                builderBoostFactor: parseBuilderBoostFactor(query.builder_boost_factor),
-                strictFeeRecipientCheck: query.strict_fee_recipient_check,
-                blindedLocal: query.blinded_local,
-            },
-        ],
-        schema: {
-            params: { slot: Schema.UintRequired },
-            query: {
-                randao_reveal: Schema.StringRequired,
-                graffiti: Schema.String,
-                fee_recipient: Schema.String,
-                skip_randao_verification: Schema.String,
-                builder_selection: Schema.String,
-                builder_boost_factor: Schema.String,
-                strict_fee_recipient_check: Schema.Boolean,
-                blinded_local: Schema.Boolean,
-            },
-        },
-    };
+export const LivenessResponseDataType = new ContainerType({
+    index: ssz.ValidatorIndex,
+    isLive: ssz.Boolean,
+}, { jsonCase: "eth2" });
+export const ValidatorIndicesType = ArrayOf(ssz.ValidatorIndex);
+export const AttesterDutyListType = ArrayOf(AttesterDutyType);
+export const ProposerDutyListType = ArrayOf(ProposerDutyType);
+export const SyncDutyListType = ArrayOf(SyncDutyType);
+export const SignedAggregateAndProofListType = ArrayOf(ssz.phase0.SignedAggregateAndProof);
+export const SignedContributionAndProofListType = ArrayOf(ssz.altair.SignedContributionAndProof);
+export const BeaconCommitteeSubscriptionListType = ArrayOf(BeaconCommitteeSubscriptionType);
+export const SyncCommitteeSubscriptionListType = ArrayOf(SyncCommitteeSubscriptionType);
+export const ProposerPreparationDataListType = ArrayOf(ProposerPreparationDataType);
+export const BeaconCommitteeSelectionListType = ArrayOf(BeaconCommitteeSelectionType);
+export const SyncCommitteeSelectionListType = ArrayOf(SyncCommitteeSelectionType);
+export const LivenessResponseDataListType = ArrayOf(LivenessResponseDataType);
+export const SignedValidatorRegistrationV1ListType = ArrayOf(ssz.bellatrix.SignedValidatorRegistrationV1);
+export function getDefinitions(_config) {
     return {
         getAttesterDuties: {
-            writeReq: (epoch, indexes) => ({ params: { epoch }, body: indexes.map((i) => toU64Str(i)) }),
-            parseReq: ({ params, body }) => [params.epoch, body.map((i) => fromU64Str(i))],
-            schema: {
-                params: { epoch: Schema.UintRequired },
-                body: Schema.StringArray,
+            url: "/eth/v1/validator/duties/attester/{epoch}",
+            method: "POST",
+            req: {
+                writeReqJson: ({ epoch, indices }) => ({ params: { epoch }, body: ValidatorIndicesType.toJson(indices) }),
+                parseReqJson: ({ params, body }) => ({ epoch: params.epoch, indices: ValidatorIndicesType.fromJson(body) }),
+                writeReqSsz: ({ epoch, indices }) => ({ params: { epoch }, body: ValidatorIndicesType.serialize(indices) }),
+                parseReqSsz: ({ params, body }) => ({ epoch: params.epoch, indices: ValidatorIndicesType.deserialize(body) }),
+                schema: {
+                    params: { epoch: Schema.UintRequired },
+                    body: Schema.StringArray,
+                },
+            },
+            resp: {
+                data: AttesterDutyListType,
+                meta: ExecutionOptimisticAndDependentRootCodec,
             },
         },
         getProposerDuties: {
-            writeReq: (epoch) => ({ params: { epoch } }),
-            parseReq: ({ params }) => [params.epoch],
-            schema: {
-                params: { epoch: Schema.UintRequired },
+            url: "/eth/v1/validator/duties/proposer/{epoch}",
+            method: "GET",
+            req: {
+                writeReq: ({ epoch }) => ({ params: { epoch } }),
+                parseReq: ({ params }) => ({ epoch: params.epoch }),
+                schema: {
+                    params: { epoch: Schema.UintRequired },
+                },
+            },
+            resp: {
+                data: ProposerDutyListType,
+                meta: ExecutionOptimisticAndDependentRootCodec,
             },
         },
         getSyncCommitteeDuties: {
-            writeReq: (epoch, indexes) => ({ params: { epoch }, body: indexes.map((i) => toU64Str(i)) }),
-            parseReq: ({ params, body }) => [params.epoch, body.map((i) => fromU64Str(i))],
-            schema: {
-                params: { epoch: Schema.UintRequired },
-                body: Schema.StringArray,
+            url: "/eth/v1/validator/duties/sync/{epoch}",
+            method: "POST",
+            req: {
+                writeReqJson: ({ epoch, indices }) => ({ params: { epoch }, body: ValidatorIndicesType.toJson(indices) }),
+                parseReqJson: ({ params, body }) => ({ epoch: params.epoch, indices: ValidatorIndicesType.fromJson(body) }),
+                writeReqSsz: ({ epoch, indices }) => ({ params: { epoch }, body: ValidatorIndicesType.serialize(indices) }),
+                parseReqSsz: ({ params, body }) => ({ epoch: params.epoch, indices: ValidatorIndicesType.deserialize(body) }),
+                schema: {
+                    params: { epoch: Schema.UintRequired },
+                    body: Schema.StringArray,
+                },
+            },
+            resp: {
+                data: SyncDutyListType,
+                meta: ExecutionOptimisticCodec,
+            },
+        },
+        produceBlock: {
+            url: "/eth/v1/validator/blocks/{slot}",
+            method: "GET",
+            req: {
+                writeReq: ({ slot, randaoReveal, graffiti }) => ({
+                    params: { slot },
+                    query: { randao_reveal: toHexString(randaoReveal), graffiti: toGraffitiHex(graffiti) },
+                }),
+                parseReq: ({ params, query }) => ({
+                    slot: params.slot,
+                    randaoReveal: fromHexString(query.randao_reveal),
+                    graffiti: fromGraffitiHex(query.graffiti),
+                }),
+                schema: {
+                    params: { slot: Schema.UintRequired },
+                    query: {
+                        randao_reveal: Schema.StringRequired,
+                        graffiti: Schema.String,
+                    },
+                },
+            },
+            resp: {
+                data: WithVersion((fork) => ssz[fork].BeaconBlock),
+                meta: VersionCodec,
+            },
+        },
+        produceBlockV2: {
+            url: "/eth/v2/validator/blocks/{slot}",
+            method: "GET",
+            req: {
+                writeReq: ({ slot, randaoReveal, graffiti, feeRecipient, builderSelection, strictFeeRecipientCheck }) => ({
+                    params: { slot },
+                    query: {
+                        randao_reveal: toHexString(randaoReveal),
+                        graffiti: toGraffitiHex(graffiti),
+                        fee_recipient: feeRecipient,
+                        builder_selection: builderSelection,
+                        strict_fee_recipient_check: strictFeeRecipientCheck,
+                    },
+                }),
+                parseReq: ({ params, query }) => ({
+                    slot: params.slot,
+                    randaoReveal: fromHexString(query.randao_reveal),
+                    graffiti: fromGraffitiHex(query.graffiti),
+                    feeRecipient: query.fee_recipient,
+                    builderSelection: query.builder_selection,
+                    strictFeeRecipientCheck: query.strict_fee_recipient_check,
+                }),
+                schema: {
+                    params: { slot: Schema.UintRequired },
+                    query: {
+                        randao_reveal: Schema.StringRequired,
+                        graffiti: Schema.String,
+                        fee_recipient: Schema.String,
+                        builder_selection: Schema.String,
+                        strict_fee_recipient_check: Schema.Boolean,
+                    },
+                },
+            },
+            resp: {
+                data: WithVersion((fork) => (isForkBlobs(fork) ? BlockContentsType : ssz[fork].BeaconBlock)),
+                meta: VersionCodec,
+            },
+        },
+        produceBlockV3: {
+            url: "/eth/v3/validator/blocks/{slot}",
+            method: "GET",
+            req: {
+                writeReq: ({ slot, randaoReveal, graffiti, skipRandaoVerification, feeRecipient, builderSelection, builderBoostFactor, strictFeeRecipientCheck, blindedLocal, }) => ({
+                    params: { slot },
+                    query: {
+                        randao_reveal: toHexString(randaoReveal),
+                        graffiti: toGraffitiHex(graffiti),
+                        skip_randao_verification: writeSkipRandaoVerification(skipRandaoVerification),
+                        fee_recipient: feeRecipient,
+                        builder_selection: builderSelection,
+                        builder_boost_factor: builderBoostFactor?.toString(),
+                        strict_fee_recipient_check: strictFeeRecipientCheck,
+                        blinded_local: blindedLocal,
+                    },
+                }),
+                parseReq: ({ params, query }) => ({
+                    slot: params.slot,
+                    randaoReveal: fromHexString(query.randao_reveal),
+                    graffiti: fromGraffitiHex(query.graffiti),
+                    skipRandaoVerification: parseSkipRandaoVerification(query.skip_randao_verification),
+                    feeRecipient: query.fee_recipient,
+                    builderSelection: query.builder_selection,
+                    builderBoostFactor: parseBuilderBoostFactor(query.builder_boost_factor),
+                    strictFeeRecipientCheck: query.strict_fee_recipient_check,
+                    blindedLocal: query.blinded_local,
+                }),
+                schema: {
+                    params: { slot: Schema.UintRequired },
+                    query: {
+                        randao_reveal: Schema.StringRequired,
+                        graffiti: Schema.String,
+                        skip_randao_verification: Schema.String,
+                        fee_recipient: Schema.String,
+                        builder_selection: Schema.String,
+                        builder_boost_factor: Schema.String,
+                        strict_fee_recipient_check: Schema.Boolean,
+                        blinded_local: Schema.Boolean,
+                    },
+                },
+            },
+            resp: {
+                data: WithMeta(({ version, executionPayloadBlinded }) => (executionPayloadBlinded
+                    ? getBlindedForkTypes(version).BeaconBlock
+                    : isForkBlobs(version)
+                        ? BlockContentsType
+                        : ssz[version].BeaconBlock)),
+                meta: {
+                    toJson: (meta) => ({
+                        ...ProduceBlockV3MetaType.toJson(meta),
+                        execution_payload_source: meta.executionPayloadSource,
+                    }),
+                    fromJson: (val) => {
+                        const { executionPayloadBlinded, ...meta } = ProduceBlockV3MetaType.fromJson(val);
+                        // Extract source from the data and assign defaults in the spec compliant manner if not present
+                        const executionPayloadSource = val.execution_payload_source ??
+                            (executionPayloadBlinded === true ? ProducedBlockSource.builder : ProducedBlockSource.engine);
+                        return { ...meta, executionPayloadBlinded, executionPayloadSource };
+                    },
+                    toHeadersObject: (meta) => ({
+                        [MetaHeader.Version]: meta.version,
+                        [MetaHeader.ExecutionPayloadBlinded]: meta.executionPayloadBlinded.toString(),
+                        [MetaHeader.ExecutionPayloadSource]: meta.executionPayloadSource.toString(),
+                        [MetaHeader.ExecutionPayloadValue]: meta.executionPayloadValue.toString(),
+                        [MetaHeader.ConsensusBlockValue]: meta.consensusBlockValue.toString(),
+                    }),
+                    fromHeaders: (headers) => {
+                        const executionPayloadBlinded = toBoolean(headers.getRequired(MetaHeader.ExecutionPayloadBlinded));
+                        // Extract source from the headers and assign defaults in a spec compliant manner if not present
+                        const executionPayloadSource = headers.get(MetaHeader.ExecutionPayloadSource) ??
+                            (executionPayloadBlinded === true ? ProducedBlockSource.builder : ProducedBlockSource.engine);
+                        return {
+                            version: toForkName(headers.getRequired(MetaHeader.Version)),
+                            executionPayloadBlinded,
+                            executionPayloadSource,
+                            executionPayloadValue: BigInt(headers.getRequired(MetaHeader.ExecutionPayloadValue)),
+                            consensusBlockValue: BigInt(headers.getRequired(MetaHeader.ConsensusBlockValue)),
+                        };
+                    },
+                },
+            },
+        },
+        produceBlindedBlock: {
+            url: "/eth/v1/validator/blinded_blocks/{slot}",
+            method: "GET",
+            req: {
+                writeReq: ({ slot, randaoReveal, graffiti }) => ({
+                    params: { slot },
+                    query: { randao_reveal: toHexString(randaoReveal), graffiti: toGraffitiHex(graffiti) },
+                }),
+                parseReq: ({ params, query }) => ({
+                    slot: params.slot,
+                    randaoReveal: fromHexString(query.randao_reveal),
+                    graffiti: fromGraffitiHex(query.graffiti),
+                }),
+                schema: {
+                    params: { slot: Schema.UintRequired },
+                    query: {
+                        randao_reveal: Schema.StringRequired,
+                        graffiti: Schema.String,
+                    },
+                },
+            },
+            resp: {
+                data: WithVersion((fork) => getBlindedForkTypes(fork).BeaconBlock),
+                meta: VersionCodec,
             },
         },
-        produceBlock: produceBlockV3,
-        produceBlockV2: produceBlockV3,
-        produceBlockV3,
-        produceBlindedBlock: produceBlockV3,
         produceAttestationData: {
-            writeReq: (index, slot) => ({ query: { slot, committee_index: index } }),
-            parseReq: ({ query }) => [query.committee_index, query.slot],
-            schema: {
-                query: { slot: Schema.UintRequired, committee_index: Schema.UintRequired },
+            url: "/eth/v1/validator/attestation_data",
+            method: "GET",
+            req: {
+                writeReq: ({ committeeIndex, slot }) => ({ query: { slot, committee_index: committeeIndex } }),
+                parseReq: ({ query }) => ({ committeeIndex: query.committee_index, slot: query.slot }),
+                schema: {
+                    query: { slot: Schema.UintRequired, committee_index: Schema.UintRequired },
+                },
+            },
+            resp: {
+                data: ssz.phase0.AttestationData,
+                meta: EmptyMetaCodec,
             },
         },
         produceSyncCommitteeContribution: {
-            writeReq: (slot, index, root) => ({
-                query: { slot, subcommittee_index: index, beacon_block_root: toHexString(root) },
-            }),
-            parseReq: ({ query }) => [query.slot, query.subcommittee_index, fromHexString(query.beacon_block_root)],
-            schema: {
-                query: {
-                    slot: Schema.UintRequired,
-                    subcommittee_index: Schema.UintRequired,
-                    beacon_block_root: Schema.StringRequired,
+            url: "/eth/v1/validator/sync_committee_contribution",
+            method: "GET",
+            req: {
+                writeReq: ({ slot, subcommitteeIndex, beaconBlockRoot }) => ({
+                    query: { slot, subcommittee_index: subcommitteeIndex, beacon_block_root: toHexString(beaconBlockRoot) },
+                }),
+                parseReq: ({ query }) => ({
+                    slot: query.slot,
+                    subcommitteeIndex: query.subcommittee_index,
+                    beaconBlockRoot: fromHexString(query.beacon_block_root),
+                }),
+                schema: {
+                    query: {
+                        slot: Schema.UintRequired,
+                        subcommittee_index: Schema.UintRequired,
+                        beacon_block_root: Schema.StringRequired,
+                    },
                 },
             },
+            resp: {
+                data: ssz.altair.SyncCommitteeContribution,
+                meta: EmptyMetaCodec,
+            },
         },
         getAggregatedAttestation: {
-            writeReq: (root, slot) => ({ query: { attestation_data_root: toHexString(root), slot } }),
-            parseReq: ({ query }) => [fromHexString(query.attestation_data_root), query.slot],
-            schema: {
-                query: { attestation_data_root: Schema.StringRequired, slot: Schema.UintRequired },
+            url: "/eth/v1/validator/aggregate_attestation",
+            method: "GET",
+            req: {
+                writeReq: ({ attestationDataRoot, slot }) => ({
+                    query: { attestation_data_root: toHexString(attestationDataRoot), slot },
+                }),
+                parseReq: ({ query }) => ({ attestationDataRoot: fromHexString(query.attestation_data_root), slot: query.slot }),
+                schema: {
+                    query: { attestation_data_root: Schema.StringRequired, slot: Schema.UintRequired },
+                },
+            },
+            resp: {
+                data: ssz.phase0.Attestation,
+                meta: EmptyMetaCodec,
+            },
+        },
+        publishAggregateAndProofs: {
+            url: "/eth/v1/validator/aggregate_and_proofs",
+            method: "POST",
+            req: {
+                writeReqJson: ({ signedAggregateAndProofs }) => ({
+                    body: SignedAggregateAndProofListType.toJson(signedAggregateAndProofs),
+                }),
+                parseReqJson: ({ body }) => ({ signedAggregateAndProofs: SignedAggregateAndProofListType.fromJson(body) }),
+                writeReqSsz: ({ signedAggregateAndProofs }) => ({
+                    body: SignedAggregateAndProofListType.serialize(signedAggregateAndProofs),
+                }),
+                parseReqSsz: ({ body }) => ({ signedAggregateAndProofs: SignedAggregateAndProofListType.deserialize(body) }),
+                schema: {
+                    body: Schema.ObjectArray,
+                },
+            },
+            resp: EmptyResponseCodec,
+        },
+        publishContributionAndProofs: {
+            url: "/eth/v1/validator/contribution_and_proofs",
+            method: "POST",
+            req: {
+                writeReqJson: ({ contributionAndProofs }) => ({
+                    body: SignedContributionAndProofListType.toJson(contributionAndProofs),
+                }),
+                parseReqJson: ({ body }) => ({ contributionAndProofs: SignedContributionAndProofListType.fromJson(body) }),
+                writeReqSsz: ({ contributionAndProofs }) => ({
+                    body: SignedContributionAndProofListType.serialize(contributionAndProofs),
+                }),
+                parseReqSsz: ({ body }) => ({ contributionAndProofs: SignedContributionAndProofListType.deserialize(body) }),
+                schema: {
+                    body: Schema.ObjectArray,
+                },
+            },
+            resp: EmptyResponseCodec,
+        },
+        prepareBeaconCommitteeSubnet: {
+            url: "/eth/v1/validator/beacon_committee_subscriptions",
+            method: "POST",
+            req: {
+                writeReqJson: ({ subscriptions }) => ({ body: BeaconCommitteeSubscriptionListType.toJson(subscriptions) }),
+                parseReqJson: ({ body }) => ({ subscriptions: BeaconCommitteeSubscriptionListType.fromJson(body) }),
+                writeReqSsz: ({ subscriptions }) => ({ body: BeaconCommitteeSubscriptionListType.serialize(subscriptions) }),
+                parseReqSsz: ({ body }) => ({ subscriptions: BeaconCommitteeSubscriptionListType.deserialize(body) }),
+                schema: { body: Schema.ObjectArray },
             },
+            resp: EmptyResponseCodec,
+        },
+        prepareSyncCommitteeSubnets: {
+            url: "/eth/v1/validator/sync_committee_subscriptions",
+            method: "POST",
+            req: {
+                writeReqJson: ({ subscriptions }) => ({ body: SyncCommitteeSubscriptionListType.toJson(subscriptions) }),
+                parseReqJson: ({ body }) => ({ subscriptions: SyncCommitteeSubscriptionListType.fromJson(body) }),
+                writeReqSsz: ({ subscriptions }) => ({ body: SyncCommitteeSubscriptionListType.serialize(subscriptions) }),
+                parseReqSsz: ({ body }) => ({ subscriptions: SyncCommitteeSubscriptionListType.deserialize(body) }),
+                schema: { body: Schema.ObjectArray },
+            },
+            resp: EmptyResponseCodec,
         },
-        publishAggregateAndProofs: reqOnlyBody(ArrayOf(ssz.phase0.SignedAggregateAndProof), Schema.ObjectArray),
-        publishContributionAndProofs: reqOnlyBody(ArrayOf(ssz.altair.SignedContributionAndProof), Schema.ObjectArray),
-        prepareBeaconCommitteeSubnet: reqOnlyBody(ArrayOf(BeaconCommitteeSubscription), Schema.ObjectArray),
-        prepareSyncCommitteeSubnets: reqOnlyBody(ArrayOf(SyncCommitteeSubscription), Schema.ObjectArray),
         prepareBeaconProposer: {
-            writeReq: (items) => ({ body: items.map((item) => jsonType("snake").toJson(item)) }),
-            parseReq: ({ body }) => [
-                body.map((item) => jsonType("snake").fromJson(item)),
-            ],
-            schema: { body: Schema.ObjectArray },
+            url: "/eth/v1/validator/prepare_beacon_proposer",
+            method: "POST",
+            req: JsonOnlyReq({
+                writeReqJson: ({ proposers }) => ({ body: ProposerPreparationDataListType.toJson(proposers) }),
+                parseReqJson: ({ body }) => ({ proposers: ProposerPreparationDataListType.fromJson(body) }),
+                schema: { body: Schema.ObjectArray },
+            }),
+            resp: EmptyResponseCodec,
         },
         submitBeaconCommitteeSelections: {
-            writeReq: (items) => ({ body: ArrayOf(BeaconCommitteeSelection).toJson(items) }),
-            parseReq: () => [[]],
+            url: "/eth/v1/validator/beacon_committee_selections",
+            method: "POST",
+            req: {
+                writeReqJson: ({ selections }) => ({ body: BeaconCommitteeSelectionListType.toJson(selections) }),
+                parseReqJson: ({ body }) => ({ selections: BeaconCommitteeSelectionListType.fromJson(body) }),
+                writeReqSsz: ({ selections }) => ({ body: BeaconCommitteeSelectionListType.serialize(selections) }),
+                parseReqSsz: ({ body }) => ({ selections: BeaconCommitteeSelectionListType.deserialize(body) }),
+                schema: {
+                    body: Schema.ObjectArray,
+                },
+            },
+            resp: {
+                data: BeaconCommitteeSelectionListType,
+                meta: EmptyMetaCodec,
+            },
         },
         submitSyncCommitteeSelections: {
-            writeReq: (items) => ({ body: ArrayOf(SyncCommitteeSelection).toJson(items) }),
-            parseReq: () => [[]],
+            url: "/eth/v1/validator/sync_committee_selections",
+            method: "POST",
+            req: {
+                writeReqJson: ({ selections }) => ({ body: SyncCommitteeSelectionListType.toJson(selections) }),
+                parseReqJson: ({ body }) => ({ selections: SyncCommitteeSelectionListType.fromJson(body) }),
+                writeReqSsz: ({ selections }) => ({ body: SyncCommitteeSelectionListType.serialize(selections) }),
+                parseReqSsz: ({ body }) => ({ selections: SyncCommitteeSelectionListType.deserialize(body) }),
+                schema: {
+                    body: Schema.ObjectArray,
+                },
+            },
+            resp: {
+                data: SyncCommitteeSelectionListType,
+                meta: EmptyMetaCodec,
+            },
         },
         getLiveness: {
-            writeReq: (epoch, indexes) => ({ params: { epoch }, body: indexes.map((i) => toU64Str(i)) }),
-            parseReq: ({ params, body }) => [params.epoch, body.map((i) => fromU64Str(i))],
-            schema: {
-                params: { epoch: Schema.UintRequired },
-                body: Schema.StringArray,
+            url: "/eth/v1/validator/liveness/{epoch}",
+            method: "POST",
+            req: {
+                writeReqJson: ({ epoch, indices }) => ({ params: { epoch }, body: ValidatorIndicesType.toJson(indices) }),
+                parseReqJson: ({ params, body }) => ({ epoch: params.epoch, indices: ValidatorIndicesType.fromJson(body) }),
+                writeReqSsz: ({ epoch, indices }) => ({ params: { epoch }, body: ValidatorIndicesType.serialize(indices) }),
+                parseReqSsz: ({ params, body }) => ({ epoch: params.epoch, indices: ValidatorIndicesType.deserialize(body) }),
+                schema: {
+                    params: { epoch: Schema.UintRequired },
+                    body: Schema.StringArray,
+                },
             },
-        },
-        registerValidator: reqOnlyBody(ArrayOf(ssz.bellatrix.SignedValidatorRegistrationV1), Schema.ObjectArray),
-    };
-}
-export function getReturnTypes() {
-    const rootHexType = new StringType();
-    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-    const WithDependentRootExecutionOptimistic = (dataType) => new ContainerType({
-        executionOptimistic: ssz.Boolean,
-        data: dataType,
-        dependentRoot: rootHexType,
-    }, { jsonCase: "eth2" });
-    const AttesterDuty = new ContainerType({
-        pubkey: ssz.BLSPubkey,
-        validatorIndex: ssz.ValidatorIndex,
-        committeeIndex: ssz.CommitteeIndex,
-        committeeLength: ssz.UintNum64,
-        committeesAtSlot: ssz.UintNum64,
-        validatorCommitteeIndex: ssz.UintNum64,
-        slot: ssz.Slot,
-    }, { jsonCase: "eth2" });
-    const ProposerDuty = new ContainerType({
-        slot: ssz.Slot,
-        validatorIndex: ssz.ValidatorIndex,
-        pubkey: ssz.BLSPubkey,
-    }, { jsonCase: "eth2" });
-    const SyncDuty = new ContainerType({
-        pubkey: ssz.BLSPubkey,
-        validatorIndex: ssz.ValidatorIndex,
-        validatorSyncCommitteeIndices: ArrayOf(ssz.UintNum64),
-    }, { jsonCase: "eth2" });
-    const produceBlockOrContents = WithBlockValues(WithVersion((fork) => isForkBlobs(fork) ? allForksBlockContentsResSerializer(fork) : ssz[fork].BeaconBlock));
-    const produceBlindedBlock = WithBlockValues(WithVersion((fork) => ssz.allForksBlinded[isForkExecution(fork) ? fork : ForkName.bellatrix].BeaconBlock));
-    return {
-        getAttesterDuties: WithDependentRootExecutionOptimistic(ArrayOf(AttesterDuty)),
-        getProposerDuties: WithDependentRootExecutionOptimistic(ArrayOf(ProposerDuty)),
-        getSyncCommitteeDuties: ContainerDataExecutionOptimistic(ArrayOf(SyncDuty)),
-        produceBlock: ContainerData(ssz.phase0.BeaconBlock),
-        produceBlockV2: produceBlockOrContents,
-        produceBlockV3: {
-            toJson: (data) => {
-                if (data.executionPayloadBlinded) {
-                    return {
-                        execution_payload_blinded: true,
-                        execution_payload_source: data.executionPayloadSource,
-                        ...produceBlindedBlock.toJson(data),
-                    };
-                }
-                else {
-                    return {
-                        execution_payload_blinded: false,
-                        execution_payload_source: data.executionPayloadSource,
-                        ...produceBlockOrContents.toJson(data),
-                    };
-                }
+            resp: {
+                data: LivenessResponseDataListType,
+                meta: EmptyMetaCodec,
             },
-            fromJson: (data) => {
-                const executionPayloadBlinded = data.execution_payload_blinded;
-                if (executionPayloadBlinded === undefined) {
-                    throw Error(`Invalid executionPayloadBlinded=${executionPayloadBlinded} for fromJson deserialization`);
-                }
-                // extract source from the data and assign defaults in the spec complaint manner if not present in response
-                const executionPayloadSource = data.execution_payload_source ??
-                    (executionPayloadBlinded ? ProducedBlockSource.builder : ProducedBlockSource.engine);
-                if (executionPayloadBlinded) {
-                    return { executionPayloadBlinded, executionPayloadSource, ...produceBlindedBlock.fromJson(data) };
-                }
-                else {
-                    return { executionPayloadBlinded, executionPayloadSource, ...produceBlockOrContents.fromJson(data) };
-                }
+        },
+        registerValidator: {
+            url: "/eth/v1/validator/register_validator",
+            method: "POST",
+            req: {
+                writeReqJson: ({ registrations }) => ({ body: SignedValidatorRegistrationV1ListType.toJson(registrations) }),
+                parseReqJson: ({ body }) => ({ registrations: SignedValidatorRegistrationV1ListType.fromJson(body) }),
+                writeReqSsz: ({ registrations }) => ({ body: SignedValidatorRegistrationV1ListType.serialize(registrations) }),
+                parseReqSsz: ({ body }) => ({ registrations: SignedValidatorRegistrationV1ListType.deserialize(body) }),
+                schema: {
+                    body: Schema.ObjectArray,
+                },
             },
+            resp: EmptyResponseCodec,
         },
-        produceBlindedBlock,
-        produceAttestationData: ContainerData(ssz.phase0.AttestationData),
-        produceSyncCommitteeContribution: ContainerData(ssz.altair.SyncCommitteeContribution),
-        getAggregatedAttestation: ContainerData(ssz.phase0.Attestation),
-        submitBeaconCommitteeSelections: ContainerData(ArrayOf(BeaconCommitteeSelection)),
-        submitSyncCommitteeSelections: ContainerData(ArrayOf(SyncCommitteeSelection)),
-        getLiveness: jsonType("snake"),
     };
 }
 function parseBuilderBoostFactor(builderBoostFactorInput) {
     return builderBoostFactorInput !== undefined ? BigInt(builderBoostFactorInput) : undefined;
 }
+function writeSkipRandaoVerification(skipRandaoVerification) {
+    return skipRandaoVerification === true ? "" : undefined;
+}
 function parseSkipRandaoVerification(skipRandaoVerification) {
     return skipRandaoVerification !== undefined && skipRandaoVerification === "";
 }