@bithomp/xrpl-api 3.7.31 → 3.7.37

package/lib/src/parse/mptoken_normalize.js

@@ -0,0 +1,215 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeMPTokensPreviousFields = normalizeMPTokensPreviousFields;
+exports.normalizeMPTokensPreviousFieldsEscrowCreate = normalizeMPTokensPreviousFieldsEscrowCreate;
+exports.normalizeMPTokensPreviousFieldsEscrowFinish = normalizeMPTokensPreviousFieldsEscrowFinish;
+exports.normalizeMPTokensPreviousFieldsEscrowCancel = normalizeMPTokensPreviousFieldsEscrowCancel;
+exports.normalizeMPTokensPreviousFieldsTransfer = normalizeMPTokensPreviousFieldsTransfer;
+const TRANSFER_TRANSACTION_TYPES = ["Payment", "CheckCash", "EscrowFinish", "Clawback", "AMMClawback"];
+function normalizeMPTokensPreviousFields(meta, tx) {
+    if (meta.TransactionResult !== "tesSUCCESS") {
+        return;
+    }
+    if (tx.TransactionType === "EscrowCreate") {
+        normalizeMPTokensPreviousFieldsEscrowCreate(meta);
+    }
+    else if (tx.TransactionType === "EscrowFinish") {
+        normalizeMPTokensPreviousFieldsEscrowFinish(meta);
+    }
+    else if (tx.TransactionType === "EscrowCancel") {
+        normalizeMPTokensPreviousFieldsEscrowCancel(meta);
+    }
+    else if (TRANSFER_TRANSACTION_TYPES.includes(tx.TransactionType)) {
+        normalizeMPTokensPreviousFieldsTransfer(meta, tx);
+    }
+}
+function normalizeMPTokensPreviousFieldsEscrowCreate(meta) {
+    const escrowNode = meta.AffectedNodes.find((node) => {
+        const createdNode = node.CreatedNode;
+        return createdNode && createdNode.LedgerEntryType === "Escrow";
+    });
+    if (!escrowNode) {
+        return;
+    }
+    const escrowFields = escrowNode.CreatedNode.NewFields;
+    const mptokenIssuanceID = escrowFields?.Amount?.mpt_issuance_id;
+    if (!mptokenIssuanceID) {
+        return;
+    }
+    const mptIssuanceNode = meta.AffectedNodes.find((node) => {
+        const modifiedNode = node.ModifiedNode;
+        return modifiedNode && modifiedNode.LedgerEntryType === "MPTokenIssuance";
+    });
+    if (mptIssuanceNode) {
+        const prevFields = mptIssuanceNode.ModifiedNode.PreviousFields;
+        if (prevFields && prevFields.LockedAmount === undefined) {
+            if (prevFields.LockedAmount === undefined) {
+                prevFields.LockedAmount = "0";
+            }
+        }
+    }
+    const mptokenNode = meta.AffectedNodes.find((node) => {
+        const modifiedNode = node.ModifiedNode;
+        return (modifiedNode &&
+            modifiedNode.LedgerEntryType === "MPToken" &&
+            modifiedNode.FinalFields.Account === escrowFields.Account &&
+            modifiedNode.FinalFields.MPTokenIssuanceID === mptokenIssuanceID);
+    });
+    if (mptokenNode) {
+        const finalFields = mptokenNode.ModifiedNode.FinalFields;
+        const prevFields = mptokenNode.ModifiedNode.PreviousFields;
+        if (prevFields && prevFields.LockedAmount === undefined) {
+            if (finalFields.Amount === undefined) {
+                finalFields.Amount = "0";
+            }
+            if (prevFields.LockedAmount === undefined) {
+                prevFields.LockedAmount = "0";
+            }
+        }
+    }
+}
+function normalizeMPTokensPreviousFieldsEscrowFinish(meta) {
+    const escrowNode = meta.AffectedNodes.find((node) => {
+        const deletedNode = node.DeletedNode;
+        return deletedNode && deletedNode.LedgerEntryType === "Escrow";
+    });
+    if (!escrowNode) {
+        return;
+    }
+    const escrowFields = escrowNode.DeletedNode.FinalFields;
+    const mptokenIssuanceID = escrowFields?.Amount?.mpt_issuance_id;
+    if (!mptokenIssuanceID) {
+        return;
+    }
+    const value = escrowFields?.Amount?.value ?? "0";
+    if (escrowFields.Account === escrowFields.Destination) {
+        const mptokenNode = meta.AffectedNodes.find((node) => {
+            const modifiedNode = node.ModifiedNode;
+            return (modifiedNode &&
+                modifiedNode.LedgerEntryType === "MPToken" &&
+                modifiedNode.FinalFields.Account === escrowFields.Account &&
+                modifiedNode.FinalFields.MPTokenIssuanceID === mptokenIssuanceID);
+        });
+        if (mptokenNode) {
+            const finalFields = mptokenNode.ModifiedNode.FinalFields;
+            const prevFields = mptokenNode.ModifiedNode.PreviousFields;
+            if (prevFields) {
+                if (finalFields.LockedAmount === undefined) {
+                    finalFields.LockedAmount = "0";
+                }
+                if (prevFields.MPTAmount === undefined) {
+                    prevFields.MPTAmount = "0";
+                }
+            }
+        }
+        return;
+    }
+    const mptokenSourceNode = meta.AffectedNodes.find((node) => {
+        const modifiedNode = node.ModifiedNode;
+        return (modifiedNode &&
+            modifiedNode.LedgerEntryType === "MPToken" &&
+            modifiedNode.FinalFields.Account === escrowFields.Account &&
+            modifiedNode.FinalFields.MPTokenIssuanceID === mptokenIssuanceID);
+    });
+    if (mptokenSourceNode) {
+        const finalFields = mptokenSourceNode.ModifiedNode.FinalFields;
+        const prevFields = mptokenSourceNode.ModifiedNode.PreviousFields;
+        if (prevFields && prevFields.MPTAmount === undefined) {
+            if (finalFields.MPTAmount === undefined) {
+                finalFields.MPTAmount = "0";
+            }
+            if (finalFields.LockedAmount === undefined) {
+                finalFields.LockedAmount = "0";
+            }
+            if (prevFields.LockedAmount === undefined) {
+                prevFields.LockedAmount = value;
+            }
+        }
+    }
+    const mptokenDestNode = meta.AffectedNodes.find((node) => {
+        const modifiedNode = node.ModifiedNode;
+        return (modifiedNode &&
+            modifiedNode.LedgerEntryType === "MPToken" &&
+            modifiedNode.FinalFields.Account === escrowFields.Destination &&
+            modifiedNode.FinalFields.MPTokenIssuanceID === mptokenIssuanceID);
+    });
+    if (mptokenDestNode) {
+        const prevFields = mptokenDestNode.ModifiedNode.PreviousFields;
+        if (prevFields && prevFields.LockedAmount === undefined) {
+            if (prevFields.MPTAmount === undefined) {
+                prevFields.MPTAmount = "0";
+            }
+        }
+    }
+}
+function normalizeMPTokensPreviousFieldsEscrowCancel(meta) {
+    const escrowNode = meta.AffectedNodes.find((node) => {
+        const deletedNode = node.DeletedNode;
+        return deletedNode && deletedNode.LedgerEntryType === "Escrow";
+    });
+    if (!escrowNode) {
+        return;
+    }
+    const escrowFields = escrowNode.DeletedNode.FinalFields;
+    const mptokenIssuanceID = escrowFields?.Amount?.mpt_issuance_id;
+    if (!mptokenIssuanceID) {
+        return;
+    }
+    const mptokenNode = meta.AffectedNodes.find((node) => {
+        const modifiedNode = node.ModifiedNode;
+        return (modifiedNode &&
+            modifiedNode.LedgerEntryType === "MPToken" &&
+            modifiedNode.FinalFields.Account === escrowFields.Account &&
+            modifiedNode.FinalFields.MPTokenIssuanceID === mptokenIssuanceID);
+    });
+    if (mptokenNode) {
+        const finalFields = mptokenNode.ModifiedNode.FinalFields;
+        const prevFields = mptokenNode.ModifiedNode.PreviousFields;
+        if (prevFields) {
+            if (finalFields.LockedAmount === undefined) {
+                finalFields.LockedAmount = "0";
+            }
+            if (prevFields.MPTAmount === undefined) {
+                prevFields.MPTAmount = "0";
+            }
+        }
+    }
+}
+function normalizeMPTokensPreviousFieldsTransfer(meta, tx) {
+    if (tx.Destination === undefined) {
+        return;
+    }
+    let amount = null;
+    if (typeof tx.Amount === "object") {
+        amount = tx.Amount;
+    }
+    else if (typeof tx.SendMax === "object") {
+        amount = tx.SendMax;
+    }
+    else if (typeof tx.DeliverMax === "object") {
+        amount = tx.DeliverMax;
+    }
+    if (!amount) {
+        return;
+    }
+    const mptokenIssuanceID = amount.mpt_issuance_id;
+    const destination = tx.Destination;
+    if (!mptokenIssuanceID || !destination) {
+        return;
+    }
+    const mptokenNode = meta.AffectedNodes.find((node) => {
+        const modifiedNode = node.ModifiedNode;
+        return (modifiedNode &&
+            modifiedNode.LedgerEntryType === "MPToken" &&
+            modifiedNode.FinalFields.Account === destination &&
+            modifiedNode.FinalFields.MPTokenIssuanceID === mptokenIssuanceID);
+    });
+    if (mptokenNode) {
+        const prevFields = mptokenNode.ModifiedNode.PreviousFields;
+        if (prevFields && prevFields.LockedAmount === undefined) {
+            if (prevFields.MPTAmount === undefined) {
+                prevFields.MPTAmount = "0";
+            }
+        }
+    }
+}

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

