@bithomp/xrpl-api 3.3.10 → 3.4.1

package/lib/ledger/account_tx.d.ts

@@ -26,4 +26,12 @@ export interface FindTransactionsOptions extends GetTransactionsOptions {
     legacy?: boolean;
     formatted?: boolean;
 }
+interface FindTransactionsResponse {
+    account: string;
+    transactions: any[];
+    marker?: any;
+    validated?: boolean;
+}
+export declare function findTransactionsExt(account: string, options?: FindTransactionsOptions): Promise<FindTransactionsResponse | ErrorResponse>;
 export declare function findTransactions(account: string, options?: FindTransactionsOptions): Promise<object[] | ErrorResponse>;
+export {};

package/lib/ledger/account_tx.js

@@ -37,6 +37,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getTransactions = getTransactions;
+exports.findTransactionsExt = findTransactionsExt;
 exports.findTransactions = findTransactions;
 const lodash_1 = __importDefault(require("lodash"));
 const xrpl_1 = require("xrpl");
@@ -76,7 +77,7 @@ async function getTransactions(account, options = { limit: DEFAULT_LIMIT }) {
         };
     }
     if (response.error) {
-        const { error, error_code, error_message, error_exception, status, validated } = response;
+        const { error, error_code, error_message, error_exception, status, validated, warnings } = response;
         return (0, utils_1.removeUndefined)({
             account,
             error,
@@ -85,15 +86,17 @@ async function getTransactions(account, options = { limit: DEFAULT_LIMIT }) {
             error_exception,
             status,
             validated,
+            warnings,
         });
     }
     const result = response?.result;
     if (!result) {
-        return {
+        return (0, utils_1.removeUndefined)({
             account,
             status: "error",
             error: "invalidResponse",
-        };
+            warnings: response.warnings,
+        });
     }
     if (Array.isArray(result.transactions)) {
         if (options.balanceChanges === true || options.specification === true) {
@@ -112,13 +115,27 @@ async function getTransactions(account, options = { limit: DEFAULT_LIMIT }) {
             }
         }
     }
+    if (Array.isArray(result.transactions)) {
+        for (const transaction of result.transactions) {
+            const tx = transaction.tx || transaction;
+            if (!tx.hasOwnProperty("ctid")) {
+                const ctid = (0, transaction_1.encodeCTIDforTransaction)(transaction, connection.getNetworkID());
+                if (ctid) {
+                    tx.ctid = ctid;
+                }
+            }
+        }
+    }
     const newMarker = (0, utils_1.createMarker)(connection.hash, result.marker);
     if (newMarker) {
         result.marker = newMarker;
     }
+    if (response.warnings && response.warnings.length > 0) {
+        result.warnings = response.warnings;
+    }
     return result;
 }
