@bithomp/xrpl-api 3.7.30 → 3.7.37

package/lib/src/parse/outcome/amm_changes.js

@@ -0,0 +1,214 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAmmChanges = parseAmmChanges;
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const common_1 = require("../../common");
+const utils_1 = require("../utils");
+const amount_1 = __importDefault(require("../ledger/amount"));
+const asset_1 = __importDefault(require("../ledger/asset"));
+const auth_accounts_1 = __importDefault(require("../ledger/auth-accounts"));
+const client_1 = require("../../client");
+const models_1 = require("../../models");
+function parseAmmStatus(node) {
+    if (node.diffType === "CreatedNode") {
+        return "created";
+    }
+    if (node.diffType === "ModifiedNode") {
+        return "modified";
+    }
+    if (node.diffType === "DeletedNode") {
+        return "deleted";
+    }
+    return undefined;
+}
+function parseAuctionSlot(auctionSlot) {
+    const slot = {
+        account: auctionSlot.Account,
+        authAccounts: (0, auth_accounts_1.default)(auctionSlot.AuthAccounts),
+        discountedFee: auctionSlot.DiscountedFee,
+        expiration: auctionSlot.Expiration ? (0, models_1.ledgerTimeToUnixTime)(auctionSlot.Expiration) : undefined,
+        price: auctionSlot.Price,
+        timeInterval: auctionSlot.TimeInterval,
+    };
+    return (0, common_1.removeUndefined)(slot);
+}
+function parseVoteSlot(voteSlot) {
+    return {
+        account: voteSlot.VoteEntry.Account,
+        tradingFee: voteSlot.VoteEntry.TradingFee,
+        voteWeight: voteSlot.VoteEntry.VoteWeight,
+    };
+}
+function summarizeVoteSlotsChanges(node) {
+    const final = node.diffType === "CreatedNode" ? node.newFields : node.finalFields;
+    const prev = node.previousFields;
+    const changes = final.VoteSlots.reduce((acc, slot) => {
+        const prevSlot = prev.VoteSlots.find((s) => s.VoteEntry.Account === slot.VoteEntry.Account);
+        if (!prevSlot) {
+            return acc.concat({
+                status: "added",
+                account: slot.VoteEntry.Account,
+                tradingFee: slot.VoteEntry.TradingFee,
+                voteWeight: slot.VoteEntry.VoteWeight,
+            });
+        }
+        const tradingFeeChange = slot.VoteEntry.TradingFee - prevSlot.VoteEntry.TradingFee;
+        const voteWeightChange = slot.VoteEntry.VoteWeight - prevSlot.VoteEntry.VoteWeight;
+        if (tradingFeeChange !== 0 || voteWeightChange !== 0) {
+            return acc.concat((0, common_1.removeUndefined)({
+                status: "modified",
+                account: slot.VoteEntry.Account,
+                tradingFee: slot.VoteEntry.TradingFee,
+                voteWeight: slot.VoteEntry.VoteWeight,
+                tradingFeeChange: tradingFeeChange || undefined,
+                voteWeightChange: voteWeightChange || undefined,
+            }));
+        }
+        return acc;
+    }, []);
+    const removed = prev.VoteSlots.filter((s) => {
+        return !final.VoteSlots.find((slot) => slot.VoteEntry.Account === s.VoteEntry.Account);
+    });
+    if (removed.length > 0) {
+        return changes.concat(removed.map((s) => {
+            return {
+                status: "removed",
+                account: s.VoteEntry.Account,
+                tradingFee: s.VoteEntry.TradingFee,
+                voteWeight: s.VoteEntry.VoteWeight,
+            };
+        }));
+    }
+    if (changes.length === 0) {
+        return undefined;
+    }
+    return changes;
+}
+function summarizeActionSlotChanges(node) {
+    const final = node.diffType === "CreatedNode" ? node.newFields : node.finalFields;
+    const prev = node.previousFields;
+    const changes = {};
+    if (prev.AuctionSlot) {
+        if (final.AuctionSlot.Account !== prev.AuctionSlot.Account) {
+            changes.accountChanges = final.AuctionSlot.Account;
+        }
+        if (final.AuctionSlot.DiscountedFee !== prev.AuctionSlot.DiscountedFee) {
+            changes.discountedFeeChange = final.AuctionSlot.DiscountedFee - prev.AuctionSlot.DiscountedFee;
+        }
+        if (final.AuctionSlot.Expiration !== prev.AuctionSlot.Expiration) {
+            changes.expirationChange = final.AuctionSlot.Expiration - prev.AuctionSlot.Expiration;
+        }
+        if (final.AuctionSlot.Price.value !== prev.AuctionSlot.Price.value) {
+            changes.priceChange = {
+                currency: final.AuctionSlot.Price.currency,
+                issuer: final.AuctionSlot.Price.issuer,
+                value: new bignumber_js_1.default(final.AuctionSlot.Price.value)
+                    .minus(new bignumber_js_1.default(prev.AuctionSlot.Price.value))
+                    .toString(10),
+                counterparty: final.AuctionSlot.Price.issuer,
+            };
+        }
+        if (final.AuctionSlot.TimeInterval !== prev.AuctionSlot.TimeInterval) {
+            changes.timeIntervalChange = final.AuctionSlot.TimeInterval - prev.AuctionSlot.TimeInterval;
+        }
+        if (!isEqualAuthAccounts(final.AuctionSlot.AuthAccounts, prev.AuctionSlot.AuthAccounts)) {
+            const prevAuthAccounts = prev.AuctionSlot.AuthAccounts || [];
+            const finalAuthAccounts = final.AuctionSlot.AuthAccounts || [];
+            let authAccountsChanges = finalAuthAccounts.map((auth) => {
+                if (!prevAuthAccounts.includes(auth.AuthAccount.Account)) {
+                    return {
+                        status: "added",
+                        account: auth.AuthAccount.Account,
+                    };
+                }
+            });
+            const removed = prevAuthAccounts.filter((auth) => {
+                return !finalAuthAccounts.includes(auth.AuthAccount.Account);
+            });
+            if (removed.length > 0) {
+                authAccountsChanges = authAccountsChanges.concat(removed.map((account) => {
+                    return {
+                        status: "removed",
+                        account: account.AuthAccount.Account,
+                    };
+                }));
+            }
+            changes.authAccountsChanges = authAccountsChanges;
+        }
+    }
+    if (Object.keys(changes).length === 0) {
+        return undefined;
+    }
+    return (0, common_1.removeUndefined)(changes);
+}
+function isEqualAuthAccounts(obj1, obj2) {
+    if (obj1 === undefined && obj2 === undefined) {
+        return true;
+    }
+    if ((obj1 === undefined && obj2 !== undefined) || (obj1 !== undefined && obj2 === undefined)) {
+        return false;
+    }
+    if (obj1.length !== obj2.length) {
+        return false;
+    }
+    const obj1Sorted = obj1.sort((a, b) => a.AuthAccount.Account.localeCompare(b.AuthAccount.Account));
+    const obj2Sorted = obj2.sort((a, b) => a.AuthAccount.Account.localeCompare(b.AuthAccount.Account));
+    for (let i = 0; i < obj1Sorted.length; i++) {
+        if (obj1Sorted[i].AuthAccount.Account !== obj2Sorted[i].AuthAccount.Account) {
+            return false;
+        }
+    }
+    return true;
+}
+function summarizeAmm(node) {
+    const final = node.diffType === "CreatedNode" ? node.newFields : node.finalFields;
+    const prev = node.previousFields;
+    let asset = (0, asset_1.default)(final.Asset);
+    if (node.diffType === "CreatedNode" && !asset) {
+        asset = { currency: (0, client_1.getNativeCurrency)() };
+    }
+    const summary = {
+        status: parseAmmStatus(node),
+        ammID: node.ledgerIndex,
+        account: final.Account,
+        asset: asset,
+        asset2: (0, asset_1.default)(final.Asset2),
+        auctionSlot: parseAuctionSlot(final.AuctionSlot),
+        lpTokenBalance: (0, amount_1.default)(final.LPTokenBalance),
+        tradingFee: final.TradingFee,
+        ownerNode: final.OwnerNode,
+        voteSlots: final.VoteSlots ? final.VoteSlots.map(parseVoteSlot) : undefined,
+    };
+    if (prev.LPTokenBalance) {
+        summary.lpTokenBalanceChange = {
+            currency: final.LPTokenBalance.currency,
+            issuer: final.LPTokenBalance.issuer,
+            value: new bignumber_js_1.default(final.LPTokenBalance.value).minus(new bignumber_js_1.default(prev.LPTokenBalance.value)).toString(10),
+            counterparty: final.LPTokenBalance.issuer,
+        };
+    }
+    if (prev.VoteSlots) {
+        summary.voteSlotsChanges = summarizeVoteSlotsChanges(node);
+    }
+    if (prev.TradingFee) {
+        summary.tradingFeeChanges = final.TradingFee - (prev.TradingFee || 0);
+    }
+    if (prev.AuctionSlot) {
+        summary.auctionSlotChanges = summarizeActionSlotChanges(node);
+    }
+    return (0, common_1.removeUndefined)(summary);
+}
+function parseAmmChanges(metadata) {
+    const affectedNodes = metadata.AffectedNodes.filter((affectedNode) => {
+        const node = affectedNode.CreatedNode || affectedNode.ModifiedNode || affectedNode.DeletedNode;
+        return node.LedgerEntryType === "AMM";
+    });
+    if (affectedNodes.length !== 1) {
+        return undefined;
+    }
+    const normalizedNode = (0, utils_1.normalizeNode)(affectedNodes[0]);
+    return summarizeAmm(normalizedNode);
+}

