@lodestar/api/lib/utils/metadata.js

A Typescript REST client for the Ethereum Consensus API

import { ContainerType } from "@chainsafe/ssz";
import { StringType, ssz, stringType } from "@lodestar/types";
import { toForkName } from "./fork.js";
import { HttpHeader } from "./headers.js";
import { toBoolean } from "./serdes.js";
export const VersionType = new ContainerType({
    /**
     * Fork code name
     */
    version: new StringType(),
});
VersionType.fields.version.fromJson = (json) => {
    return toForkName(stringType.fromJson(json));
};
export const ExecutionOptimisticType = new ContainerType({
    /**
     * True if the response references an unverified execution payload.
     * Optimistic information may be invalidated at a later time.
     */
    executionOptimistic: ssz.Boolean,
}, { jsonCase: "eth2" });
export const ExecutionOptimisticAndFinalizedType = new ContainerType({
    ...ExecutionOptimisticType.fields,
    /**
     * True if the response references the finalized history of the chain, as determined by fork choice
     */
    finalized: ssz.Boolean,
}, { jsonCase: "eth2" });
export const ExecutionOptimisticAndVersionType = new ContainerType({
    ...ExecutionOptimisticType.fields,
    ...VersionType.fields,
}, { jsonCase: "eth2" });
export const ExecutionOptimisticFinalizedAndVersionType = new ContainerType({
    ...ExecutionOptimisticAndFinalizedType.fields,
    ...VersionType.fields,
}, { jsonCase: "eth2" });
export const ExecutionOptimisticAndDependentRootType = new ContainerType({
    ...ExecutionOptimisticType.fields,
    /**
     * The block root that this response is dependent on
     */
    dependentRoot: stringType,
}, { jsonCase: "eth2" });
export { MetaHeader };
var MetaHeader;
(function (MetaHeader) {
    MetaHeader["Version"] = "Eth-Consensus-Version";
    MetaHeader["ConsensusBlockValue"] = "Eth-Consensus-Block-Value";
    MetaHeader["ExecutionPayloadBlinded"] = "Eth-Execution-Payload-Blinded";
    MetaHeader["ExecutionPayloadValue"] = "Eth-Execution-Payload-Value";
    /* Lodestar-specific (non-standardized) headers */
    MetaHeader["Finalized"] = "Eth-Consensus-Finalized";
    MetaHeader["DependentRoot"] = "Eth-Consensus-Dependent-Root";
    MetaHeader["ExecutionOptimistic"] = "Eth-Execution-Optimistic";
    MetaHeader["ExecutionPayloadSource"] = "Eth-Execution-Payload-Source";
})(MetaHeader || (MetaHeader = {}));
export const ExecutionOptimisticCodec = {
    toJson: (val) => ExecutionOptimisticType.toJson(val),
    fromJson: (val) => ExecutionOptimisticType.fromJson(val),
    toHeadersObject: (val) => ({
        [MetaHeader.ExecutionOptimistic]: val.executionOptimistic.toString(),
        [HttpHeader.ExposeHeaders]: MetaHeader.ExecutionOptimistic,
    }),
    fromHeaders: (headers) => ({
        executionOptimistic: toBoolean(headers.getOrDefault(MetaHeader.ExecutionOptimistic, "false")),
    }),
};
export const VersionCodec = {
    toJson: (val) => VersionType.toJson(val),
    fromJson: (val) => VersionType.fromJson(val),
    toHeadersObject: (val) => ({
        [MetaHeader.Version]: val.version,
        [HttpHeader.ExposeHeaders]: MetaHeader.Version,
    }),
    fromHeaders: (headers) => ({
        version: toForkName(headers.getRequired(MetaHeader.Version)),
    }),
};
export const ExecutionOptimisticAndVersionCodec = {
    toJson: (val) => ExecutionOptimisticAndVersionType.toJson(val),
    fromJson: (val) => ExecutionOptimisticAndVersionType.fromJson(val),
    toHeadersObject: (val) => ({
        [MetaHeader.ExecutionOptimistic]: val.executionOptimistic.toString(),
        [MetaHeader.Version]: val.version,
        [HttpHeader.ExposeHeaders]: [MetaHeader.ExecutionOptimistic, MetaHeader.Version].toString(),
    }),
    fromHeaders: (headers) => ({
        executionOptimistic: toBoolean(headers.getOrDefault(MetaHeader.ExecutionOptimistic, "false")),
        version: toForkName(headers.getRequired(MetaHeader.Version)),
    }),
};
export const ExecutionOptimisticAndFinalizedCodec = {
    toJson: (val) => ExecutionOptimisticAndFinalizedType.toJson(val),
    fromJson: (val) => ExecutionOptimisticAndFinalizedType.fromJson(val),
    toHeadersObject: (val) => ({
        [MetaHeader.ExecutionOptimistic]: val.executionOptimistic.toString(),
        [MetaHeader.Finalized]: val.finalized.toString(),
        [HttpHeader.ExposeHeaders]: [MetaHeader.ExecutionOptimistic, MetaHeader.Finalized].toString(),
    }),
    fromHeaders: (headers) => ({
        executionOptimistic: toBoolean(headers.getOrDefault(MetaHeader.ExecutionOptimistic, "false")),
        finalized: toBoolean(headers.getOrDefault(MetaHeader.Finalized, "false")),
    }),
};
export const ExecutionOptimisticFinalizedAndVersionCodec = {
    toJson: (val) => ExecutionOptimisticFinalizedAndVersionType.toJson(val),
    fromJson: (val) => ExecutionOptimisticFinalizedAndVersionType.fromJson(val),
    toHeadersObject: (val) => ({
        [MetaHeader.ExecutionOptimistic]: val.executionOptimistic.toString(),
        [MetaHeader.Finalized]: val.finalized.toString(),
        [MetaHeader.Version]: val.version,
        [HttpHeader.ExposeHeaders]: [MetaHeader.ExecutionOptimistic, MetaHeader.Finalized, MetaHeader.Version].toString(),
    }),
    fromHeaders: (headers) => ({
        executionOptimistic: toBoolean(headers.getOrDefault(MetaHeader.ExecutionOptimistic, "false")),
        finalized: toBoolean(headers.getOrDefault(MetaHeader.Finalized, "false")),
        version: toForkName(headers.getRequired(MetaHeader.Version)),
    }),
};
export const ExecutionOptimisticAndDependentRootCodec = {
    toJson: (val) => ExecutionOptimisticAndDependentRootType.toJson(val),
    fromJson: (val) => ExecutionOptimisticAndDependentRootType.fromJson(val),
    toHeadersObject: (val) => ({
        [MetaHeader.ExecutionOptimistic]: val.executionOptimistic.toString(),
        [MetaHeader.DependentRoot]: val.dependentRoot,
        [HttpHeader.ExposeHeaders]: [MetaHeader.ExecutionOptimistic, MetaHeader.DependentRoot].toString(),
    }),
    fromHeaders: (headers) => ({
        executionOptimistic: toBoolean(headers.getOrDefault(MetaHeader.ExecutionOptimistic, "false")),
        dependentRoot: headers.getRequired(MetaHeader.DependentRoot),
    }),
};
//# sourceMappingURL=metadata.js.map