@bithomp/xrpl-api 3.7.31 → 3.7.37

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

@@ -0,0 +1,234 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __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.parseNFTokenChanges = parseNFTokenChanges;
+const lodash_1 = __importDefault(require("lodash"));
+const AddressCodec = __importStar(require("ripple-address-codec"));
+const common_1 = require("../../common");
+function parseNFTokenChanges(tx) {
+    return new NFTokenChanges(tx).call();
+}
+class NFTokenChanges {
+    constructor(tx) {
+        this.tx = tx;
+        this.changes = {};
+        this.affectedAccounts = [];
+        this.finalNFTokens = {};
+        this.previousNFTokens = {};
+    }
+    call() {
+        if (this.hasAffectedNodes() === false) {
+            return this.changes;
+        }
+        if (this.tx.TransactionType === "NFTokenModify") {
+            this.parseNFTokensURIChanges();
+        }
+        else {
+            this.parseAffectedNodes();
+            this.parseNFTokensChanges();
+        }
+        return this.changes;
+    }
+    hasAffectedNodes() {
+        if (this.tx.meta?.AffectedNodes === undefined) {
+            return false;
+        }
+        if (this.tx.meta?.AffectedNodes?.length === 0) {
+            return false;
+        }
+        return true;
+    }
+    addChange(account, change) {
+        if (!this.changes[account]) {
+            this.changes[account] = [];
+        }
+        this.changes[account].push((0, common_1.removeUndefined)(change));
+    }
+    parseAffectedNodes() {
+        for (const affectedNode of this.tx.meta.AffectedNodes) {
+            const node = affectedNode.CreatedNode || affectedNode.ModifiedNode || affectedNode.DeletedNode;
+            if (node?.LedgerEntryType === "NFTokenPage" && node?.LedgerIndex) {
+                const account = AddressCodec.encodeAccountID(Buffer.from(node?.LedgerIndex.slice(0, 40), "hex"));
+                if (this.affectedAccounts.includes(account) === false) {
+                    this.affectedAccounts.push(account);
+                }
+                if (affectedNode.CreatedNode) {
+                    this.parseFinalNFTokens(account, node.NewFields?.NFTokens);
+                }
+                if ((affectedNode.ModifiedNode || affectedNode.DeletedNode) && Array.isArray(node.PreviousFields?.NFTokens)) {
+                    this.parseFinalNFTokens(account, node.FinalFields?.NFTokens);
+                    this.parsePreviousNFTokens(account, node.PreviousFields?.NFTokens);
+                }
+                if (affectedNode.DeletedNode && node.PreviousFields === undefined) {
+                    this.parsePreviousNFTokens(account, node.FinalFields?.NFTokens);
+                }
+            }
+        }
+    }
+    parseFinalNFTokens(account, NFTokens) {
+        if (this.finalNFTokens[account] === undefined) {
+            this.finalNFTokens[account] = [];
+        }
+        if (Array.isArray(NFTokens)) {
+            this.finalNFTokens[account] = lodash_1.default.concat(this.finalNFTokens[account], NFTokens);
+        }
+    }
+    parsePreviousNFTokens(account, NFTokens) {
+        if (this.previousNFTokens[account] === undefined) {
+            this.previousNFTokens[account] = [];
+        }
+        if (Array.isArray(NFTokens)) {
+            this.previousNFTokens[account] = lodash_1.default.concat(this.previousNFTokens[account], NFTokens);
+        }
+    }
+    parseNFTokensChanges() {
+        for (const account of this.affectedAccounts) {
+            let finalTokens = [];
+            if (Array.isArray(this.finalNFTokens[account])) {
+                finalTokens = this.finalNFTokens[account].map((NFToken) => NFToken.NFToken.NFTokenID);
+                finalTokens = [...new Set(finalTokens)];
+            }
+            let previousTokens = [];
+            if (Array.isArray(this.previousNFTokens[account])) {
+                previousTokens = this.previousNFTokens[account].map((NFToken) => NFToken.NFToken.NFTokenID);
+                previousTokens = [...new Set(previousTokens)];
+            }
+            const added = lodash_1.default.difference(finalTokens, previousTokens);
+            const removed = lodash_1.default.difference(previousTokens, finalTokens);
+            for (const nftokenID of added) {
+                const uri = this.findNFTokenUri(nftokenID);
+                this.addChange(account, {
+                    status: "added",
+                    nftokenID,
+                    uri,
+                });
+            }
+            for (const nftokenID of removed) {
+                const uri = this.findNFTokenUri(nftokenID);
+                this.addChange(account, {
+                    status: "removed",
+                    nftokenID,
+                    uri,
+                });
+            }
+        }
+    }
+    findNFTokenUri(nftokenID) {
+        for (const affectedNode of this.tx.meta.AffectedNodes) {
+            const node = affectedNode.CreatedNode || affectedNode.ModifiedNode || affectedNode.DeletedNode;
+            if (node?.LedgerEntryType === "NFTokenPage") {
+                if (Array.isArray(node.NewFields?.NFTokens)) {
+                    for (const tokenNode of node.NewFields?.NFTokens) {
+                        if (tokenNode.NFToken.NFTokenID === nftokenID) {
+                            return tokenNode.NFToken.URI;
+                        }
+                    }
+                }
+                if (Array.isArray(node.FinalFields?.NFTokens)) {
+                    for (const tokenNode of node.FinalFields?.NFTokens) {
+                        if (tokenNode.NFToken.NFTokenID === nftokenID) {
+                            return tokenNode.NFToken.URI;
+                        }
+                    }
+                }
+                if (Array.isArray(node.PreviousFields?.NFTokens)) {
+                    for (const tokenNode of node.PreviousFields?.NFTokens) {
+                        if (tokenNode.NFToken.NFTokenID === nftokenID) {
+                            return tokenNode.NFToken.URI;
+                        }
+                    }
+                }
+            }
+        }
+        return undefined;
+    }
+    parseNFTokensURIChanges() {
+        const nftokenID = this.tx.NFTokenID;
+        const nftokenChanges = this.findNFTokenChangedNode(nftokenID);
+        if (!nftokenChanges) {
+            return;
+        }
+        const [currentTokenNode, previousTokenNode] = nftokenChanges;
+        const uri = currentTokenNode?.URI;
+        const previousURI = previousTokenNode?.URI;
+        if (uri === previousURI) {
+            return;
+        }
+        this.addChange(currentTokenNode.account, {
+            status: "modified",
+            nftokenID,
+            uri,
+            previousURI,
+        });
+    }
+    findNFTokenChangedNode(nftokenID) {
+        let currentTokenNode;
+        let previousTokenNode;
+        for (const affectedNode of this.tx.meta.AffectedNodes) {
+            const node = affectedNode.ModifiedNode;
+            if (node?.LedgerEntryType === "NFTokenPage") {
+                if (Array.isArray(node.FinalFields?.NFTokens)) {
+                    for (const tokenNode of node.FinalFields?.NFTokens) {
+                        if (tokenNode.NFToken.NFTokenID === nftokenID) {
+                            currentTokenNode = tokenNode.NFToken;
+                            const account = AddressCodec.encodeAccountID(Buffer.from(node?.LedgerIndex.slice(0, 40), "hex"));
+                            currentTokenNode.account = account;
+                            if (currentTokenNode && previousTokenNode) {
+                                return [currentTokenNode, previousTokenNode];
+                            }
+                        }
+                    }
+                }
+                if (Array.isArray(node.PreviousFields?.NFTokens)) {
+                    for (const tokenNode of node.PreviousFields?.NFTokens) {
+                        if (tokenNode.NFToken.NFTokenID === nftokenID) {
+                            previousTokenNode = tokenNode.NFToken;
+                            if (currentTokenNode && previousTokenNode) {
+                                return [currentTokenNode, previousTokenNode];
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        if (!currentTokenNode || !previousTokenNode) {
+            return undefined;
+        }
+        return [currentTokenNode, previousTokenNode];
+    }
+}

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

@@ -0,0 +1,2 @@
+declare function parseNFTokenOfferChanges(tx: object): object;
+export { parseNFTokenOfferChanges };

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

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseNFTokenOfferChanges = parseNFTokenOfferChanges;
+const ledger_1 = require("../../models/ledger");
+const common_1 = require("../../common");
+function parseNFTokenOfferChanges(tx) {
+    return new NFTokenOfferChanges(tx).call();
+}
+class NFTokenOfferChanges {
+    constructor(tx) {
+        this.tx = tx;
+        this.changes = {};
+    }
+    call() {
+        if (this.hasAffectedNodes() === false) {
+            return this.changes;
+        }
+        for (const affectedNode of this.tx.meta.AffectedNodes) {
+            this.parseAffectedNode(affectedNode);
+        }
+        return this.changes;
+    }
+    addChange(account, change) {
+        if (!this.changes[account]) {
+            this.changes[account] = [];
+        }
+        this.changes[account].push((0, common_1.removeUndefined)(change));
+    }
+    hasAffectedNodes() {
+        if (this.tx.meta?.AffectedNodes === undefined) {
+            return false;
+        }
+        if (this.tx.meta?.AffectedNodes?.length === 0) {
+            return false;
+        }
+        return true;
+    }
+    parseAffectedNode(affectedNode) {
+        if (this.isNFTokensCreateOfferNode(affectedNode)) {
+            this.parseNFTokensCreateOfferNode(affectedNode);
+        }
+        else if (this.isNFTokensDeleteOfferNode(affectedNode)) {
+            this.parseNFTokensDeleteOfferNode(affectedNode);
+        }
+    }
+    isNFTokensCreateOfferNode(affectedNode) {
+        return affectedNode.CreatedNode?.LedgerEntryType === "NFTokenOffer" && affectedNode.CreatedNode?.NewFields;
+    }
+    parseNFTokensCreateOfferNode(affectedNode) {
+        const status = "created";
+        const amount = affectedNode.CreatedNode.NewFields.Amount;
+        const flags = affectedNode.CreatedNode.NewFields.Flags;
+        const nftokenID = affectedNode.CreatedNode.NewFields.NFTokenID;
+        const owner = affectedNode.CreatedNode.NewFields.Owner;
+        const index = affectedNode.CreatedNode.LedgerIndex;
+        const destination = affectedNode.CreatedNode.NewFields.Destination;
+        const previousTxnID = affectedNode.CreatedNode.NewFields.PreviousTxnID;
+        const previousTxnLgrSeq = affectedNode.CreatedNode.NewFields.PreviousTxnLgrSeq;
+        let expiration = affectedNode.CreatedNode.NewFields.Expiration;
+        if (typeof expiration === "number") {
+            expiration = (0, ledger_1.ledgerTimeToUnixTime)(expiration);
+        }
+        this.addChange(this.tx.Account, {
+            status,
+            amount,
+            flags,
+            nftokenID,
+            owner,
+            destination,
+            expiration,
+            index,
+            previousTxnID,
+            previousTxnLgrSeq,
+        });
+    }
+    isNFTokensDeleteOfferNode(affectedNode) {
+        return affectedNode.DeletedNode?.LedgerEntryType === "NFTokenOffer" && affectedNode.DeletedNode?.FinalFields;
+    }
+    parseNFTokensDeleteOfferNode(affectedNode) {
+        const status = "deleted";
+        const amount = affectedNode.DeletedNode.FinalFields.Amount;
+        const flags = affectedNode.DeletedNode.FinalFields.Flags;
+        const nftokenID = affectedNode.DeletedNode.FinalFields.NFTokenID;
+        const owner = affectedNode.DeletedNode.FinalFields.Owner;
+        const index = affectedNode.DeletedNode.LedgerIndex;
+        const destination = affectedNode.DeletedNode.FinalFields.Destination;
+        const previousTxnID = affectedNode.DeletedNode.FinalFields.PreviousTxnID;
+        const previousTxnLgrSeq = affectedNode.DeletedNode.FinalFields.PreviousTxnLgrSeq;
+        let expiration = affectedNode.DeletedNode.FinalFields.Expiration;
+        if (typeof expiration === "number") {
+            expiration = (0, ledger_1.ledgerTimeToUnixTime)(expiration);
+        }
+        this.addChange(owner, {
+            status,
+            amount,
+            flags,
+            nftokenID,
+            owner,
+            destination,
+            expiration,
+            index,
+            previousTxnID,
+            previousTxnLgrSeq,
+        });
+    }
+}

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

@@ -0,0 +1,29 @@
+import { TransactionMetadata, PriceData } from "xrpl";
+import { FormattedOraclePriceDataSeriesInterface } from "../../types";
+interface FormattedOracleSummaryInterface {
+    status?: "created" | "modified" | "deleted";
+    oracleID?: string;
+    oracleDocumentID?: number;
+    provider: string;
+    uri?: string;
+    assetClass: string;
+    lastUpdateTime: number;
+    priceDataSeries: FormattedOraclePriceDataSeriesInterface[];
+    uriChanges?: string;
+    lastUpdateTimeChanges?: number;
+    priceDataSeriesChanges?: FormattedPriceDataSeriesChanges[];
+}
+interface FormattedPriceDataSeriesChanges {
+    status: "added" | "modified" | "removed";
+    baseAsset: string;
+    quoteAsset: string;
+    assetPrice?: string;
+    scale?: number;
+    originalAssetPrice?: string;
+    assetPriceChange?: string;
+    scaleChange?: number;
+    originalPriceChange?: string;
+}
+declare function parsePriceDataSeries(series: PriceData): FormattedOraclePriceDataSeriesInterface;
+declare function parseOracleChanges(metadata: TransactionMetadata): FormattedOracleSummaryInterface | undefined;
+export { parseOracleChanges, parsePriceDataSeries };

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

@@ -0,0 +1,150 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseOracleChanges = parseOracleChanges;
+exports.parsePriceDataSeries = parsePriceDataSeries;
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const utils_1 = require("../utils");
+const common_1 = require("../../common");
+function parseOracleStatus(node) {
+    if (node.diffType === "CreatedNode") {
+        return "created";
+    }
+    if (node.diffType === "ModifiedNode") {
+        return "modified";
+    }
+    if (node.diffType === "DeletedNode") {
+        return "deleted";
+    }
+    return undefined;
+}
+function hexPriceToBigNumber(hex) {
+    if (hex === undefined) {
+        return undefined;
+    }
+    if (typeof hex !== "string") {
+        throw new Error("Price must be a string.");
+    }
+    return new bignumber_js_1.default(`0x${hex}`);
+}
+function getOriginalAssetPrice(assetPrice, scale) {
+    if (assetPrice === undefined) {
+        return undefined;
+    }
+    if (assetPrice.isZero()) {
+        return assetPrice;
+    }
+    if (scale === 0 || scale === undefined) {
+        return assetPrice;
+    }
+    return assetPrice.dividedBy(new bignumber_js_1.default(10).pow(scale));
+}
+function parsePriceDataSeries(series) {
+    const assetPrice = hexPriceToBigNumber(series.PriceData.AssetPrice);
+    const scale = series.PriceData.Scale;
+    const originalAssetPrice = getOriginalAssetPrice(assetPrice, scale);
+    return (0, common_1.removeUndefined)({
+        baseAsset: series.PriceData.BaseAsset,
+        quoteAsset: series.PriceData.QuoteAsset,
+        assetPrice: assetPrice?.toString(),
+        scale: series.PriceData.Scale,
+        originalAssetPrice: originalAssetPrice?.toString(),
+    });
+}
+function summarizePriceDataSeriesChanges(node) {
+    const final = node.diffType === "CreatedNode" ? node.newFields : node.finalFields;
+    const prev = node.previousFields;
+    const changes = final.PriceDataSeries.reduce((acc, series) => {
+        const prevSeries = prev.PriceDataSeries.find((s) => s.PriceData.BaseAsset === series.PriceData.BaseAsset && s.PriceData.QuoteAsset === series.PriceData.QuoteAsset);
+        const priceFinal = hexPriceToBigNumber(series.PriceData.AssetPrice) || new bignumber_js_1.default(0);
+        const scaleFinal = series.PriceData.Scale || 0;
+        const originalPriceFinal = getOriginalAssetPrice(priceFinal, scaleFinal);
+        if (!prevSeries) {
+            return acc.concat({
+                status: "added",
+                baseAsset: series.PriceData.BaseAsset,
+                quoteAsset: series.PriceData.QuoteAsset,
+                assetPrice: priceFinal?.toString(),
+                scale: scaleFinal,
+                originalAssetPrice: originalPriceFinal?.toString(),
+            });
+        }
+        const pricePrev = hexPriceToBigNumber(prevSeries.PriceData.AssetPrice) || new bignumber_js_1.default(0);
+        const scalePrev = prevSeries.PriceData.Scale || 0;
+        const assetPriceChange = (priceFinal || new bignumber_js_1.default(0)).minus(pricePrev);
+        const scaleChange = (scaleFinal ?? 0) - scalePrev;
+        if (!assetPriceChange.isZero() || scaleChange !== 0) {
+            const originalPricePrev = getOriginalAssetPrice(pricePrev, scalePrev) || new bignumber_js_1.default(0);
+            const originalPriceChange = (originalPriceFinal || new bignumber_js_1.default(0)).minus(originalPricePrev);
+            return acc.concat((0, common_1.removeUndefined)({
+                status: "modified",
+                baseAsset: series.PriceData.BaseAsset,
+                quoteAsset: series.PriceData.QuoteAsset,
+                assetPrice: priceFinal?.toString(),
+                scale: scaleFinal,
+                originalAssetPrice: originalPriceFinal?.toString(),
+                assetPriceChange: assetPriceChange.isZero() ? undefined : assetPriceChange?.toString(),
+                scaleChange: scaleChange || undefined,
+                originalPriceChange: originalPriceChange.isZero() ? undefined : originalPriceChange.toString(),
+            }));
+        }
+        return acc;
+    }, []);
+    const removed = prev.PriceDataSeries.filter((s) => {
+        return !final.PriceDataSeries.find((series) => series.PriceData.BaseAsset === s.PriceData.BaseAsset && series.PriceData.QuoteAsset === s.PriceData.QuoteAsset);
+    });
+    if (removed.length > 0) {
+        return changes.concat(removed.map((s) => {
+            const price = hexPriceToBigNumber(s.PriceData.AssetPrice);
+            return {
+                status: "removed",
+                baseAsset: s.PriceData.BaseAsset,
+                quoteAsset: s.PriceData.QuoteAsset,
+                assetPrice: price?.toString(),
+                scale: s.PriceData.Scale,
+                originalAssetPrice: getOriginalAssetPrice(price, s.PriceData.Scale),
+            };
+        }));
+    }
+    if (changes.length === 0) {
+        return undefined;
+    }
+    return changes;
+}
+function summarizeOracle(node) {
+    const final = node.diffType === "CreatedNode" ? node.newFields : node.finalFields;
+    const prev = node.previousFields;
+    const summary = {
+        status: parseOracleStatus(node),
+        oracleID: node.ledgerIndex,
+        oracleDocumentID: final.OracleDocumentID,
+        provider: final.Provider,
+        uri: final.URI,
+        assetClass: final.AssetClass,
+        lastUpdateTime: final.LastUpdateTime,
+        priceDataSeries: final.PriceDataSeries.map(parsePriceDataSeries),
+    };
+    if (prev.URI) {
+        summary.uriChanges = final.URI;
+    }
+    if (prev.LastUpdateTime) {
+        summary.lastUpdateTimeChanges = final.LastUpdateTime - (prev.LastUpdateTime || 0);
+    }
+    if (prev.PriceDataSeries) {
+        summary.priceDataSeriesChanges = summarizePriceDataSeriesChanges(node);
+    }
+    return (0, common_1.removeUndefined)(summary);
+}
+function parseOracleChanges(metadata) {
+    const affectedNodes = metadata.AffectedNodes.filter((affectedNode) => {
+        const node = affectedNode.CreatedNode || affectedNode.ModifiedNode || affectedNode.DeletedNode;
+        return node.LedgerEntryType === "Oracle";
+    });
+    if (affectedNodes.length !== 1) {
+        return undefined;
+    }
+    const normalizedNode = (0, utils_1.normalizeNode)(affectedNodes[0]);
+    return summarizeOracle(normalizedNode);
+}

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

@@ -0,0 +1,21 @@
+import { TransactionMetadata } from "xrpl";
+import { FormattedAmount, OfferFlagsKeysInterface } from "../../types";
+type OfferDescription = {
+    flags: OfferFlagsKeysInterface;
+    account?: string;
+    sequence: number;
+    takerGets?: FormattedAmount;
+    takerPays?: FormattedAmount;
+    status?: string;
+    makerExchangeRate: string;
+    expirationTime?: string;
+    domainID?: string;
+    direction: string;
+    quantity: any;
+    totalPrice: any;
+};
+type Orderbook = {
+    [key: string]: OfferDescription[];
+};
+declare function parseOrderbookChanges(metadata: TransactionMetadata): Orderbook;
+export { parseOrderbookChanges };

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

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseOrderbookChanges = parseOrderbookChanges;
+const lodash_1 = __importDefault(require("lodash"));
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const BigNumber = bignumber_js_1.default.clone({ DECIMAL_PLACES: 40 });
+const xrpl_1 = require("xrpl");
+const common_1 = require("../../common");
+const models_1 = require("../../models");
+const utils_1 = require("../utils");
+const orderbook_quality_1 = require("./orderbook_quality");
+const currency_amount_1 = __importDefault(require("../ledger/currency-amount"));
+const offer_flags_1 = __importDefault(require("../ledger/offer-flags"));
+const client_1 = require("../../client");
+function getExpirationTime(node) {
+    const expirationTime = (node.finalFields.Expiration || node.newFields.Expiration);
+    if (expirationTime === undefined) {
+        return undefined;
+    }
+    return new Date((0, models_1.ledgerTimeToTimestamp)(expirationTime)).toISOString();
+}
+function getQuality(node) {
+    const takerGets = (node.finalFields.TakerGets || node.newFields.TakerGets);
+    const takerPays = (node.finalFields.TakerPays || node.newFields.TakerPays);
+    const takerGetsCurrency = typeof takerGets === "string" ? (0, client_1.getNativeCurrency)() : null;
+    const takerPaysCurrency = typeof takerPays === "string" ? (0, client_1.getNativeCurrency)() : null;
+    const bookDirectory = (node.finalFields.BookDirectory || node.newFields.BookDirectory);
+    const qualityHex = bookDirectory.substring(bookDirectory.length - 16);
+    return (0, orderbook_quality_1.parseOrderbookQuality)(qualityHex, takerGetsCurrency, takerPaysCurrency);
+}
+function parseOrderStatus(node) {
+    if (node.diffType === "CreatedNode") {
+        return "created";
+    }
+    if (node.diffType === "ModifiedNode") {
+        return "partially-filled";
+    }
+    if (node.diffType === "DeletedNode") {
+        if (node.previousFields.hasOwnProperty("TakerPays")) {
+            return "filled";
+        }
+        return "cancelled";
+    }
+    return undefined;
+}
+function calculateDelta(finalAmount, previousAmount) {
+    if (previousAmount) {
+        const finalValue = new BigNumber(finalAmount.value);
+        const previousValue = new BigNumber(previousAmount.value);
+        return finalValue.minus(previousValue).abs().toString();
+    }
+    return "0";
+}
+function parseChangeAmount(node, type) {
+    const status = parseOrderStatus(node);
+    if (status === "cancelled") {
+        return (0, currency_amount_1.default)(node.finalFields[type]);
+    }
+    else if (status === "created") {
+        return (0, currency_amount_1.default)(node.newFields[type]);
+    }
+    const finalAmount = (0, currency_amount_1.default)(node.finalFields[type]);
+    const previousAmount = (0, currency_amount_1.default)(node.previousFields[type]);
+    const value = calculateDelta(finalAmount, previousAmount);
+    return lodash_1.default.assign({}, finalAmount, { value: value });
+}
+function parseOrderChange(node) {
+    const takerPays = parseChangeAmount(node, "TakerPays");
+    const takerGets = parseChangeAmount(node, "TakerGets");
+    const fields = Object.keys(node.finalFields).length > 0 ? node.finalFields : node.newFields;
+    const flags = (0, offer_flags_1.default)(fields.Flags);
+    const orderChange = (0, common_1.removeUndefined)({
+        flags,
+        takerGets,
+        takerPays,
+        sequence: fields.Sequence,
+        status: parseOrderStatus(node),
+        makerExchangeRate: getQuality(node),
+        expirationTime: getExpirationTime(node),
+        domainID: fields.DomainID,
+        direction: (node.finalFields.Flags & xrpl_1.LedgerEntry.OfferFlags.lsfSell) === 0 ? "buy" : "sell",
+        quantity: flags.sell === true ? takerGets : takerPays,
+        totalPrice: flags.sell === true ? takerPays : takerGets,
+    });
+    Object.defineProperty(orderChange, "account", {
+        value: fields.Account,
+    });
+    return orderChange;
+}
+function groupByAddress(orderChanges) {
+    return lodash_1.default.groupBy(orderChanges, function (change) {
+        return change.account;
+    });
+}
+function parseOrderbookChanges(metadata) {
+    const affectedNodes = metadata.AffectedNodes.filter((affectedNode) => {
+        const node = affectedNode.CreatedNode || affectedNode.ModifiedNode || affectedNode.DeletedNode;
+        return node.LedgerEntryType === "Offer";
+    });
+    const orderChanges = affectedNodes.map((affectedNode) => {
+        const normalizedNode = (0, utils_1.normalizeNode)(affectedNode);
+        return parseOrderChange(normalizedNode);
+    });
+    return groupByAddress(orderChanges);
+}

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

@@ -0,0 +1,2 @@
+declare function parseOrderbookQuality(qualityHex: string, takerGetsCurrency: string | null, takerPaysCurrency: string | null): string;
+export { parseOrderbookQuality };