@exromany/lido-csm-sdk/dist/cjs/deposit-data-sdk/parser.js

[](https://github.com/lidofinance/lido-csm-sdk/blob/main/LICENSE.txt) [](h

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.removeKey = exports.parseDepositData = void 0;
const is_hexadecimal_string_js_1 = require("../common/utils/is-hexadecimal-string.js");
const constants_js_1 = require("./constants.js");
const normalizeHexInJson = (text) => {
    return text.replace(/"0x/gm, '"');
};
const parseAndValidateJson = (data) => {
    if (!data || data.trim() === '') {
        return {
            depositData: [],
            error: 'Deposit data should not be empty',
        };
    }
    if (data.length > constants_js_1.MAX_JSON_LENGTH) {
        return {
            depositData: [],
            error: `Deposit data is too big (max ${Math.round(constants_js_1.MAX_JSON_LENGTH / 1024 / 1024)}MB)`,
        };
    }
    let parsed;
    try {
        parsed = JSON.parse(data);
    }
    catch (error) {
        return {
            depositData: [],
            error: 'Invalid JSON format',
        };
    }
    const rawItems = Array.isArray(parsed) ? parsed : [parsed];
    const depositData = rawItems.map((item) => ({
        ...item,
        pubkey: item.pubkey ? (0, is_hexadecimal_string_js_1.toHexString)(item.pubkey) : item.pubkey,
        withdrawal_credentials: item.withdrawal_credentials
            ? (0, is_hexadecimal_string_js_1.toHexString)(item.withdrawal_credentials)
            : item.withdrawal_credentials,
        signature: item.signature ? (0, is_hexadecimal_string_js_1.toHexString)(item.signature) : item.signature,
        deposit_message_root: item.deposit_message_root
            ? (0, is_hexadecimal_string_js_1.toHexString)(item.deposit_message_root)
            : item.deposit_message_root,
        deposit_data_root: item.deposit_data_root
            ? (0, is_hexadecimal_string_js_1.toHexString)(item.deposit_data_root)
            : item.deposit_data_root,
        fork_version: item.fork_version
            ? (0, is_hexadecimal_string_js_1.toHexString)(item.fork_version)
            : item.fork_version,
    }));
    if (depositData.length === 0) {
        return {
            depositData: [],
            error: 'Should have at least 1 key',
        };
    }
    for (const [index, item] of depositData.entries()) {
        if (!item || typeof item !== 'object') {
            return {
                depositData: [],
                error: `Item at index ${index} should be an object`,
            };
        }
        const requiredFields = [
            'pubkey',
            'withdrawal_credentials',
            'amount',
            'signature',
            'deposit_message_root',
            'deposit_data_root',
            'fork_version',
        ];
        for (const field of requiredFields) {
            if (!(field in item)) {
                return {
                    depositData: [],
                    error: `Item at index ${index} is missing required field: ${field}`,
                };
            }
        }
    }
    return { depositData };
};
const parseDepositData = (jsonDepositData) => {
    const normalizedJson = normalizeHexInJson(jsonDepositData);
    const result = parseAndValidateJson(normalizedJson);
    if (result.error) {
        return {
            success: false,
            error: result.error,
        };
    }
    return {
        success: true,
        data: result.depositData,
    };
};
exports.parseDepositData = parseDepositData;
const removeKey = (jsonDepositData, index) => {
    if (!Number.isInteger(index) || index < 0) {
        return {
            success: false,
            error: 'Index must be a non-negative integer',
        };
    }
    const parseResult = (0, exports.parseDepositData)(jsonDepositData);
    if (!parseResult.success || !parseResult.data) {
        return {
            success: false,
            error: parseResult.error || 'Failed to parse deposit data',
        };
    }
    const depositData = parseResult.data;
    if (index >= depositData.length) {
        return {
            success: false,
            error: `Index ${index} is out of bounds (array length: ${depositData.length})`,
        };
    }
    const updatedData = Array.from(depositData);
    updatedData.splice(index, 1);
    const json = updatedData.length > 0 ? JSON.stringify(updatedData, null, 2) : '';
    return {
        success: true,
        data: updatedData,
        json,
    };
};
exports.removeKey = removeKey;
//# sourceMappingURL=parser.js.map