@bithomp/xrpl-api 3.7.31 → 3.7.37

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

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCheckChanges = parseCheckChanges;
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const amount_1 = __importDefault(require("../ledger/amount"));
+const source_1 = require("../ledger/source");
+const destination_1 = require("../ledger/destination");
+const utils_1 = require("../utils");
+const models_1 = require("../../models");
+function parseCheckStatus(node) {
+    if (node.diffType === "CreatedNode") {
+        return "created";
+    }
+    if (node.diffType === "ModifiedNode") {
+        return "modified";
+    }
+    if (node.diffType === "DeletedNode") {
+        return "deleted";
+    }
+    return undefined;
+}
+function summarizeCheck(node) {
+    const final = node.diffType === "CreatedNode" ? node.newFields : node.finalFields;
+    const prev = node.previousFields;
+    const summary = {
+        status: parseCheckStatus(node),
+        checkID: node.ledgerIndex,
+        source: (0, source_1.parseSource)(final),
+        destination: (0, destination_1.parseDestination)(final),
+        sendMax: (0, amount_1.default)(final.SendMax),
+        sequence: final.Sequence,
+    };
+    if (final.Expiration) {
+        summary.expiration = (0, models_1.ledgerTimeToUnixTime)(final.Expiration);
+    }
+    if (final.InvoiceID) {
+        summary.invoiceID = final.InvoiceID;
+    }
+    if (prev.SendMax) {
+        summary.sendMaxChange = (0, amount_1.default)(prev.SendMax);
+        summary.sendMaxChange.value = new bignumber_js_1.default(summary.sendMaxChange.value)
+            .minus(new bignumber_js_1.default(summary.sendMax.value))
+            .toString(10);
+    }
+    if (node.PreviousTxnID) {
+        summary.previousTxnID = node.PreviousTxnID;
+    }
+    return summary;
+}
+function parseCheckChanges(metadata) {
+    const affectedNodes = metadata.AffectedNodes.filter((affectedNode) => {
+        const node = affectedNode.CreatedNode || affectedNode.ModifiedNode || affectedNode.DeletedNode;
+        return node.LedgerEntryType === "Check";
+    });
+    if (affectedNodes.length !== 1) {
+        return undefined;
+    }
+    const normalizedNode = (0, utils_1.normalizeNode)(affectedNodes[0]);
+    return summarizeCheck(normalizedNode);
+}

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

@@ -0,0 +1,16 @@
+import { TransactionMetadata } from "xrpl";
+import { CredentialFlagsKeysInterface } from "../../types";
+interface FormattedCredentialSummaryInterface {
+    status?: "created" | "modified" | "deleted";
+    credentialIndex: string;
+    issuer?: string;
+    subject?: string;
+    credentialType?: string;
+    expiration?: number;
+    uri?: string;
+    flags?: CredentialFlagsKeysInterface;
+    previousTxnID?: string;
+    flagsChange?: CredentialFlagsKeysInterface;
+}
+declare function parseCredentialChanges(metadata: TransactionMetadata): FormattedCredentialSummaryInterface | undefined;
+export { parseCredentialChanges };

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

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCredentialChanges = parseCredentialChanges;
+const models_1 = require("../../models");
+const utils_1 = require("../utils");
+const credential_flags_1 = __importDefault(require("../ledger/credential-flags"));
+function parseCredentialStatus(node) {
+    if (node.diffType === "CreatedNode") {
+        return "created";
+    }
+    if (node.diffType === "ModifiedNode") {
+        return "modified";
+    }
+    if (node.diffType === "DeletedNode") {
+        return "deleted";
+    }
+    return undefined;
+}
+function summarizeCredential(node) {
+    const final = node.diffType === "CreatedNode" ? node.newFields : node.finalFields;
+    const prev = node.previousFields;
+    const summary = {
+        status: parseCredentialStatus(node),
+        credentialIndex: node.ledgerIndex,
+        issuer: final.Issuer,
+        subject: final.Subject,
+        credentialType: (0, utils_1.decodeHexData)(final.CredentialType),
+        flags: (0, credential_flags_1.default)(final.Flags, { excludeFalse: false }),
+    };
+    if (final.Expiration !== undefined) {
+        summary.expiration = (0, models_1.ledgerTimeToUnixTime)(final.Expiration);
+    }
+    if (final.URI !== undefined) {
+        summary.uri = final.URI;
+    }
+    if (node.diffType === "ModifiedNode") {
+        if (prev.Flags !== undefined) {
+            summary.flagsChange = (0, credential_flags_1.default)(prev.Flags, { excludeFalse: false });
+        }
+    }
+    if (node.PreviousTxnID) {
+        summary.previousTxnID = node.PreviousTxnID;
+    }
+    return summary;
+}
+function parseCredentialChanges(metadata) {
+    const affectedNodes = metadata.AffectedNodes.filter((affectedNode) => {
+        const node = affectedNode.CreatedNode || affectedNode.ModifiedNode || affectedNode.DeletedNode;
+        return node.LedgerEntryType === "Credential";
+    });
+    if (affectedNodes.length !== 1) {
+        return undefined;
+    }
+    const normalizedNode = (0, utils_1.normalizeNode)(affectedNodes[0]);
+    return summarizeCredential(normalizedNode);
+}

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

