@bithomp/xrpl-api/lib/parse/outcome/balance_changes.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.parseBalanceChanges = parseBalanceChanges;
exports.parseFinalBalances = parseFinalBalances;
const lodash_1 = __importDefault(require("lodash"));
const bignumber_js_1 = __importDefault(require("bignumber.js"));
const common_1 = require("../../common");
const client_1 = require("../../client");
const utils_1 = require("../utils");
function groupByAddress(balanceChanges) {
    const grouped = lodash_1.default.groupBy(balanceChanges, function (node) {
        return node.address;
    });
    return lodash_1.default.mapValues(grouped, function (group) {
        return lodash_1.default.map(group, function (node) {
            return node.balance;
        });
    });
}
function parseValue(value) {
    if (Array.isArray(value)) {
        return new bignumber_js_1.default(0);
    }
    if (typeof value === "string" || typeof value === "number") {
        return new bignumber_js_1.default(value);
    }
    return new bignumber_js_1.default(value.value ?? value.MPTAmount ?? 0);
}
function computeBalanceChange(node) {
    let value = null;
    if (node.newFields.Balance) {
        value = parseValue(node.newFields.Balance);
    }
    else if (node.newFields.MPTAmount) {
        value = parseValue(node.newFields);
    }
    else if (node.previousFields.Balance && node.finalFields.Balance) {
        value = parseValue(node.finalFields.Balance).minus(parseValue(node.previousFields.Balance));
    }
    else if (node.previousFields.MPTAmount || node.finalFields.MPTAmount) {
        value = parseValue(node.finalFields).minus(parseValue(node.previousFields));
    }
    return value === null ? null : value.isZero() ? null : value;
}
function parseFinalBalance(node) {
    if (node.newFields.Balance) {
        return parseValue(node.newFields.Balance);
    }
    else if (node.finalFields.Balance) {
        return parseValue(node.finalFields.Balance);
    }
    else if (node.finalFields.MPTAmount) {
        return parseValue(node.finalFields);
    }
    return null;
}
function parseXRPQuantity(node, valueParser, nativeCurrency) {
    const value = valueParser(node);
    if (value === null) {
        return null;
    }
    return {
        address: (node.finalFields.Account || node.newFields.Account),
        balance: {
            currency: nativeCurrency || (0, client_1.getNativeCurrency)(),
            value: (0, common_1.dropsToXrp)(value).toString(),
        },
    };
}
function flipTrustlinePerspective(quantity) {
    const negatedBalance = new bignumber_js_1.default(quantity.balance.value).negated();
    return {
        address: quantity.balance.issuer,
        balance: {
            issuer: quantity.balance.issuer,
            currency: quantity.balance.currency,
            value: negatedBalance.toString(),
            counterparty: quantity.address,
        },
    };
}
function parseTrustlineQuantity(node, valueParser) {
    const value = valueParser(node);
    if (value === null) {
        return null;
    }
    const fields = lodash_1.default.isEmpty(node.newFields) ? node.finalFields : node.newFields;
    const previousFields = node.previousFields;
    let viewLowest = true;
    if (previousFields && previousFields.Balance && previousFields.Balance.value !== "0") {
        viewLowest = previousFields.Balance.value[0] !== "-";
    }
    else {
        viewLowest = fields.Balance.value[0] !== "-";
    }
    const sign = viewLowest ? 1 : -1;
    const currency = fields.Balance.currency;
    const issuer = viewLowest ? fields.HighLimit.issuer : fields.LowLimit.issuer;
    const holder = viewLowest ? fields.LowLimit.issuer : fields.HighLimit.issuer;
    const result = {
        address: holder,
        balance: {
            issuer,
            currency,
            value: value.times(sign).toString(),
            counterparty: issuer,
        },
    };
    return [result, flipTrustlinePerspective(result)];
}
function parseMPTQuantity(node, valueParser) {
    const value = valueParser(node);
    if (value === null) {
        return null;
    }
    const fields = lodash_1.default.isEmpty(node.newFields) ? node.finalFields : node.newFields;
    return {
        address: fields.Account,
        balance: {
            value: value.toString(),
            mpt_issuance_id: fields.MPTokenIssuanceID,
        },
    };
}
function parseQuantities(metadata, valueParser, nativeCurrency) {
    const values = metadata.AffectedNodes.map(function (affectedNode) {
        const node = affectedNode.CreatedNode || affectedNode.ModifiedNode || affectedNode.DeletedNode;
        if (!["AccountRoot", "RippleState", "MPToken"].includes(node.LedgerEntryType)) {
            return [];
        }
        const normalizedNode = (0, utils_1.normalizeNode)(affectedNode);
        if (node.LedgerEntryType === "AccountRoot") {
            return [parseXRPQuantity(normalizedNode, valueParser, nativeCurrency)];
        }
        else if (node.LedgerEntryType === "RippleState") {
            return parseTrustlineQuantity(normalizedNode, valueParser);
        }
        else if (node.LedgerEntryType === "MPToken") {
            return [parseMPTQuantity(normalizedNode, valueParser)];
        }
        return [];
    });
    return groupByAddress(lodash_1.default.compact(lodash_1.default.flatten(values)));
}
function parseBalanceChanges(metadata, nativeCurrency) {
    return parseQuantities(metadata, computeBalanceChange, nativeCurrency);
}
function parseFinalBalances(metadata, nativeCurrency) {
    return parseQuantities(metadata, parseFinalBalance, nativeCurrency);
}