@bithomp/xrpl-api 2.3.6

package/lib/parse/outcome/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseOrderbookChanges = exports.parseChannelChanges = exports.parseLockedBalanceChanges = exports.parseBalanceChanges = exports.parseNFTokenOfferChanges = exports.parseNFTokenChanges = exports.parseAffectedObjects = void 0;
+var affected_objects_1 = require("./affected_objects");
+Object.defineProperty(exports, "parseAffectedObjects", { enumerable: true, get: function () { return affected_objects_1.parseAffectedObjects; } });
+var nftoken_changes_1 = require("./nftoken_changes");
+Object.defineProperty(exports, "parseNFTokenChanges", { enumerable: true, get: function () { return nftoken_changes_1.parseNFTokenChanges; } });
+var nftoken_offer_changes_1 = require("./nftoken_offer_changes");
+Object.defineProperty(exports, "parseNFTokenOfferChanges", { enumerable: true, get: function () { return nftoken_offer_changes_1.parseNFTokenOfferChanges; } });
+var balance_changes_1 = require("./balance_changes");
+Object.defineProperty(exports, "parseBalanceChanges", { enumerable: true, get: function () { return balance_changes_1.parseBalanceChanges; } });
+var locked_balance_changes_1 = require("./locked_balance_changes");
+Object.defineProperty(exports, "parseLockedBalanceChanges", { enumerable: true, get: function () { return locked_balance_changes_1.parseLockedBalanceChanges; } });
+var channel_changes_1 = require("./channel_changes");
+Object.defineProperty(exports, "parseChannelChanges", { enumerable: true, get: function () { return channel_changes_1.parseChannelChanges; } });
+var orderbook_changes_1 = require("./orderbook_changes");
+Object.defineProperty(exports, "parseOrderbookChanges", { enumerable: true, get: function () { return orderbook_changes_1.parseOrderbookChanges; } });

package/lib/parse/outcome/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 };

package/lib/parse/outcome/locked_balance_changes.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFinalLockedBalances = exports.parseLockedBalanceChanges = 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(lockedBalanceChanges) {
+    const grouped = lodash_1.default.groupBy(lockedBalanceChanges, function (node) {
+        return node.address;
+    });
+    return lodash_1.default.mapValues(grouped, function (group) {
+        return lodash_1.default.map(group, function (node) {
+            return node.lockedBalance;
+        });
+    });
+}
+function parseValue(value) {
+    return new bignumber_js_1.default(value.value || value);
+}
+function computeBalanceChange(node) {
+    var value = null;
+    if (node.newFields.LockedBalance) {
+        value = parseValue(node.newFields.LockedBalance);
+    }
+    else if (node.previousFields.LockedBalance && node.finalFields.LockedBalance) {
+        value = parseValue(node.finalFields.LockedBalance).minus(parseValue(node.previousFields.LockedBalance));
+    }
+    return value === null ? null : value.isZero() ? null : value;
+}
+function parseFinalBalance(node) {
+    if (node.newFields.LockedBalance) {
+        return parseValue(node.newFields.LockedBalance);
+    }
+    else if (node.finalFields.LockedBalance) {
+        return parseValue(node.finalFields.LockedBalance);
+    }
+    return null;
+}
+function parseXRPQuantity(node, valueParser) {
+    var value = valueParser(node);
+    if (value === null) {
+        return null;
+    }
+    return {
+        address: node.finalFields.Account || node.newFields.Account,
+        lockedBalance: {
+            counterparty: "",
+            currency: "XRP",
+            value: (0, common_1.dropsToXrp)(value).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,
+        lockedBalance: {
+            counterparty: fields.HighLimit.issuer,
+            currency: fields.LockedBalance.currency,
+            value: value.toString(),
+        },
+    };
+    return [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 parseLockedBalanceChanges(metadata) {
+    return parseQuantities(metadata, computeBalanceChange);
+}
+exports.parseLockedBalanceChanges = parseLockedBalanceChanges;
+function parseFinalLockedBalances(metadata) {
+    return parseQuantities(metadata, parseFinalBalance);
+}
+exports.parseFinalLockedBalances = parseFinalLockedBalances;

package/lib/parse/outcome/nftoken_changes.d.ts

@@ -0,0 +1 @@
+export declare function parseNFTokenChanges(tx: object): object;

package/lib/parse/outcome/nftoken_changes.js

@@ -0,0 +1,143 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseNFTokenChanges = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const AddressCodec = require("ripple-address-codec");
+const common_1 = require("../../common");
+function parseNFTokenChanges(tx) {
+    return new NFTokenChanges(tx).call();
+}
+exports.parseNFTokenChanges = parseNFTokenChanges;
+class NFTokenChanges {
+    constructor(tx) {
+        this.tx = tx;
+        this.changes = {};
+        this.affectedAccounts = [];
+        this.finalNFTokens = {};
+        this.previousNFTokens = {};
+    }
+    call() {
+        if (this.hasAffectedNodes() === false) {
+            return this.changes;
+        }
+        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;
+    }
+}

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

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

package/lib/parse/outcome/nftoken_offer_changes.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseNFTokenOfferChanges = void 0;
+const ledger_1 = require("../../models/ledger");
+const common_1 = require("../../common");
+function parseNFTokenOfferChanges(tx) {
+    return new NFTokenOfferChanges(tx).call();
+}
+exports.parseNFTokenOfferChanges = parseNFTokenOfferChanges;
+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 prevTxHash = affectedNode.CreatedNode.NewFields.PreviousTxnID;
+        const prevLedgerIndex = 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,
+            prevTxHash,
+            prevLedgerIndex,
+        });
+    }
+    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 prevTxHash = affectedNode.DeletedNode.FinalFields.PreviousTxnID;
+        const prevLedgerIndex = 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,
+            prevTxHash,
+            prevLedgerIndex,
+        });
+    }
+}

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

