@bithomp/xrpl-api 3.7.30 → 3.7.37

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

@@ -0,0 +1,49 @@
+"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.parseOrderbookQuality = parseOrderbookQuality;
+const assert = __importStar(require("assert"));
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const utils_1 = require("../utils");
+function parseOrderbookQuality(qualityHex, takerGetsCurrency, takerPaysCurrency) {
+    assert.ok(qualityHex.length === 16);
+    const mantissa = new bignumber_js_1.default(qualityHex.substring(2), 16);
+    const offset = parseInt(qualityHex.substring(0, 2), 16) - 100;
+    const quality = mantissa.toString() + "e" + offset.toString();
+    return (0, utils_1.adjustQualityForXRP)(quality, takerGetsCurrency, takerPaysCurrency);
+}

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

@@ -0,0 +1,14 @@
+import { FormattedRemark } from "../../types";
+type FormattedRemarkSummaryInterface = {
+    status?: "created" | "modified" | "deleted";
+    previousValue?: string;
+} & FormattedRemark;
+interface FormattedRemarksSummaryInterface {
+    status?: "created" | "modified" | "deleted";
+    objectID: string;
+    entryType?: string;
+    remarks?: FormattedRemarkSummaryInterface[];
+    previousTxnID?: string;
+}
+declare function parseRemarksChanges(tx: any): FormattedRemarksSummaryInterface | undefined;
+export { parseRemarksChanges };

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

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRemarksChanges = parseRemarksChanges;
+const utils_1 = require("../utils");
+const remarks_1 = require("../ledger/remarks");
+function parseEntryRemarks(node) {
+    const final = node.diffType === "CreatedNode" ? node.newFields : node.finalFields;
+    const prev = node.previousFields;
+    if (!final.Remarks && !prev.Remarks) {
+        return undefined;
+    }
+    const remarks = ((0, remarks_1.parseRemarks)(final.Remarks) || []);
+    if (prev.Remarks) {
+        const previousRemarks = (0, remarks_1.parseRemarks)(prev.Remarks) || [];
+        remarks.forEach((remark) => {
+            const previousRemark = previousRemarks.find((r) => r.name === remark.name);
+            if (previousRemark) {
+                if (previousRemark.value !== remark.value) {
+                    remark.status = "modified";
+                    remark.previousValue = previousRemark.value;
+                }
+            }
+            else {
+                remark.status = "created";
+            }
+        });
+        previousRemarks.forEach((previousRemark) => {
+            if (!remarks.some((r) => r.name === previousRemark.name)) {
+                remarks.push({
+                    ...previousRemark,
+                    status: "deleted",
+                });
+            }
+        });
+    }
+    else {
+        remarks.forEach((remark) => {
+            remark.status = "created";
+        });
+    }
+    return remarks;
+}
+function summarizeRemarks(node) {
+    const summary = {
+        objectID: node.ledgerIndex,
+        entryType: node.entryType,
+        remarks: parseEntryRemarks(node),
+    };
+    if (node.PreviousTxnID) {
+        summary.previousTxnID = node.PreviousTxnID;
+    }
+    return summary;
+}
+function parseRemarksChanges(tx) {
+    if (!tx.ObjectID || !tx.meta || !Array.isArray(tx.meta.AffectedNodes)) {
+        return undefined;
+    }
+    const metadata = tx.meta;
+    const affectedNodes = metadata.AffectedNodes.filter((affectedNode) => {
+        const node = affectedNode.CreatedNode || affectedNode.ModifiedNode || affectedNode.DeletedNode;
+        return node.LedgerIndex === tx.ObjectID;
+    });
+    if (affectedNodes.length !== 1) {
+        return undefined;
+    }
+    const normalizedNode = (0, utils_1.normalizeNode)(affectedNodes[0]);
+    return summarizeRemarks(normalizedNode);
+}

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