package/lib/src/parse/outcome/balance_changes.d.ts

@@ -0,0 +1,24 @@
+import { TransactionMetadata } from "xrpl";
+interface BalanceChangeQuantity {
+    issuer?: string;
+    currency?: string;
+    value: string;
+    counterparty?: string;
+    mpt_issuance_id?: string;
+}
+export interface AddressBalanceChangeQuantity {
+    address: string;
+    balance: BalanceChangeQuantity;
+}
+export interface BalanceChanges {
+    [key: string]: BalanceChangeQuantity[];
+}
+interface ParseBalanceChangesOptions {
+    adjustBalancesForNativeEscrow?: boolean;
+    adjustBalancesForPaymentChannel?: boolean;
+}
+declare function parseBalanceChanges(metadata: TransactionMetadata, nativeCurrency?: string, tx?: any, options?: ParseBalanceChangesOptions): BalanceChanges;
+declare function parseFinalBalances(metadata: TransactionMetadata, nativeCurrency?: string): {
+    [x: string]: BalanceChangeQuantity[];
+};
+export { parseBalanceChanges, parseFinalBalances };

package/lib/src/parse/outcome/balance_changes.js

@@ -0,0 +1,337 @@
+"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");
+const mptoken_1 = require("../../models/mptoken");
+const mptoken_normalize_1 = require("../mptoken_normalize");
+const amount_1 = __importDefault(require("../ledger/amount"));
+const channel_changes_1 = require("./channel_changes");
+const ESCROW_TYPES = ["EscrowFinish", "EscrowCreate", "EscrowCancel"];
+const PAYMENT_CHANNEL_TYPES = ["PaymentChannelClaim", "PaymentChannelCreate", "PaymentChannelFund"];
+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 (typeof value === "string" || typeof value === "number") {
+        return new bignumber_js_1.default(value);
+    }
+    return new bignumber_js_1.default(value.value ?? 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.MPTAmount);
+    }
+    else if (node.previousFields.Balance && node.finalFields.Balance) {
+        value = parseValue(node.finalFields.Balance).minus(parseValue(node.previousFields.Balance));
+    }
+    else if (node.entryType === "MPToken" && (node.previousFields.MPTAmount || node.previousFields.LockedAmount)) {
+        value = new bignumber_js_1.default(0);
+        if (node.previousFields.MPTAmount) {
+            value = value
+                .plus(parseValue(node.finalFields.MPTAmount ?? 0))
+                .minus(parseValue(node.previousFields.MPTAmount ?? 0));
+        }
+        if (node.previousFields.LockedAmount) {
+            value = value
+                .plus(parseValue(node.finalFields.LockedAmount ?? 0))
+                .minus(parseValue(node.previousFields.LockedAmount ?? 0));
+        }
+    }
+    else if (node.entryType === "MPTokenIssuance") {
+        if (node.newFields.MaximumAmount) {
+            value = parseValue(node.newFields.MaximumAmount);
+        }
+        else if (node.diffType === "DeletedNode" && node.finalFields.MaximumAmount) {
+            value = parseValue(node.finalFields.MaximumAmount).multipliedBy(-1);
+        }
+        else if (node.previousFields.OutstandingAmount) {
+            value = parseValue(node.previousFields.OutstandingAmount ?? 0).minus(parseValue(node.finalFields.OutstandingAmount ?? 0));
+        }
+    }
+    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.entryType === "MPToken") {
+        if (node.finalFields.MPTAmount) {
+            return parseValue(node.finalFields.MPTAmount);
+        }
+    }
+    else if (node.entryType === "MPTokenIssuance") {
+        if (node.newFields.MaximumAmount) {
+            return parseValue(node.newFields.MaximumAmount);
+        }
+        else if (node.diffType === "DeletedNode" && node.finalFields.MaximumAmount) {
+            return new bignumber_js_1.default(0);
+        }
+        else if (node.finalFields.MaximumAmount) {
+            return parseValue(node.finalFields.MaximumAmount).minus(parseValue(node.finalFields.OutstandingAmount));
+        }
+    }
+    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 parseMPTokenIssuanceQuantity(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.Issuer,
+        balance: {
+            value: value.toString(),
+            mpt_issuance_id: (0, mptoken_1.buildMPTokenIssuanceID)(fields.Sequence, fields.Issuer),
+        },
+    };
+}
+function parseQuantities(metadata, valueParser, nativeCurrency) {
+    const values = metadata.AffectedNodes.map(function (affectedNode) {
+        const node = affectedNode.CreatedNode || affectedNode.ModifiedNode || affectedNode.DeletedNode;
+        if (!["AccountRoot", "RippleState", "MPToken", "MPTokenIssuance"].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)];
+        }
+        else if (node.LedgerEntryType === "MPTokenIssuance") {
+            return [parseMPTokenIssuanceQuantity(normalizedNode, valueParser)];
+        }
+        return [];
+    });
+    return groupByAddress(lodash_1.default.compact(lodash_1.default.flatten(values)));
+}
+function adjustBalancesForNativeEscrow(balanceChanges, metadata, nativeCurrency, tx) {
+    let escrow;
+    if (tx.TransactionType === "EscrowCreate") {
+        escrow = metadata.AffectedNodes.find((node) => node.CreatedNode?.LedgerEntryType === "Escrow");
+    }
+    else {
+        escrow = metadata.AffectedNodes.find((node) => node.DeletedNode?.LedgerEntryType === "Escrow");
+    }
+    if (!escrow) {
+        return;
+    }
+    const fields = escrow.CreatedNode?.NewFields || escrow.DeletedNode?.FinalFields;
+    if (!fields || !fields.Amount) {
+        return;
+    }
+    const amount = (0, amount_1.default)(fields.Amount);
+    if (!amount || amount.currency !== (nativeCurrency || common_1.MAINNET_NATIVE_CURRENCY) || !amount.value) {
+        return;
+    }
+    const source = fields.Account;
+    if (tx.TransactionType === "EscrowCreate") {
+        adjustBalancesChanges(balanceChanges, source, [{ currency: amount.currency, value: amount.value }]);
+    }
+    else if (tx.TransactionType === "EscrowFinish" || tx.TransactionType === "EscrowCancel") {
+        adjustBalancesChanges(balanceChanges, source, [{ currency: amount.currency, value: `-${amount.value}` }]);
+    }
+}
+function adjustBalancesForPaymentChannel(balanceChanges, metadata, nativeCurrency, tx) {
+    const channelChanges = (0, channel_changes_1.parseChannelChanges)(metadata);
+    if (!channelChanges) {
+        return;
+    }
+    if (!channelChanges.source?.address) {
+        return;
+    }
+    if (tx.TransactionType === "PaymentChannelCreate") {
+        adjustBalancesChanges(balanceChanges, channelChanges.source.address, [
+            { currency: channelChanges.amount.currency, value: channelChanges.amount.value },
+        ]);
+    }
+    else if (tx.TransactionType === "PaymentChannelFund") {
+        if (channelChanges.amountChange) {
+            adjustBalancesChanges(balanceChanges, channelChanges.source.address, [
+                { currency: channelChanges.amountChange.currency, value: channelChanges.amountChange.value },
+            ]);
+        }
+        else if (channelChanges.status === "deleted") {
+            let unlockedAmount = new bignumber_js_1.default(0);
+            if (channelChanges?.balanceChange) {
+                unlockedAmount = new bignumber_js_1.default(channelChanges?.balanceChange?.value || "0").abs();
+            }
+            else {
+                unlockedAmount = new bignumber_js_1.default(channelChanges.amount.value).minus(channelChanges?.balance?.value || "0");
+            }
+            if (!unlockedAmount.isZero()) {
+                adjustBalancesChanges(balanceChanges, channelChanges.source.address, [
+                    { currency: channelChanges.amount.currency, value: `-${unlockedAmount.toString()}` },
+                ]);
+            }
+        }
+    }
+    else if (tx.TransactionType === "PaymentChannelClaim") {
+        if (tx.Account === channelChanges.source.address && channelChanges.amountChange) {
+            adjustBalancesChanges(balanceChanges, channelChanges.source.address, [
+                { currency: channelChanges.amountChange.currency, value: channelChanges.amountChange.value },
+            ]);
+        }
+        else if (channelChanges.status === "deleted") {
+            let unlockedAmount = new bignumber_js_1.default(0);
+            if (channelChanges?.balanceChange) {
+                unlockedAmount = new bignumber_js_1.default(channelChanges?.balanceChange?.value || "0").abs();
+            }
+            else {
+                unlockedAmount = new bignumber_js_1.default(channelChanges.amount.value).minus(channelChanges?.balance?.value || "0");
+            }
+            if (!unlockedAmount.isZero()) {
+                adjustBalancesChanges(balanceChanges, channelChanges.source.address, [
+                    { currency: channelChanges.amount.currency, value: `-${unlockedAmount.toString()}` },
+                ]);
+            }
+            if (channelChanges.balanceChange) {
+                if (channelChanges.source.address !== tx.Account && channelChanges?.balance && channelChanges?.amount) {
+                    const returnedAmount = new bignumber_js_1.default(channelChanges.amount.value).minus(new bignumber_js_1.default(channelChanges.balance.value));
+                    if (!returnedAmount.isZero()) {
+                        adjustBalancesChanges(balanceChanges, channelChanges.source.address, [
+                            { currency: channelChanges.amount.currency, value: `-${returnedAmount.toString()}` },
+                        ]);
+                    }
+                }
+            }
+        }
+        else if (channelChanges.balanceChange) {
+            adjustBalancesChanges(balanceChanges, channelChanges.source.address, [
+                { currency: channelChanges.balanceChange.currency, value: channelChanges.balanceChange.value },
+            ]);
+        }
+    }
+}
+function adjustBalancesChanges(balanceChanges, address, changes) {
+    const existingChanges = balanceChanges[address] || [];
+    const change = existingChanges.find((c) => c.currency === changes[0].currency && c.issuer === changes[0].issuer);
+    if (change) {
+        const newValue = new bignumber_js_1.default(change.value).plus(new bignumber_js_1.default(changes[0].value));
+        if (newValue.isZero()) {
+            balanceChanges[address] = existingChanges.filter((c) => c !== change);
+            if (balanceChanges[address].length === 0) {
+                delete balanceChanges[address];
+            }
+        }
+        else {
+            change.value = newValue.toString();
+        }
+    }
+    else {
+        existingChanges.push(changes[0]);
+        balanceChanges[address] = existingChanges;
+    }
+}
+function parseBalanceChanges(metadata, nativeCurrency, tx, options) {
+    if (tx && nativeCurrency === common_1.MAINNET_NATIVE_CURRENCY && metadata.TransactionResult === "tesSUCCESS") {
+        (0, mptoken_normalize_1.normalizeMPTokensPreviousFields)(metadata, tx);
+    }
+    const balanceChanges = parseQuantities(metadata, computeBalanceChange, nativeCurrency);
+    if (tx && tx.TransactionType && options) {
+        if (options.adjustBalancesForNativeEscrow && ESCROW_TYPES.includes(tx.TransactionType)) {
+            adjustBalancesForNativeEscrow(balanceChanges, metadata, nativeCurrency, tx);
+        }
+        else if (options.adjustBalancesForPaymentChannel && PAYMENT_CHANNEL_TYPES.includes(tx.TransactionType)) {
+            adjustBalancesForPaymentChannel(balanceChanges, metadata, nativeCurrency, tx);
+        }
+    }
+    return balanceChanges;
+}
+function parseFinalBalances(metadata, nativeCurrency) {
+    return parseQuantities(metadata, parseFinalBalance, nativeCurrency);
+}