@@ -0,0 +1,13 @@
+interface FormattedCronSummaryInterface {
+    status?: "created" | "cancelled" | "executed" | "modified";
+    cronIndex?: string;
+    previousCronIndex?: string;
+    owner?: string;
+    startTime?: number;
+    repeatCount?: number;
+    delaySeconds?: number;
+    previousTxnID?: string;
+    previousTxnLgrSeq?: number;
+}
+declare function parseCronChanges(tx: any): FormattedCronSummaryInterface | undefined;
+export { parseCronChanges };

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

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCronChanges = parseCronChanges;
+const common_1 = require("../../common");
+const utils_1 = require("../utils");
+const ledger_1 = require("../../models/ledger");
+function parseCronStatus(tx, currentNode, previousNode) {
+    if (tx.TransactionType === "Cron") {
+        return "executed";
+    }
+    if (tx.TransactionType === "CronSet") {
+        if (currentNode.diffType === "CreatedNode" && previousNode && previousNode.diffType === "DeletedNode") {
+            return "modified";
+        }
+        if (currentNode.diffType === "CreatedNode" && !previousNode) {
+            return "created";
+        }
+        if (tx.Flags === 1) {
+            return "cancelled";
+        }
+    }
+    return undefined;
+}
+function summarizeCron(tx, currentNode, previousNode) {
+    const final = currentNode.diffType === "CreatedNode" ? currentNode.newFields : currentNode.finalFields;
+    const summary = {
+        status: parseCronStatus(tx, currentNode, previousNode),
+        cronIndex: currentNode.ledgerIndex,
+        owner: final.Owner,
+        startTime: (0, ledger_1.ledgerTimeToTimestamp)(final.StartTime),
+        repeatCount: final.RepeatCount,
+        delaySeconds: final.DelaySeconds,
+    };
+    if (previousNode) {
+        summary.previousCronIndex = previousNode.ledgerIndex;
+        const previous = previousNode.finalFields;
+        if (previous.PreviousTxnID) {
+            summary.previousTxnID = previous.PreviousTxnID;
+        }
+        if (previous.PreviousTxnLgrSeq) {
+            summary.previousTxnLgrSeq = previous.PreviousTxnLgrSeq;
+        }
+    }
+    return (0, common_1.removeUndefined)(summary);
+}
+function parseCronChanges(tx) {
+    const affectedNodes = tx.meta.AffectedNodes.filter((affectedNode) => {
+        const node = affectedNode.CreatedNode || affectedNode.ModifiedNode || affectedNode.DeletedNode;
+        return node.LedgerEntryType === "Cron";
+    });
+    if (affectedNodes.length > 2 || affectedNodes.length === 0) {
+        return undefined;
+    }
+    let currentNode;
+    let previousNode;
+    if (affectedNodes.length === 2) {
+        const firstNode = (0, utils_1.normalizeNode)(affectedNodes[0]);
+        const secondNode = (0, utils_1.normalizeNode)(affectedNodes[1]);
+        if (firstNode.diffType === "DeletedNode") {
+            previousNode = firstNode;
+            currentNode = secondNode;
+        }
+        else {
+            previousNode = secondNode;
+            currentNode = firstNode;
+        }
+    }
+    else {
+        currentNode = (0, utils_1.normalizeNode)(affectedNodes[0]);
+    }
+    return summarizeCron(tx, currentNode, previousNode);
+}

package/lib/src/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/src/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/src/parse/outcome/delivered_amount.d.ts

