@bithomp/xrpl-api 2.3.6

package/lib/models/index.js

@@ -0,0 +1,56 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseNFTokenCreateOffer = exports.parseNFTokenCancelOffer = exports.parseNFTokenAcceptOffer = exports.parseNFTOfferFlags = exports.parseNFTokenFlags = exports.parseNFTokenBurn = exports.parseNFTokenMint = exports.parseOrderbookChanges = exports.parseChannelChanges = exports.parseLockedBalanceChanges = exports.parseBalanceChanges = exports.parseNFTokenOfferChanges = exports.parseNFTokenChanges = exports.parseAffectedObjects = void 0;
+__exportStar(require("./account_info"), exports);
+__exportStar(require("./account_nfts"), exports);
+__exportStar(require("./account_object"), exports);
+__exportStar(require("./ledger"), exports);
+__exportStar(require("./manifest"), exports);
+__exportStar(require("./transaction"), exports);
+__exportStar(require("./account_lines"), exports);
+__exportStar(require("./vl"), exports);
+var affected_objects_1 = require("../parse/outcome/affected_objects");
+Object.defineProperty(exports, "parseAffectedObjects", { enumerable: true, get: function () { return affected_objects_1.parseAffectedObjects; } });
+var nftoken_changes_1 = require("../parse/outcome/nftoken_changes");
+Object.defineProperty(exports, "parseNFTokenChanges", { enumerable: true, get: function () { return nftoken_changes_1.parseNFTokenChanges; } });
+var nftoken_offer_changes_1 = require("../parse/outcome/nftoken_offer_changes");
+Object.defineProperty(exports, "parseNFTokenOfferChanges", { enumerable: true, get: function () { return nftoken_offer_changes_1.parseNFTokenOfferChanges; } });
+var balance_changes_1 = require("../parse/outcome/balance_changes");
+Object.defineProperty(exports, "parseBalanceChanges", { enumerable: true, get: function () { return balance_changes_1.parseBalanceChanges; } });
+var locked_balance_changes_1 = require("../parse/outcome/locked_balance_changes");
+Object.defineProperty(exports, "parseLockedBalanceChanges", { enumerable: true, get: function () { return locked_balance_changes_1.parseLockedBalanceChanges; } });
+var channel_changes_1 = require("../parse/outcome/channel_changes");
+Object.defineProperty(exports, "parseChannelChanges", { enumerable: true, get: function () { return channel_changes_1.parseChannelChanges; } });
+var orderbook_changes_1 = require("../parse/outcome/orderbook_changes");
+Object.defineProperty(exports, "parseOrderbookChanges", { enumerable: true, get: function () { return orderbook_changes_1.parseOrderbookChanges; } });
+const nftoken_burn_1 = __importDefault(require("../parse/specification/nftoken-burn"));
+exports.parseNFTokenBurn = nftoken_burn_1.default;
+const nftoken_mint_1 = __importDefault(require("../parse/specification/nftoken-mint"));
+exports.parseNFTokenMint = nftoken_mint_1.default;
+const nftoken_flags_1 = __importDefault(require("../parse/ledger/nftoken-flags"));
+exports.parseNFTokenFlags = nftoken_flags_1.default;
+const nftoken_offer_flags_1 = __importDefault(require("../parse/ledger/nftoken-offer-flags"));
+exports.parseNFTOfferFlags = nftoken_offer_flags_1.default;
+const nftoken_accept_offer_1 = __importDefault(require("../parse/specification/nftoken-accept-offer"));
+exports.parseNFTokenAcceptOffer = nftoken_accept_offer_1.default;
+const nftoken_cancel_offer_1 = __importDefault(require("../parse/specification/nftoken-cancel-offer"));
+exports.parseNFTokenCancelOffer = nftoken_cancel_offer_1.default;
+const nftoken_create_offer_1 = __importDefault(require("../parse/specification/nftoken-create-offer"));
+exports.parseNFTokenCreateOffer = nftoken_create_offer_1.default;

package/lib/models/ledger.d.ts

