@bithomp/xrpl-api 2.3.6

package/lib/parse/ledger/flags.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFlags = void 0;
+function parseFlags(value, keys, options = {}) {
+    const flags = {};
+    for (const flagName in keys) {
+        if (value & keys[flagName]) {
+            flags[flagName] = true;
+        }
+        else {
+            if (!options.excludeFalse) {
+                flags[flagName] = false;
+            }
+        }
+    }
+    return flags;
+}
+exports.parseFlags = parseFlags;

package/lib/parse/ledger/index.d.ts

@@ -0,0 +1,4 @@
+import parseAmount from "./amount";
+import parseMemos from "./memos";
+export * from "../utils";
+export { parseAmount, parseMemos };

package/lib/parse/ledger/index.js

@@ -0,0 +1,25 @@
+"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.parseMemos = exports.parseAmount = void 0;
+const amount_1 = __importDefault(require("./amount"));
+exports.parseAmount = amount_1.default;
+const memos_1 = __importDefault(require("./memos"));
+exports.parseMemos = memos_1.default;
+__exportStar(require("../utils"), exports);

package/lib/parse/ledger/ledger.d.ts

@@ -0,0 +1,2 @@
+import { Ledger, FormattedLedger } from "../../v1/common/types/objects";
+export declare function parseLedger(ledger: Ledger, includeRawTransactions: boolean): FormattedLedger;

package/lib/parse/ledger/ledger.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseLedger = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const common_1 = require("../../common");
+const models_1 = require("../../models");
+const transaction_1 = require("../transaction");
+function parseTransactionWrapper(ledgerVersion, includeRawTransaction, tx) {
+    const transaction = Object.assign({}, lodash_1.default.omit(tx, "metaData"), {
+        meta: tx.metaData,
+        ledger_index: ledgerVersion,
+    });
+    const result = (0, transaction_1.parseTransaction)(transaction, includeRawTransaction);
+    if (!result.outcome) {
+        result.outcome = {};
+    }
+    if (!result.outcome.ledgerVersion) {
+        result.outcome.ledgerVersion = ledgerVersion;
+    }
+    return result;
+}
+function parseTransactions(transactions, ledgerVersion, includeRawTransactions) {
+    if (lodash_1.default.isEmpty(transactions)) {
+        return {};
+    }
+    if (typeof transactions[0] === "string") {
+        return { transactionHashes: transactions };
+    }
+    return {
+        transactions: transactions.map(lodash_1.default.partial(parseTransactionWrapper, ledgerVersion, includeRawTransactions)),
+    };
+}
+function parseState(state) {
+    if (lodash_1.default.isEmpty(state)) {
+        return {};
+    }
+    if (typeof state[0] === "string") {
+        return { stateHashes: state };
+    }
+    return { rawState: JSON.stringify(state) };
+}
+function parseLedger(ledger, includeRawTransactions) {
+    const ledgerVersion = parseInt(ledger.ledger_index, 10);
+    return (0, common_1.removeUndefined)(Object.assign({
+        stateHash: ledger.account_hash,
+        close_time: (0, models_1.ledgerTimeToUnixTime)(ledger.close_time),
+        closeTime: (0, models_1.ledgerTimeToISO8601)(ledger.close_time),
+        closeTimeResolution: ledger.close_time_resolution,
+        closeFlags: ledger.close_flags,
+        ledgerHash: ledger.ledger_hash,
+        ledgerVersion: ledgerVersion,
+        parentLedgerHash: ledger.parent_hash,
+        parentCloseTime: (0, models_1.ledgerTimeToISO8601)(ledger.parent_close_time),
+        totalDrops: ledger.total_coins,
+        transactionHash: ledger.transaction_hash,
+    }, parseTransactions(ledger.transactions, ledgerVersion, includeRawTransactions), parseState(ledger.accountState)));
+}
+exports.parseLedger = parseLedger;

package/lib/parse/ledger/memos.d.ts

@@ -0,0 +1,3 @@
+import { FormattedMemo } from "../../v1/common/types/objects";
+declare function parseMemos(tx: any): Array<FormattedMemo> | undefined;
+export default parseMemos;