@@ -0,0 +1,4 @@
+import { IssuedCurrencyAmount, FormattedIssuedCurrencyAmount, FormattedIssuedMPTAmount } from "../../types";
+import { BalanceChanges } from "./balance_changes";
+declare function parseDeliveredAmount(tx: any, balanceChanges: BalanceChanges): IssuedCurrencyAmount | FormattedIssuedCurrencyAmount | FormattedIssuedMPTAmount | undefined;
+export { parseDeliveredAmount };

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

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDeliveredAmount = parseDeliveredAmount;
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const client_1 = require("../../client");
+const import_1 = require("../ledger/import");
+const amount_1 = __importDefault(require("../ledger/amount"));
+const balance_changes_1 = require("./balance_changes");
+function parseDeliveredAmount(tx, balanceChanges) {
+    if (tx.meta.TransactionResult !== "tesSUCCESS") {
+        return undefined;
+    }
+    if (tx.TransactionType === "Payment") {
+        const txBalanceChanges = balanceChanges || (0, balance_changes_1.parseBalanceChanges)(tx.meta, (0, client_1.getNativeCurrency)(), tx);
+        if (txBalanceChanges) {
+            const account = tx.Destination;
+            const changes = txBalanceChanges[account];
+            if (changes) {
+                const positives = changes.filter((change) => change.value[0] !== "-");
+                if (positives.length === 1) {
+                    return positives[0];
+                }
+            }
+        }
+    }
+    else if (tx.TransactionType === "CheckCash") {
+        const txBalanceChanges = balanceChanges || (0, balance_changes_1.parseBalanceChanges)(tx.meta, (0, client_1.getNativeCurrency)(), tx);
+        if (txBalanceChanges) {
+            const account = tx.Account;
+            const changes = txBalanceChanges[account];
+            if (changes) {
+                const positives = changes.filter((change) => change.value[0] !== "-");
+                if (positives.length === 1) {
+                    return positives[0];
+                }
+            }
+        }
+    }
+    else if (tx.TransactionType === "Import") {
+        const txBalanceChanges = balanceChanges || (0, balance_changes_1.parseBalanceChanges)(tx.meta, (0, client_1.getNativeCurrency)(), tx);
+        const blob = (0, import_1.parseImportBlob)(tx.Blob);
+        if (typeof blob === "object") {
+            const account = blob.transaction.tx.Account;
+            const balanceChange = txBalanceChanges[account];
+            if (balanceChange && balanceChange.length === 1) {
+                return {
+                    currency: balanceChange[0].currency,
+                    value: new bignumber_js_1.default(balanceChange[0].value).abs().toString(),
+                };
+            }
+        }
+    }
+    if (tx.meta.delivered_amount && tx.meta.delivered_amount !== "unavailable") {
+        return (0, amount_1.default)(tx.meta.delivered_amount);
+    }
+    if (tx.meta.DeliveredAmount) {
+        return (0, amount_1.default)(tx.meta.DeliveredAmount);
+    }
+    return undefined;
+}

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

@@ -0,0 +1,14 @@
+import { TransactionMetadata } from "xrpl";
+interface FormattedDIDSummaryInterface {
+    status?: "created" | "modified" | "deleted";
+    didID?: string;
+    account?: string;
+    uri: string;
+    data: string;
+    didDocument: string;
+    uriChange?: string;
+    dataChanges?: string;
+    didDocumentChanges?: string;
+}
+declare function parseDIDChanges(metadata: TransactionMetadata): FormattedDIDSummaryInterface | undefined;
+export { parseDIDChanges };

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

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDIDChanges = parseDIDChanges;
+const utils_1 = require("../utils");
+const common_1 = require("../../common");
+function parseDIDStatus(node) {
+    if (node.diffType === "CreatedNode") {
+        return "created";
+    }
+    if (node.diffType === "ModifiedNode") {
+        return "modified";
+    }
+    if (node.diffType === "DeletedNode") {
+        return "deleted";
+    }
+    return undefined;
+}
+function summarizeDID(node) {
+    const final = node.diffType === "CreatedNode" ? node.newFields : node.finalFields;
+    const prev = node.previousFields;
+    const summary = {
+        status: parseDIDStatus(node),
+        didID: node.ledgerIndex,
+        account: final.Account,
+        uri: final.URI,
+        data: final.Data,
+        didDocument: final.DIDDocument,
+    };
+    if (prev.URI) {
+        summary.uriChange = prev.URI;
+    }
+    if (prev.Data) {
+        summary.dataChanges = prev.Data;
+    }
+    if (prev.DIDDocument) {
+        summary.didDocumentChanges = prev.DIDDocument;
+    }
+    return (0, common_1.removeUndefined)(summary);
+}
+function parseDIDChanges(metadata) {
+    const affectedNodes = metadata.AffectedNodes.filter((affectedNode) => {
+        const node = affectedNode.CreatedNode || affectedNode.ModifiedNode || affectedNode.DeletedNode;
+        return node.LedgerEntryType === "DID";
+    });
+    if (affectedNodes.length !== 1) {
+        return undefined;
+    }
+    const normalizedNode = (0, utils_1.normalizeNode)(affectedNodes[0]);
+    return summarizeDID(normalizedNode);
+}

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