@@ -0,0 +1,4 @@
+import { TransactionMetadata } from "xrpl";
+import { AccountRootFlagsKeysInterface } from "../../models/account_info";
+declare function parseAccountSettingChanges(metadata: TransactionMetadata): AccountRootFlagsKeysInterface | undefined;
+export { parseAccountSettingChanges };

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

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAccountSettingChanges = parseAccountSettingChanges;
+const lodash_1 = __importDefault(require("lodash"));
+const account_info_1 = require("../../models/account_info");
+const account_fields_1 = require("../ledger/account-fields");
+function summarizeSetting(modifiedNode) {
+    const settings = {};
+    const oldFlags = lodash_1.default.get(modifiedNode.PreviousFields, "Flags");
+    const newFlags = lodash_1.default.get(modifiedNode.FinalFields, "Flags");
+    if (oldFlags != null && newFlags != null) {
+        const changedFlags = oldFlags ^ newFlags;
+        const setFlags = newFlags & changedFlags;
+        const clearedFlags = oldFlags & changedFlags;
+        Object.entries((0, account_info_1.getAccountRootFlagsKeys)()).forEach((entry) => {
+            const [flagName, flagValue] = entry;
+            if (setFlags & flagValue) {
+                settings[flagName] = true;
+            }
+            else if (clearedFlags & flagValue) {
+                settings[flagName] = false;
+            }
+        });
+    }
+    const oldAccountTxnIDField = lodash_1.default.get(modifiedNode.PreviousFields, "AccountTxnID");
+    const newAccountTxnIDField = lodash_1.default.get(modifiedNode.FinalFields, "AccountTxnID");
+    if (newAccountTxnIDField && !oldAccountTxnIDField) {
+        settings.enableTransactionIDTracking = true;
+    }
+    else if (oldAccountTxnIDField && !newAccountTxnIDField) {
+        settings.enableTransactionIDTracking = false;
+    }
+    for (const fieldName in account_info_1.AccountFields) {
+        const oldFieldValue = lodash_1.default.get(modifiedNode.PreviousFields, fieldName);
+        const newFieldValue = lodash_1.default.get(modifiedNode.FinalFields, fieldName);
+        if (oldFieldValue !== undefined && newFieldValue !== undefined && oldFieldValue !== newFieldValue) {
+            const info = account_info_1.AccountFields[fieldName];
+            settings[info.name] = (0, account_fields_1.parseField)(info, newFieldValue);
+        }
+        else if (oldFieldValue !== undefined && newFieldValue === undefined) {
+            const info = account_info_1.AccountFields[fieldName];
+            settings[info.name] = null;
+        }
+    }
+    return settings;
+}
+function parseAccountSettingChanges(metadata) {
+    const affectedNodes = metadata.AffectedNodes.filter((affectedNode) => {
+        if (!affectedNode.ModifiedNode) {
+            return false;
+        }
+        const node = affectedNode.ModifiedNode;
+        return node.LedgerEntryType === "AccountRoot";
+    });
+    if (affectedNodes.length !== 1) {
+        return undefined;
+    }
+    const modifiedNode = affectedNodes[0].ModifiedNode;
+    const settings = summarizeSetting(modifiedNode);
+    if (Object.keys(settings).length === 0) {
+        return undefined;
+    }
+    return settings;
+}

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