package/lib/parse/ledger/memos.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const common_1 = require("../../common");
+const utils_1 = require("../utils");
+function parseMemos(tx) {
+    if (!Array.isArray(tx.Memos) || tx.Memos.length === 0) {
+        return undefined;
+    }
+    return tx.Memos.map((m) => {
+        return (0, common_1.removeUndefined)({
+            type: (0, utils_1.hexToString)(m.Memo.MemoType),
+            format: (0, utils_1.hexToString)(m.Memo.MemoFormat),
+            data: (0, utils_1.hexToString)(m.Memo.MemoData),
+        });
+    });
+}
+exports.default = parseMemos;

package/lib/parse/ledger/nftoken-flags.d.ts

@@ -0,0 +1,5 @@
+import { NFTokenFlagsKeysInterface } from "../../v1/common/types/objects/nftokens";
+declare function parseNFTokenFlags(value: number, options?: {
+    excludeFalse?: boolean;
+}): NFTokenFlagsKeysInterface;
+export default parseNFTokenFlags;

package/lib/parse/ledger/nftoken-flags.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const nftokens_1 = require("../../v1/common/types/objects/nftokens");
+const flags_1 = require("./flags");
+function parseNFTokenFlags(value, options = {}) {
+    return (0, flags_1.parseFlags)(value, nftokens_1.NFTokenFlagsKeys, options);
+}
+exports.default = parseNFTokenFlags;

package/lib/parse/ledger/nftoken-offer-flags.d.ts

@@ -0,0 +1,5 @@
+import { NFTokenOfferFlagsKeysInterface } from "../../v1/common/types/objects/nftokens";
+declare function parseNFTOfferFlags(value: number, options?: {
+    excludeFalse?: boolean;
+}): NFTokenOfferFlagsKeysInterface;
+export default parseNFTOfferFlags;

package/lib/parse/ledger/nftoken-offer-flags.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const nftokens_1 = require("../../v1/common/types/objects/nftokens");
+const flags_1 = require("./flags");
+function parseNFTOfferFlags(value, options = {}) {
+    return (0, flags_1.parseFlags)(value, nftokens_1.NFTokenOfferFlagsKeys, options);
+}
+exports.default = parseNFTOfferFlags;

package/lib/parse/ledger/orderbook-order.d.ts

@@ -0,0 +1,16 @@
+import { BookOffer } from "../../v1/common/types/commands";
+import { FormattedIssuedCurrencyAmount, FormattedOfferCreateSpecification } from "../../v1/common/types/objects";
+export type FormattedOrderbookOrder = {
+    specification: FormattedOfferCreateSpecification;
+    properties: {
+        maker: string;
+        sequence: number;
+        makerExchangeRate: string;
+    };
+    state?: {
+        fundedAmount?: FormattedIssuedCurrencyAmount;
+        priceOfFundedAmount?: FormattedIssuedCurrencyAmount;
+    };
+    data: BookOffer;
+};
+export declare function parseOrderbookOrder(data: BookOffer): FormattedOrderbookOrder;

