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

A Typescript REST client for the Ethereum Consensus API

import { ListBasicType, ListCompositeType, isBasicType, isCompositeType } from "@chainsafe/ssz";
import { objectToExpectedCase } from "@lodestar/utils";
import { WireFormat } from "./wireFormat.js";
/** Shortcut for routes that have no params, query */
export const EmptyRequestCodec = {
    writeReq: () => ({}),
    parseReq: () => { },
    schema: {},
};
export function JsonOnlyReq(req) {
    return {
        ...req,
        writeReqSsz: () => {
            throw Error("Not implemented");
        },
        parseReqSsz: () => {
            throw Error("Not implemented");
        },
        onlySupport: WireFormat.json,
    };
}
export const EmptyResponseDataCodec = {
    toJson: () => { },
    fromJson: () => { },
    serialize: () => new Uint8Array(),
    deserialize: () => { },
};
export const EmptyMetaCodec = {
    toJson: () => { },
    fromJson: () => { },
    toHeadersObject: () => ({}),
    fromHeaders: () => { },
};
export const EmptyResponseCodec = {
    data: EmptyResponseDataCodec,
    meta: EmptyMetaCodec,
    isEmpty: true,
};
export function ArrayOf(elementType, limit = Infinity) {
    if (isCompositeType(elementType)) {
        return new ListCompositeType(elementType, limit);
    }
    if (isBasicType(elementType)) {
        return new ListBasicType(elementType, limit);
    }
    throw Error(`Unknown type ${elementType.typeName}`);
}
export function WithMeta(getType) {
    return {
        toJson: (data, meta) => getType(meta).toJson(data),
        fromJson: (data, meta) => getType(meta).fromJson(data),
        serialize: (data, meta) => getType(meta).serialize(data),
        deserialize: (data, meta) => getType(meta).deserialize(data),
    };
}
export function WithVersion(getType) {
    return {
        toJson: (data, meta) => getType(meta.version).toJson(data),
        fromJson: (data, meta) => getType(meta.version).fromJson(data),
        serialize: (data, meta) => getType(meta.version).serialize(data),
        deserialize: (data, meta) => getType(meta.version).deserialize(data),
    };
}
export function JsonOnlyResp(resp) {
    return {
        ...resp,
        data: {
            ...resp.data,
            serialize: () => {
                throw Error("Not implemented");
            },
            deserialize: () => {
                throw Error("Not implemented");
            },
        },
        onlySupport: WireFormat.json,
    };
}
export const JsonOnlyResponseCodec = {
    data: {
        toJson: (data) => {
            // JSON fields use snake case across all existing routes
            return objectToExpectedCase(data, "snake");
        },
        fromJson: (data) => {
            if (typeof data !== "object" || data === null) {
                throw Error("JSON must be of type object");
            }
            // All JSON inside the JS code must be camel case
            return objectToExpectedCase(data, "camel");
        },
        serialize: () => {
            throw Error("Not implemented");
        },
        deserialize: () => {
            throw Error("Not implemented");
        },
    },
    meta: EmptyMetaCodec,
    onlySupport: WireFormat.json,
};
//# sourceMappingURL=codecs.js.map