@@ -0,0 +1,6 @@
+export type LedgerIndex = number | ("validated" | "closed" | "current");
+export type StreamType = "consensus" | "ledger" | "manifests" | "peer_status" | "transactions" | "transactions_proposed" | "server" | "validations";
+export declare function unixTimeToLedgerTime(time: number): number;
+export declare function ledgerTimeToUnixTime(ledgerTime: number): number;
+export declare function ledgerTimeToTimestamp(ledgerTime: number): number;
+export declare function ledgerTimeToISO8601(ledgerTime: number): string;

package/lib/models/ledger.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ledgerTimeToISO8601 = exports.ledgerTimeToTimestamp = exports.ledgerTimeToUnixTime = exports.unixTimeToLedgerTime = void 0;
+const RIPPLE_UNIX_DIFF = 946684800;
+function unixTimeToLedgerTime(time) {
+    return time - RIPPLE_UNIX_DIFF;
+}
+exports.unixTimeToLedgerTime = unixTimeToLedgerTime;
+function ledgerTimeToUnixTime(ledgerTime) {
+    return ledgerTime + RIPPLE_UNIX_DIFF;
+}
+exports.ledgerTimeToUnixTime = ledgerTimeToUnixTime;
+function ledgerTimeToTimestamp(ledgerTime) {
+    return ledgerTimeToUnixTime(ledgerTime) * 1000;
+}
+exports.ledgerTimeToTimestamp = ledgerTimeToTimestamp;
+function ledgerTimeToISO8601(ledgerTime) {
+    return new Date(ledgerTimeToTimestamp(ledgerTime)).toISOString();
+}
+exports.ledgerTimeToISO8601 = ledgerTimeToISO8601;

package/lib/models/manifest.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="node" />
+export interface ManifestInterface {
+    Sequence?: number;
+    PublicKey?: string;
+    publicKey?: string;
+    address?: string;
+    SigningPubKey?: string;
+    signingPubKey?: string;
+    Signature?: string;
+    Domain?: string;
+    domain?: string;
+    MasterSignature?: string;
+    verifyFields?: Buffer;
+    error?: string;
+}
+export declare function decodeManifest(manifest: string): ManifestInterface;
+export declare function parseManifest(manifest: string): ManifestInterface;
+export interface GenerateanifestInterface {
+    Sequence: number;
+    PublicKey: string;
+    SigningPubKey: string;
+    Domain?: string;
+    SigningPrivateKey: string;
+    MasterPrivateKey: string;
+}
+export declare function generateManifest(manifest: GenerateanifestInterface): string;

package/lib/models/manifest.js