package/lib/parse/ledger/orderbook-order.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseOrderbookOrder = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const utils_1 = require("../utils");
+const common_1 = require("../../common");
+const flags_1 = require("../../v1/common/types/objects/flags");
+const amount_1 = __importDefault(require("./amount"));
+function parseOrderbookOrder(data) {
+    const direction = (data.Flags & flags_1.orderFlags.Sell) === 0 ? "buy" : "sell";
+    const takerGetsAmount = (0, amount_1.default)(data.TakerGets);
+    const takerPaysAmount = (0, amount_1.default)(data.TakerPays);
+    const quantity = direction === "buy" ? takerPaysAmount : takerGetsAmount;
+    const totalPrice = direction === "buy" ? takerGetsAmount : takerPaysAmount;
+    const specification = (0, common_1.removeUndefined)({
+        direction: direction,
+        quantity: quantity,
+        totalPrice: totalPrice,
+        passive: (data.Flags & flags_1.orderFlags.Passive) !== 0 || undefined,
+        expirationTime: (0, utils_1.parseTimestamp)(data.Expiration),
+    });
+    const properties = {
+        maker: data.Account,
+        sequence: data.Sequence,
+        makerExchangeRate: (0, utils_1.adjustQualityForXRP)(data.quality, takerGetsAmount.currency, takerPaysAmount.currency),
+    };
+    const takerGetsFunded = data.taker_gets_funded ? (0, amount_1.default)(data.taker_gets_funded) : undefined;
+    const takerPaysFunded = data.taker_pays_funded ? (0, amount_1.default)(data.taker_pays_funded) : undefined;
+    const available = (0, common_1.removeUndefined)({
+        fundedAmount: takerGetsFunded,
+        priceOfFundedAmount: takerPaysFunded,
+    });
+    const state = lodash_1.default.isEmpty(available) ? undefined : available;
+    return (0, common_1.removeUndefined)({ specification, properties, state, data });
+}
+exports.parseOrderbookOrder = parseOrderbookOrder;

package/lib/parse/ledger/pathfind.d.ts

@@ -0,0 +1,4 @@
+import { GetPaths } from "../../v1/common/types/objects/path_find";
+import { RippledPathsResponse } from "../../v1/common/types/commands/path_find";
+declare function parsePathfind(pathfindResult: RippledPathsResponse): GetPaths;
+export default parsePathfind;

package/lib/parse/ledger/pathfind.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const lodash_1 = __importDefault(require("lodash"));
+const amount_1 = __importDefault(require("./amount"));
+function parsePaths(paths) {
+    return paths.map((steps) => steps.map((step) => lodash_1.default.omit(step, ["type", "type_hex"])));
+}
+function removeAnyCounterpartyEncoding(address, amount) {
+    return amount.counterparty === address ? lodash_1.default.omit(amount, "counterparty") : amount;
+}
+function createAdjustment(address, adjustmentWithoutAddress) {
+    const amountKey = Object.keys(adjustmentWithoutAddress)[0];
+    const amount = adjustmentWithoutAddress[amountKey];
+    return lodash_1.default.set({ address: address }, amountKey, removeAnyCounterpartyEncoding(address, amount));
+}
+function parseAlternative(sourceAddress, destinationAddress, destinationAmount, alternative) {
+    const amounts = alternative.destination_amount != null
+        ? {
+            source: { amount: (0, amount_1.default)(alternative.source_amount) },
+            destination: { minAmount: (0, amount_1.default)(alternative.destination_amount) },
+        }
+        : {
+            source: { maxAmount: (0, amount_1.default)(alternative.source_amount) },
+            destination: { amount: (0, amount_1.default)(destinationAmount) },
+        };
+    return {
+        source: createAdjustment(sourceAddress, amounts.source),
+        destination: createAdjustment(destinationAddress, amounts.destination),
+        paths: JSON.stringify(parsePaths(alternative.paths_computed)),
+    };
+}
+function parsePathfind(pathfindResult) {
+    const sourceAddress = pathfindResult.source_account;
+    const destinationAddress = pathfindResult.destination_account;
+    const destinationAmount = pathfindResult.destination_amount;
+    return pathfindResult.alternatives.map((alt) => parseAlternative(sourceAddress, destinationAddress, destinationAmount, alt));
+}
+exports.default = parsePathfind;

package/lib/parse/ledger/payment-channel.d.ts

@@ -0,0 +1,16 @@
+import { PayChannelLedgerEntry } from "../../v1/common/types/objects";
+export type FormattedPaymentChannel = {
+    account: string;
+    amount: string;
+    balance: string;
+    publicKey: string;
+    destination: string;
+    settleDelay: number;
+    expiration?: string;
+    cancelAfter?: string;
+    sourceTag?: number;
+    destinationTag?: number;
+    previousAffectingTransactionID: string;
+    previousAffectingTransactionLedgerVersion: number;
+};
+export declare function parsePaymentChannel(data: PayChannelLedgerEntry): FormattedPaymentChannel;