@@ -0,0 +1,3 @@
+import _ from "lodash";
+declare function parseOrderbookChanges(metadata: any): _.Dictionary<any[]>;
+export { parseOrderbookChanges };

package/lib/parse/outcome/orderbook_changes.js

@@ -0,0 +1,111 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseOrderbookChanges = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const bignumber_js_1 = require("bignumber.js");
+const BigNumber = bignumber_js_1.BigNumber.clone({ DECIMAL_PLACES: 40 });
+const common_1 = require("../../common");
+const models_1 = require("../../models");
+const utils_1 = require("../../v1/common/utils");
+const orderbook_quality_1 = require("./orderbook_quality");
+const currency_amount_1 = __importDefault(require("../ledger/currency-amount"));
+const lsfSell = 0x00020000;
+function convertOrderChange(order) {
+    var takerGets = order.taker_gets;
+    var takerPays = order.taker_pays;
+    var direction = order.sell ? "sell" : "buy";
+    var quantity = direction === "buy" ? takerPays : takerGets;
+    var totalPrice = direction === "buy" ? takerGets : takerPays;
+    return (0, common_1.removeUndefined)({
+        direction: direction,
+        quantity: quantity,
+        totalPrice: totalPrice,
+        sequence: order.sequence,
+        status: order.status,
+        makerExchangeRate: order.quality,
+        expirationTime: order.expiration,
+    });
+}
+function getExpirationTime(node) {
+    var expirationTime = node.finalFields.Expiration || node.newFields.Expiration;
+    if (expirationTime === undefined) {
+        return undefined;
+    }
+    return new Date((0, models_1.ledgerTimeToTimestamp)(expirationTime)).toISOString();
+}
+function getQuality(node) {
+    var takerGets = node.finalFields.TakerGets || node.newFields.TakerGets;
+    var takerPays = node.finalFields.TakerPays || node.newFields.TakerPays;
+    var takerGetsCurrency = takerGets.currency || "XRP";
+    var takerPaysCurrency = takerPays.currency || "XRP";
+    var bookDirectory = node.finalFields.BookDirectory || node.newFields.BookDirectory;
+    var 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) {
+        var finalValue = new BigNumber(finalAmount.value);
+        var previousValue = new BigNumber(previousAmount.value);
+        return finalValue.minus(previousValue).abs().toString();
+    }
+    return "0";
+}
+function parseChangeAmount(node, type) {
+    var 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]);
+    }
+    var finalAmount = (0, currency_amount_1.default)(node.finalFields[type]);
+    var previousAmount = (0, currency_amount_1.default)(node.previousFields[type]);
+    var value = calculateDelta(finalAmount, previousAmount);
+    return lodash_1.default.assign({}, finalAmount, { value: value });
+}
+function parseOrderChange(node) {
+    var orderChange = convertOrderChange({
+        taker_pays: parseChangeAmount(node, "TakerPays"),
+        taker_gets: parseChangeAmount(node, "TakerGets"),
+        sell: (node.finalFields.Flags & lsfSell) !== 0,
+        sequence: node.finalFields.Sequence || node.newFields.Sequence,
+        status: parseOrderStatus(node),
+        quality: getQuality(node),
+        expiration: getExpirationTime(node),
+    });
+    Object.defineProperty(orderChange, "account", {
+        value: node.finalFields.Account || node.newFields.Account,
+    });
+    return orderChange;
+}
+function groupByAddress(orderChanges) {
+    return lodash_1.default.groupBy(orderChanges, function (change) {
+        return change.account;
+    });
+}
+function parseOrderbookChanges(metadata) {
+    var nodes = (0, utils_1.normalizeNodes)(metadata);
+    var orderChanges = lodash_1.default.map(lodash_1.default.filter(nodes, function (node) {
+        return node.entryType === "Offer";
+    }), parseOrderChange);
+    return groupByAddress(orderChanges);
+}
+exports.parseOrderbookChanges = parseOrderbookChanges;

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

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