@@ -0,0 +1,187 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateManifest = exports.parseManifest = exports.decodeManifest = void 0;
+const ripple_binary_codec_1 = require("ripple-binary-codec");
+const ripple_address_codec_1 = require("ripple-address-codec");
+const Validator = __importStar(require("../validator"));
+function decodeManifest(manifest) {
+    const manifestHex = Buffer.from(manifest, "base64").toString("hex").toUpperCase();
+    const manifestDecoded = (0, ripple_binary_codec_1.decode)(manifestHex);
+    if (!manifestDecoded) {
+        return manifestDecoded;
+    }
+    const { PublicKey, SigningPubKey, Domain } = manifestDecoded;
+    if (typeof PublicKey === "string") {
+        const publicKeyBuffer = Buffer.from(PublicKey, "hex");
+        manifestDecoded.publicKey = (0, ripple_address_codec_1.encodeNodePublic)(publicKeyBuffer);
+        manifestDecoded.address = Validator.classicAddressFromValidatorPK(publicKeyBuffer);
+    }
+    if (typeof SigningPubKey === "string") {
+        const signingKeyBuffer = Buffer.from(SigningPubKey, "hex");
+        manifestDecoded.signingPubKey = (0, ripple_address_codec_1.encodeNodePublic)(signingKeyBuffer);
+    }
+    if (typeof Domain === "string") {
+        manifestDecoded.domain = Buffer.from(Domain, "hex").toString("utf8");
+    }
+    return manifestDecoded;
+}
+exports.decodeManifest = decodeManifest;
+function parseManifest(manifest) {
+    const buf = Buffer.from(manifest, "base64");
+    const decoded = {};
+    let cur = 0;
+    const verifyFields = [Buffer.from("MAN\x00", "utf-8")];
+    let lastSigning = 0;
+    if (buf[cur++] !== 0x24) {
+        decoded.error = "Missing Sequence Number";
+        return decoded;
+    }
+    decoded.Sequence = (buf[cur] << 24) + (buf[cur + 1] << 16) + (buf[cur + 2] << 8) + buf[cur + 3];
+    cur += 4;
+    verifyFields.push(buf.slice(lastSigning, cur));
+    lastSigning = cur;
+    if (buf[cur++] !== 0x71) {
+        decoded.error = "Missing Public Key";
+        return decoded;
+    }
+    if (buf[cur++] !== 33) {
+        decoded.error = "Missing Public Key size";
+        return decoded;
+    }
+    decoded.PublicKey = buf
+        .slice(cur, cur + 33)
+        .toString("hex")
+        .toUpperCase();
+    decoded.publicKey = (0, ripple_address_codec_1.encodeNodePublic)(buf.slice(cur, cur + 33));
+    decoded.address = Validator.classicAddressFromValidatorPK(buf.slice(cur, cur + 33));
+    cur += 33;
+    verifyFields.push(buf.slice(lastSigning, cur));
+    lastSigning = cur;
+    if (buf[cur++] === 0x73) {
+        if (buf[cur++] !== 33) {
+            decoded.error = "Missing Signing Public Key size";
+            return decoded;
+        }
+        decoded.SigningPubKey = buf
+            .slice(cur, cur + 33)
+            .toString("hex")
+            .toUpperCase();
+        decoded.signingPubKey = (0, ripple_address_codec_1.encodeNodePublic)(buf.slice(cur, cur + 33));
+        cur += 33;
+        verifyFields.push(buf.slice(lastSigning, cur));
+        lastSigning = cur;
+    }
+    if (buf[cur++] === 0x76) {
+        const signatureSize = buf[cur++];
+        decoded.Signature = buf
+            .slice(cur, cur + signatureSize)
+            .toString("hex")
+            .toUpperCase();
+        cur += signatureSize;
+        lastSigning = cur;
+    }
+    if (buf[cur] === 0x77) {
+        cur++;
+        const domainSize = buf[cur++];
+        decoded.Domain = buf
+            .slice(cur, cur + domainSize)
+            .toString("hex")
+            .toUpperCase();
+        decoded.domain = buf.slice(cur, cur + domainSize).toString("utf-8");
+        cur += domainSize;
+        verifyFields.push(buf.slice(lastSigning, cur));
+        lastSigning = cur;
+    }
+    if (buf[cur++] !== 0x70) {
+        decoded.error = "Missing Master Signature";
+        return decoded;
+    }
+    if (buf[cur++] !== 0x12) {
+        decoded.error = "Missing Master Signature follow byte";
+        return decoded;
+    }
+    const masterSize = buf[cur++];
+    decoded.MasterSignature = buf
+        .slice(cur, cur + masterSize)
+        .toString("hex")
+        .toUpperCase();
+    cur += masterSize;
+    lastSigning = cur;
+    if (cur !== buf.length) {
+        decoded.error = "Extra bytes at end of manifest";
+        return decoded;
+    }
+    decoded.verifyFields = Buffer.concat(verifyFields);
+    if (decoded.SigningPubKey && decoded.Signature) {
+        if (!Validator.verify(decoded.verifyFields, decoded.Signature, decoded.SigningPubKey)) {
+            decoded.error = "Ephemeral signature does not match";
+            return decoded;
+        }
+    }
+    if (!Validator.verify(decoded.verifyFields, decoded.MasterSignature, decoded.PublicKey)) {
+        decoded.error = "Master signature does not match";
+        return decoded;
+    }
+    return decoded;
+}
+exports.parseManifest = parseManifest;
+function generateManifest(manifest) {
+    const verifyFields = [Buffer.from("MAN\x00", "utf-8")];
+    const secuenceBuffer = Buffer.alloc(5);
+    secuenceBuffer.writeUInt8(0x24);
+    secuenceBuffer.writeUInt32BE(manifest.Sequence, 1);
+    verifyFields.push(secuenceBuffer);
+    const publicKeyBuffer = Buffer.alloc(35);
+    publicKeyBuffer.writeUInt8(0x71);
+    publicKeyBuffer.writeUInt8(manifest.PublicKey.length / 2, 1);
+    publicKeyBuffer.write(manifest.PublicKey, 2, "hex");
+    verifyFields.push(publicKeyBuffer);
+    const signingPubKeyBuffer = Buffer.alloc(35);
+    signingPubKeyBuffer.writeUInt8(0x73);
+    signingPubKeyBuffer.writeUInt8(manifest.SigningPubKey.length / 2, 1);
+    signingPubKeyBuffer.write(manifest.SigningPubKey, 2, "hex");
+    verifyFields.push(signingPubKeyBuffer);
+    if (manifest.Domain) {
+        const domainBuffer = Buffer.alloc(2 + manifest.Domain.length / 2);
+        domainBuffer.writeUInt8(0x77);
+        domainBuffer.writeUInt8(manifest.Domain.length / 2, 1);
+        domainBuffer.write(manifest.Domain, 2, "hex");
+        verifyFields.push(domainBuffer);
+    }
+    const verifyData = Buffer.concat(verifyFields);
+    const ephemeralSignature = Validator.sign(verifyData, manifest.SigningPrivateKey);
+    const masterSignature = Validator.sign(verifyData, manifest.MasterPrivateKey);
+    const manifestBuffer = Buffer.from((0, ripple_binary_codec_1.encode)({
+        Sequence: manifest.Sequence,
+        PublicKey: manifest.PublicKey,
+        SigningPubKey: manifest.SigningPubKey,
+        Signature: ephemeralSignature,
+        Domain: manifest.Domain,
+        MasterSignature: masterSignature,
+    }), "hex");
+    return manifestBuffer.toString("base64");
+}
+exports.generateManifest = generateManifest;

