@lodestar/api/lib/builder/routes.js

A Typescript REST client for the Ethereum Consensus API

import { isForkPostDeneb } from "@lodestar/params";
import { ssz, } from "@lodestar/types";
import { fromHex, toPubkeyHex, toRootHex } from "@lodestar/utils";
import { ArrayOf, EmptyRequestCodec, EmptyResponseCodec, JsonOnlyReq, WithVersion, } from "../utils/codecs.js";
import { getPostBellatrixForkTypes, getPostDenebForkTypes, toForkName } from "../utils/fork.js";
import { fromHeaders } from "../utils/headers.js";
import { Schema } from "../utils/index.js";
import { MetaHeader, VersionCodec } from "../utils/metadata.js";
const RegistrationsType = ArrayOf(ssz.bellatrix.SignedValidatorRegistrationV1);
export function getDefinitions(config) {
    return {
        status: {
            url: "/eth/v1/builder/status",
            method: "GET",
            req: EmptyRequestCodec,
            resp: EmptyResponseCodec,
        },
        registerValidator: {
            url: "/eth/v1/builder/validators",
            method: "POST",
            req: JsonOnlyReq({
                writeReqJson: ({ registrations }) => ({ body: RegistrationsType.toJson(registrations) }),
                parseReqJson: ({ body }) => ({ registrations: RegistrationsType.fromJson(body) }),
                schema: { body: Schema.ObjectArray },
            }),
            resp: EmptyResponseCodec,
        },
        getHeader: {
            url: "/eth/v1/builder/header/{slot}/{parent_hash}/{pubkey}",
            method: "GET",
            req: {
                writeReq: ({ slot, parentHash, proposerPubkey: proposerPubKey }) => ({
                    params: { slot, parent_hash: toRootHex(parentHash), pubkey: toPubkeyHex(proposerPubKey) },
                }),
                parseReq: ({ params }) => ({
                    slot: params.slot,
                    parentHash: fromHex(params.parent_hash),
                    proposerPubkey: fromHex(params.pubkey),
                }),
                schema: {
                    params: { slot: Schema.UintRequired, parent_hash: Schema.StringRequired, pubkey: Schema.StringRequired },
                },
            },
            resp: {
                data: WithVersion((fork) => getPostBellatrixForkTypes(fork).SignedBuilderBid),
                meta: VersionCodec,
            },
        },
        submitBlindedBlock: {
            url: "/eth/v1/builder/blinded_blocks",
            method: "POST",
            req: {
                writeReqJson: ({ signedBlindedBlock }) => {
                    const fork = config.getForkName(signedBlindedBlock.data.message.slot);
                    return {
                        body: getPostBellatrixForkTypes(fork).SignedBlindedBeaconBlock.toJson(signedBlindedBlock.data),
                        headers: {
                            [MetaHeader.Version]: fork,
                        },
                    };
                },
                parseReqJson: ({ body, headers }) => {
                    const fork = toForkName(fromHeaders(headers, MetaHeader.Version));
                    return {
                        signedBlindedBlock: { data: getPostBellatrixForkTypes(fork).SignedBlindedBeaconBlock.fromJson(body) },
                    };
                },
                writeReqSsz: ({ signedBlindedBlock }) => {
                    const fork = config.getForkName(signedBlindedBlock.data.message.slot);
                    return {
                        body: signedBlindedBlock.bytes ??
                            getPostBellatrixForkTypes(fork).SignedBlindedBeaconBlock.serialize(signedBlindedBlock.data),
                        headers: {
                            [MetaHeader.Version]: fork,
                        },
                    };
                },
                parseReqSsz: ({ body, headers }) => {
                    const fork = toForkName(fromHeaders(headers, MetaHeader.Version));
                    return {
                        signedBlindedBlock: { data: getPostBellatrixForkTypes(fork).SignedBlindedBeaconBlock.deserialize(body) },
                    };
                },
                schema: {
                    body: Schema.Object,
                    headers: { [MetaHeader.Version]: Schema.String },
                },
            },
            resp: {
                data: WithVersion((fork) => {
                    return isForkPostDeneb(fork)
                        ? getPostDenebForkTypes(fork).ExecutionPayloadAndBlobsBundle
                        : getPostBellatrixForkTypes(fork).ExecutionPayload;
                }),
                meta: VersionCodec,
            },
        },
    };
}
//# sourceMappingURL=routes.js.map