@@ -0,0 +1,13 @@
+interface FormattedUNLReportSummaryInterface {
+    status: "added";
+    activeValidator?: {
+        account: string;
+        publicKey: string;
+    };
+    importVLKey?: {
+        account: string;
+        publicKey: string;
+    };
+}
+declare function parseUNLReportChanges(tx: any): FormattedUNLReportSummaryInterface | undefined;
+export { parseUNLReportChanges };

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

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseUNLReportChanges = parseUNLReportChanges;
+const common_1 = require("../../common");
+const utils_1 = require("../utils");
+function summarizeUNLReport(tx, node) {
+    const final = node.diffType === "CreatedNode" ? node.newFields : node.finalFields;
+    if (tx.ImportVLKey && final.ImportVLKeys) {
+        for (const vlKey of final.ImportVLKeys) {
+            if (vlKey.ImportVLKey.PublicKey === tx.ImportVLKey.PublicKey) {
+                const summary = {
+                    status: "added",
+                    importVLKey: {
+                        account: vlKey.ImportVLKey.Account,
+                        publicKey: vlKey.ImportVLKey.PublicKey,
+                    },
+                };
+                return (0, common_1.removeUndefined)(summary);
+            }
+        }
+    }
+    if (tx.ActiveValidator && final.ActiveValidators) {
+        for (const activeValidator of final.ActiveValidators) {
+            if (activeValidator.ActiveValidator.PublicKey === tx.ActiveValidator.PublicKey) {
+                const summary = {
+                    status: "added",
+                    activeValidator: {
+                        account: activeValidator.ActiveValidator.Account,
+                        publicKey: activeValidator.ActiveValidator.PublicKey,
+                    },
+                };
+                return (0, common_1.removeUndefined)(summary);
+            }
+        }
+    }
+    return undefined;
+}
+function parseUNLReportChanges(tx) {
+    const affectedNodes = tx.meta.AffectedNodes.filter((affectedNode) => {
+        const node = affectedNode.CreatedNode || affectedNode.ModifiedNode || affectedNode.DeletedNode;
+        return node.LedgerEntryType === "UNLReport";
+    });
+    if (affectedNodes.length !== 1) {
+        return undefined;
+    }
+    const normalizedNode = (0, utils_1.normalizeNode)(affectedNodes[0]);
+    return summarizeUNLReport(tx, normalizedNode);
+}

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

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

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

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseURITokenChanges = parseURITokenChanges;
+const common_1 = require("../../common");
+function parseURITokenChanges(tx) {
+    return new URITokenChanges(tx).call();
+}
+class URITokenChanges {
+    constructor(tx) {
+        this.tx = tx;
+        this.changes = {};
+    }
+    call() {
+        if (this.hasAffectedNodes() === false) {
+            return this.changes;
+        }
+        this.parseAffectedNodes();
+        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 === "URIToken" && node?.LedgerIndex) {
+                const uritokenID = node.LedgerIndex;
+                if (affectedNode.CreatedNode) {
+                    this.addChange(node.NewFields.Owner, {
+                        status: "added",
+                        flags: node.NewFields.Flags,
+                        uritokenID,
+                        uri: node.NewFields.URI,
+                        digest: node.NewFields.Digest,
+                        issuer: node.NewFields.Issuer,
+                    });
+                }
+                if (affectedNode.ModifiedNode) {
+                    if (node.PreviousFields.Owner && node.PreviousFields.Owner !== node.FinalFields.Owner) {
+                        this.addChange(node.PreviousFields.Owner, {
+                            status: "removed",
+                            flags: node.FinalFields.Flags,
+                            uritokenID,
+                            uri: node.FinalFields.URI,
+                            digest: node.FinalFields.Digest,
+                            issuer: node.FinalFields.Issuer,
+                        });
+                        this.addChange(node.FinalFields.Owner, {
+                            status: "added",
+                            flags: node.FinalFields.Flags,
+                            uritokenID,
+                            uri: node.FinalFields.URI,
+                            digest: node.FinalFields.Digest,
+                            issuer: node.FinalFields.Issuer,
+                        });
+                    }
+                }
+                if (affectedNode.DeletedNode) {
+                    this.addChange(node.FinalFields.Owner, {
+                        status: "removed",
+                        flags: node.FinalFields.Flags,
+                        uritokenID,
+                        uri: node.FinalFields.URI,
+                        digest: node.FinalFields.Digest,
+                        issuer: node.FinalFields.Issuer,
+                    });
+                }
+            }
+        }
+    }
+}

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

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

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

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseURITokenSellOfferChanges = parseURITokenSellOfferChanges;
+const common_1 = require("../../common");
+function parseURITokenSellOfferChanges(tx) {
+    return new URITokenSellOfferChanges(tx).call();
+}
+class URITokenSellOfferChanges {
+    constructor(tx) {
+        this.tx = tx;
+        this.changes = {};
+    }
+    call() {
+        if (this.hasAffectedNodes() === false) {
+            return this.changes;
+        }
+        this.parseAffectedNodes();
+        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 === "URIToken" && node?.LedgerIndex) {
+                const uritokenID = node.LedgerIndex;
+                if (affectedNode.CreatedNode) {
+                    if (node.NewFields.Amount || node.NewFields.Destination) {
+                        this.addChange(node.NewFields.Owner, {
+                            status: "created",
+                            uritokenID,
+                            amount: node.NewFields.Amount,
+                            destination: node.NewFields.Destination,
+                        });
+                    }
+                }
+                if (affectedNode.ModifiedNode) {
+                    if (node.PreviousFields.Amount !== node.FinalFields.Amount ||
+                        node.PreviousFields.Destination !== node.FinalFields.Destination) {
+                        if (node.PreviousFields.Amount || node.PreviousFields.Destination) {
+                            let owner;
+                            if (node.PreviousFields.hasOwnProperty("Owner")) {
+                                owner = node.PreviousFields.Owner;
+                            }
+                            else {
+                                owner = node.FinalFields.Owner;
+                            }
+                            let destination;
+                            if (node.PreviousFields.hasOwnProperty("Destination")) {
+                                destination = node.PreviousFields.Destination;
+                            }
+                            else {
+                                destination = node.FinalFields.Destination;
+                            }
+                            let amount;
+                            if (node.PreviousFields.hasOwnProperty("Amount")) {
+                                amount = node.PreviousFields.Amount;
+                            }
+                            else {
+                                amount = node.FinalFields.Amount;
+                            }
+                            this.addChange(owner, {
+                                status: "deleted",
+                                uritokenID,
+                                amount,
+                                destination,
+                            });
+                        }
+                        if (node.FinalFields.Amount || node.FinalFields.Destination) {
+                            this.addChange(node.FinalFields.Owner, {
+                                status: "created",
+                                uritokenID,
+                                amount: node.FinalFields.Amount,
+                                destination: node.FinalFields.Destination,
+                            });
+                        }
+                    }
+                }
+                if (affectedNode.DeletedNode) {
+                    if (node.FinalFields.Amount || node.FinalFields.Destination) {
+                        this.addChange(node.FinalFields.Owner, {
+                            status: "deleted",
+                            uritokenID,
+                            amount: node.FinalFields.Amount,
+                            destination: node.FinalFields.Destination,
+                        });
+                    }
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,4 @@
+import { XrplDefinitionsBase } from "ripple-binary-codec";
+import { Outcome } from "../types/outcome";
+declare function parseOutcome(tx: any, nativeCurrency?: string, definitions?: XrplDefinitionsBase): Outcome | undefined;
+export { parseOutcome };

package/lib/src/parse/outcome.js

@@ -0,0 +1,264 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseOutcome = parseOutcome;
+const client_1 = require("../client");
+const index_1 = require("./outcome/index");
+const utils_1 = require("./utils");
+const common_1 = require("../common");
+const ESCROW_TYPES = ["EscrowFinish", "EscrowCreate", "EscrowCancel"];
+const CHANNEL_TYPES = ["PaymentChannelCreate", "PaymentChannelFund", "PaymentChannelClaim"];
+const CHECK_TYPES = ["CheckCreate", "CheckCash", "CheckCancel"];
+const NFTOKEN_TYPES = [
+    "NFTokenMint",
+    "NFTokenBurn",
+    "NFTokenCreateOffer",
+    "NFTokenCancelOffer",
+    "NFTokenAcceptOffer",
+    "NFTokenModify",
+];
+const URITOKEN_TYPES = [
+    "Remit",
+    "URITokenMint",
+    "URITokenBurn",
+    "URITokenBuy",
+    "URITokenCreateSellOffer",
+    "URITokenCancelSellOffer",
+];
+const AMM_TYPES = ["AMMBid", "AMMCreate", "AMMDelete", "AMMDeposit", "AMMWithdraw", "AMMVote", "AMMClawback"];
+const DID_TYPES = ["DIDSet", "DIDDelete"];
+const ORACLE_TYPES = ["OracleSet", "OracleDelete"];
+const UNL_REPORT_TYPES = ["UNLReport"];
+const MPTOKEN_TYPES = [
+    "MPTokenIssuanceCreate",
+    "MPTokenAuthorize",
+    "MPTokenIssuanceSet",
+    "MPTokenIssuanceDestroy",
+    "Payment",
+    "Clawback",
+    "EscrowFinish",
+    "EscrowCreate",
+    "EscrowCancel",
+];
+const CREDENTIAL_TYPES = ["CredentialCreate", "CredentialAccept", "CredentialDelete"];
+const DELEGATE_TYPES = ["DelegateSet"];
+const REMARKS_TYPES = ["SetRemarks"];
+const CRON_TYPES = ["Cron", "CronSet"];
+const AMENDMENT_TYPES = ["EnableAmendment"];
+const ACCOUNT_SETTING_TYPES = ["AccountSet"];
+function parseOutcome(tx, nativeCurrency, definitions) {
+    const metadata = tx.meta || tx.metaData;
+    if (!metadata) {
+        return undefined;
+    }
+    const balanceChanges = getBalanceChanges(tx, nativeCurrency || (0, client_1.getNativeCurrency)());
+    return (0, common_1.removeUndefined)({
+        result: tx.meta.TransactionResult,
+        timestamp: (0, utils_1.parseTimestamp)(tx.date),
+        fee: (0, common_1.dropsToXrp)(tx.Fee),
+        settingsChanges: getSettingsChanges(tx),
+        balanceChanges,
+        lockedBalanceChanges: getLockedBalanceChanges(tx),
+        orderbookChanges: getOrderbookChanges(tx),
+        channelChanges: getChannelChanges(tx),
+        checkChanges: getCheckChanges(tx),
+        escrowChanges: getEscrowChanges(tx),
+        amendmentChanges: getAmendmentChanges(tx),
+        nftokenChanges: getNFTokenChanges(tx),
+        nftokenOfferChanges: getNFTokenOfferChanges(tx),
+        uritokenChanges: getURITokenChanges(tx),
+        uritokenSellOfferChanges: getURITokenSellOfferChanges(tx),
+        affectedObjects: getAffectedObjects(tx),
+        ammChanges: getAmmChanges(tx),
+        didChanges: getDIDChanges(tx),
+        oracleChanges: getOracleChanges(tx),
+        mptokenIssuanceChanges: getMPTokenIssuanceChanges(tx, nativeCurrency || (0, client_1.getNativeCurrency)()),
+        mptokenChanges: getMPTokenChanges(tx, nativeCurrency || (0, client_1.getNativeCurrency)()),
+        credentialChanges: getCredentialChanges(tx, nativeCurrency || (0, client_1.getNativeCurrency)()),
+        delegateChanges: getDelegateChanges(tx, nativeCurrency || (0, client_1.getNativeCurrency)()),
+        remarksChanges: getRemarksChanges(tx, nativeCurrency || (0, client_1.getNativeCurrency)()),
+        cronChanges: getCronChanges(tx, nativeCurrency || (0, client_1.getNativeCurrency)()),
+        unlReportChanges: getUNLReportChanges(tx, nativeCurrency || (0, client_1.getNativeCurrency)()),
+        hooksExecutions: getHooksExecutions(tx, nativeCurrency || (0, client_1.getNativeCurrency)()),
+        emittedTxns: getEmittedTxns(tx, nativeCurrency || (0, client_1.getNativeCurrency)(), definitions),
+        parentBatchID: tx.meta.ParentBatchID,
+        ledgerIndex: tx.ledger_index || tx.inLedger,
+        ledgerVersion: tx.ledger_index || tx.inLedger,
+        indexInLedger: tx.meta.TransactionIndex,
+        deliveredAmount: (0, index_1.parseDeliveredAmount)(tx, balanceChanges),
+    });
+}
+function getBalanceChanges(tx, nativeCurrency) {
+    const balanceChanges = (0, index_1.parseBalanceChanges)(tx.meta, nativeCurrency, tx);
+    return Object.keys(balanceChanges).length > 0 ? balanceChanges : undefined;
+}
+function getLockedBalanceChanges(tx) {
+    if (!ESCROW_TYPES.includes(tx.TransactionType)) {
+        return undefined;
+    }
+    const lockedBalanceChanges = (0, index_1.parseLockedBalanceChanges)(tx.meta);
+    return Object.keys(lockedBalanceChanges).length > 0 ? lockedBalanceChanges : undefined;
+}
+function getOrderbookChanges(tx) {
+    const orderbookChanges = (0, index_1.parseOrderbookChanges)(tx.meta);
+    return Object.keys(orderbookChanges).length > 0 ? orderbookChanges : undefined;
+}
+function getChannelChanges(tx) {
+    if (!CHANNEL_TYPES.includes(tx.TransactionType)) {
+        return undefined;
+    }
+    return (0, index_1.parseChannelChanges)(tx.meta);
+}
+function getCheckChanges(tx) {
+    if (!CHECK_TYPES.includes(tx.TransactionType)) {
+        return undefined;
+    }
+    return (0, index_1.parseCheckChanges)(tx.meta);
+}
+function getEscrowChanges(tx) {
+    if (!ESCROW_TYPES.includes(tx.TransactionType)) {
+        return undefined;
+    }
+    return (0, index_1.parseEscrowChanges)(tx);
+}
+function getAmendmentChanges(tx) {
+    if (!AMENDMENT_TYPES.includes(tx.TransactionType)) {
+        return undefined;
+    }
+    return (0, index_1.parseAmendmentChanges)(tx);
+}
+function getSettingsChanges(tx) {
+    if (!ACCOUNT_SETTING_TYPES.includes(tx.TransactionType)) {
+        return undefined;
+    }
+    return (0, index_1.parseAccountSettingChanges)(tx.meta);
+}
+function getAffectedObjects(tx) {
+    if (!NFTOKEN_TYPES.includes(tx.TransactionType) && !URITOKEN_TYPES.includes(tx.TransactionType)) {
+        return undefined;
+    }
+    const affectedObjects = (0, index_1.parseAffectedObjects)(tx);
+    return affectedObjects ? (0, common_1.removeUndefined)(affectedObjects) : undefined;
+}
+function getNFTokenChanges(tx) {
+    if (!NFTOKEN_TYPES.includes(tx.TransactionType)) {
+        return undefined;
+    }
+    const nftokenChanges = (0, index_1.parseNFTokenChanges)(tx);
+    return Object.keys(nftokenChanges).length > 0 ? nftokenChanges : undefined;
+}
+function getNFTokenOfferChanges(tx) {
+    if (!NFTOKEN_TYPES.includes(tx.TransactionType)) {
+        return undefined;
+    }
+    const nftokenOfferChanges = (0, index_1.parseNFTokenOfferChanges)(tx);
+    return Object.keys(nftokenOfferChanges).length > 0 ? nftokenOfferChanges : undefined;
+}
+function getURITokenChanges(tx) {
+    if (!URITOKEN_TYPES.includes(tx.TransactionType)) {
+        return undefined;
+    }
+    const uritokenChanges = (0, index_1.parseURITokenChanges)(tx);
+    return Object.keys(uritokenChanges).length > 0 ? uritokenChanges : undefined;
+}
+function getURITokenSellOfferChanges(tx) {
+    if (!URITOKEN_TYPES.includes(tx.TransactionType)) {
+        return undefined;
+    }
+    const uritokenSellOfferChanges = (0, index_1.parseURITokenSellOfferChanges)(tx);
+    return Object.keys(uritokenSellOfferChanges).length > 0 ? uritokenSellOfferChanges : undefined;
+}
+function getHooksExecutions(tx, nativeCurrency) {
+    if (nativeCurrency !== common_1.XAHAU_NATIVE_CURRENCY) {
+        return undefined;
+    }
+    return (0, index_1.parseHooksExecutions)(tx);
+}
+function getEmittedTxns(tx, nativeCurrency, definitions) {
+    if (nativeCurrency !== common_1.XAHAU_NATIVE_CURRENCY) {
+        return undefined;
+    }
+    return (0, index_1.parseEmittedTxns)(tx, nativeCurrency, definitions);
+}
+function getAmmChanges(tx) {
+    if (!AMM_TYPES.includes(tx.TransactionType)) {
+        return undefined;
+    }
+    const ammChanges = (0, index_1.parseAmmChanges)(tx.meta);
+    return ammChanges ? (0, common_1.removeUndefined)(ammChanges) : undefined;
+}
+function getDIDChanges(tx) {
+    if (!DID_TYPES.includes(tx.TransactionType)) {
+        return undefined;
+    }
+    const didChanges = (0, index_1.parseDIDChanges)(tx.meta);
+    return didChanges ? (0, common_1.removeUndefined)(didChanges) : undefined;
+}
+function getOracleChanges(tx) {
+    if (!ORACLE_TYPES.includes(tx.TransactionType)) {
+        return undefined;
+    }
+    const oracleChanges = (0, index_1.parseOracleChanges)(tx.meta);
+    return oracleChanges ? (0, common_1.removeUndefined)(oracleChanges) : undefined;
+}
+function getUNLReportChanges(tx, nativeCurrency) {
+    if (nativeCurrency !== common_1.XAHAU_NATIVE_CURRENCY) {
+        return undefined;
+    }
+    if (!UNL_REPORT_TYPES.includes(tx.TransactionType)) {
+        return undefined;
+    }
+    return (0, index_1.parseUNLReportChanges)(tx);
+}
+function getMPTokenChanges(tx, nativeCurrency) {
+    if (nativeCurrency !== common_1.MAINNET_NATIVE_CURRENCY) {
+        return undefined;
+    }
+    if (!MPTOKEN_TYPES.includes(tx.TransactionType)) {
+        return undefined;
+    }
+    const mptokenChanges = (0, index_1.parseMPTokenChanges)(tx);
+    return Object.keys(mptokenChanges).length > 0 ? mptokenChanges : undefined;
+}
+function getMPTokenIssuanceChanges(tx, nativeCurrency) {
+    if (nativeCurrency !== common_1.MAINNET_NATIVE_CURRENCY) {
+        return undefined;
+    }
+    const mptokenIssuanceChanges = (0, index_1.parseMPTokenIssuanceChanges)(tx);
+    return Object.keys(mptokenIssuanceChanges).length > 0 ? mptokenIssuanceChanges : undefined;
+}
+function getCredentialChanges(tx, nativeCurrency) {
+    if (nativeCurrency !== common_1.MAINNET_NATIVE_CURRENCY) {
+        return undefined;
+    }
+    if (!CREDENTIAL_TYPES.includes(tx.TransactionType)) {
+        return undefined;
+    }
+    return (0, index_1.parseCredentialChanges)(tx.meta);
+}
+function getDelegateChanges(tx, nativeCurrency) {
+    if (nativeCurrency !== common_1.MAINNET_NATIVE_CURRENCY) {
+        return undefined;
+    }
+    if (!DELEGATE_TYPES.includes(tx.TransactionType)) {
+        return undefined;
+    }
+    return (0, index_1.parseDelegateChanges)(tx.meta);
+}
+function getRemarksChanges(tx, nativeCurrency) {
+    if (nativeCurrency !== common_1.XAHAU_NATIVE_CURRENCY) {
+        return undefined;
+    }
+    if (!REMARKS_TYPES.includes(tx.TransactionType)) {
+        return undefined;
+    }
+    return (0, index_1.parseRemarksChanges)(tx);
+}
+function getCronChanges(tx, nativeCurrency) {
+    if (nativeCurrency !== common_1.XAHAU_NATIVE_CURRENCY) {
+        return undefined;
+    }
+    if (!CRON_TYPES.includes(tx.TransactionType)) {
+        return undefined;
+    }
+    return (0, index_1.parseCronChanges)(tx);
+}

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

@@ -0,0 +1,4 @@
+import { AccountDelete } from "xrpl";
+import { FormattedAccountDeleteSpecification } from "../../types/account";
+declare function parseAccountDelete(tx: AccountDelete, nativeCurrency?: string): FormattedAccountDeleteSpecification;
+export default parseAccountDelete;