@lodestar/prover/lib/utils/json_rpc.js

A Typescript implementation of the Ethereum Consensus light client

import { VERIFICATION_FAILED_RESPONSE_CODE } from "../constants.js";
import { isNullish } from "./validation.js";
export function getResponseForRequest(payload, res, error) {
    // If it's a notification
    if (!isRequest(payload)) {
        throw new Error("Cannot generate response for notification");
    }
    if (!isNullish(res) && isNullish(error)) {
        return {
            jsonrpc: payload.jsonrpc,
            id: payload.id,
            result: res,
        };
    }
    if (!isNullish(error)) {
        return {
            jsonrpc: payload.jsonrpc,
            id: payload.id,
            error,
        };
    }
    throw new Error("Either result or error must be defined.");
}
export function getVerificationFailedMessage(method) {
    return `verification for '${method}' request failed.`;
}
export function isVerificationFailedError(payload) {
    return !isValidResponsePayload(payload) && payload.error.code === VERIFICATION_FAILED_RESPONSE_CODE;
}
export function getErrorResponseForRequestWithFailedVerification(payload, message, data) {
    return isNullish(data)
        ? getResponseForRequest(payload, undefined, {
            code: VERIFICATION_FAILED_RESPONSE_CODE,
            message,
        })
        : getResponseForRequest(payload, undefined, {
            code: VERIFICATION_FAILED_RESPONSE_CODE,
            message,
            data,
        });
}
function isValidResponsePayload(response) {
    return !isNullish(response) && isNullish(response.error);
}
export function isValidResponse(response) {
    return Array.isArray(response) ? response.every(isValidResponsePayload) : isValidResponsePayload(response);
}
export function isValidBatchResponse(payload, response) {
    for (const [index, req] of payload.entries()) {
        if (isRequest(req)) {
            if (response[index].id !== req.id || !isValidResponse(response[index]))
                return false;
        }
    }
    return true;
}
export function mergeBatchReqResp(payload, response) {
    const result = [];
    for (const [index, req] of payload.entries()) {
        if (isRequest(req)) {
            // Some providers return raw json-rpc response, some return only result
            // we need to just merge the result back based on the provider
            result.push({ request: req, response: response[index] });
        }
    }
    return result;
}
export function isNotification(payload) {
    return !("id" in payload);
}
export function isRequest(payload) {
    return "id" in payload;
}
export function isBatchRequest(payload) {
    return Array.isArray(payload);
}
export function isBatchResponse(response) {
    return Array.isArray(response);
}
function logRequestPayload(payload, logger) {
    logger.debug("PR -> EL", {
        id: isRequest(payload) ? payload.id : "notification",
        method: payload.method,
        params: JSON.stringify(payload.params),
    });
}
export function logRequest(payload, logger) {
    if (payload === undefined || payload === null) {
        return;
    }
    for (const p of isBatchRequest(payload) ? payload : [payload]) {
        logRequestPayload(p, logger);
    }
}
function logResponsePayload(response, logger) {
    if (response === undefined || response === null) {
        logger.debug("PR <- EL (empty response)");
        return;
    }
    if (isValidResponse(response)) {
        logger.debug("PR <- EL", {
            id: response.id,
            result: JSON.stringify(response.result),
        });
    }
    else {
        logger.debug("PR <- E:", {
            id: response.id,
            error: JSON.stringify(response.error),
        });
    }
}
export function logResponse(response, logger) {
    if (response === undefined || response === null) {
        return;
    }
    for (const p of isBatchResponse(response) ? response : [response]) {
        logResponsePayload(p, logger);
    }
}
//# sourceMappingURL=json_rpc.js.map