@metamask-previews/smart-transactions-controller 19.2.1-preview-54c655a

package/dist/SmartTransactionsController.cjs

@@ -0,0 +1,694 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _SmartTransactionsController_instances, _SmartTransactionsController_interval, _SmartTransactionsController_clientId, _SmartTransactionsController_chainId, _SmartTransactionsController_supportedChainIds, _SmartTransactionsController_ethQuery, _SmartTransactionsController_trackMetaMetricsEvent, _SmartTransactionsController_getMetaMetricsProps, _SmartTransactionsController_getFeatureFlags, _SmartTransactionsController_trace, _SmartTransactionsController_fetch, _SmartTransactionsController_updateSmartTransaction, _SmartTransactionsController_addMetaMetricsPropsToNewSmartTransaction, _SmartTransactionsController_createOrUpdateSmartTransaction, _SmartTransactionsController_doesTransactionNeedConfirmation, _SmartTransactionsController_confirmSmartTransaction, _SmartTransactionsController_addNonceToTransaction, _SmartTransactionsController_getChainId, _SmartTransactionsController_getChainIds, _SmartTransactionsController_getNetworkClientId, _SmartTransactionsController_getEthQuery, _SmartTransactionsController_getCurrentSmartTransactions, _SmartTransactionsController_wipeSmartTransactionsPerChainId;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SmartTransactionsController = exports.getDefaultSmartTransactionsControllerState = exports.DEFAULT_INTERVAL = void 0;
+const bytes_1 = require("@ethersproject/bytes");
+const controller_utils_1 = require("@metamask/controller-utils");
+const eth_query_1 = __importDefault(require("@metamask/eth-query"));
+const polling_controller_1 = require("@metamask/polling-controller");
+const transaction_controller_1 = require("@metamask/transaction-controller");
+const bignumber_js_1 = require("bignumber.js");
+const cloneDeep_1 = __importDefault(require("lodash/cloneDeep.js"));
+const constants_1 = require("./constants.cjs");
+const types_1 = require("./types.cjs");
+const utils_1 = require("./utils.cjs");
+const SECOND = 1000;
+exports.DEFAULT_INTERVAL = SECOND * 5;
+const ETH_QUERY_ERROR_MSG = '`ethQuery` is not defined on SmartTransactionsController';
+/**
+ * The name of the {@link SmartTransactionsController}
+ */
+const controllerName = 'SmartTransactionsController';
+const controllerMetadata = {
+    smartTransactionsState: {
+        includeInStateLogs: true,
+        persist: false,
+        includeInDebugSnapshot: true,
+        usedInUi: true,
+    },
+};
+/**
+ * Get the default {@link SmartTransactionsController} state.
+ *
+ * @returns The default {@link SmartTransactionsController} state.
+ */
+function getDefaultSmartTransactionsControllerState() {
+    return {
+        smartTransactionsState: {
+            smartTransactions: {},
+            userOptIn: null,
+            userOptInV2: null,
+            fees: {
+                approvalTxFees: null,
+                tradeTxFees: null,
+            },
+            liveness: true,
+            livenessByChainId: {
+                [controller_utils_1.ChainId.mainnet]: true,
+                [controller_utils_1.ChainId.sepolia]: true,
+            },
+            feesByChainId: {
+                [controller_utils_1.ChainId.mainnet]: {
+                    approvalTxFees: null,
+                    tradeTxFees: null,
+                },
+                [controller_utils_1.ChainId.sepolia]: {
+                    approvalTxFees: null,
+                    tradeTxFees: null,
+                },
+            },
+        },
+    };
+}
+exports.getDefaultSmartTransactionsControllerState = getDefaultSmartTransactionsControllerState;
+class SmartTransactionsController extends (0, polling_controller_1.StaticIntervalPollingController)() {
+    constructor({ interval = exports.DEFAULT_INTERVAL, clientId, chainId: InitialChainId = controller_utils_1.ChainId.mainnet, supportedChainIds = [controller_utils_1.ChainId.mainnet, controller_utils_1.ChainId.sepolia], trackMetaMetricsEvent, state = {}, messenger, getMetaMetricsProps, getFeatureFlags, trace, }) {
+        super({
+            name: controllerName,
+            metadata: controllerMetadata,
+            messenger,
+            state: Object.assign(Object.assign({}, getDefaultSmartTransactionsControllerState()), state),
+        });
+        _SmartTransactionsController_instances.add(this);
+        _SmartTransactionsController_interval.set(this, void 0);
+        _SmartTransactionsController_clientId.set(this, void 0);
+        _SmartTransactionsController_chainId.set(this, void 0);
+        _SmartTransactionsController_supportedChainIds.set(this, void 0);
+        _SmartTransactionsController_ethQuery.set(this, void 0);
+        _SmartTransactionsController_trackMetaMetricsEvent.set(this, void 0);
+        _SmartTransactionsController_getMetaMetricsProps.set(this, void 0);
+        _SmartTransactionsController_getFeatureFlags.set(this, void 0);
+        _SmartTransactionsController_trace.set(this, void 0);
+        __classPrivateFieldSet(this, _SmartTransactionsController_interval, interval, "f");
+        __classPrivateFieldSet(this, _SmartTransactionsController_clientId, clientId, "f");
+        __classPrivateFieldSet(this, _SmartTransactionsController_chainId, InitialChainId, "f");
+        __classPrivateFieldSet(this, _SmartTransactionsController_supportedChainIds, supportedChainIds, "f");
+        this.setIntervalLength(interval);
+        __classPrivateFieldSet(this, _SmartTransactionsController_ethQuery, undefined, "f");
+        __classPrivateFieldSet(this, _SmartTransactionsController_trackMetaMetricsEvent, trackMetaMetricsEvent, "f");
+        __classPrivateFieldSet(this, _SmartTransactionsController_getMetaMetricsProps, getMetaMetricsProps, "f");
+        __classPrivateFieldSet(this, _SmartTransactionsController_getFeatureFlags, getFeatureFlags, "f");
+        __classPrivateFieldSet(this, _SmartTransactionsController_trace, trace !== null && trace !== void 0 ? trace : ((_request, fn) => fn === null || fn === void 0 ? void 0 : fn()), "f");
+        this.initializeSmartTransactionsForChainId();
+        this.messenger.subscribe('NetworkController:stateChange', ({ selectedNetworkClientId }) => {
+            const { configuration: { chainId }, provider, } = this.messenger.call('NetworkController:getNetworkClientById', selectedNetworkClientId);
+            __classPrivateFieldSet(this, _SmartTransactionsController_chainId, chainId, "f");
+            __classPrivateFieldSet(this, _SmartTransactionsController_ethQuery, new eth_query_1.default(provider), "f");
+            this.initializeSmartTransactionsForChainId();
+            this.checkPoll(this.state);
+        });
+        this.messenger.subscribe(`${controllerName}:stateChange`, (currentState) => this.checkPoll(currentState));
+    }
+    async _executePoll({ chainIds, }) {
+        // if this is going to be truly UI driven polling we shouldn't really reach here
+        // with a networkClientId that is not supported, but for now I'll add a check in case
+        // wondering if we should add some kind of predicate to the polling controller to check whether
+        // we should poll or not
+        const filteredChainIds = (chainIds !== null && chainIds !== void 0 ? chainIds : []).filter((chainId) => __classPrivateFieldGet(this, _SmartTransactionsController_supportedChainIds, "f").includes(chainId));
+        if (filteredChainIds.length === 0) {
+            return Promise.resolve();
+        }
+        return this.updateSmartTransactions({ chainIds: filteredChainIds });
+    }
+    checkPoll({ smartTransactionsState: { smartTransactions }, }) {
+        const smartTransactionsForAllChains = Object.values(smartTransactions).flat();
+        const pendingTransactions = smartTransactionsForAllChains === null || smartTransactionsForAllChains === void 0 ? void 0 : smartTransactionsForAllChains.filter(utils_1.isSmartTransactionPending);
+        if (!this.timeoutHandle && (pendingTransactions === null || pendingTransactions === void 0 ? void 0 : pendingTransactions.length) > 0) {
+            this.poll();
+        }
+        else if (this.timeoutHandle && (pendingTransactions === null || pendingTransactions === void 0 ? void 0 : pendingTransactions.length) === 0) {
+            this.stop();
+        }
+    }
+    initializeSmartTransactionsForChainId() {
+        if (__classPrivateFieldGet(this, _SmartTransactionsController_supportedChainIds, "f").includes(__classPrivateFieldGet(this, _SmartTransactionsController_chainId, "f"))) {
+            this.update((state) => {
+                var _a;
+                state.smartTransactionsState.smartTransactions[__classPrivateFieldGet(this, _SmartTransactionsController_chainId, "f")] =
+                    (_a = state.smartTransactionsState.smartTransactions[__classPrivateFieldGet(this, _SmartTransactionsController_chainId, "f")]) !== null && _a !== void 0 ? _a : [];
+            });
+        }
+    }
+    async poll(interval) {
+        if (interval) {
+            __classPrivateFieldSet(this, _SmartTransactionsController_interval, interval, "f");
+        }
+        this.timeoutHandle && clearInterval(this.timeoutHandle);
+        if (!__classPrivateFieldGet(this, _SmartTransactionsController_supportedChainIds, "f").includes(__classPrivateFieldGet(this, _SmartTransactionsController_chainId, "f"))) {
+            return;
+        }
+        this.timeoutHandle = setInterval(() => {
+            (0, controller_utils_1.safelyExecute)(async () => this.updateSmartTransactions());
+        }, __classPrivateFieldGet(this, _SmartTransactionsController_interval, "f"));
+        await (0, controller_utils_1.safelyExecute)(async () => this.updateSmartTransactions());
+    }
+    async stop() {
+        this.timeoutHandle && clearInterval(this.timeoutHandle);
+        this.timeoutHandle = undefined;
+    }
+    setOptInState(optInState) {
+        this.update((state) => {
+            state.smartTransactionsState.userOptInV2 = optInState;
+        });
+    }
+    trackStxStatusChange(smartTransaction, prevSmartTransaction) {
+        let updatedSmartTransaction = (0, cloneDeep_1.default)(smartTransaction);
+        updatedSmartTransaction = Object.assign(Object.assign({}, (0, cloneDeep_1.default)(prevSmartTransaction)), updatedSmartTransaction);
+        if (updatedSmartTransaction.status === (prevSmartTransaction === null || prevSmartTransaction === void 0 ? void 0 : prevSmartTransaction.status)) {
+            return; // If status hasn't changed, don't track it again.
+        }
+        __classPrivateFieldGet(this, _SmartTransactionsController_trackMetaMetricsEvent, "f").call(this, {
+            event: constants_1.MetaMetricsEventName.StxStatusUpdated,
+            category: constants_1.MetaMetricsEventCategory.Transactions,
+            properties: (0, utils_1.getSmartTransactionMetricsProperties)(updatedSmartTransaction),
+            sensitiveProperties: (0, utils_1.getSmartTransactionMetricsSensitiveProperties)(updatedSmartTransaction),
+        });
+    }
+    isNewSmartTransaction(smartTransactionUuid, chainId) {
+        const { smartTransactionsState: { smartTransactions }, } = this.state;
+        const currentSmartTransactions = smartTransactions[chainId !== null && chainId !== void 0 ? chainId : __classPrivateFieldGet(this, _SmartTransactionsController_chainId, "f")];
+        const currentIndex = currentSmartTransactions === null || currentSmartTransactions === void 0 ? void 0 : currentSmartTransactions.findIndex((stx) => stx.uuid === smartTransactionUuid);
+        return currentIndex === -1 || currentIndex === undefined;
+    }
+    updateSmartTransaction(smartTransaction, { networkClientId } = {}) {
+        let ethQuery = __classPrivateFieldGet(this, _SmartTransactionsController_ethQuery, "f");
+        let chainId = __classPrivateFieldGet(this, _SmartTransactionsController_chainId, "f");
+        if (networkClientId) {
+            const { configuration, provider } = this.messenger.call('NetworkController:getNetworkClientById', networkClientId);
+            chainId = configuration.chainId;
+            ethQuery = new eth_query_1.default(provider);
+        }
+        __classPrivateFieldGet(this, _SmartTransactionsController_instances, "m", _SmartTransactionsController_createOrUpdateSmartTransaction).call(this, smartTransaction, {
+            chainId,
+            ethQuery,
+        });
+    }
+    async updateSmartTransactions({ chainIds, } = {
+        chainIds: __classPrivateFieldGet(this, _SmartTransactionsController_instances, "m", _SmartTransactionsController_getChainIds).call(this),
+    }) {
+        const { smartTransactionsState: { smartTransactions }, } = this.state;
+        // Iterate over each chain group directly
+        for (const [chainId, transactions] of Object.entries(smartTransactions)) {
+            if (chainIds && !chainIds.includes(chainId)) {
+                continue;
+            }
+            // Filter pending transactions and map them to the desired shape
+            const pendingTransactions = transactions
+                .filter(utils_1.isSmartTransactionPending)
+                .map((pendingSmartTransaction) => {
+                // Use the transaction's chainId (from the key) to derive a networkClientId
+                const networkClientIdToUse = __classPrivateFieldGet(this, _SmartTransactionsController_instances, "m", _SmartTransactionsController_getNetworkClientId).call(this, {
+                    chainId: chainId,
+                });
+                return {
+                    uuid: pendingSmartTransaction.uuid,
+                    networkClientId: networkClientIdToUse,
+                    chainId: pendingSmartTransaction.chainId, // same as the key, but explicit on the transaction
+                };
+            });
+            if (pendingTransactions.length > 0) {
+                // Since each group is per chain, all transactions share the same chainId.
+                await this.fetchSmartTransactionsStatus(pendingTransactions);
+            }
+        }
+    }
+    // ! Ask backend API to accept list of uuids as params
+    async fetchSmartTransactionsStatus(transactions) {
+        // Since transactions come from the same chain group, take the chainId from the first one.
+        const { chainId } = transactions[0];
+        // Build query parameters with all UUIDs
+        const uuids = transactions.map((tx) => tx.uuid);
+        const params = new URLSearchParams({ uuids: uuids.join(',') });
+        // Get the ethQuery for the first transaction's networkClientId
+        const ethQuery = __classPrivateFieldGet(this, _SmartTransactionsController_instances, "m", _SmartTransactionsController_getEthQuery).call(this, {
+            networkClientId: transactions[0].networkClientId,
+        });
+        // Construct the URL and fetch the data
+        const url = `${(0, utils_1.getAPIRequestURL)(types_1.APIType.BATCH_STATUS, chainId)}?${params.toString()}`;
+        const data = (await __classPrivateFieldGet(this, _SmartTransactionsController_instances, "m", _SmartTransactionsController_fetch).call(this, url));
+        // Process each returned status
+        for (const [uuid, stxStatus] of Object.entries(data)) {
+            const matchingTx = transactions.find((tx) => tx.uuid === uuid);
+            if (!matchingTx) {
+                console.error(`No matching transaction found for uuid: ${uuid}`);
+                continue;
+            }
+            const smartTransaction = {
+                statusMetadata: stxStatus,
+                status: (0, utils_1.calculateStatus)(stxStatus),
+                cancellable: (0, utils_1.isSmartTransactionCancellable)(stxStatus),
+                uuid,
+                networkClientId: matchingTx.networkClientId,
+            };
+            await __classPrivateFieldGet(this, _SmartTransactionsController_instances, "m", _SmartTransactionsController_createOrUpdateSmartTransaction).call(this, smartTransaction, {
+                chainId,
+                ethQuery,
+            });
+        }
+        return data;
+    }
+    clearFees() {
+        const fees = {
+            approvalTxFees: null,
+            tradeTxFees: null,
+        };
+        this.update((state) => {
+            state.smartTransactionsState.fees = fees;
+        });
+        return fees;
+    }
+    async getFees(tradeTx, approvalTx, { networkClientId } = {}) {
+        const selectedNetworkClientId = networkClientId !== null && networkClientId !== void 0 ? networkClientId : this.messenger.call('NetworkController:getState').selectedNetworkClientId;
+        const chainId = __classPrivateFieldGet(this, _SmartTransactionsController_instances, "m", _SmartTransactionsController_getChainId).call(this, {
+            networkClientId: selectedNetworkClientId,
+        });
+        const transactions = [];
+        let unsignedTradeTransactionWithNonce;
+        if (approvalTx) {
+            const unsignedApprovalTransactionWithNonce = await __classPrivateFieldGet(this, _SmartTransactionsController_instances, "m", _SmartTransactionsController_addNonceToTransaction).call(this, approvalTx, selectedNetworkClientId);
+            transactions.push(unsignedApprovalTransactionWithNonce);
+            unsignedTradeTransactionWithNonce = Object.assign(Object.assign({}, tradeTx), { 
+                // If there is an approval tx, the trade tx's nonce is increased by 1.
+                nonce: (0, utils_1.incrementNonceInHex)(unsignedApprovalTransactionWithNonce.nonce) });
+        }
+        else if (tradeTx.nonce) {
+            unsignedTradeTransactionWithNonce = tradeTx;
+        }
+        else {
+            unsignedTradeTransactionWithNonce = await __classPrivateFieldGet(this, _SmartTransactionsController_instances, "m", _SmartTransactionsController_addNonceToTransaction).call(this, tradeTx, selectedNetworkClientId);
+        }
+        transactions.push(unsignedTradeTransactionWithNonce);
+        const data = await __classPrivateFieldGet(this, _SmartTransactionsController_trace, "f").call(this, { name: constants_1.SmartTransactionsTraceName.GetFees }, async () => await __classPrivateFieldGet(this, _SmartTransactionsController_instances, "m", _SmartTransactionsController_fetch).call(this, (0, utils_1.getAPIRequestURL)(types_1.APIType.GET_FEES, chainId), {
+            method: 'POST',
+            body: JSON.stringify({
+                txs: transactions,
+            }),
+        }));
+        let approvalTxFees;
+        let tradeTxFees;
+        if (approvalTx) {
+            approvalTxFees = data === null || data === void 0 ? void 0 : data.txs[0];
+            tradeTxFees = data === null || data === void 0 ? void 0 : data.txs[1];
+        }
+        else {
+            approvalTxFees = null;
+            tradeTxFees = data === null || data === void 0 ? void 0 : data.txs[0];
+        }
+        this.update((state) => {
+            if (chainId === __classPrivateFieldGet(this, _SmartTransactionsController_chainId, "f")) {
+                state.smartTransactionsState.fees = {
+                    approvalTxFees,
+                    tradeTxFees,
+                };
+            }
+            state.smartTransactionsState.feesByChainId[chainId] = {
+                approvalTxFees,
+                tradeTxFees,
+            };
+        });
+        return {
+            approvalTxFees,
+            tradeTxFees,
+        };
+    }
+    // * After this successful call client must add a nonce representative to
+    // * transaction controller external transactions list
+    async submitSignedTransactions({ transactionMeta, txParams, signedTransactions, signedCanceledTransactions = [], networkClientId, }) {
+        var _a, _b;
+        const selectedNetworkClientId = networkClientId !== null && networkClientId !== void 0 ? networkClientId : this.messenger.call('NetworkController:getState').selectedNetworkClientId;
+        const chainId = __classPrivateFieldGet(this, _SmartTransactionsController_instances, "m", _SmartTransactionsController_getChainId).call(this, {
+            networkClientId: selectedNetworkClientId,
+        });
+        const ethQuery = __classPrivateFieldGet(this, _SmartTransactionsController_instances, "m", _SmartTransactionsController_getEthQuery).call(this, {
+            networkClientId: selectedNetworkClientId,
+        });
+        const data = await __classPrivateFieldGet(this, _SmartTransactionsController_trace, "f").call(this, { name: constants_1.SmartTransactionsTraceName.SubmitTransactions }, async () => await __classPrivateFieldGet(this, _SmartTransactionsController_instances, "m", _SmartTransactionsController_fetch).call(this, (0, utils_1.getAPIRequestURL)(types_1.APIType.SUBMIT_TRANSACTIONS, chainId), {
+            method: 'POST',
+            body: JSON.stringify({
+                rawTxs: signedTransactions,
+                rawCancelTxs: signedCanceledTransactions,
+            }),
+        }));
+        const time = Date.now();
+        let preTxBalance;
+        try {
+            if (txParams === null || txParams === void 0 ? void 0 : txParams.from) {
+                const preTxBalanceBN = await (0, controller_utils_1.query)(ethQuery, 'getBalance', [
+                    txParams.from,
+                ]);
+                preTxBalance = new bignumber_js_1.BigNumber(preTxBalanceBN).toString(16);
+            }
+        }
+        catch (error) {
+            console.error('ethQuery.getBalance error:', error);
+        }
+        const requiresNonce = txParams && !txParams.nonce;
+        let nonce;
+        let nonceLock;
+        let nonceDetails = {};
+        // This should only happen for Swaps. Non-swaps transactions should already have a nonce
+        if (requiresNonce) {
+            try {
+                nonceLock = await this.messenger.call('TransactionController:getNonceLock', txParams.from, selectedNetworkClientId);
+                nonce = (0, bytes_1.hexlify)(nonceLock.nextNonce);
+                nonceDetails = nonceLock.nonceDetails;
+                (_a = txParams.nonce) !== null && _a !== void 0 ? _a : (txParams.nonce = nonce);
+            }
+            catch (error) {
+                console.error('Failed to acquire nonce lock:', error);
+                throw error;
+            }
+        }
+        const txHashes = signedTransactions.map((tx) => (0, utils_1.getTxHash)(tx));
+        const submitTransactionResponse = Object.assign(Object.assign({}, data), { txHash: txHashes[txHashes.length - 1], // For backward compatibility - use the last tx hash
+            txHashes });
+        try {
+            await __classPrivateFieldGet(this, _SmartTransactionsController_instances, "m", _SmartTransactionsController_createOrUpdateSmartTransaction).call(this, {
+                chainId,
+                nonceDetails,
+                preTxBalance,
+                status: types_1.SmartTransactionStatuses.PENDING,
+                time,
+                txParams,
+                uuid: submitTransactionResponse.uuid,
+                txHash: submitTransactionResponse.txHash,
+                cancellable: true,
+                type: (_b = transactionMeta === null || transactionMeta === void 0 ? void 0 : transactionMeta.type) !== null && _b !== void 0 ? _b : 'swap',
+                transactionId: transactionMeta === null || transactionMeta === void 0 ? void 0 : transactionMeta.id,
+                networkClientId: selectedNetworkClientId,
+                txHashes, // Add support for multiple transaction hashes
+            }, { chainId, ethQuery });
+        }
+        catch (error) {
+            console.error('Failed to create a smart transaction:', error);
+            throw error;
+        }
+        finally {
+            if (nonceLock) {
+                nonceLock.releaseLock();
+            }
+        }
+        return submitTransactionResponse;
+    }
+    // TODO: This should return if the cancellation was on chain or not (for nonce management)
+    // After this successful call client must update nonce representative
+    // in transaction controller external transactions list
+    async cancelSmartTransaction(uuid, { networkClientId, } = {}) {
+        const chainId = __classPrivateFieldGet(this, _SmartTransactionsController_instances, "m", _SmartTransactionsController_getChainId).call(this, { networkClientId });
+        await __classPrivateFieldGet(this, _SmartTransactionsController_trace, "f").call(this, { name: constants_1.SmartTransactionsTraceName.CancelTransaction }, async () => await __classPrivateFieldGet(this, _SmartTransactionsController_instances, "m", _SmartTransactionsController_fetch).call(this, (0, utils_1.getAPIRequestURL)(types_1.APIType.CANCEL, chainId), {
+            method: 'POST',
+            body: JSON.stringify({ uuid }),
+        }));
+    }
+    async fetchLiveness({ networkClientId, } = {}) {
+        const chainId = __classPrivateFieldGet(this, _SmartTransactionsController_instances, "m", _SmartTransactionsController_getChainId).call(this, { networkClientId });
+        let liveness = false;
+        try {
+            const response = await __classPrivateFieldGet(this, _SmartTransactionsController_trace, "f").call(this, { name: constants_1.SmartTransactionsTraceName.FetchLiveness }, async () => await __classPrivateFieldGet(this, _SmartTransactionsController_instances, "m", _SmartTransactionsController_fetch).call(this, (0, utils_1.getAPIRequestURL)(types_1.APIType.LIVENESS, chainId)));
+            liveness = Boolean(response.smartTransactions);
+        }
+        catch (error) {
+            console.log('"fetchLiveness" API call failed');
+        }
+        this.update((state) => {
+            if (chainId === __classPrivateFieldGet(this, _SmartTransactionsController_chainId, "f")) {
+                state.smartTransactionsState.liveness = liveness;
+            }
+            state.smartTransactionsState.livenessByChainId[chainId] = liveness;
+        });
+        return liveness;
+    }
+    async setStatusRefreshInterval(interval) {
+        if (interval !== __classPrivateFieldGet(this, _SmartTransactionsController_interval, "f")) {
+            __classPrivateFieldSet(this, _SmartTransactionsController_interval, interval, "f");
+        }
+    }
+    getTransactions({ addressFrom, status, }) {
+        const currentSmartTransactions = __classPrivateFieldGet(this, _SmartTransactionsController_instances, "m", _SmartTransactionsController_getCurrentSmartTransactions).call(this);
+        return currentSmartTransactions.filter((stx) => {
+            var _a;
+            return stx.status === status && ((_a = stx.txParams) === null || _a === void 0 ? void 0 : _a.from) === addressFrom;
+        });
+    }
+    getSmartTransactionByMinedTxHash(txHash) {
+        if (!txHash) {
+            return undefined;
+        }
+        const currentSmartTransactions = __classPrivateFieldGet(this, _SmartTransactionsController_instances, "m", _SmartTransactionsController_getCurrentSmartTransactions).call(this);
+        return currentSmartTransactions.find((smartTransaction) => {
+            var _a, _b;
+            return (((_b = (_a = smartTransaction.statusMetadata) === null || _a === void 0 ? void 0 : _a.minedHash) === null || _b === void 0 ? void 0 : _b.toLowerCase()) ===
+                txHash.toLowerCase());
+        });
+    }
+    wipeSmartTransactions({ address, ignoreNetwork, }) {
+        if (!address) {
+            return;
+        }
+        const addressLowerCase = address.toLowerCase();
+        if (ignoreNetwork) {
+            const { smartTransactionsState: { smartTransactions }, } = this.state;
+            Object.keys(smartTransactions).forEach((chainId) => {
+                __classPrivateFieldGet(this, _SmartTransactionsController_instances, "m", _SmartTransactionsController_wipeSmartTransactionsPerChainId).call(this, {
+                    chainId,
+                    addressLowerCase,
+                });
+            });
+        }
+        else {
+            __classPrivateFieldGet(this, _SmartTransactionsController_instances, "m", _SmartTransactionsController_wipeSmartTransactionsPerChainId).call(this, {
+                chainId: __classPrivateFieldGet(this, _SmartTransactionsController_chainId, "f"),
+                addressLowerCase,
+            });
+        }
+    }
+}
+exports.SmartTransactionsController = SmartTransactionsController;
+_SmartTransactionsController_interval = new WeakMap(), _SmartTransactionsController_clientId = new WeakMap(), _SmartTransactionsController_chainId = new WeakMap(), _SmartTransactionsController_supportedChainIds = new WeakMap(), _SmartTransactionsController_ethQuery = new WeakMap(), _SmartTransactionsController_trackMetaMetricsEvent = new WeakMap(), _SmartTransactionsController_getMetaMetricsProps = new WeakMap(), _SmartTransactionsController_getFeatureFlags = new WeakMap(), _SmartTransactionsController_trace = new WeakMap(), _SmartTransactionsController_instances = new WeakSet(), _SmartTransactionsController_fetch = 
+/* istanbul ignore next */
+async function _SmartTransactionsController_fetch(request, options) {
+    const fetchOptions = Object.assign(Object.assign({}, options), { headers: Object.assign({ 'Content-Type': 'application/json' }, (__classPrivateFieldGet(this, _SmartTransactionsController_clientId, "f") && { 'X-Client-Id': __classPrivateFieldGet(this, _SmartTransactionsController_clientId, "f") })) });
+    return (0, utils_1.handleFetch)(request, fetchOptions);
+}, _SmartTransactionsController_updateSmartTransaction = function _SmartTransactionsController_updateSmartTransaction(smartTransaction, { chainId = __classPrivateFieldGet(this, _SmartTransactionsController_chainId, "f"), }) {
+    var _a;
+    const { smartTransactionsState: { smartTransactions }, } = this.state;
+    const currentSmartTransactions = (_a = smartTransactions[chainId]) !== null && _a !== void 0 ? _a : [];
+    const currentIndex = currentSmartTransactions === null || currentSmartTransactions === void 0 ? void 0 : currentSmartTransactions.findIndex((stx) => stx.uuid === smartTransaction.uuid);
+    if (currentIndex === -1) {
+        return; // Smart transaction not found, don't update anything.
+    }
+    if (!(0, controller_utils_1.isSafeDynamicKey)(chainId)) {
+        return;
+    }
+    this.update((state) => {
+        state.smartTransactionsState.smartTransactions[chainId][currentIndex] = Object.assign(Object.assign({}, state.smartTransactionsState.smartTransactions[chainId][currentIndex]), smartTransaction);
+    });
+}, _SmartTransactionsController_addMetaMetricsPropsToNewSmartTransaction = async function _SmartTransactionsController_addMetaMetricsPropsToNewSmartTransaction(smartTransaction) {
+    const metaMetricsProps = await __classPrivateFieldGet(this, _SmartTransactionsController_getMetaMetricsProps, "f").call(this);
+    smartTransaction.accountHardwareType =
+        metaMetricsProps === null || metaMetricsProps === void 0 ? void 0 : metaMetricsProps.accountHardwareType;
+    smartTransaction.accountType = metaMetricsProps === null || metaMetricsProps === void 0 ? void 0 : metaMetricsProps.accountType;
+    smartTransaction.deviceModel = metaMetricsProps === null || metaMetricsProps === void 0 ? void 0 : metaMetricsProps.deviceModel;
+}, _SmartTransactionsController_createOrUpdateSmartTransaction = async function _SmartTransactionsController_createOrUpdateSmartTransaction(smartTransaction, { chainId = __classPrivateFieldGet(this, _SmartTransactionsController_chainId, "f"), ethQuery = __classPrivateFieldGet(this, _SmartTransactionsController_ethQuery, "f"), }) {
+    var _a;
+    const { smartTransactionsState: { smartTransactions }, } = this.state;
+    const currentSmartTransactions = (_a = smartTransactions[chainId]) !== null && _a !== void 0 ? _a : [];
+    const currentIndex = currentSmartTransactions === null || currentSmartTransactions === void 0 ? void 0 : currentSmartTransactions.findIndex((stx) => stx.uuid === smartTransaction.uuid);
+    const isNewSmartTransaction = this.isNewSmartTransaction(smartTransaction.uuid, chainId);
+    if (ethQuery === undefined) {
+        throw new Error(ETH_QUERY_ERROR_MSG);
+    }
+    if (isNewSmartTransaction) {
+        try {
+            await __classPrivateFieldGet(this, _SmartTransactionsController_instances, "m", _SmartTransactionsController_addMetaMetricsPropsToNewSmartTransaction).call(this, smartTransaction);
+        }
+        catch (error) {
+            console.error('Failed to add metrics props to smart transaction:', error);
+            // Continue without metrics props
+        }
+    }
+    this.trackStxStatusChange(smartTransaction, isNewSmartTransaction
+        ? undefined
+        : currentSmartTransactions[currentIndex]);
+    if (isNewSmartTransaction) {
+        // add smart transaction
+        const cancelledNonceIndex = currentSmartTransactions === null || currentSmartTransactions === void 0 ? void 0 : currentSmartTransactions.findIndex((stx) => {
+            var _a, _b, _c;
+            return ((_a = stx.txParams) === null || _a === void 0 ? void 0 : _a.nonce) === ((_b = smartTransaction.txParams) === null || _b === void 0 ? void 0 : _b.nonce) &&
+                ((_c = stx.status) === null || _c === void 0 ? void 0 : _c.startsWith('cancelled'));
+        });
+        const snapshot = (0, cloneDeep_1.default)(smartTransaction);
+        const history = [snapshot];
+        const historifiedSmartTransaction = Object.assign(Object.assign({}, smartTransaction), { history });
+        const nextSmartTransactions = cancelledNonceIndex > -1
+            ? currentSmartTransactions
+                .slice(0, cancelledNonceIndex)
+                .concat(currentSmartTransactions.slice(cancelledNonceIndex + 1))
+                .concat(historifiedSmartTransaction)
+            : currentSmartTransactions.concat(historifiedSmartTransaction);
+        this.update((state) => {
+            state.smartTransactionsState.smartTransactions[chainId] =
+                nextSmartTransactions;
+        });
+        return;
+    }
+    const currentSmartTransaction = currentSmartTransactions[currentIndex];
+    const nextSmartTransaction = Object.assign(Object.assign({}, currentSmartTransaction), smartTransaction);
+    // We have to emit this event here, because then a txHash is returned to the TransactionController once it's available
+    // and the #doesTransactionNeedConfirmation function will work properly, since it will find the txHash in the regular transactions list.
+    this.messenger.publish(`SmartTransactionsController:smartTransaction`, nextSmartTransaction);
+    if ((0, utils_1.shouldMarkRegularTransactionAsFailed)({
+        smartTransaction: nextSmartTransaction,
+        clientId: __classPrivateFieldGet(this, _SmartTransactionsController_clientId, "f"),
+        getFeatureFlags: __classPrivateFieldGet(this, _SmartTransactionsController_getFeatureFlags, "f"),
+    })) {
+        (0, utils_1.markRegularTransactionAsFailed)({
+            smartTransaction: nextSmartTransaction,
+            getRegularTransactions: () => this.messenger.call('TransactionController:getTransactions'),
+            updateTransaction: (transactionMeta, note) => this.messenger.call('TransactionController:updateTransaction', transactionMeta, note),
+        });
+    }
+    if ((smartTransaction.status === types_1.SmartTransactionStatuses.SUCCESS ||
+        smartTransaction.status === types_1.SmartTransactionStatuses.REVERTED) &&
+        !smartTransaction.confirmed) {
+        await __classPrivateFieldGet(this, _SmartTransactionsController_instances, "m", _SmartTransactionsController_confirmSmartTransaction).call(this, nextSmartTransaction, {
+            chainId,
+            ethQuery,
+        });
+    }
+    else {
+        __classPrivateFieldGet(this, _SmartTransactionsController_instances, "m", _SmartTransactionsController_updateSmartTransaction).call(this, smartTransaction, {
+            chainId,
+        });
+    }
+}, _SmartTransactionsController_doesTransactionNeedConfirmation = function _SmartTransactionsController_doesTransactionNeedConfirmation(txHash) {
+    if (!txHash) {
+        return true;
+    }
+    const transactions = this.messenger.call('TransactionController:getTransactions');
+    const foundTransaction = transactions === null || transactions === void 0 ? void 0 : transactions.find((tx) => {
+        var _a;
+        return ((_a = tx.hash) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === txHash.toLowerCase();
+    });
+    if (!foundTransaction) {
+        return true;
+    }
+    // If a found transaction is either confirmed or submitted, it doesn't need confirmation from the STX controller.
+    // When it's in the submitted state, the TransactionController checks its status and confirms it,
+    // so no need to confirm it again here.
+    return ![transaction_controller_1.TransactionStatus.confirmed, transaction_controller_1.TransactionStatus.submitted].includes(foundTransaction.status);
+}, _SmartTransactionsController_confirmSmartTransaction = async function _SmartTransactionsController_confirmSmartTransaction(smartTransaction, { chainId = __classPrivateFieldGet(this, _SmartTransactionsController_chainId, "f"), ethQuery = __classPrivateFieldGet(this, _SmartTransactionsController_ethQuery, "f"), }) {
+    var _a;
+    if (ethQuery === undefined) {
+        throw new Error(ETH_QUERY_ERROR_MSG);
+    }
+    const txHash = (_a = smartTransaction.statusMetadata) === null || _a === void 0 ? void 0 : _a.minedHash;
+    try {
+        const transactionReceipt = await (0, controller_utils_1.query)(ethQuery, 'getTransactionReceipt', [txHash]);
+        const transaction = await (0, controller_utils_1.query)(ethQuery, 'getTransactionByHash', [txHash]);
+        const maxFeePerGas = transaction === null || transaction === void 0 ? void 0 : transaction.maxFeePerGas;
+        const maxPriorityFeePerGas = transaction === null || transaction === void 0 ? void 0 : transaction.maxPriorityFeePerGas;
+        if (transactionReceipt === null || transactionReceipt === void 0 ? void 0 : transactionReceipt.blockNumber) {
+            const blockData = await (0, controller_utils_1.query)(ethQuery, 'getBlockByNumber', [transactionReceipt === null || transactionReceipt === void 0 ? void 0 : transactionReceipt.blockNumber, false]);
+            const baseFeePerGas = blockData === null || blockData === void 0 ? void 0 : blockData.baseFeePerGas;
+            const updatedTxParams = Object.assign(Object.assign({}, smartTransaction.txParams), { maxFeePerGas,
+                maxPriorityFeePerGas });
+            // call confirmExternalTransaction
+            const originalTxMeta = Object.assign(Object.assign({}, smartTransaction), { id: smartTransaction.uuid, status: transaction_controller_1.TransactionStatus.confirmed, hash: txHash, txParams: updatedTxParams });
+            // create txMeta snapshot for history
+            const snapshot = (0, utils_1.snapshotFromTxMeta)(originalTxMeta);
+            // recover previous tx state obj
+            const previousState = (0, utils_1.replayHistory)(originalTxMeta.history);
+            // generate history entry and add to history
+            const entry = (0, utils_1.generateHistoryEntry)(previousState, snapshot, 'txStateManager: setting status to confirmed');
+            const txMeta = entry.length > 0
+                ? Object.assign(Object.assign({}, originalTxMeta), { history: originalTxMeta.history.concat(entry) }) : originalTxMeta;
+            if (__classPrivateFieldGet(this, _SmartTransactionsController_instances, "m", _SmartTransactionsController_doesTransactionNeedConfirmation).call(this, txHash)) {
+                this.messenger.call('TransactionController:confirmExternalTransaction', 
+                // TODO: Replace 'as' assertion with correct typing for `txMeta`
+                txMeta, transactionReceipt, 
+                // TODO: Replace 'as' assertion with correct typing for `baseFeePerGas`
+                baseFeePerGas);
+            }
+            __classPrivateFieldGet(this, _SmartTransactionsController_trackMetaMetricsEvent, "f").call(this, {
+                event: constants_1.MetaMetricsEventName.StxConfirmed,
+                category: constants_1.MetaMetricsEventCategory.Transactions,
+                properties: (0, utils_1.getSmartTransactionMetricsProperties)(smartTransaction),
+                sensitiveProperties: (0, utils_1.getSmartTransactionMetricsSensitiveProperties)(smartTransaction),
+            });
+            __classPrivateFieldGet(this, _SmartTransactionsController_instances, "m", _SmartTransactionsController_updateSmartTransaction).call(this, Object.assign(Object.assign({}, smartTransaction), { confirmed: true }), {
+                chainId,
+            });
+        }
+    }
+    catch (error) {
+        __classPrivateFieldGet(this, _SmartTransactionsController_trackMetaMetricsEvent, "f").call(this, {
+            event: constants_1.MetaMetricsEventName.StxConfirmationFailed,
+            category: constants_1.MetaMetricsEventCategory.Transactions,
+        });
+        console.error('confirm error', error);
+    }
+    finally {
+        this.messenger.publish(`SmartTransactionsController:smartTransactionConfirmationDone`, smartTransaction);
+    }
+}, _SmartTransactionsController_addNonceToTransaction = async function _SmartTransactionsController_addNonceToTransaction(transaction, networkClientId) {
+    const nonceLock = await this.messenger.call('TransactionController:getNonceLock', transaction.from, networkClientId);
+    const nonce = nonceLock.nextNonce;
+    nonceLock.releaseLock();
+    return Object.assign(Object.assign({}, transaction), { nonce: `0x${nonce.toString(16)}` });
+}, _SmartTransactionsController_getChainId = function _SmartTransactionsController_getChainId({ networkClientId, } = {}) {
+    if (networkClientId) {
+        return this.messenger.call('NetworkController:getNetworkClientById', networkClientId).configuration.chainId;
+    }
+    return __classPrivateFieldGet(this, _SmartTransactionsController_chainId, "f");
+}, _SmartTransactionsController_getChainIds = function _SmartTransactionsController_getChainIds() {
+    const { networkConfigurationsByChainId } = this.messenger.call('NetworkController:getState');
+    return Object.keys(networkConfigurationsByChainId).filter((chainId) => __classPrivateFieldGet(this, _SmartTransactionsController_supportedChainIds, "f").includes(chainId));
+}, _SmartTransactionsController_getNetworkClientId = function _SmartTransactionsController_getNetworkClientId({ chainId }) {
+    const { networkConfigurationsByChainId } = this.messenger.call('NetworkController:getState');
+    return networkConfigurationsByChainId[chainId].rpcEndpoints[networkConfigurationsByChainId[chainId].defaultRpcEndpointIndex].networkClientId;
+}, _SmartTransactionsController_getEthQuery = function _SmartTransactionsController_getEthQuery({ networkClientId, } = {}) {
+    if (networkClientId) {
+        const { provider } = this.messenger.call('NetworkController:getNetworkClientById', networkClientId);
+        return new eth_query_1.default(provider);
+    }
+    if (__classPrivateFieldGet(this, _SmartTransactionsController_ethQuery, "f") === undefined) {
+        throw new Error(ETH_QUERY_ERROR_MSG);
+    }
+    return __classPrivateFieldGet(this, _SmartTransactionsController_ethQuery, "f");
+}, _SmartTransactionsController_getCurrentSmartTransactions = function _SmartTransactionsController_getCurrentSmartTransactions() {
+    const { smartTransactionsState: { smartTransactions }, } = this.state;
+    const smartTransactionsForAllChains = Object.values(smartTransactions).flat();
+    if (!smartTransactionsForAllChains ||
+        smartTransactionsForAllChains.length === 0) {
+        return [];
+    }
+    return smartTransactionsForAllChains;
+}, _SmartTransactionsController_wipeSmartTransactionsPerChainId = function _SmartTransactionsController_wipeSmartTransactionsPerChainId({ chainId, addressLowerCase, }) {
+    const { smartTransactionsState: { smartTransactions }, } = this.state;
+    const smartTransactionsForSelectedChain = smartTransactions === null || smartTransactions === void 0 ? void 0 : smartTransactions[chainId];
+    if (!smartTransactionsForSelectedChain ||
+        smartTransactionsForSelectedChain.length === 0) {
+        return;
+    }
+    const newSmartTransactionsForSelectedChain = smartTransactionsForSelectedChain.filter((smartTransaction) => { var _a; return ((_a = smartTransaction.txParams) === null || _a === void 0 ? void 0 : _a.from) !== addressLowerCase; });
+    this.update((state) => {
+        state.smartTransactionsState.smartTransactions[chainId] =
+            newSmartTransactionsForSelectedChain;
+    });
+};
+//# sourceMappingURL=SmartTransactionsController.cjs.map