@@ -0,0 +1,9 @@
+import { XrplDefinitionsBase } from "ripple-binary-codec";
+import { FormattedSpecification } from "../../parse/transaction";
+interface FormattedEmittedTxnInterface {
+    id?: string | undefined;
+    specification: FormattedSpecification;
+    tx: any;
+}
+export declare function parseEmittedTxns(tx: any, nativeCurrency: string, definitions?: XrplDefinitionsBase): FormattedEmittedTxnInterface[] | undefined;
+export {};

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

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseEmittedTxns = parseEmittedTxns;
+const common_1 = require("../../common");
+const wallet_1 = require("../../wallet");
+const transaction_1 = require("../../parse/transaction");
+function parseEmittedTxns(tx, nativeCurrency, definitions) {
+    return new EmittedTxns(tx, nativeCurrency, definitions).call();
+}
+class EmittedTxns {
+    constructor(tx, nativeCurrency, definitions) {
+        this.emittedTxns = [];
+        this.tx = tx;
+        this.nativeCurrency = nativeCurrency;
+        this.definitions = definitions;
+    }
+    call() {
+        if (this.hasAffectedNodes() === false) {
+            return undefined;
+        }
+        this.parseAffectedNodes();
+        if (this.emittedTxns.length === 0) {
+            return undefined;
+        }
+        return this.emittedTxns;
+    }
+    hasAffectedNodes() {
+        if (this.tx.meta?.AffectedNodes === undefined) {
+            return false;
+        }
+        if (this.tx.meta?.AffectedNodes?.length === 0) {
+            return false;
+        }
+        return true;
+    }
+    parseAffectedNodes() {
+        for (const affectedNode of this.tx.meta.AffectedNodes) {
+            const node = affectedNode.CreatedNode;
+            if (node?.LedgerEntryType === "EmittedTxn" && node?.LedgerIndex) {
+                if (affectedNode.CreatedNode) {
+                    const tx = node.NewFields.EmittedTxn;
+                    let id;
+                    try {
+                        id = (0, wallet_1.hashSignedTx)(tx, this.definitions, false);
+                    }
+                    catch (_err) {
+                    }
+                    this.emittedTxns.push((0, common_1.removeUndefined)({
+                        id,
+                        specification: (0, transaction_1.parseTransaction)(tx, false, this.nativeCurrency, this.definitions).specification,
+                        tx,
+                    }));
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,16 @@
+import { FormattedSourceAddress, FormattedDestinationAddress } from "../../types/account";
+interface FormattedEscrowSummaryInterface {
+    status?: "created" | "cancelled" | "executed" | "deleted";
+    escrowIndex?: string;
+    escrowSequence?: number;
+    amount?: string;
+    condition?: string;
+    source?: FormattedSourceAddress;
+    destination?: FormattedDestinationAddress;
+    allowCancelAfter?: string;
+    allowExecuteAfter?: string;
+    previousTxnID?: string;
+    previousTxnLgrSeq?: number;
+}
+declare function parseEscrowChanges(tx: any): FormattedEscrowSummaryInterface | undefined;
+export { parseEscrowChanges };

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

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseEscrowChanges = parseEscrowChanges;
+const common_1 = require("../../common");
+const utils_1 = require("../utils");
+function parseEscrowStatus(tx, node) {
+    if (node.diffType === "CreatedNode") {
+        return "created";
+    }
+    if (node.diffType === "DeletedNode") {
+        if (tx.TransactionType === "EscrowCancel") {
+            return "cancelled";
+        }
+        if (tx.TransactionType === "EscrowFinish") {
+            return "executed";
+        }
+        return "deleted";
+    }
+    return undefined;
+}
+function parseEscrowSequence(tx) {
+    if (tx.TransactionType === "EscrowCreate") {
+        return tx.Sequence || tx.TicketSequence;
+    }
+    if (tx.TransactionType === "EscrowCancel" || tx.TransactionType === "EscrowFinish") {
+        return tx.OfferSequence;
+    }
+    return undefined;
+}
+function summarizeEscrow(tx, node) {
+    const final = node.diffType === "CreatedNode" ? node.newFields : node.finalFields;
+    const source = {
+        address: final.Account,
+        tag: final.SourceTag,
+    };
+    const destination = {
+        address: final.Destination,
+        tag: final.DestinationTag,
+    };
+    const summary = {
+        status: parseEscrowStatus(tx, node),
+        escrowIndex: node.ledgerIndex,
+        escrowSequence: parseEscrowSequence(tx),
+        amount: final.Amount,
+        condition: final.Condition,
+        source: (0, common_1.removeUndefined)(source),
+        destination: (0, common_1.removeUndefined)(destination),
+        allowCancelAfter: (0, utils_1.parseTimestamp)(final.CancelAfter),
+        allowExecuteAfter: (0, utils_1.parseTimestamp)(final.FinishAfter),
+    };
+    if (final.PreviousTxnID) {
+        summary.previousTxnID = final.PreviousTxnID;
+    }
+    else if (node.diffType === "CreatedNode") {
+        summary.previousTxnID = tx.hash;
+    }
+    if (final.PreviousTxnLgrSeq) {
+        summary.previousTxnLgrSeq = final.PreviousTxnLgrSeq;
+    }
+    else if (node.diffType === "CreatedNode") {
+        summary.previousTxnLgrSeq = tx.ledger_index;
+    }
+    return (0, common_1.removeUndefined)(summary);
+}
+function parseEscrowChanges(tx) {
+    const affectedNodes = tx.meta.AffectedNodes.filter((affectedNode) => {
+        const node = affectedNode.CreatedNode || affectedNode.ModifiedNode || affectedNode.DeletedNode;
+        return node.LedgerEntryType === "Escrow";
+    });
+    if (affectedNodes.length !== 1) {
+        return undefined;
+    }
+    const normalizedNode = (0, utils_1.normalizeNode)(affectedNodes[0]);
+    return summarizeEscrow(tx, normalizedNode);
+}

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

@@ -0,0 +1,13 @@
+interface FormattedHooksExecutionInterface {
+    account: string;
+    emitCount: number;
+    executionIndex: number;
+    hash: string;
+    instructionCount: string;
+    result: number;
+    returnCode: string;
+    returnString: string;
+    stateChangeCount: number;
+}
+export declare function parseHooksExecutions(tx: any): FormattedHooksExecutionInterface[] | undefined;
+export {};

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

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseHooksExecutions = parseHooksExecutions;
+function parseHooksExecutions(tx) {
+    return new HooksExecutions(tx).call();
+}
+class HooksExecutions {
+    constructor(tx) {
+        this.tx = tx;
+        this.executions = [];
+    }
+    call() {
+        const hookExecutions = this.tx.meta.HookExecutions;
+        if (!hookExecutions) {
+            return undefined;
+        }
+        for (const execution of hookExecutions) {
+            if (execution.HookExecution) {
+                this.executions.push(this.parseHookExecution(execution.HookExecution));
+            }
+        }
+        if (this.executions.length === 0) {
+            return undefined;
+        }
+        return this.executions;
+    }
+    parseHookExecution(hookExecution) {
+        let hookReturnString = Buffer.from(hookExecution.HookReturnString, "hex");
+        hookReturnString = hookReturnString.subarray(0, hookReturnString.indexOf(0x00));
+        return {
+            account: hookExecution.HookAccount,
+            emitCount: hookExecution.HookEmitCount,
+            executionIndex: hookExecution.HookExecutionIndex,
+            hash: hookExecution.HookHash,
+            instructionCount: hookExecution.HookInstructionCount,
+            result: hookExecution.HookResult,
+            returnCode: hookExecution.HookReturnCode,
+            returnString: hookReturnString.toString("utf-8"),
+            stateChangeCount: hookExecution.HookStateChangeCount,
+        };
+    }
+}