package/lib/parse/outcome/orderbook_quality.js

@@ -0,0 +1,45 @@
+"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.parseOrderbookQuality = void 0;
+const assert = __importStar(require("assert"));
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+function adjustQualityForXRP(quality, takerGetsCurrency, takerPaysCurrency) {
+    var numeratorShift = takerPaysCurrency === "XRP" ? -6 : 0;
+    var denominatorShift = takerGetsCurrency === "XRP" ? -6 : 0;
+    var shift = numeratorShift - denominatorShift;
+    return shift === 0 ? new bignumber_js_1.default(quality).toString() : new bignumber_js_1.default(quality).shiftedBy(shift).toString();
+}
+function parseOrderbookQuality(qualityHex, takerGetsCurrency, takerPaysCurrency) {
+    assert.ok(qualityHex.length === 16);
+    var mantissa = new bignumber_js_1.default(qualityHex.substring(2), 16);
+    var offset = parseInt(qualityHex.substring(0, 2), 16) - 100;
+    var quality = mantissa.toString() + "e" + offset.toString();
+    return adjustQualityForXRP(quality, takerGetsCurrency, takerPaysCurrency);
+}
+exports.parseOrderbookQuality = parseOrderbookQuality;

package/lib/parse/outcome.d.ts

@@ -0,0 +1,3 @@
+import { Outcome } from "../v1/transaction/types";
+declare function parseOutcome(tx: any): Outcome | undefined;
+export { parseOutcome };

