@bithomp/xrpl-api/lib/parse/utils.js

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

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.parseQuality = parseQuality;
exports.parseTimestamp = parseTimestamp;
exports.adjustQualityForXRP = adjustQualityForXRP;
exports.isPartialPayment = isPartialPayment;
exports.removeGenericCounterparty = removeGenericCounterparty;
exports.normalizeNodes = normalizeNodes;
exports.normalizeNode = normalizeNode;
exports.hexToString = hexToString;
exports.decodeHexData = decodeHexData;
exports.stringToHex = stringToHex;
exports.bytesToHex = bytesToHex;
exports.hexToBytes = hexToBytes;
exports.parseUint32 = parseUint32;
exports.parseUint64 = parseUint64;
const lodash_1 = __importDefault(require("lodash"));
const bignumber_js_1 = __importDefault(require("bignumber.js"));
const xrpl_1 = require("xrpl");
const models_1 = require("../models");
const client_1 = require("../client");
function adjustQualityForXRP(quality, takerGetsCurrency, takerPaysCurrency) {
    const numeratorShift = takerPaysCurrency === (0, client_1.getNativeCurrency)() ? -6 : 0;
    const denominatorShift = takerGetsCurrency === (0, client_1.getNativeCurrency)() ? -6 : 0;
    const shift = numeratorShift - denominatorShift;
    return shift === 0 ? quality : new bignumber_js_1.default(quality).shiftedBy(shift).toString();
}
function parseQuality(quality) {
    if (typeof quality !== "number") {
        return undefined;
    }
    return new bignumber_js_1.default(quality).shiftedBy(-9).toNumber();
}
function parseTimestamp(rippleTime) {
    if (typeof rippleTime !== "number") {
        return undefined;
    }
    return (0, models_1.ledgerTimeToISO8601)(rippleTime);
}
function isPartialPayment(tx) {
    return (tx.Flags & xrpl_1.PaymentFlags.tfPartialPayment) !== 0;
}
function removeGenericCounterparty(amount, address) {
    if ("counterparty" in amount) {
        return amount.counterparty === address ? lodash_1.default.omit(amount, "counterparty") : amount;
    }
    if ("issuer" in amount) {
        return amount.issuer === address ? lodash_1.default.omit(amount, "issuer") : amount;
    }
    return amount;
}
function normalizeNode(affectedNode) {
    const diffType = Object.keys(affectedNode)[0];
    const node = affectedNode[diffType];
    return Object.assign({}, node, {
        diffType,
        entryType: node.LedgerEntryType,
        ledgerIndex: node.LedgerIndex,
        newFields: node.NewFields || {},
        finalFields: node.FinalFields || {},
        previousFields: node.PreviousFields || {},
    });
}
function normalizeNodes(metadata) {
    if (!metadata.AffectedNodes) {
        return [];
    }
    return metadata.AffectedNodes.map(normalizeNode);
}
function hexToString(hex) {
    return hex ? Buffer.from(hex, "hex").toString("utf-8") : undefined;
}
function decodeHexData(data) {
    if (!data) {
        return undefined;
    }
    const decoded = hexToString(data);
    if (decoded && decoded.includes("�")) {
        return data;
    }
    return decoded;
}
function stringToHex(value) {
    return value ? Buffer.from(value, "utf8").toString("hex").toUpperCase() : undefined;
}
function bytesToHex(value) {
    return Buffer.from(value)
        .toString("hex")
        .toUpperCase();
}
function hexToBytes(value) {
    if (value.length % 2 !== 0) {
        throw new Error("Invalid hex string length");
    }
    if (!/^[0-9a-fA-F]*$/.test(value)) {
        throw new Error("Invalid hex string");
    }
    if (value.length === 0) {
        return new Uint8Array(0);
    }
    return Uint8Array.from(Buffer.from(value, "hex"));
}
function parseUint32(buf, cur) {
    return ((BigInt(buf[cur]) << 24n) + (BigInt(buf[cur + 1]) << 16n) + (BigInt(buf[cur + 2]) << 8n) + BigInt(buf[cur + 3]) + "");
}
function parseUint64(buf, cur) {
    return ((BigInt(buf[cur]) << 56n) +
        (BigInt(buf[cur + 1]) << 48n) +
        (BigInt(buf[cur + 2]) << 40n) +
        (BigInt(buf[cur + 3]) << 32n) +
        (BigInt(buf[cur + 4]) << 24n) +
        (BigInt(buf[cur + 5]) << 16n) +
        (BigInt(buf[cur + 6]) << 8n) +
        BigInt(buf[cur + 7]) +
        "");
}