package/lib/models/transaction/affected_objects.d.ts

@@ -0,0 +1,6 @@
+interface AffectedObjectsInterface {
+    nftokens?: any;
+    nftokenOffers?: any;
+}
+declare function parseAffectedObjects(tx: any): AffectedObjectsInterface | undefined;
+export { parseAffectedObjects };

package/lib/models/transaction/affected_objects.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAffectedObjects = void 0;
+const nftoken_changes_1 = require("./nftoken_changes");
+const nftoken_offer_changes_1 = require("./nftoken_offer_changes");
+const account_nfts_1 = require("../../models/account_nfts");
+function parseAffectedObjects(tx) {
+    return new AffectedObjects(tx).call();
+}
+exports.parseAffectedObjects = parseAffectedObjects;
+class AffectedObjects {
+    constructor(tx) {
+        this.tx = tx;
+        this.affectedObjects = {};
+        this.nftChanges = undefined;
+        this.nftOfferChanges = undefined;
+    }
+    call() {
+        this.parseNFTokens();
+        this.parseNFTokenOffers();
+        if (Object.keys(this.affectedObjects).length > 0) {
+            return this.affectedObjects;
+        }
+        return undefined;
+    }
+    getNFTokenChanges() {
+        if (this.nftChanges) {
+            return this.nftChanges;
+        }
+        this.nftChanges = (0, nftoken_changes_1.parseNFTokenChanges)(this.tx);
+        return this.nftChanges;
+    }
+    getNFTokenOfferChanges() {
+        if (this.nftOfferChanges) {
+            return this.nftOfferChanges;
+        }
+        this.nftOfferChanges = (0, nftoken_offer_changes_1.parseNFTokenOfferChanges)(this.tx);
+        return this.nftOfferChanges;
+    }
+    parseNFTokens() {
+        const nftokens = {};
+        const nftokenChanges = this.getNFTokenChanges();
+        for (const account in nftokenChanges) {
+            for (const nftsChange of nftokenChanges[account]) {
+                if (nftokens[nftsChange.nftokenID]) {
+                    continue;
+                }
+                const nftokenIDInfo = (0, account_nfts_1.parseNFTokenID)(nftsChange.nftokenID);
+                if (nftokenIDInfo) {
+                    nftokens[nftsChange.nftokenID] = {
+                        nftokenID: nftsChange.nftokenID,
+                        flags: (0, account_nfts_1.parseNFTokenFlags)(nftokenIDInfo.Flags),
+                        transferFee: nftokenIDInfo.TransferFee,
+                        issuer: nftokenIDInfo.Issuer,
+                        nftokenTaxon: nftokenIDInfo.NFTokenTaxon,
+                        sequence: nftokenIDInfo.Sequence,
+                    };
+                }
+            }
+        }
+        const nftokenOfferChanges = this.getNFTokenOfferChanges();
+        for (const account in nftokenOfferChanges) {
+            for (const nftokenOfferChange of nftokenOfferChanges[account]) {
+                if (nftokens[nftokenOfferChange.nftokenID]) {
+                    continue;
+                }
+                const nftokenIDInfo = (0, account_nfts_1.parseNFTokenID)(nftokenOfferChange.nftokenID);
+                if (nftokenIDInfo) {
+                    nftokens[nftokenOfferChange.nftokenID] = {
+                        nftokenID: nftokenOfferChange.nftokenID,
+                        flags: (0, account_nfts_1.parseNFTokenFlags)(nftokenIDInfo.Flags),
+                        transferFee: nftokenIDInfo.TransferFee,
+                        issuer: nftokenIDInfo.Issuer,
+                        nftokenTaxon: nftokenIDInfo.NFTokenTaxon,
+                        sequence: nftokenIDInfo.Sequence,
+                    };
+                }
+            }
+        }
+        if (Object.keys(nftokens).length > 0) {
+            this.affectedObjects.nftokens = nftokens;
+        }
+    }
+    parseNFTokenOffers() {
+        const nftokenOffers = {};
+        const nftokenOfferChanges = this.getNFTokenOfferChanges();
+        for (const account in nftokenOfferChanges) {
+            for (const nftokenOfferChange of nftokenOfferChanges[account]) {
+                if (nftokenOffers[nftokenOfferChange.index]) {
+                    continue;
+                }
+                nftokenOffers[nftokenOfferChange.index] = {
+                    index: nftokenOfferChange.index,
+                    nftokenID: nftokenOfferChange.nftokenID,
+                    flags: (0, account_nfts_1.parseNFTOfferFlags)(nftokenOfferChange.flags),
+                    owner: nftokenOfferChange.owner,
+                };
+            }
+        }
+        if (Object.keys(nftokenOffers).length > 0) {
+            this.affectedObjects.nftokenOffers = nftokenOffers;
+        }
+    }
+}