-async function findTransactions(account, options = { limit: DEFAULT_LIMIT, timeout: 15000 }) {
+async function findTransactionsExt(account, options = { limit: DEFAULT_LIMIT, timeout: 15000 }) {
     let transactions = [];
     let accountTransactionsError = null;
     const timeStart = new Date();
@@ -134,6 +151,9 @@ async function findTransactions(account, options = { limit: DEFAULT_LIMIT, timeo
     if (loadOptions.sourceTag || loadOptions.destinationTag) {
         getTransactionsLimit += LIMIT_INCREASE_COUNT;
     }
+    if (loadOptions.types) {
+        getTransactionsLimit += LIMIT_INCREASE_COUNT;
+    }
     if (getTransactionsLimit > MAX_LIMIT) {
         getTransactionsLimit = MAX_LIMIT;
     }
@@ -182,8 +202,26 @@ async function findTransactions(account, options = { limit: DEFAULT_LIMIT, timeo
             }
         }
         if (newTransactions.length > 0) {
+            const transactionsToTake = loadOptions.limit - transactions.length;
+            if (transactionsToTake !== newTransactions.length) {
+                const isClio = accountTransactions.warnings?.some((w) => w.id === 2001);
+                let markerTransaction = null;
+                if (isClio) {
+                    markerTransaction = newTransactions[transactionsToTake - 1];
+                }
+                else {
+                    markerTransaction = newTransactions[transactionsToTake];
+                }
+                if (markerTransaction) {
+                    loadOptions.marker = {
+                        ledger: markerTransaction.tx.ledger_index,
+                        seq: markerTransaction.meta.TransactionIndex,
+                        bithompHash: loadOptions.marker.bithompHash,
+                    };
+                }
+            }
+            newTransactions = newTransactions.slice(0, transactionsToTake);
             transactions = transactions.concat(newTransactions);
-            transactions = transactions.slice(0, loadOptions.limit);
         }
         if (loadOptions.marker === undefined) {
             break;
@@ -202,7 +240,19 @@ async function findTransactions(account, options = { limit: DEFAULT_LIMIT, timeo
     if (formatted === true) {
         transactions = transactions.map((transaction) => (0, transaction_1.getAccountTxDetails)(transaction, loadOptions.includeRawTransactions === true));
     }
-    return transactions;
+    return {
+        account,
+        transactions,
+        marker: loadOptions.marker,
+        validated: true,
+    };
+}
+async function findTransactions(account, options = { limit: DEFAULT_LIMIT, timeout: 15000 }) {
+    const result = await findTransactionsExt(account, options);
+    if (result.error) {
+        return result;
+    }
+    return result.transactions || [];
 }
 function applyLimitOptions(options) {
     if (options.sourceTag > 0 || options.destinationTag > 0) {

package/lib/ledger/transaction.js

@@ -102,6 +102,15 @@ async function getTransaction(transaction, options = {}) {
             }
         }
     }
+    if (!result.hasOwnProperty("ctid")) {
+        const ctid = (0, transaction_1.encodeCTIDforTransaction)(result, connection.getNetworkID());
+        if (ctid) {
+            result.ctid = ctid;
+        }
+    }
+    if (result.hasOwnProperty("tx_json") && result.tx_json.hasOwnProperty("ctid")) {
+        delete result.tx_json.ctid;
+    }
     return result;
 }
 async function getTransactionByCTID(ctid, options = {}) {

package/lib/models/transaction.d.ts

@@ -41,6 +41,7 @@ export declare function accountTxToTx(accountTx: AccountTransaction): Transactio
 export declare function ledgerTxToTx(ledgerTx: LedgerTransaction, ledgerIndex: number, closeTime: number): TransactionResponse;
 export declare function streamTxToTx(streamTx: StreamTransaction): TransactionResponse;
 export declare function isCTID(ctid: string | bigint): boolean;
+export declare function encodeCTIDforTransaction(transaction: TransactionResponse, networkID: number): string | undefined;
 export declare function encodeCTID(ledgerIndex: number, txIndex: number, networkID: number): string;
 export interface DecodeCTIDInterface {
     ledgerIndex: number;

package/lib/models/transaction.js

@@ -11,6 +11,7 @@ exports.accountTxToTx = accountTxToTx;
 exports.ledgerTxToTx = ledgerTxToTx;
 exports.streamTxToTx = streamTxToTx;
 exports.isCTID = isCTID;
+exports.encodeCTIDforTransaction = encodeCTIDforTransaction;
 exports.encodeCTID = encodeCTID;
 exports.decodeCTID = decodeCTID;
 const lodash_1 = __importDefault(require("lodash"));
@@ -66,6 +67,29 @@ function isCTID(ctid) {
     }
     return true;
 }
+function encodeCTIDforTransaction(transaction, networkID) {
+    let ledgerIndex;
+    if (transaction.ledger_index) {
+        ledgerIndex = transaction.ledger_index;
+    }
+    else if (transaction.tx && transaction.tx.ledger_index) {
+        ledgerIndex = transaction.tx.ledger_index;
+    }
+    else if (transaction.tx_json && transaction.tx_json.ledger_index) {
+        ledgerIndex = transaction.tx_json.ledger_index;
+    }
+    if (typeof ledgerIndex !== "number") {
+        return undefined;
+    }
+    const meta = (transaction.meta || transaction.metaData);
+    if (!meta || !meta.TransactionIndex) {
+        return undefined;
+    }
+    if (typeof networkID !== "number") {
+        return undefined;
+    }
+    return encodeCTID(ledgerIndex, meta.TransactionIndex, networkID);
+}
 function encodeCTID(ledgerIndex, txIndex, networkID) {
     if (typeof ledgerIndex !== "number") {
         throw new Error("ledgerIndex must be a number.");

package/lib/models/transactions/SetRemarks.d.ts

@@ -0,0 +1,3 @@
+export declare const enum SetRemarksFlags {
+    tfImmutable = 1
+}

package/lib/models/transactions/SetRemarks.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/parse/ledger/delegate.d.ts

@@ -0,0 +1,2 @@
+import { FormattedSignerRegularKey } from "../../types/account";
+export declare function parseDelegate(tx: any): FormattedSignerRegularKey | undefined;

package/lib/parse/ledger/delegate.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDelegate = parseDelegate;
+const common_1 = require("../../common");
+function parseDelegate(tx) {
+    if (tx && tx.Delegate) {
+        return (0, common_1.removeUndefined)({
+            address: tx.Delegate,
+        });
+    }
+}

package/lib/parse/ledger/index.d.ts

@@ -1,5 +1,6 @@
 import parseAmount from "./amount";
 import { parseMemos } from "./memos";
+import { parseRemarks, REMARKS_SUPPORTED_ENTRIES } from "./remarks";
 export * from "./account";
 export * from "../utils";
-export { parseAmount, parseMemos };
+export { parseAmount, parseMemos, parseRemarks, REMARKS_SUPPORTED_ENTRIES };

package/lib/parse/ledger/index.js

@@ -17,10 +17,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseMemos = exports.parseAmount = void 0;
+exports.REMARKS_SUPPORTED_ENTRIES = exports.parseRemarks = exports.parseMemos = exports.parseAmount = void 0;
 const amount_1 = __importDefault(require("./amount"));
 exports.parseAmount = amount_1.default;
 const memos_1 = require("./memos");
 Object.defineProperty(exports, "parseMemos", { enumerable: true, get: function () { return memos_1.parseMemos; } });
+const remarks_1 = require("./remarks");
+Object.defineProperty(exports, "parseRemarks", { enumerable: true, get: function () { return remarks_1.parseRemarks; } });
+Object.defineProperty(exports, "REMARKS_SUPPORTED_ENTRIES", { enumerable: true, get: function () { return remarks_1.REMARKS_SUPPORTED_ENTRIES; } });
 __exportStar(require("./account"), exports);
 __exportStar(require("../utils"), exports);

package/lib/parse/ledger/permissions.d.ts

@@ -0,0 +1,2 @@
+import { Permission } from "xrpl";
+export declare function parsePermissions(permissions: Permission[]): string[];

package/lib/parse/ledger/permissions.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePermissions = parsePermissions;
+function parsePermissions(permissions) {
+    if (!permissions) {
+        return [];
+    }
+    return permissions.map((perm) => perm.Permission.PermissionValue).sort();
+}

package/lib/parse/ledger/remark-flags.d.ts

@@ -0,0 +1,5 @@
+import { RemarksFlagsKeysInterface } from "../../types/remarks";
+declare function parseRemarkFlags(value: number, options?: {
+    excludeFalse?: boolean;
+}): RemarksFlagsKeysInterface;
+export default parseRemarkFlags;

package/lib/parse/ledger/remark-flags.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const remarks_1 = require("../../types/remarks");
+const flags_1 = require("./flags");
+function parseRemarkFlags(value, options = {}) {
+    return (0, flags_1.parseFlags)(value, remarks_1.RemarksFlagsKeys, options);
+}
+exports.default = parseRemarkFlags;

package/lib/parse/ledger/remarks.d.ts

@@ -0,0 +1,3 @@
+import { FormattedRemark, Remark } from "../../types";
+export declare const REMARKS_SUPPORTED_ENTRIES: string[];
+export declare function parseRemarks(remarks: Remark[]): FormattedRemark[];

package/lib/parse/ledger/remarks.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REMARKS_SUPPORTED_ENTRIES = void 0;
+exports.parseRemarks = parseRemarks;
+const common_1 = require("../../common");
+const utils_1 = require("../utils");
+const remark_flags_1 = __importDefault(require("./remark-flags"));
+exports.REMARKS_SUPPORTED_ENTRIES = [
+    "AccountRoot",
+    "Offer",
+    "Escrow",
+    "Ticket",
+    "PayChannel",
+    "Check",
+    "DepositPreauth",
+    "URIToken",
+    "RippleState",
+];
+function parseRemarks(remarks) {
+    if (!Array.isArray(remarks)) {
+        return [];
+    }
+    return remarks.map((remark) => {
+        return (0, common_1.removeUndefined)(parseRemark(remark));
+    });
+}
+function parseRemark(remark) {
+    const { RemarkName, RemarkValue, Flags } = remark.Remark;
+    return (0, common_1.removeUndefined)({
+        name: (0, utils_1.hexToString)(RemarkName),
+        value: decodeData(RemarkValue),
+        flags: (0, remark_flags_1.default)(Flags),
+    });
+}
+function decodeData(data) {
+    if (!data) {
+        return undefined;
+    }
+    const decoded = (0, utils_1.hexToString)(data);
+    if (decoded && decoded.includes("�")) {
+        return data;
+    }
+    return decoded;
+}

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

@@ -0,0 +1,12 @@
+import { TransactionMetadata } from "xrpl";
+interface FormattedDelegateSummaryInterface {
+    status?: "created" | "modified" | "deleted";
+    delegateIndex: string;
+    account?: string;
+    authorize?: string;
+    permissions?: string[];
+    permissionsChange?: string[];
+    previousTxnID?: string;
+}
+declare function parseDelegateChanges(metadata: TransactionMetadata): FormattedDelegateSummaryInterface | undefined;
+export { parseDelegateChanges };

package/lib/parse/outcome/delegate_changes.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDelegateChanges = parseDelegateChanges;
+const utils_1 = require("../utils");
+const permissions_1 = require("../ledger/permissions");
+function parseDelegateStatus(node) {
+    if (node.diffType === "CreatedNode") {
+        return "created";
+    }
+    if (node.diffType === "ModifiedNode") {
+        return "modified";
+    }
+    if (node.diffType === "DeletedNode") {
+        return "deleted";
+    }
+    return undefined;
+}
+function summarizeDelegate(node) {
+    const final = node.diffType === "CreatedNode" ? node.newFields : node.finalFields;
+    const prev = node.previousFields;
+    const summary = {
+        status: parseDelegateStatus(node),
+        delegateIndex: node.ledgerIndex,
+        account: final.Account,
+        authorize: final.Authorize,
+        permissions: (0, permissions_1.parsePermissions)(final.Permissions),
+    };
+    if (node.diffType === "ModifiedNode") {
+        summary.permissionsChange = [];
+        const prevPermissions = (0, permissions_1.parsePermissions)(prev.Permissions);
+        const finalPermissions = summary.permissions || [];
+        const addedPermissions = finalPermissions.filter((perm) => !prevPermissions.includes(perm));
+        const removedPermissions = prevPermissions.filter((perm) => !finalPermissions.includes(perm));
+        if (addedPermissions.length > 0) {
+            summary.permissionsChange.push(...addedPermissions);
+        }
+        if (removedPermissions.length > 0) {
+            summary.permissionsChange.push(...removedPermissions);
+        }
+        if (summary.permissionsChange.length === 0) {
+            summary.permissionsChange = undefined;
+        }
+    }
+    if (node.PreviousTxnID) {
+        summary.previousTxnID = node.PreviousTxnID;
+    }
+    return summary;
+}
+function parseDelegateChanges(metadata) {
+    const affectedNodes = metadata.AffectedNodes.filter((affectedNode) => {
+        const node = affectedNode.CreatedNode || affectedNode.ModifiedNode || affectedNode.DeletedNode;
+        return node.LedgerEntryType === "Delegate";
+    });
+    if (affectedNodes.length !== 1) {
+        return undefined;
+    }
+    const normalizedNode = (0, utils_1.normalizeNode)(affectedNodes[0]);
+    return summarizeDelegate(normalizedNode);
+}

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

@@ -18,3 +18,5 @@ export { parseOracleChanges } from "./oracle_changes";
 export { parseDeliveredAmount } from "./delivered_amount";
 export { parseMPTokenIssuanceChanges } from "./mptoken_issuance_changes";
 export { parseMPTokenChanges } from "./mptoken_changes";
+export { parseDelegateChanges } from "./delegate_changes";
+export { parseRemarksChanges } from "./remarks_changes";

package/lib/parse/outcome/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseMPTokenChanges = exports.parseMPTokenIssuanceChanges = exports.parseDeliveredAmount = exports.parseOracleChanges = exports.parseDIDChanges = exports.parseAmmChanges = exports.parseUNLReportChanges = exports.parseEscrowChanges = exports.parseEmittedTxns = exports.parseHooksExecutions = exports.parseOrderbookChanges = exports.parseCheckChanges = exports.parseChannelChanges = exports.parseLockedBalanceChanges = exports.parseBalanceChanges = exports.parseURITokenSellOfferChanges = exports.parseURITokenChanges = exports.parseNFTokenOfferChanges = exports.parseNFTokenChanges = exports.parseAffectedObjects = void 0;
+exports.parseRemarksChanges = exports.parseDelegateChanges = exports.parseMPTokenChanges = exports.parseMPTokenIssuanceChanges = exports.parseDeliveredAmount = exports.parseOracleChanges = exports.parseDIDChanges = exports.parseAmmChanges = exports.parseUNLReportChanges = exports.parseEscrowChanges = exports.parseEmittedTxns = exports.parseHooksExecutions = exports.parseOrderbookChanges = exports.parseCheckChanges = exports.parseChannelChanges = exports.parseLockedBalanceChanges = exports.parseBalanceChanges = exports.parseURITokenSellOfferChanges = exports.parseURITokenChanges = 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");
@@ -41,3 +41,7 @@ var mptoken_issuance_changes_1 = require("./mptoken_issuance_changes");
 Object.defineProperty(exports, "parseMPTokenIssuanceChanges", { enumerable: true, get: function () { return mptoken_issuance_changes_1.parseMPTokenIssuanceChanges; } });
 var mptoken_changes_1 = require("./mptoken_changes");
 Object.defineProperty(exports, "parseMPTokenChanges", { enumerable: true, get: function () { return mptoken_changes_1.parseMPTokenChanges; } });
+var delegate_changes_1 = require("./delegate_changes");
+Object.defineProperty(exports, "parseDelegateChanges", { enumerable: true, get: function () { return delegate_changes_1.parseDelegateChanges; } });
+var remarks_changes_1 = require("./remarks_changes");
+Object.defineProperty(exports, "parseRemarksChanges", { enumerable: true, get: function () { return remarks_changes_1.parseRemarksChanges; } });

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

@@ -1,5 +1,5 @@
-import { TransactionMetadata } from "xrpl";
-import { OraclePriceDataSeriesInterface, FormattedOraclePriceDataSeriesInterface } from "../../types";
+import { TransactionMetadata, PriceData } from "xrpl";
+import { FormattedOraclePriceDataSeriesInterface } from "../../types";
 interface FormattedOracleSummaryInterface {
     status?: "created" | "modified" | "deleted";
     oracleID?: string;
@@ -24,6 +24,6 @@ interface FormattedPriceDataSeriesChanges {
     scaleChange?: number;
     originalPriceChange?: string;
 }
-declare function parsePriceDataSeries(series: OraclePriceDataSeriesInterface): FormattedOraclePriceDataSeriesInterface;
+declare function parsePriceDataSeries(series: PriceData): FormattedOraclePriceDataSeriesInterface;
 declare function parseOracleChanges(metadata: TransactionMetadata): FormattedOracleSummaryInterface | undefined;
 export { parseOracleChanges, parsePriceDataSeries };

package/lib/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/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/parse/outcome.js

@@ -36,6 +36,8 @@ const MPTOKEN_TYPES = [
     "Payment",
     "Clawback",
 ];
+const DELEGATE_TYPES = ["DelegateSet"];
+const REMARKS_TYPES = ["SetRemarks"];
 function parseOutcome(tx, nativeCurrency, definitions) {
     const metadata = tx.meta || tx.metaData;
     if (!metadata) {
@@ -62,6 +64,8 @@ function parseOutcome(tx, nativeCurrency, definitions) {
         oracleChanges: getOracleChanges(tx),
         mptokenIssuanceChanges: getMPTokenIssuanceChanges(tx, nativeCurrency || (0, client_1.getNativeCurrency)()),
         mptokenChanges: getMPTokenChanges(tx, nativeCurrency || (0, client_1.getNativeCurrency)()),
+        delegateChanges: getDelegateChanges(tx, nativeCurrency || (0, client_1.getNativeCurrency)()),
+        remarksChanges: getRemarksChanges(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),
@@ -198,3 +202,21 @@ function getMPTokenIssuanceChanges(tx, nativeCurrency) {
     const mptokenIssuanceChanges = (0, index_1.parseMPTokenIssuanceChanges)(tx);
     return Object.keys(mptokenIssuanceChanges).length > 0 ? mptokenIssuanceChanges : undefined;
 }
+function getDelegateChanges(tx, nativeCurrency) {
+    if (nativeCurrency !== "XRP") {
+        return undefined;
+    }
+    if (!DELEGATE_TYPES.includes(tx.TransactionType)) {
+        return undefined;
+    }
+    return (0, index_1.parseDelegateChanges)(tx.meta);
+}
+function getRemarksChanges(tx, nativeCurrency) {
+    if (nativeCurrency !== "XAH") {
+        return undefined;
+    }
+    if (!REMARKS_TYPES.includes(tx.TransactionType)) {
+        return undefined;
+    }
+    return (0, index_1.parseRemarksChanges)(tx);
+}

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

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

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

@@ -39,6 +39,7 @@ const emit_details_1 = require("../ledger/emit_details");
 const memos_1 = require("../ledger/memos");
 const signers_1 = require("../ledger/signers");
 const regular_key_1 = require("../ledger/regular-key");
+const delegate_1 = require("../ledger/delegate");
 const source_1 = require("../ledger/source");
 const destination_1 = require("../ledger/destination");
 function parseAccountDelete(tx) {
@@ -46,6 +47,7 @@ function parseAccountDelete(tx) {
     return (0, common_1.removeUndefined)({
         signers: (0, signers_1.parseSigners)(tx),
         signer: (0, regular_key_1.parseSignerRegularKey)(tx),
+        delegate: (0, delegate_1.parseDelegate)(tx),
         source: (0, source_1.parseSource)(tx),
         destination: (0, destination_1.parseDestination)(tx),
         emittedDetails: (0, emit_details_1.parseEmittedDetails)(tx),

package/lib/parse/specification/amm-bid.d.ts

@@ -1,3 +1,4 @@
+import { AMMBid } from "xrpl";
 import { FormattedAmmBidSpecification } from "../../types/amm";
-declare function parseAmmBid(tx: any): FormattedAmmBidSpecification;
+declare function parseAmmBid(tx: AMMBid): FormattedAmmBidSpecification;
 export default parseAmmBid;

package/lib/parse/specification/amm-bid.js

@@ -44,12 +44,14 @@ const auth_accounts_1 = __importDefault(require("../ledger/auth-accounts"));
 const memos_1 = require("../ledger/memos");
 const signers_1 = require("../ledger/signers");
 const regular_key_1 = require("../ledger/regular-key");
+const delegate_1 = require("../ledger/delegate");
 const source_1 = require("../ledger/source");
 function parseAmmBid(tx) {
     assert.ok(tx.TransactionType === "AMMBid");
     return (0, common_1.removeUndefined)({
         signers: (0, signers_1.parseSigners)(tx),
         signer: (0, regular_key_1.parseSignerRegularKey)(tx),
+        delegate: (0, delegate_1.parseDelegate)(tx),
         source: (0, source_1.parseSource)(tx),
         asset: (0, asset_1.default)(tx.Asset),
         asset2: (0, asset_1.default)(tx.Asset2),

package/lib/parse/specification/amm-clawback.d.ts

@@ -1,3 +1,4 @@
+import { AMMClawback } from "xrpl";
 import { FormattedAmmClawbackSpecification } from "../../types/amm";
-declare function parseAmmClawback(tx: any): FormattedAmmClawbackSpecification;
+declare function parseAmmClawback(tx: AMMClawback): FormattedAmmClawbackSpecification;
 export default parseAmmClawback;

package/lib/parse/specification/amm-clawback.js

@@ -44,6 +44,7 @@ const memos_1 = require("../ledger/memos");
 const account_1 = require("../ledger/account");
 const signers_1 = require("../ledger/signers");
 const regular_key_1 = require("../ledger/regular-key");
+const delegate_1 = require("../ledger/delegate");
 const source_1 = require("../ledger/source");
 const amm_clawback_flags_1 = __importDefault(require("../ledger/amm-clawback-flags"));
 function parseAmmClawback(tx) {
@@ -51,6 +52,7 @@ function parseAmmClawback(tx) {
     return (0, common_1.removeUndefined)({
         signers: (0, signers_1.parseSigners)(tx),
         signer: (0, regular_key_1.parseSignerRegularKey)(tx),
+        delegate: (0, delegate_1.parseDelegate)(tx),
         source: (0, source_1.parseSource)(tx),
         asset: (0, asset_1.default)(tx.Asset),
         asset2: (0, asset_1.default)(tx.Asset2),