@@ -0,0 +1,7 @@
+interface AffectedObjectsInterface {
+    nftokens?: any;
+    nftokenOffers?: any;
+    uritokens?: any;
+}
+declare function parseAffectedObjects(tx: any): AffectedObjectsInterface | undefined;
+export { parseAffectedObjects };

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

@@ -0,0 +1,147 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAffectedObjects = parseAffectedObjects;
+const nftoken_changes_1 = require("./nftoken_changes");
+const nftoken_offer_changes_1 = require("./nftoken_offer_changes");
+const account_nfts_1 = require("../../models/account_nfts");
+const nftoken_flags_1 = __importDefault(require("../ledger/nftoken-flags"));
+const nftoken_offer_flags_1 = __importDefault(require("../ledger/nftoken-offer-flags"));
+const uritoken_flags_1 = __importDefault(require("../ledger/uritoken-flags"));
+const common_1 = require("../../common");
+function parseAffectedObjects(tx) {
+    return new AffectedObjects(tx).call();
+}
+class AffectedObjects {
+    constructor(tx) {
+        this.tx = tx;
+        this.affectedObjects = {};
+        this.nftChanges = undefined;
+        this.nftOfferChanges = undefined;
+    }
+    call() {
+        this.parseNFTokens();
+        this.parseNFTokenOffers();
+        this.parseURITokenChanges();
+        if (Object.keys(this.affectedObjects).length > 0) {
+            return this.affectedObjects;
+        }
+        return undefined;
+    }
+    getNFTokenChanges() {
+        if (this.nftChanges) {
+            return this.nftChanges;
+        }
+        this.nftChanges = (0, nftoken_changes_1.parseNFTokenChanges)(this.tx);
+        return this.nftChanges;
+    }
+    getNFTokenOfferChanges() {
+        if (this.nftOfferChanges) {
+            return this.nftOfferChanges;
+        }
+        this.nftOfferChanges = (0, nftoken_offer_changes_1.parseNFTokenOfferChanges)(this.tx);
+        return this.nftOfferChanges;
+    }
+    parseNFTokens() {
+        const nftokens = {};
+        const nftokenChanges = this.getNFTokenChanges();
+        for (const account in nftokenChanges) {
+            for (const nftsChange of nftokenChanges[account]) {
+                if (nftokens[nftsChange.nftokenID]) {
+                    continue;
+                }
+                const nftokenIDInfo = (0, account_nfts_1.parseNFTokenID)(nftsChange.nftokenID);
+                if (nftokenIDInfo) {
+                    nftokens[nftsChange.nftokenID] = {
+                        nftokenID: nftsChange.nftokenID,
+                        flags: (0, nftoken_flags_1.default)(nftokenIDInfo.Flags),
+                        transferFee: nftokenIDInfo.TransferFee,
+                        issuer: nftokenIDInfo.Issuer,
+                        nftokenTaxon: nftokenIDInfo.NFTokenTaxon,
+                        sequence: nftokenIDInfo.Sequence,
+                    };
+                }
+            }
+        }
+        const nftokenOfferChanges = this.getNFTokenOfferChanges();
+        for (const account in nftokenOfferChanges) {
+            for (const nftokenOfferChange of nftokenOfferChanges[account]) {
+                if (nftokens[nftokenOfferChange.nftokenID]) {
+                    continue;
+                }
+                const nftokenIDInfo = (0, account_nfts_1.parseNFTokenID)(nftokenOfferChange.nftokenID);
+                if (nftokenIDInfo) {
+                    nftokens[nftokenOfferChange.nftokenID] = {
+                        nftokenID: nftokenOfferChange.nftokenID,
+                        flags: (0, nftoken_flags_1.default)(nftokenIDInfo.Flags),
+                        transferFee: nftokenIDInfo.TransferFee,
+                        issuer: nftokenIDInfo.Issuer,
+                        nftokenTaxon: nftokenIDInfo.NFTokenTaxon,
+                        sequence: nftokenIDInfo.Sequence,
+                    };
+                }
+            }
+        }
+        if (Object.keys(nftokens).length > 0) {
+            this.affectedObjects.nftokens = nftokens;
+        }
+    }
+    parseNFTokenOffers() {
+        const nftokenOffers = {};
+        const nftokenOfferChanges = this.getNFTokenOfferChanges();
+        for (const account in nftokenOfferChanges) {
+            for (const nftokenOfferChange of nftokenOfferChanges[account]) {
+                if (nftokenOffers[nftokenOfferChange.index]) {
+                    continue;
+                }
+                nftokenOffers[nftokenOfferChange.index] = {
+                    index: nftokenOfferChange.index,
+                    nftokenID: nftokenOfferChange.nftokenID,
+                    flags: (0, nftoken_offer_flags_1.default)(nftokenOfferChange.flags),
+                    owner: nftokenOfferChange.owner,
+                };
+            }
+        }
+        if (Object.keys(nftokenOffers).length > 0) {
+            this.affectedObjects.nftokenOffers = nftokenOffers;
+        }
+    }
+    parseURITokenChanges() {
+        const uritokens = {};
+        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) {
+                    uritokens[uritokenID] = (0, common_1.removeUndefined)({
+                        uritokenID,
+                        flags: (0, uritoken_flags_1.default)(node.NewFields.Flags),
+                        uri: node.NewFields.URI,
+                        digest: node.NewFields.Digest,
+                        issuer: node.NewFields.Issuer,
+                        owner: node.NewFields.Owner,
+                        amount: node.NewFields.Amount,
+                        destination: node.NewFields.Destination,
+                    });
+                }
+                if (affectedNode.ModifiedNode || affectedNode.DeletedNode) {
+                    uritokens[uritokenID] = (0, common_1.removeUndefined)({
+                        uritokenID,
+                        flags: (0, uritoken_flags_1.default)(node.FinalFields.Flags),
+                        uri: node.FinalFields.URI,
+                        digest: node.FinalFields.Digest,
+                        issuer: node.FinalFields.Issuer,
+                        owner: node.FinalFields.Owner,
+                        amount: node.FinalFields.Amount,
+                        destination: node.FinalFields.Destination,
+                    });
+                }
+            }
+        }
+        if (Object.keys(uritokens).length > 0) {
+            this.affectedObjects.uritokens = uritokens;
+        }
+    }
+}

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