package/lib/parse/ledger/payment-channel.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePaymentChannel = void 0;
+const utils_1 = require("../utils");
+const common_1 = require("../../common");
+const memos_1 = __importDefault(require("./memos"));
+function parsePaymentChannel(data) {
+    return (0, common_1.removeUndefined)({
+        memos: (0, memos_1.default)(data),
+        account: data.Account,
+        amount: (0, common_1.dropsToXrp)(data.Amount),
+        balance: (0, common_1.dropsToXrp)(data.Balance),
+        destination: data.Destination,
+        publicKey: data.PublicKey,
+        settleDelay: data.SettleDelay,
+        expiration: (0, utils_1.parseTimestamp)(data.Expiration),
+        cancelAfter: (0, utils_1.parseTimestamp)(data.CancelAfter),
+        sourceTag: data.SourceTag,
+        destinationTag: data.DestinationTag,
+        previousAffectingTransactionID: data.PreviousTxnID,
+        previousAffectingTransactionLedgerVersion: data.PreviousTxnLgrSeq,
+    });
+}
+exports.parsePaymentChannel = parsePaymentChannel;

package/lib/parse/ledger/ripple-amount.d.ts

@@ -0,0 +1,3 @@
+import { Amount, FormattedAmount } from "../../v1/common/types/objects";
+declare function parseRippledAmount(amount: Amount): FormattedAmount | undefined;
+export default parseRippledAmount;

package/lib/parse/ledger/ripple-amount.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const common_1 = require("../../common");
+const amount_1 = __importDefault(require("./amount"));
+function parseRippledAmount(amount) {
+    if (amount === undefined) {
+        return undefined;
+    }
+    if (typeof amount === "string") {
+        return (0, common_1.dropsToXrp)(amount);
+    }
+    return (0, amount_1.default)(amount);
+}
+exports.default = parseRippledAmount;

package/lib/parse/outcome/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/parse/outcome/affected_objects.js

@@ -0,0 +1,109 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+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");
+const nftoken_flags_1 = __importDefault(require("../ledger/nftoken-flags"));
+const nftoken_offer_flags_1 = __importDefault(require("../ledger/nftoken-offer-flags"));
+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, nftoken_flags_1.default)(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, nftoken_flags_1.default)(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, nftoken_offer_flags_1.default)(nftokenOfferChange.flags),
+                    owner: nftokenOfferChange.owner,
+                };
+            }
+        }
+        if (Object.keys(nftokenOffers).length > 0) {
+            this.affectedObjects.nftokenOffers = nftokenOffers;
+        }
+    }
+}

package/lib/parse/outcome/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/parse/outcome/balance_changes.js

@@ -0,0 +1,103 @@
+"use strict";
+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 lodash_1 = __importDefault(require("lodash"));
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const common_1 = require("../../common");
+const utils_1 = require("../../v1/common/utils");
+function groupByAddress(balanceChanges) {
+    var 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) {
+    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, common_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 = lodash_1.default.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(lodash_1.default.compact(lodash_1.default.flatten(values)));
+}
+function parseBalanceChanges(metadata) {
+    return parseQuantities(metadata, computeBalanceChange);
+}
+exports.parseBalanceChanges = parseBalanceChanges;
+function parseFinalBalances(metadata) {
+    return parseQuantities(metadata, parseFinalBalance);
+}
+exports.parseFinalBalances = parseFinalBalances;

package/lib/parse/outcome/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/parse/outcome/channel_changes.js

@@ -0,0 +1,53 @@
+"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/parse/outcome/index.d.ts

@@ -0,0 +1,7 @@
+export { parseAffectedObjects } from "./affected_objects";
+export { parseNFTokenChanges } from "./nftoken_changes";
+export { parseNFTokenOfferChanges } from "./nftoken_offer_changes";
+export { parseBalanceChanges } from "./balance_changes";
+export { parseLockedBalanceChanges } from "./locked_balance_changes";
+export { parseChannelChanges } from "./channel_changes";
+export { parseOrderbookChanges } from "./orderbook_changes";