package/lib/src/parse/outcome/channel_changes.d.ts

@@ -0,0 +1,20 @@
+import { TransactionMetadata } from "xrpl";
+import { FormattedSourceAddress, FormattedDestinationAddress } from "../../types/account";
+import { IssuedCurrencyAmount } from "../../types/amounts";
+interface FormattedChannelSummaryInterface {
+    status?: "created" | "modified" | "deleted";
+    channelId: string;
+    source?: FormattedSourceAddress;
+    destination?: FormattedDestinationAddress;
+    channelAmountDrops: string;
+    amount: IssuedCurrencyAmount;
+    channelBalanceDrops?: string;
+    balance?: IssuedCurrencyAmount;
+    channelAmountChangeDrops?: string;
+    amountChange?: IssuedCurrencyAmount;
+    channelBalanceChangeDrops?: string;
+    balanceChange?: IssuedCurrencyAmount;
+    previousTxnID?: string;
+}
+declare function parseChannelChanges(metadata: TransactionMetadata): FormattedChannelSummaryInterface | undefined;
+export { parseChannelChanges };

package/lib/src/parse/outcome/channel_changes.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseChannelChanges = parseChannelChanges;
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const amount_1 = __importDefault(require("../ledger/amount"));
+const source_1 = require("../ledger/source");
+const destination_1 = require("../ledger/destination");
+const utils_1 = require("../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: (0, source_1.parseSource)(final),
+        destination: (0, destination_1.parseDestination)(final),
+        channelAmountDrops: new bignumber_js_1.default(final.Amount || 0).toString(10),
+        amount: (0, amount_1.default)(final.Amount),
+    };
+    if (final.Balance) {
+        summary.channelBalanceDrops = new bignumber_js_1.default(final.Balance || 0).toString(10);
+        summary.balance = (0, amount_1.default)(final.Balance);
+    }
+    if (prev.Amount) {
+        summary.channelAmountChangeDrops = new bignumber_js_1.default(final.Amount).minus(new bignumber_js_1.default(prev.Amount || 0)).toString(10);
+        summary.amountChange = (0, amount_1.default)(prev.Amount);
+        summary.amountChange.value = new bignumber_js_1.default(summary.amount.value)
+            .minus(new bignumber_js_1.default(summary.amountChange.value))
+            .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);
+        summary.balanceChange = (0, amount_1.default)(prev.Balance);
+        summary.balanceChange.value = new bignumber_js_1.default(summary.balanceChange.value)
+            .minus(new bignumber_js_1.default(summary.balance?.value || 0))
+            .toString(10);
+    }
+    if (node.PreviousTxnID) {
+        summary.previousTxnID = node.PreviousTxnID;
+    }
+    return summary;
+}
+function parseChannelChanges(metadata) {
+    const affectedNodes = metadata.AffectedNodes.filter((affectedNode) => {
+        const node = affectedNode.CreatedNode || affectedNode.ModifiedNode || affectedNode.DeletedNode;
+        return node.LedgerEntryType === "PayChannel";
+    });
+    if (affectedNodes.length !== 1) {
+        return undefined;
+    }
+    const normalizedNode = (0, utils_1.normalizeNode)(affectedNodes[0]);
+    return summarizePaymentChannel(normalizedNode);
+}

package/lib/src/parse/outcome/check_changes.d.ts

@@ -0,0 +1,17 @@
+import { TransactionMetadata } from "xrpl";
+import { FormattedSourceAddress, FormattedDestinationAddress } from "../../types/account";
+import { IssuedCurrencyAmount, FormattedIssuedMPTAmount } from "../../types/amounts";
+interface FormattedCheckSummaryInterface {
+    status?: "created" | "modified" | "deleted";
+    checkID: string;
+    source?: FormattedSourceAddress;
+    destination?: FormattedDestinationAddress;
+    sendMax: IssuedCurrencyAmount | FormattedIssuedMPTAmount;
+    expiration?: number;
+    invoiceID?: string;
+    sequence?: number;
+    sendMaxChange?: IssuedCurrencyAmount | FormattedIssuedMPTAmount;
+    previousTxnID?: string;
+}
+declare function parseCheckChanges(metadata: TransactionMetadata): FormattedCheckSummaryInterface | undefined;
+export { parseCheckChanges };