package/lib/models/transaction/balance_changes.d.ts

@@ -0,0 +1,7 @@
+declare function parseBalanceChanges(metadata: any): {
+    [x: string]: any[];
+};
+declare function parseFinalBalances(metadata: any): {
+    [x: string]: any[];
+};
+export { parseBalanceChanges, parseFinalBalances };

package/lib/models/transaction/balance_changes.js

@@ -0,0 +1,125 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFinalBalances = exports.parseBalanceChanges = void 0;
+const _ = __importStar(require("lodash"));
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const utils_1 = require("../../v1/common/utils");
+function groupByAddress(balanceChanges) {
+    var grouped = _.groupBy(balanceChanges, function (node) {
+        return node.address;
+    });
+    return _.mapValues(grouped, function (group) {
+        return _.map(group, function (node) {
+            return node.balance;
+        });
+    });
+}
+function parseValue(value) {
+    return new bignumber_js_1.default(value.value || value);
+}
+function computeBalanceChange(node) {
+    var value = null;
+    if (node.newFields.Balance) {
+        value = parseValue(node.newFields.Balance);
+    }
+    else if (node.previousFields.Balance && node.finalFields.Balance) {
+        value = parseValue(node.finalFields.Balance).minus(parseValue(node.previousFields.Balance));
+    }
+    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);
+    }
+    return null;
+}
+function parseXRPQuantity(node, valueParser) {
+    var value = valueParser(node);
+    if (value === null) {
+        return null;
+    }
+    return {
+        address: node.finalFields.Account || node.newFields.Account,
+        balance: {
+            counterparty: '',
+            currency: 'XRP',
+            value: (0, utils_1.dropsToXrp)(value).toString()
+        }
+    };
+}
+function flipTrustlinePerspective(quantity) {
+    var negatedBalance = (new bignumber_js_1.default(quantity.balance.value)).negated();
+    return {
+        address: quantity.balance.counterparty,
+        balance: {
+            counterparty: quantity.address,
+            currency: quantity.balance.currency,
+            value: negatedBalance.toString()
+        }
+    };
+}
+function parseTrustlineQuantity(node, valueParser) {
+    var value = valueParser(node);
+    if (value === null) {
+        return null;
+    }
+    var fields = _.isEmpty(node.newFields) ? node.finalFields : node.newFields;
+    var result = {
+        address: fields.LowLimit.issuer,
+        balance: {
+            counterparty: fields.HighLimit.issuer,
+            currency: fields.Balance.currency,
+            value: value.toString()
+        }
+    };
+    return [result, flipTrustlinePerspective(result)];
+}
+function parseQuantities(metadata, valueParser) {
+    var values = (0, utils_1.normalizeNodes)(metadata).map(function (node) {
+        if (node.entryType === 'AccountRoot') {
+            return [parseXRPQuantity(node, valueParser)];
+        }
+        else if (node.entryType === 'RippleState') {
+            return parseTrustlineQuantity(node, valueParser);
+        }
+        return [];
+    });
+    return groupByAddress(_.compact(_.flatten(values)));
+}
+function parseBalanceChanges(metadata) {
+    return parseQuantities(metadata, computeBalanceChange);
+}
+exports.parseBalanceChanges = parseBalanceChanges;
+function parseFinalBalances(metadata) {
+    return parseQuantities(metadata, parseFinalBalance);
+}
+exports.parseFinalBalances = parseFinalBalances;