package/lib/parse/outcome.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseOutcome = void 0;
+const index_1 = require("./outcome/index");
+const amount_1 = __importDefault(require("./ledger/amount"));
+const utils_1 = require("./utils");
+const common_1 = require("../common");
+function removeEmptyCounterparty(amount) {
+    if (amount.counterparty === "") {
+        delete amount.counterparty;
+    }
+}
+function removeEmptyCounterpartyInBalanceChanges(balanceChanges) {
+    Object.entries(balanceChanges).forEach(([_, changes]) => {
+        changes.forEach(removeEmptyCounterparty);
+    });
+}
+function removeEmptyCounterpartyInOrderbookChanges(orderbookChanges) {
+    Object.entries(orderbookChanges).forEach(([_, changes]) => {
+        changes.forEach((change) => {
+            Object.entries(change).forEach(removeEmptyCounterparty);
+        });
+    });
+}
+function parseDeliveredAmount(tx) {
+    if (tx.TransactionType !== "Payment" || tx.meta.TransactionResult !== "tesSUCCESS") {
+        return undefined;
+    }
+    if (tx.meta.delivered_amount && tx.meta.delivered_amount === "unavailable") {
+        return undefined;
+    }
+    if (tx.meta.delivered_amount) {
+        return (0, amount_1.default)(tx.meta.delivered_amount);
+    }
+    if (tx.meta.DeliveredAmount) {
+        return (0, amount_1.default)(tx.meta.DeliveredAmount);
+    }
+    if (tx.Amount && !(0, utils_1.isPartialPayment)(tx)) {
+        return (0, amount_1.default)(tx.Amount);
+    }
+    if (tx.Amount && tx.ledger_index > 4594094) {
+        return (0, amount_1.default)(tx.Amount);
+    }
+    return undefined;
+}
+function parseOutcome(tx) {
+    const metadata = tx.meta || tx.metaData;
+    if (!metadata) {
+        return undefined;
+    }
+    const balanceChanges = (0, index_1.parseBalanceChanges)(metadata);
+    const lockedBalanceChanges = (0, index_1.parseLockedBalanceChanges)(metadata);
+    const orderbookChanges = (0, index_1.parseOrderbookChanges)(metadata);
+    const channelChanges = (0, index_1.parseChannelChanges)(metadata);
+    const nftokenChanges = (0, index_1.parseNFTokenChanges)(tx);
+    const nftokenOfferChanges = (0, index_1.parseNFTokenOfferChanges)(tx);
+    const affectedObjects = (0, index_1.parseAffectedObjects)(tx);
+    removeEmptyCounterpartyInBalanceChanges(balanceChanges);
+    removeEmptyCounterpartyInBalanceChanges(lockedBalanceChanges);
+    removeEmptyCounterpartyInOrderbookChanges(orderbookChanges);
+    return (0, common_1.removeUndefined)({
+        result: tx.meta.TransactionResult,
+        timestamp: (0, utils_1.parseTimestamp)(tx.date),
+        fee: (0, common_1.dropsToXrp)(tx.Fee),
+        balanceChanges,
+        lockedBalanceChanges,
+        orderbookChanges,
+        channelChanges,
+        nftokenChanges,
+        nftokenOfferChanges,
+        affectedObjects: affectedObjects ? (0, common_1.removeUndefined)(affectedObjects) : undefined,
+        ledgerVersion: tx.ledger_index,
+        indexInLedger: tx.meta.TransactionIndex,
+        deliveredAmount: parseDeliveredAmount(tx),
+    });
+}
+exports.parseOutcome = parseOutcome;

package/lib/parse/specification/account-delete.d.ts

@@ -0,0 +1,3 @@
+import { FormattedAccountDeleteSpecification } from "../../v1/common/types/objects/account";
+declare function parseAccountDelete(tx: any): FormattedAccountDeleteSpecification;
+export default parseAccountDelete;

package/lib/parse/specification/account-delete.js

@@ -0,0 +1,42 @@
+"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 });
+const assert = __importStar(require("assert"));
+const common_1 = require("../../common");
+const ripple_address_codec_1 = require("ripple-address-codec");
+const memos_1 = __importDefault(require("../ledger/memos"));
+function parseAccountDelete(tx) {
+    assert.ok(tx.TransactionType === "AccountDelete");
+    return (0, common_1.removeUndefined)({
+        memos: (0, memos_1.default)(tx),
+        destination: tx.Destination,
+        destinationTag: tx.DestinationTag,
+        destinationXAddress: (0, ripple_address_codec_1.classicAddressToXAddress)(tx.Destination, tx.DestinationTag == null ? false : tx.DestinationTag, false),
+    });
+}
+exports.default = parseAccountDelete;