@bithomp/xrpl-api/lib/ledger/vl-v2.js

A Bithomp JavaScript/TypeScript library for interacting with the XRP Ledger

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
    var ownKeys = function(o) {
        ownKeys = Object.getOwnPropertyNames || function (o) {
            var ar = [];
            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
            return ar;
        };
        return ownKeys(o);
    };
    return function (mod) {
        if (mod && mod.__esModule) return mod;
        var result = {};
        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
        __setModuleDefault(result, mod);
        return result;
    };
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.createVLv2 = createVLv2;
exports.createVLBlobV2 = createVLBlobV2;
const vl_1 = require("../models/vl");
const manifest_1 = require("../models/manifest");
const ledger_1 = require("../models/ledger");
const Validator = __importStar(require("../validator"));
const vl_2 = require("./vl");
const common_1 = require("../common");
async function createVLv2(masterKey, ephemeralKey, publishBlobs) {
    if (!masterKey) {
        throw new Error("Master key is required");
    }
    if (!ephemeralKey) {
        throw new Error("Ephemeral key is required");
    }
    if (masterKey.publicKey === ephemeralKey.publicKey) {
        throw new Error("Master and ephemeral keys must be different.");
    }
    let globalSequence;
    const blobs = [];
    for (const publishBlob of publishBlobs) {
        const { sequence, effective, expiration, validatorsPublicKeys } = publishBlob;
        if (typeof sequence !== "number") {
            throw new Error("sequence must be a number.");
        }
        if (typeof effective !== "number" && effective !== undefined) {
            throw new Error("effective must be a number.");
        }
        if (typeof expiration !== "number") {
            throw new Error("expiration must be a number.");
        }
        if (Array.isArray(validatorsPublicKeys) === false) {
            throw new Error("validatorsPublicKeys must be an array.");
        }
        if (validatorsPublicKeys.length === 0) {
            throw new Error("validatorsPublicKeys must not be empty.");
        }
        for (const publicKey of validatorsPublicKeys) {
            if (typeof publicKey !== "string") {
                throw new Error("validatorsPublicKeys must be an array of strings.");
            }
            if (publicKey[0] !== "n") {
                throw new Error("validatorsPublicKeys must be an array of strings starting with 'n'.");
            }
        }
        const blobInfo = {};
        const vlBlob = await createVLBlobV2(sequence, effective, expiration, validatorsPublicKeys);
        blobInfo.blob = (0, vl_1.encodeVLBlob)(vlBlob);
        blobInfo.signature = Validator.sign(Buffer.from(blobInfo.blob, "base64"), ephemeralKey.privateKey);
        if (globalSequence === undefined) {
            globalSequence = sequence;
        }
        else if (globalSequence !== sequence) {
            blobInfo.manifest = (0, manifest_1.generateManifest)({
                Sequence: sequence,
                PublicKey: masterKey.publicKey,
                SigningPubKey: ephemeralKey.publicKey,
                SigningPrivateKey: ephemeralKey.privateKey,
                MasterPrivateKey: masterKey.privateKey,
            });
        }
        blobs.push(blobInfo);
    }
    if (globalSequence === undefined) {
        throw new Error("sequence must be a number.");
    }
    const globalManifest = (0, manifest_1.generateManifest)({
        Sequence: globalSequence,
        PublicKey: masterKey.publicKey,
        SigningPubKey: ephemeralKey.publicKey,
        SigningPrivateKey: ephemeralKey.privateKey,
        MasterPrivateKey: masterKey.privateKey,
    });
    return {
        "blobs_v2": blobs,
        manifest: globalManifest,
        public_key: masterKey.publicKey,
        version: 2,
    };
}
async function createVLBlobV2(sequence, effective, expiration, validatorsPublicKeys) {
    const validators = await (0, vl_2.getVLBlobValidatorsManifest)(validatorsPublicKeys);
    return (0, common_1.removeUndefined)({
        sequence,
        effective: effective ? (0, ledger_1.unixTimeToLedgerTime)(effective) : undefined,
        expiration: (0, ledger_1.unixTimeToLedgerTime)(expiration),
        validators,
    });
}