@@ -0,0 +1,8 @@
+type AmendmentStatus = "majority" | "enabled" | "lostMajority" | "obsolete";
+interface FormattedAmendmentSummaryInterface {
+    status?: AmendmentStatus;
+    amendment?: string;
+    closeTime?: number;
+}
+declare function parseAmendmentChanges(tx: any): FormattedAmendmentSummaryInterface | undefined;
+export { parseAmendmentChanges };

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

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAmendmentChanges = parseAmendmentChanges;
+const utils_1 = require("../utils");
+const ledger_1 = require("../../models/ledger");
+function parseAmendmentStatus(tx, node) {
+    const amendment = tx.Amendment;
+    const final = node.diffType === "CreatedNode" ? node.newFields : node.finalFields;
+    const prev = node.previousFields;
+    const amendments = final.Amendments || [];
+    const majority = final.Majorities || [];
+    if (amendments.includes(amendment)) {
+        return "enabled";
+    }
+    for (const maj of majority) {
+        if (maj.Majority.Amendment === amendment) {
+            return "majority";
+        }
+    }
+    if (prev && prev.Majorities) {
+        const prevMajority = prev.Majorities;
+        for (const maj of prevMajority) {
+            if (maj.Majority.Amendment === amendment) {
+                return "lostMajority";
+            }
+        }
+    }
+    if (node.diffType === "DeletedNode") {
+        const prevFinal = node.finalFields;
+        const prevAmendments = prevFinal.Amendments || [];
+        if (!prevAmendments.includes(amendment)) {
+            return "obsolete";
+        }
+    }
+    return undefined;
+}
+function summarizeAmendment(tx, node) {
+    const summary = {
+        amendment: tx.Amendment,
+        status: parseAmendmentStatus(tx, node),
+    };
+    if (summary.status === "majority") {
+        const final = node.diffType === "CreatedNode" ? node.newFields : node.finalFields;
+        const majority = final.Majorities || [];
+        for (const maj of majority) {
+            if (maj.Majority.Amendment === tx.Amendment) {
+                if (maj.Majority.CloseTime) {
+                    summary.closeTime = (0, ledger_1.ledgerTimeToTimestamp)(maj.Majority.CloseTime);
+                }
+                break;
+            }
+        }
+    }
+    else if (summary.status === "lostMajority") {
+        const prev = node.previousFields;
+        if (prev && prev.Majorities) {
+            const prevMajority = prev.Majorities;
+            for (const maj of prevMajority) {
+                if (maj.Majority.Amendment === tx.Amendment) {
+                    if (maj.Majority.CloseTime) {
+                        summary.closeTime = (0, ledger_1.ledgerTimeToTimestamp)(maj.Majority.CloseTime);
+                    }
+                    break;
+                }
+            }
+        }
+    }
+    return summary;
+}
+function parseAmendmentChanges(tx) {
+    const amendment = tx.Amendment;
+    if (!amendment) {
+        return undefined;
+    }
+    const affectedNodes = tx.meta.AffectedNodes.filter((affectedNode) => {
+        const node = affectedNode.CreatedNode || affectedNode.ModifiedNode || affectedNode.DeletedNode;
+        return node.LedgerEntryType === "Amendments";
+    });
+    if (affectedNodes.length !== 1) {
+        return undefined;
+    }
+    const normalizedNode = (0, utils_1.normalizeNode)(affectedNodes[0]);
+    return summarizeAmendment(tx, normalizedNode);
+}

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