package/lib/models/transaction/channel_changes.d.ts

@@ -0,0 +1,9 @@
+declare function parseChannelChanges(metadata: any): {
+    status: string | undefined;
+    channelId: any;
+    source: any;
+    destination: any;
+    channelAmountDrops: string;
+    channelBalanceDrops: string;
+} | undefined;
+export { parseChannelChanges };

package/lib/models/transaction/channel_changes.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseChannelChanges = void 0;
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const utils_1 = require("../../v1/common/utils");
+function parsePaymentChannelStatus(node) {
+    if (node.diffType === 'CreatedNode') {
+        return 'created';
+    }
+    if (node.diffType === 'ModifiedNode') {
+        return 'modified';
+    }
+    if (node.diffType === 'DeletedNode') {
+        return 'deleted';
+    }
+    return undefined;
+}
+function summarizePaymentChannel(node) {
+    const final = (node.diffType === 'CreatedNode') ?
+        node.newFields : node.finalFields;
+    const prev = node.previousFields || {};
+    const summary = {
+        status: parsePaymentChannelStatus(node),
+        channelId: node.ledgerIndex,
+        source: final.Account,
+        destination: final.Destination,
+        channelAmountDrops: new bignumber_js_1.default(final.Amount || 0).toString(10),
+        channelBalanceDrops: new bignumber_js_1.default(final.Balance || 0).toString(10),
+    };
+    if (prev.Amount) {
+        summary.channelAmountChangeDrops = new bignumber_js_1.default(final.Amount)
+            .minus(new bignumber_js_1.default(prev.Amount || 0))
+            .toString(10);
+    }
+    if (prev.Balance) {
+        summary.channelBalanceChangeDrops = new bignumber_js_1.default(final.Balance)
+            .minus(new bignumber_js_1.default(prev.Balance || 0))
+            .toString(10);
+    }
+    if (node.PreviousTxnID) {
+        summary.previousTxnId = node.PreviousTxnID;
+    }
+    return summary;
+}
+function parseChannelChanges(metadata) {
+    const paymentChannels = (0, utils_1.normalizeNodes)(metadata)
+        .filter(n => {
+        return n.entryType === 'PayChannel';
+    });
+    return (paymentChannels.length === 1) ?
+        summarizePaymentChannel(paymentChannels[0]) :
+        undefined;
+}
+exports.parseChannelChanges = parseChannelChanges;

package/lib/models/transaction/locked_balance_changes.d.ts

@@ -0,0 +1,7 @@
+declare function parseLockedBalanceChanges(metadata: any): {
+    [x: string]: any[];
+};
+declare function parseFinalLockedBalances(metadata: any): {
+    [x: string]: any[];
+};
+export { parseLockedBalanceChanges, parseFinalLockedBalances };