@@ -0,0 +1,52 @@
+import { TransactionMetadata } from "xrpl";
+import { FormattedIssuedCurrency, FormattedAmount } from "../../types";
+interface FormattedAuctionSlot {
+    account: string;
+    authAccounts?: string[];
+    discountedFee?: number;
+    expiration?: number;
+    price?: FormattedAmount;
+    timeInterval?: number;
+}
+interface FormattedVoteSlot {
+    account: string;
+    tradingFee?: number;
+    voteWeight?: number;
+}
+interface FormattedAmmSummaryInterface {
+    status?: "created" | "modified" | "deleted";
+    ammID?: string;
+    account?: string;
+    asset?: FormattedIssuedCurrency;
+    asset2?: FormattedIssuedCurrency;
+    auctionSlot: FormattedAuctionSlot;
+    lpTokenBalance: FormattedAmount;
+    tradingFee: number;
+    ownerNode: string;
+    voteSlots: FormattedVoteSlot[];
+    lpTokenBalanceChange?: FormattedAmount;
+    tradingFeeChanges?: number;
+    voteSlotsChanges?: FormattedAmmVoteSlotChanges[];
+    auctionSlotChanges?: FormattedAuctionSlotChanges;
+}
+interface FormattedAuctionSlotChanges {
+    accountChanges?: string;
+    authAccountsChanges?: {
+        status: string;
+        account: string;
+    }[];
+    discountedFeeChange?: number;
+    expirationChange?: number;
+    priceChange?: FormattedAmount;
+    timeIntervalChange?: number;
+}
+interface FormattedAmmVoteSlotChanges {
+    status: "added" | "modified" | "removed";
+    account: string;
+    tradingFee?: number;
+    voteWeight?: number;
+    tradingFeeChange?: number;
+    voteWeightChange?: number;
+}
+declare function parseAmmChanges(metadata: TransactionMetadata): FormattedAmmSummaryInterface | undefined;
+export { parseAmmChanges };