@metamask/transaction-controller 36.1.0 → 37.1.0

package/dist/TransactionController.mjs

@@ -1,46 +1,2074 @@
-import {
-  ApprovalState,
-  CANCEL_RATE,
-  HARDFORK,
-  SPEED_UP_RATE,
-  TransactionController
-} from "./chunk-XTMJ25EF.mjs";
-import "./chunk-6DDVVUJC.mjs";
-import "./chunk-JOQK7A5G.mjs";
-import "./chunk-3AVRGHUO.mjs";
-import "./chunk-K4KOSAGM.mjs";
-import "./chunk-KG4UW4K4.mjs";
-import "./chunk-X4XSEYPL.mjs";
-import "./chunk-6B5BEO3R.mjs";
-import "./chunk-FRKQ3Z2L.mjs";
-import "./chunk-5G6OHAXI.mjs";
-import "./chunk-SMC5Q6ZH.mjs";
-import "./chunk-VEVVBHP3.mjs";
-import "./chunk-Z4GV3YQQ.mjs";
-import "./chunk-FG74Z3F5.mjs";
-import "./chunk-FMRLPVFZ.mjs";
-import "./chunk-VGFPVAKX.mjs";
-import "./chunk-NOHEXQ7Y.mjs";
-import "./chunk-3ZV5YEUV.mjs";
-import "./chunk-4V4XIPCI.mjs";
-import "./chunk-EKJXGERC.mjs";
-import "./chunk-EGQCE3FK.mjs";
-import "./chunk-HQSNKCXI.mjs";
-import "./chunk-KYRW4BLA.mjs";
-import "./chunk-AWIJZAW3.mjs";
-import "./chunk-SFFOC25Q.mjs";
-import "./chunk-JIFPK37W.mjs";
-import "./chunk-UHSRHP55.mjs";
-import "./chunk-NNHSNPT2.mjs";
-import "./chunk-O6ZZVIFH.mjs";
-import "./chunk-UQQWZT6C.mjs";
-import "./chunk-LFFYCDHB.mjs";
-import "./chunk-XUI43LEZ.mjs";
-export {
-  ApprovalState,
-  CANCEL_RATE,
-  HARDFORK,
-  SPEED_UP_RATE,
-  TransactionController
+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 __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 _TransactionController_instances, _TransactionController_internalEvents, _TransactionController_incomingTransactionOptions, _TransactionController_pendingTransactionOptions, _TransactionController_trace, _TransactionController_transactionHistoryLimit, _TransactionController_isSimulationEnabled, _TransactionController_testGasFeeFlows, _TransactionController_multichainTrackingHelper, _TransactionController_retryTransaction, _TransactionController_createNonceTracker, _TransactionController_createIncomingTransactionHelper, _TransactionController_createPendingTransactionTracker, _TransactionController_checkForPendingTransactionAndStartPolling, _TransactionController_stopAllTracking, _TransactionController_removeIncomingTransactionHelperListeners, _TransactionController_addIncomingTransactionHelperListeners, _TransactionController_removePendingTransactionTrackerListeners, _TransactionController_addPendingTransactionTrackerListeners, _TransactionController_getNonceTrackerPendingTransactions, _TransactionController_getGasFeeFlows, _TransactionController_getLayer1GasFeeFlows, _TransactionController_updateTransactionInternal, _TransactionController_checkIfTransactionParamsUpdated, _TransactionController_onTransactionParamsUpdated, _TransactionController_updateSimulationData, _TransactionController_onGasFeePollerTransactionUpdate, _TransactionController_getNetworkClientId, _TransactionController_getGlobalNetworkClientId, _TransactionController_getGlobalChainId, _TransactionController_isCustomNetwork, _TransactionController_getSelectedAccount, _TransactionController_updateSubmitHistory;
+function $importDefault(module) {
+    if (module?.__esModule) {
+        return module.default;
+    }
+    return module;
+}
+import $ethereumjscommon from "@ethereumjs/common";
+const { Hardfork, Common } = $ethereumjscommon;
+import { TransactionFactory } from "@ethereumjs/tx";
+import $ethereumjsutil from "@ethereumjs/util";
+const { bufferToHex } = $ethereumjsutil;
+import { BaseController } from "@metamask/base-controller";
+import { query, ApprovalType, ORIGIN_METAMASK, convertHexToDecimal, isInfuraNetworkType } from "@metamask/controller-utils";
+import $EthQuery from "@metamask/eth-query";
+const EthQuery = $importDefault($EthQuery);
+import { NetworkClientType } from "@metamask/network-controller";
+import { NonceTracker } from "@metamask/nonce-tracker";
+import { errorCodes, rpcErrors, providerErrors } from "@metamask/rpc-errors";
+import { add0x } from "@metamask/utils";
+import { Mutex } from "async-mutex";
+import { MethodRegistry } from "eth-method-registry";
+import { EventEmitter } from "events";
+import $lodash from "lodash";
+const { cloneDeep, mapValues, merge, pickBy, sortBy, isEqual } = $lodash;
+import { v1 as random } from "uuid";
+import { DefaultGasFeeFlow } from "./gas-flows/DefaultGasFeeFlow.mjs";
+import { LineaGasFeeFlow } from "./gas-flows/LineaGasFeeFlow.mjs";
+import { OptimismLayer1GasFeeFlow } from "./gas-flows/OptimismLayer1GasFeeFlow.mjs";
+import { ScrollLayer1GasFeeFlow } from "./gas-flows/ScrollLayer1GasFeeFlow.mjs";
+import { TestGasFeeFlow } from "./gas-flows/TestGasFeeFlow.mjs";
+import { EtherscanRemoteTransactionSource } from "./helpers/EtherscanRemoteTransactionSource.mjs";
+import { GasFeePoller } from "./helpers/GasFeePoller.mjs";
+import { IncomingTransactionHelper } from "./helpers/IncomingTransactionHelper.mjs";
+import { MultichainTrackingHelper } from "./helpers/MultichainTrackingHelper.mjs";
+import { PendingTransactionTracker } from "./helpers/PendingTransactionTracker.mjs";
+import { projectLogger as log } from "./logger.mjs";
+import { TransactionEnvelopeType, TransactionType, TransactionStatus, SimulationErrorCode } from "./types.mjs";
+import { validateConfirmedExternalTransaction } from "./utils/external-transactions.mjs";
+import { addGasBuffer, estimateGas, updateGas } from "./utils/gas.mjs";
+import { updateGasFees } from "./utils/gas-fees.mjs";
+import { getGasFeeFlow } from "./utils/gas-flow.mjs";
+import { addInitialHistorySnapshot, updateTransactionHistory } from "./utils/history.mjs";
+import { getTransactionLayer1GasFee, updateTransactionLayer1GasFee } from "./utils/layer1-gas-fee-flow.mjs";
+import { getAndFormatTransactionsForNonceTracker, getNextNonce } from "./utils/nonce.mjs";
+import { getTransactionParamsWithIncreasedGasFee } from "./utils/retry.mjs";
+import { getSimulationData } from "./utils/simulation.mjs";
+import { updatePostTransactionBalance, updateSwapsTransaction } from "./utils/swaps.mjs";
+import { determineTransactionType } from "./utils/transaction-type.mjs";
+import { normalizeTransactionParams, isEIP1559Transaction, validateGasValues, validateIfTransactionUnapproved, normalizeTxError, normalizeGasFeeValues } from "./utils/utils.mjs";
+import { validateTransactionOrigin, validateTxParams } from "./utils/validation.mjs";
+/**
+ * Metadata for the TransactionController state, describing how to "anonymize"
+ * the state and which parts should be persisted.
+ */
+const metadata = {
+    transactions: {
+        persist: true,
+        anonymous: false,
+    },
+    methodData: {
+        persist: true,
+        anonymous: false,
+    },
+    lastFetchedBlockNumbers: {
+        persist: true,
+        anonymous: false,
+    },
+    submitHistory: {
+        persist: true,
+        anonymous: false,
+    },
+};
+export const HARDFORK = Hardfork.London;
+const SUBMIT_HISTORY_LIMIT = 100;
+/**
+ * Multiplier used to determine a transaction's increased gas fee during cancellation
+ */
+export const CANCEL_RATE = 1.1;
+/**
+ * Multiplier used to determine a transaction's increased gas fee during speed up
+ */
+export const SPEED_UP_RATE = 1.1;
+/**
+ * The name of the {@link TransactionController}.
+ */
+const controllerName = 'TransactionController';
+/**
+ * Possible states of the approve transaction step.
+ */
+export var ApprovalState;
+(function (ApprovalState) {
+    ApprovalState["Approved"] = "approved";
+    ApprovalState["NotApproved"] = "not-approved";
+    ApprovalState["SkippedViaBeforePublishHook"] = "skipped-via-before-publish-hook";
+})(ApprovalState || (ApprovalState = {}));
+/**
+ * Get the default TransactionsController state.
+ *
+ * @returns The default TransactionsController state.
+ */
+function getDefaultTransactionControllerState() {
+    return {
+        methodData: {},
+        transactions: [],
+        lastFetchedBlockNumbers: {},
+        submitHistory: [],
+    };
+}
+/**
+ * Controller responsible for submitting and managing transactions.
+ */
+export class TransactionController extends BaseController {
+    failTransaction(transactionMeta, error, actionId) {
+        let newTransactionMeta;
+        try {
+            newTransactionMeta = __classPrivateFieldGet(this, _TransactionController_instances, "m", _TransactionController_updateTransactionInternal).call(this, {
+                transactionId: transactionMeta.id,
+                note: 'TransactionController#failTransaction - Add error message and set status to failed',
+                skipValidation: true,
+            }, (draftTransactionMeta) => {
+                draftTransactionMeta.status = TransactionStatus.failed;
+                draftTransactionMeta.error = normalizeTxError(error);
+            });
+        }
+        catch (err) {
+            log('Failed to mark transaction as failed', err);
+            newTransactionMeta = {
+                ...transactionMeta,
+                status: TransactionStatus.failed,
+                error: normalizeTxError(error),
+            };
+        }
+        this.messagingSystem.publish(`${controllerName}:transactionFailed`, {
+            actionId,
+            error: error.message,
+            transactionMeta: newTransactionMeta,
+        });
+        this.onTransactionStatusChange(newTransactionMeta);
+        this.messagingSystem.publish(`${controllerName}:transactionFinished`, newTransactionMeta);
+        __classPrivateFieldGet(this, _TransactionController_internalEvents, "f").emit(`${transactionMeta.id}:finished`, newTransactionMeta);
+    }
+    async registryLookup(fourBytePrefix) {
+        const registryMethod = await this.registry.lookup(fourBytePrefix);
+        if (!registryMethod) {
+            return {
+                registryMethod: '',
+                parsedRegistryMethod: { name: undefined, args: undefined },
+            };
+        }
+        const parsedRegistryMethod = this.registry.parse(registryMethod);
+        return { registryMethod, parsedRegistryMethod };
+    }
+    /**
+     * Constructs a TransactionController.
+     *
+     * @param options - The controller options.
+     * @param options.blockTracker - The block tracker used to poll for new blocks data.
+     * @param options.disableHistory - Whether to disable storing history in transaction metadata.
+     * @param options.disableSendFlowHistory - Explicitly disable transaction metadata history.
+     * @param options.disableSwaps - Whether to disable additional processing on swaps transactions.
+     * @param options.getCurrentAccountEIP1559Compatibility - Whether or not the account supports EIP-1559.
+     * @param options.getCurrentNetworkEIP1559Compatibility - Whether or not the network supports EIP-1559.
+     * @param options.getExternalPendingTransactions - Callback to retrieve pending transactions from external sources.
+     * @param options.getGasFeeEstimates - Callback to retrieve gas fee estimates.
+     * @param options.getNetworkClientRegistry - Gets the network client registry.
+     * @param options.getNetworkState - Gets the state of the network controller.
+     * @param options.getPermittedAccounts - Get accounts that a given origin has permissions for.
+     * @param options.getSavedGasFees - Gets the saved gas fee config.
+     * @param options.incomingTransactions - Configuration options for incoming transaction support.
+     * @param options.isMultichainEnabled - Enable multichain support.
+     * @param options.isSimulationEnabled - Whether new transactions will be automatically simulated.
+     * @param options.messenger - The controller messenger.
+     * @param options.onNetworkStateChange - Allows subscribing to network controller state changes.
+     * @param options.pendingTransactions - Configuration options for pending transaction support.
+     * @param options.provider - The provider used to create the underlying EthQuery instance.
+     * @param options.securityProviderRequest - A function for verifying a transaction, whether it is malicious or not.
+     * @param options.sign - Function used to sign transactions.
+     * @param options.state - Initial state to set on this controller.
+     * @param options.testGasFeeFlows - Whether to use the test gas fee flow.
+     * @param options.trace - Callback to generate trace information.
+     * @param options.transactionHistoryLimit - Transaction history limit.
+     * @param options.hooks - The controller hooks.
+     */
+    constructor({ blockTracker, disableHistory, disableSendFlowHistory, disableSwaps, getCurrentAccountEIP1559Compatibility, getCurrentNetworkEIP1559Compatibility, getExternalPendingTransactions, getGasFeeEstimates, getNetworkClientRegistry, getNetworkState, getPermittedAccounts, getSavedGasFees, incomingTransactions = {}, isMultichainEnabled = false, isSimulationEnabled, messenger, onNetworkStateChange, pendingTransactions = {}, provider, securityProviderRequest, sign, state, testGasFeeFlows, trace, transactionHistoryLimit = 40, hooks, }) {
+        super({
+            name: controllerName,
+            metadata,
+            messenger,
+            state: {
+                ...getDefaultTransactionControllerState(),
+                ...state,
+            },
+        });
+        _TransactionController_instances.add(this);
+        _TransactionController_internalEvents.set(this, new EventEmitter());
+        this.approvingTransactionIds = new Set();
+        this.mutex = new Mutex();
+        _TransactionController_incomingTransactionOptions.set(this, void 0);
+        _TransactionController_pendingTransactionOptions.set(this, void 0);
+        this.signAbortCallbacks = new Map();
+        _TransactionController_trace.set(this, void 0);
+        _TransactionController_transactionHistoryLimit.set(this, void 0);
+        _TransactionController_isSimulationEnabled.set(this, void 0);
+        _TransactionController_testGasFeeFlows.set(this, void 0);
+        _TransactionController_multichainTrackingHelper.set(this, void 0);
+        _TransactionController_checkForPendingTransactionAndStartPolling.set(this, () => {
+            // PendingTransactionTracker reads state through its getTransactions hook
+            this.pendingTransactionTracker.startIfPendingTransactions();
+            __classPrivateFieldGet(this, _TransactionController_multichainTrackingHelper, "f").checkForPendingTransactionAndStartPolling();
+        });
+        this.messagingSystem = messenger;
+        this.getNetworkState = getNetworkState;
+        this.isSendFlowHistoryDisabled = disableSendFlowHistory ?? false;
+        this.isHistoryDisabled = disableHistory ?? false;
+        this.isSwapsDisabled = disableSwaps ?? false;
+        __classPrivateFieldSet(this, _TransactionController_isSimulationEnabled, isSimulationEnabled ?? (() => true), "f");
+        // @ts-expect-error the type in eth-method-registry is inappropriate and should be changed
+        this.registry = new MethodRegistry({ provider });
+        this.getSavedGasFees = getSavedGasFees ?? ((_chainId) => undefined);
+        this.getCurrentAccountEIP1559Compatibility =
+            getCurrentAccountEIP1559Compatibility ?? (() => Promise.resolve(true));
+        this.getCurrentNetworkEIP1559Compatibility =
+            getCurrentNetworkEIP1559Compatibility;
+        this.getGasFeeEstimates =
+            getGasFeeEstimates || (() => Promise.resolve({}));
+        this.getPermittedAccounts = getPermittedAccounts;
+        this.getExternalPendingTransactions =
+            getExternalPendingTransactions ?? (() => []);
+        this.securityProviderRequest = securityProviderRequest;
+        __classPrivateFieldSet(this, _TransactionController_incomingTransactionOptions, incomingTransactions, "f");
+        __classPrivateFieldSet(this, _TransactionController_pendingTransactionOptions, pendingTransactions, "f");
+        __classPrivateFieldSet(this, _TransactionController_transactionHistoryLimit, transactionHistoryLimit, "f");
+        this.sign = sign;
+        __classPrivateFieldSet(this, _TransactionController_testGasFeeFlows, testGasFeeFlows === true, "f");
+        __classPrivateFieldSet(this, _TransactionController_trace, trace ?? ((_request, fn) => fn?.()), "f");
+        this.afterSign = hooks?.afterSign ?? (() => true);
+        this.beforeCheckPendingTransaction =
+            hooks?.beforeCheckPendingTransaction ??
+                /* istanbul ignore next */
+                (() => true);
+        this.beforePublish = hooks?.beforePublish ?? (() => true);
+        this.getAdditionalSignArguments =
+            hooks?.getAdditionalSignArguments ?? (() => []);
+        this.publish =
+            hooks?.publish ?? (() => Promise.resolve({ transactionHash: undefined }));
+        this.nonceTracker = __classPrivateFieldGet(this, _TransactionController_instances, "m", _TransactionController_createNonceTracker).call(this, {
+            provider,
+            blockTracker,
+        });
+        const findNetworkClientIdByChainId = (chainId) => {
+            return this.messagingSystem.call(`NetworkController:findNetworkClientIdByChainId`, chainId);
+        };
+        __classPrivateFieldSet(this, _TransactionController_multichainTrackingHelper, new MultichainTrackingHelper({
+            isMultichainEnabled,
+            provider,
+            nonceTracker: this.nonceTracker,
+            incomingTransactionOptions: incomingTransactions,
+            findNetworkClientIdByChainId,
+            getNetworkClientById: ((networkClientId) => {
+                return this.messagingSystem.call(`NetworkController:getNetworkClientById`, networkClientId);
+            }),
+            getNetworkClientRegistry,
+            removeIncomingTransactionHelperListeners: __classPrivateFieldGet(this, _TransactionController_instances, "m", _TransactionController_removeIncomingTransactionHelperListeners).bind(this),
+            removePendingTransactionTrackerListeners: __classPrivateFieldGet(this, _TransactionController_instances, "m", _TransactionController_removePendingTransactionTrackerListeners).bind(this),
+            createNonceTracker: __classPrivateFieldGet(this, _TransactionController_instances, "m", _TransactionController_createNonceTracker).bind(this),
+            createIncomingTransactionHelper: __classPrivateFieldGet(this, _TransactionController_instances, "m", _TransactionController_createIncomingTransactionHelper).bind(this),
+            createPendingTransactionTracker: __classPrivateFieldGet(this, _TransactionController_instances, "m", _TransactionController_createPendingTransactionTracker).bind(this),
+            onNetworkStateChange: (listener) => {
+                this.messagingSystem.subscribe('NetworkController:stateChange', listener);
+            },
+        }), "f");
+        __classPrivateFieldGet(this, _TransactionController_multichainTrackingHelper, "f").initialize();
+        const etherscanRemoteTransactionSource = new EtherscanRemoteTransactionSource({
+            includeTokenTransfers: incomingTransactions.includeTokenTransfers,
+        });
+        this.incomingTransactionHelper = __classPrivateFieldGet(this, _TransactionController_instances, "m", _TransactionController_createIncomingTransactionHelper).call(this, {
+            blockTracker,
+            etherscanRemoteTransactionSource,
+        });
+        this.pendingTransactionTracker = __classPrivateFieldGet(this, _TransactionController_instances, "m", _TransactionController_createPendingTransactionTracker).call(this, {
+            provider,
+            blockTracker,
+        });
+        this.gasFeeFlows = __classPrivateFieldGet(this, _TransactionController_instances, "m", _TransactionController_getGasFeeFlows).call(this);
+        this.layer1GasFeeFlows = __classPrivateFieldGet(this, _TransactionController_instances, "m", _TransactionController_getLayer1GasFeeFlows).call(this);
+        const gasFeePoller = new GasFeePoller({
+            findNetworkClientIdByChainId,
+            gasFeeFlows: this.gasFeeFlows,
+            getGasFeeControllerEstimates: this.getGasFeeEstimates,
+            getProvider: (chainId, networkClientId) => __classPrivateFieldGet(this, _TransactionController_multichainTrackingHelper, "f").getProvider({
+                networkClientId,
+                chainId,
+            }),
+            getTransactions: () => this.state.transactions,
+            layer1GasFeeFlows: this.layer1GasFeeFlows,
+            onStateChange: (listener) => {
+                this.messagingSystem.subscribe('TransactionController:stateChange', listener);
+            },
+        });
+        gasFeePoller.hub.on('transaction-updated', __classPrivateFieldGet(this, _TransactionController_instances, "m", _TransactionController_onGasFeePollerTransactionUpdate).bind(this));
+        // when transactionsController state changes
+        // check for pending transactions and start polling if there are any
+        this.messagingSystem.subscribe('TransactionController:stateChange', __classPrivateFieldGet(this, _TransactionController_checkForPendingTransactionAndStartPolling, "f"));
+        // TODO once v2 is merged make sure this only runs when
+        // selectedNetworkClientId changes
+        onNetworkStateChange(() => {
+            log('Detected network change', this.getChainId());
+            this.pendingTransactionTracker.startIfPendingTransactions();
+            this.onBootCleanup();
+        });
+        this.onBootCleanup();
+        __classPrivateFieldGet(this, _TransactionController_checkForPendingTransactionAndStartPolling, "f").call(this);
+    }
+    /**
+     * Stops polling and removes listeners to prepare the controller for garbage collection.
+     */
+    destroy() {
+        __classPrivateFieldGet(this, _TransactionController_instances, "m", _TransactionController_stopAllTracking).call(this);
+    }
+    /**
+     * Handle new method data request.
+     *
+     * @param fourBytePrefix - The method prefix.
+     * @returns The method data object corresponding to the given signature prefix.
+     */
+    async handleMethodData(fourBytePrefix) {
+        const releaseLock = await this.mutex.acquire();
+        try {
+            const { methodData } = this.state;
+            const knownMethod = Object.keys(methodData).find((knownFourBytePrefix) => fourBytePrefix === knownFourBytePrefix);
+            if (knownMethod) {
+                return methodData[fourBytePrefix];
+            }
+            const registry = await this.registryLookup(fourBytePrefix);
+            this.update((state) => {
+                state.methodData[fourBytePrefix] = registry;
+            });
+            return registry;
+        }
+        finally {
+            releaseLock();
+        }
+    }
+    /**
+     * Add a new unapproved transaction to state. Parameters will be validated, a
+     * unique transaction id will be generated, and gas and gasPrice will be calculated
+     * if not provided. If A `<tx.id>:unapproved` hub event will be emitted once added.
+     *
+     * @param txParams - Standard parameters for an Ethereum transaction.
+     * @param opts - Additional options to control how the transaction is added.
+     * @param opts.actionId - Unique ID to prevent duplicate requests.
+     * @param opts.deviceConfirmedOn - An enum to indicate what device confirmed the transaction.
+     * @param opts.method - RPC method that requested the transaction.
+     * @param opts.origin - The origin of the transaction request, such as a dApp hostname.
+     * @param opts.requireApproval - Whether the transaction requires approval by the user, defaults to true unless explicitly disabled.
+     * @param opts.securityAlertResponse - Response from security validator.
+     * @param opts.sendFlowHistory - The sendFlowHistory entries to add.
+     * @param opts.type - Type of transaction to add, such as 'cancel' or 'swap'.
+     * @param opts.swaps - Options for swaps transactions.
+     * @param opts.swaps.hasApproveTx - Whether the transaction has an approval transaction.
+     * @param opts.swaps.meta - Metadata for swap transaction.
+     * @param opts.networkClientId - The id of the network client for this transaction.
+     * @param opts.traceContext - The parent context for any new traces.
+     * @returns Object containing a promise resolving to the transaction hash if approved.
+     */
+    async addTransaction(txParams, { actionId, deviceConfirmedOn, method, origin, requireApproval, securityAlertResponse, sendFlowHistory, swaps = {}, traceContext, type, networkClientId: requestNetworkClientId, } = {}) {
+        log('Adding transaction', txParams);
+        txParams = normalizeTransactionParams(txParams);
+        if (requestNetworkClientId &&
+            !__classPrivateFieldGet(this, _TransactionController_multichainTrackingHelper, "f").has(requestNetworkClientId)) {
+            throw new Error('The networkClientId for this transaction could not be found');
+        }
+        const networkClientId = requestNetworkClientId ?? __classPrivateFieldGet(this, _TransactionController_instances, "m", _TransactionController_getGlobalNetworkClientId).call(this);
+        const isEIP1559Compatible = await this.getEIP1559Compatibility(networkClientId);
+        validateTxParams(txParams, isEIP1559Compatible);
+        if (origin && this.getPermittedAccounts) {
+            await validateTransactionOrigin(await this.getPermittedAccounts(origin), __classPrivateFieldGet(this, _TransactionController_instances, "m", _TransactionController_getSelectedAccount).call(this).address, txParams.from, origin);
+        }
+        const dappSuggestedGasFees = this.generateDappSuggestedGasFees(txParams, origin);
+        const chainId = this.getChainId(networkClientId);
+        const ethQuery = __classPrivateFieldGet(this, _TransactionController_multichainTrackingHelper, "f").getEthQuery({
+            networkClientId,
+            chainId,
+        });
+        const transactionType = type ?? (await determineTransactionType(txParams, ethQuery)).type;
+        const existingTransactionMeta = this.getTransactionWithActionId(actionId);
+        // If a request to add a transaction with the same actionId is submitted again, a new transaction will not be created for it.
+        let addedTransactionMeta = existingTransactionMeta
+            ? cloneDeep(existingTransactionMeta)
+            : {
+                // Add actionId to txMeta to check if same actionId is seen again
+                actionId,
+                chainId,
+                dappSuggestedGasFees,
+                deviceConfirmedOn,
+                id: random(),
+                origin,
+                securityAlertResponse,
+                status: TransactionStatus.unapproved,
+                time: Date.now(),
+                txParams,
+                userEditedGasLimit: false,
+                verifiedOnBlockchain: false,
+                type: transactionType,
+                networkClientId,
+            };
+        await __classPrivateFieldGet(this, _TransactionController_trace, "f").call(this, { name: 'Estimate Gas Properties', parentContext: traceContext }, (context) => this.updateGasProperties(addedTransactionMeta, {
+            traceContext: context,
+        }));
+        // Checks if a transaction already exists with a given actionId
+        if (!existingTransactionMeta) {
+            // Set security provider response
+            if (method && this.securityProviderRequest) {
+                const securityProviderResponse = await this.securityProviderRequest(addedTransactionMeta, method);
+                addedTransactionMeta.securityProviderResponse =
+                    securityProviderResponse;
+            }
+            if (!this.isSendFlowHistoryDisabled) {
+                addedTransactionMeta.sendFlowHistory = sendFlowHistory ?? [];
+            }
+            // Initial history push
+            if (!this.isHistoryDisabled) {
+                addedTransactionMeta = addInitialHistorySnapshot(addedTransactionMeta);
+            }
+            addedTransactionMeta = updateSwapsTransaction(addedTransactionMeta, transactionType, swaps, {
+                isSwapsDisabled: this.isSwapsDisabled,
+                cancelTransaction: this.cancelTransaction.bind(this),
+                messenger: this.messagingSystem,
+            });
+            this.addMetadata(addedTransactionMeta);
+            if (requireApproval !== false) {
+                __classPrivateFieldGet(this, _TransactionController_instances, "m", _TransactionController_updateSimulationData).call(this, addedTransactionMeta, {
+                    traceContext,
+                }).catch((error) => {
+                    log('Error while updating simulation data', error);
+                    throw error;
+                });
+            }
+            else {
+                log('Skipping simulation as approval not required');
+            }
+            this.messagingSystem.publish(`${controllerName}:unapprovedTransactionAdded`, addedTransactionMeta);
+        }
+        return {
+            result: this.processApproval(addedTransactionMeta, {
+                isExisting: Boolean(existingTransactionMeta),
+                requireApproval,
+                actionId,
+                traceContext,
+            }),
+            transactionMeta: addedTransactionMeta,
+        };
+    }
+    startIncomingTransactionPolling(networkClientIds = []) {
+        if (networkClientIds.length === 0) {
+            this.incomingTransactionHelper.start();
+            return;
+        }
+        __classPrivateFieldGet(this, _TransactionController_multichainTrackingHelper, "f").startIncomingTransactionPolling(networkClientIds);
+    }
+    stopIncomingTransactionPolling(networkClientIds = []) {
+        if (networkClientIds.length === 0) {
+            this.incomingTransactionHelper.stop();
+            return;
+        }
+        __classPrivateFieldGet(this, _TransactionController_multichainTrackingHelper, "f").stopIncomingTransactionPolling(networkClientIds);
+    }
+    stopAllIncomingTransactionPolling() {
+        this.incomingTransactionHelper.stop();
+        __classPrivateFieldGet(this, _TransactionController_multichainTrackingHelper, "f").stopAllIncomingTransactionPolling();
+    }
+    async updateIncomingTransactions(networkClientIds = []) {
+        if (networkClientIds.length === 0) {
+            await this.incomingTransactionHelper.update();
+            return;
+        }
+        await __classPrivateFieldGet(this, _TransactionController_multichainTrackingHelper, "f").updateIncomingTransactions(networkClientIds);
+    }
+    /**
+     * Attempts to cancel a transaction based on its ID by setting its status to "rejected"
+     * and emitting a `<tx.id>:finished` hub event.
+     *
+     * @param transactionId - The ID of the transaction to cancel.
+     * @param gasValues - The gas values to use for the cancellation transaction.
+     * @param options - The options for the cancellation transaction.
+     * @param options.actionId - Unique ID to prevent duplicate requests.
+     * @param options.estimatedBaseFee - The estimated base fee of the transaction.
+     */
+    async stopTransaction(transactionId, gasValues, { estimatedBaseFee, actionId, } = {}) {
+        return await __classPrivateFieldGet(this, _TransactionController_instances, "m", _TransactionController_retryTransaction).call(this, {
+            actionId,
+            estimatedBaseFee,
+            gasValues,
+            label: 'cancel',
+            rate: CANCEL_RATE,
+            transactionId,
+            transactionType: TransactionType.cancel,
+            prepareTransactionParams: (txParams) => {
+                delete txParams.data;
+                txParams.to = txParams.from;
+                txParams.value = '0x0';
+            },
+            afterSubmit: (newTransactionMeta) => {
+                this.messagingSystem.publish(`${controllerName}:transactionFinished`, newTransactionMeta);
+                __classPrivateFieldGet(this, _TransactionController_internalEvents, "f").emit(`${newTransactionMeta.id}:finished`, newTransactionMeta);
+            },
+        });
+    }
+    /**
+     * Attempts to speed up a transaction increasing transaction gasPrice by ten percent.
+     *
+     * @param transactionId - The ID of the transaction to speed up.
+     * @param gasValues - The gas values to use for the speed up transaction.
+     * @param options - The options for the speed up transaction.
+     * @param options.actionId - Unique ID to prevent duplicate requests
+     * @param options.estimatedBaseFee - The estimated base fee of the transaction.
+     */
+    async speedUpTransaction(transactionId, gasValues, { actionId, estimatedBaseFee, } = {}) {
+        return await __classPrivateFieldGet(this, _TransactionController_instances, "m", _TransactionController_retryTransaction).call(this, {
+            actionId,
+            estimatedBaseFee,
+            gasValues,
+            label: 'speed up',
+            rate: SPEED_UP_RATE,
+            transactionId,
+            transactionType: TransactionType.retry,
+            afterSubmit: (newTransactionMeta) => {
+                this.messagingSystem.publish(`${controllerName}:speedupTransactionAdded`, newTransactionMeta);
+            },
+        });
+    }
+    /**
+     * Estimates required gas for a given transaction.
+     *
+     * @param transaction - The transaction to estimate gas for.
+     * @param networkClientId - The network client id to use for the estimate.
+     * @returns The gas and gas price.
+     */
+    async estimateGas(transaction, networkClientId) {
+        const ethQuery = __classPrivateFieldGet(this, _TransactionController_multichainTrackingHelper, "f").getEthQuery({
+            networkClientId,
+        });
+        const { estimatedGas, simulationFails } = await estimateGas(transaction, ethQuery);
+        return { gas: estimatedGas, simulationFails };
+    }
+    /**
+     * Estimates required gas for a given transaction and add additional gas buffer with the given multiplier.
+     *
+     * @param transaction - The transaction params to estimate gas for.
+     * @param multiplier - The multiplier to use for the gas buffer.
+     * @param networkClientId - The network client id to use for the estimate.
+     */
+    async estimateGasBuffered(transaction, multiplier, networkClientId) {
+        const ethQuery = __classPrivateFieldGet(this, _TransactionController_multichainTrackingHelper, "f").getEthQuery({
+            networkClientId,
+        });
+        const { blockGasLimit, estimatedGas, simulationFails } = await estimateGas(transaction, ethQuery);
+        const gas = addGasBuffer(estimatedGas, blockGasLimit, multiplier);
+        return {
+            gas,
+            simulationFails,
+        };
+    }
+    /**
+     * Updates an existing transaction in state.
+     *
+     * @param transactionMeta - The new transaction to store in state.
+     * @param note - A note or update reason to include in the transaction history.
+     */
+    updateTransaction(transactionMeta, note) {
+        const { id: transactionId } = transactionMeta;
+        __classPrivateFieldGet(this, _TransactionController_instances, "m", _TransactionController_updateTransactionInternal).call(this, { transactionId, note }, () => ({
+            ...transactionMeta,
+        }));
+    }
+    /**
+     * Update the security alert response for a transaction.
+     *
+     * @param transactionId - ID of the transaction.
+     * @param securityAlertResponse - The new security alert response for the transaction.
+     */
+    updateSecurityAlertResponse(transactionId, securityAlertResponse) {
+        if (!securityAlertResponse) {
+            throw new Error('updateSecurityAlertResponse: securityAlertResponse should not be null');
+        }
+        const transactionMeta = this.getTransaction(transactionId);
+        if (!transactionMeta) {
+            throw new Error(`Cannot update security alert response as no transaction metadata found`);
+        }
+        const updatedTransactionMeta = {
+            ...transactionMeta,
+            securityAlertResponse,
+        };
+        this.updateTransaction(updatedTransactionMeta, `${controllerName}:updatesecurityAlertResponse - securityAlertResponse updated`);
+    }
+    /**
+     * Removes all transactions from state, optionally based on the current network.
+     *
+     * @param ignoreNetwork - Determines whether to wipe all transactions, or just those on the
+     * current network. If `true`, all transactions are wiped.
+     * @param address - If specified, only transactions originating from this address will be
+     * wiped on current network.
+     */
+    wipeTransactions(ignoreNetwork, address) {
+        /* istanbul ignore next */
+        if (ignoreNetwork && !address) {
+            this.update((state) => {
+                state.transactions = [];
+            });
+            return;
+        }
+        const currentChainId = this.getChainId();
+        const newTransactions = this.state.transactions.filter(({ chainId, txParams }) => {
+            const isMatchingNetwork = ignoreNetwork || chainId === currentChainId;
+            if (!isMatchingNetwork) {
+                return true;
+            }
+            const isMatchingAddress = !address || txParams.from?.toLowerCase() === address.toLowerCase();
+            return !isMatchingAddress;
+        });
+        this.update((state) => {
+            state.transactions = this.trimTransactionsForState(newTransactions);
+        });
+    }
+    /**
+     * Adds external provided transaction to state as confirmed transaction.
+     *
+     * @param transactionMeta - TransactionMeta to add transactions.
+     * @param transactionReceipt - TransactionReceipt of the external transaction.
+     * @param baseFeePerGas - Base fee per gas of the external transaction.
+     */
+    async confirmExternalTransaction(transactionMeta, transactionReceipt, baseFeePerGas) {
+        // Run validation and add external transaction to state.
+        const newTransactionMeta = this.addExternalTransaction(transactionMeta);
+        try {
+            const transactionId = newTransactionMeta.id;
+            // Make sure status is confirmed and define gasUsed as in receipt.
+            const updatedTransactionMeta = {
+                ...newTransactionMeta,
+                status: TransactionStatus.confirmed,
+                txReceipt: transactionReceipt,
+            };
+            if (baseFeePerGas) {
+                updatedTransactionMeta.baseFeePerGas = baseFeePerGas;
+            }
+            // Update same nonce local transactions as dropped and define replacedBy properties.
+            this.markNonceDuplicatesDropped(transactionId);
+            // Update external provided transaction with updated gas values and confirmed status.
+            this.updateTransaction(updatedTransactionMeta, `${controllerName}:confirmExternalTransaction - Add external transaction`);
+            this.onTransactionStatusChange(updatedTransactionMeta);
+            // Intentional given potential duration of process.
+            this.updatePostBalance(updatedTransactionMeta).catch((error) => {
+                log('Error while updating post balance', error);
+                throw error;
+            });
+            this.messagingSystem.publish(`${controllerName}:transactionConfirmed`, updatedTransactionMeta);
+        }
+        catch (error) {
+            console.error('Failed to confirm external transaction', error);
+        }
+    }
+    /**
+     * Append new send flow history to a transaction.
+     *
+     * @param transactionID - The ID of the transaction to update.
+     * @param currentSendFlowHistoryLength - The length of the current sendFlowHistory array.
+     * @param sendFlowHistoryToAdd - The sendFlowHistory entries to add.
+     * @returns The updated transactionMeta.
+     */
+    updateTransactionSendFlowHistory(transactionID, currentSendFlowHistoryLength, sendFlowHistoryToAdd) {
+        if (this.isSendFlowHistoryDisabled) {
+            throw new Error('Send flow history is disabled for the current transaction controller');
+        }
+        const transactionMeta = this.getTransaction(transactionID);
+        if (!transactionMeta) {
+            throw new Error(`Cannot update send flow history as no transaction metadata found`);
+        }
+        validateIfTransactionUnapproved(transactionMeta, 'updateTransactionSendFlowHistory');
+        const sendFlowHistory = transactionMeta.sendFlowHistory ?? [];
+        if (currentSendFlowHistoryLength === sendFlowHistory.length) {
+            const updatedTransactionMeta = {
+                ...transactionMeta,
+                sendFlowHistory: [...sendFlowHistory, ...sendFlowHistoryToAdd],
+            };
+            this.updateTransaction(updatedTransactionMeta, `${controllerName}:updateTransactionSendFlowHistory - sendFlowHistory updated`);
+        }
+        return this.getTransaction(transactionID);
+    }
+    /**
+     * Update the gas values of a transaction.
+     *
+     * @param transactionId - The ID of the transaction to update.
+     * @param gasValues - Gas values to update.
+     * @param gasValues.gas - Same as transaction.gasLimit.
+     * @param gasValues.gasLimit - Maxmimum number of units of gas to use for this transaction.
+     * @param gasValues.gasPrice - Price per gas for legacy transactions.
+     * @param gasValues.maxPriorityFeePerGas - Maximum amount per gas to give to validator as incentive.
+     * @param gasValues.maxFeePerGas - Maximum amount per gas to pay for the transaction, including the priority fee.
+     * @param gasValues.estimateUsed - Which estimate level was used.
+     * @param gasValues.estimateSuggested - Which estimate level that the API suggested.
+     * @param gasValues.defaultGasEstimates - The default estimate for gas.
+     * @param gasValues.originalGasEstimate - Original estimate for gas.
+     * @param gasValues.userEditedGasLimit - The gas limit supplied by user.
+     * @param gasValues.userFeeLevel - Estimate level user selected.
+     * @returns The updated transactionMeta.
+     */
+    updateTransactionGasFees(transactionId, { defaultGasEstimates, estimateUsed, estimateSuggested, gas, gasLimit, gasPrice, maxPriorityFeePerGas, maxFeePerGas, originalGasEstimate, userEditedGasLimit, userFeeLevel, }) {
+        const transactionMeta = this.getTransaction(transactionId);
+        if (!transactionMeta) {
+            throw new Error(`Cannot update transaction as no transaction metadata found`);
+        }
+        validateIfTransactionUnapproved(transactionMeta, 'updateTransactionGasFees');
+        let transactionGasFees = {
+            txParams: {
+                gas,
+                gasLimit,
+                gasPrice,
+                maxPriorityFeePerGas,
+                maxFeePerGas,
+            },
+            defaultGasEstimates,
+            estimateUsed,
+            estimateSuggested,
+            originalGasEstimate,
+            userEditedGasLimit,
+            userFeeLevel,
+            // TODO: Replace `any` with type
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        };
+        // only update what is defined
+        transactionGasFees.txParams = pickBy(transactionGasFees.txParams);
+        transactionGasFees = pickBy(transactionGasFees);
+        // merge updated gas values with existing transaction meta
+        const updatedMeta = merge({}, transactionMeta, transactionGasFees);
+        this.updateTransaction(updatedMeta, `${controllerName}:updateTransactionGasFees - gas values updated`);
+        return this.getTransaction(transactionId);
+    }
+    /**
+     * Update the previous gas values of a transaction.
+     *
+     * @param transactionId - The ID of the transaction to update.
+     * @param previousGas - Previous gas values to update.
+     * @param previousGas.gasLimit - Maxmimum number of units of gas to use for this transaction.
+     * @param previousGas.maxFeePerGas - Maximum amount per gas to pay for the transaction, including the priority fee.
+     * @param previousGas.maxPriorityFeePerGas - Maximum amount per gas to give to validator as incentive.
+     * @returns The updated transactionMeta.
+     */
+    updatePreviousGasParams(transactionId, { gasLimit, maxFeePerGas, maxPriorityFeePerGas, }) {
+        const transactionMeta = this.getTransaction(transactionId);
+        if (!transactionMeta) {
+            throw new Error(`Cannot update transaction as no transaction metadata found`);
+        }
+        validateIfTransactionUnapproved(transactionMeta, 'updatePreviousGasParams');
+        const transactionPreviousGas = {
+            previousGas: {
+                gasLimit,
+                maxFeePerGas,
+                maxPriorityFeePerGas,
+            },
+            // TODO: Replace `any` with type
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        };
+        // only update what is defined
+        transactionPreviousGas.previousGas = pickBy(transactionPreviousGas.previousGas);
+        // merge updated previous gas values with existing transaction meta
+        const updatedMeta = merge({}, transactionMeta, transactionPreviousGas);
+        this.updateTransaction(updatedMeta, `${controllerName}:updatePreviousGasParams - Previous gas values updated`);
+        return this.getTransaction(transactionId);
+    }
+    async getNonceLock(address, networkClientId) {
+        return __classPrivateFieldGet(this, _TransactionController_multichainTrackingHelper, "f").getNonceLock(address, networkClientId);
+    }
+    /**
+     * Updates the editable parameters of a transaction.
+     *
+     * @param txId - The ID of the transaction to update.
+     * @param params - The editable parameters to update.
+     * @param params.data - Data to pass with the transaction.
+     * @param params.gas - Maximum number of units of gas to use for the transaction.
+     * @param params.gasPrice - Price per gas for legacy transactions.
+     * @param params.from - Address to send the transaction from.
+     * @param params.to - Address to send the transaction to.
+     * @param params.value - Value associated with the transaction.
+     * @returns The updated transaction metadata.
+     */
+    async updateEditableParams(txId, { data, gas, gasPrice, from, to, value, }) {
+        const transactionMeta = this.getTransaction(txId);
+        if (!transactionMeta) {
+            throw new Error(`Cannot update editable params as no transaction metadata found`);
+        }
+        validateIfTransactionUnapproved(transactionMeta, 'updateEditableParams');
+        const editableParams = {
+            txParams: {
+                data,
+                from,
+                to,
+                value,
+                gas,
+                gasPrice,
+            },
+        };
+        editableParams.txParams = pickBy(editableParams.txParams);
+        const updatedTransaction = merge({}, transactionMeta, editableParams);
+        const provider = __classPrivateFieldGet(this, _TransactionController_multichainTrackingHelper, "f").getProvider({
+            chainId: transactionMeta.chainId,
+            networkClientId: transactionMeta.networkClientId,
+        });
+        const ethQuery = new EthQuery(provider);
+        const { type } = await determineTransactionType(updatedTransaction.txParams, ethQuery);
+        updatedTransaction.type = type;
+        await updateTransactionLayer1GasFee({
+            layer1GasFeeFlows: this.layer1GasFeeFlows,
+            provider,
+            transactionMeta: updatedTransaction,
+        });
+        this.updateTransaction(updatedTransaction, `Update Editable Params for ${txId}`);
+        return this.getTransaction(txId);
+    }
+    /**
+     * Signs and returns the raw transaction data for provided transaction params list.
+     *
+     * @param listOfTxParams - The list of transaction params to approve.
+     * @param opts - Options bag.
+     * @param opts.hasNonce - Whether the transactions already have a nonce.
+     * @returns The raw transactions.
+     */
+    async approveTransactionsWithSameNonce(listOfTxParams = [], { hasNonce } = {}) {
+        log('Approving transactions with same nonce', {
+            transactions: listOfTxParams,
+        });
+        if (listOfTxParams.length === 0) {
+            return '';
+        }
+        const initialTx = listOfTxParams[0];
+        const common = this.getCommonConfiguration(initialTx.chainId);
+        // We need to ensure we get the nonce using the the NonceTracker on the chain matching
+        // the txParams. In this context we only have chainId available to us, but the
+        // NonceTrackers are keyed by networkClientId. To workaround this, we attempt to find
+        // a networkClientId that matches the chainId. As a fallback, the globally selected
+        // network's NonceTracker will be used instead.
+        let networkClientId;
+        try {
+            networkClientId = this.messagingSystem.call(`NetworkController:findNetworkClientIdByChainId`, initialTx.chainId);
+        }
+        catch (err) {
+            log('failed to find networkClientId from chainId', err);
+        }
+        const initialTxAsEthTx = TransactionFactory.fromTxData(initialTx, {
+            common,
+        });
+        const initialTxAsSerializedHex = bufferToHex(initialTxAsEthTx.serialize());
+        if (this.approvingTransactionIds.has(initialTxAsSerializedHex)) {
+            return '';
+        }
+        this.approvingTransactionIds.add(initialTxAsSerializedHex);
+        let rawTransactions, nonceLock;
+        try {
+            // TODO: we should add a check to verify that all transactions have the same from address
+            const fromAddress = initialTx.from;
+            const requiresNonce = hasNonce !== true;
+            nonceLock = requiresNonce
+                ? await this.getNonceLock(fromAddress, networkClientId)
+                : undefined;
+            const nonce = nonceLock
+                ? add0x(nonceLock.nextNonce.toString(16))
+                : initialTx.nonce;
+            if (nonceLock) {
+                log('Using nonce from nonce tracker', nonce, nonceLock.nonceDetails);
+            }
+            rawTransactions = await Promise.all(listOfTxParams.map((txParams) => {
+                txParams.nonce = nonce;
+                return this.signExternalTransaction(txParams.chainId, txParams);
+            }));
+        }
+        catch (err) {
+            log('Error while signing transactions with same nonce', err);
+            // Must set transaction to submitted/failed before releasing lock
+            // continue with error chain
+            throw err;
+        }
+        finally {
+            nonceLock?.releaseLock();
+            this.approvingTransactionIds.delete(initialTxAsSerializedHex);
+        }
+        return rawTransactions;
+    }
+    /**
+     * Update a custodial transaction.
+     *
+     * @param transactionId - The ID of the transaction to update.
+     * @param options - The custodial transaction options to update.
+     * @param options.errorMessage - The error message to be assigned in case transaction status update to failed.
+     * @param options.hash - The new hash value to be assigned.
+     * @param options.status - The new status value to be assigned.
+     */
+    updateCustodialTransaction(transactionId, { errorMessage, hash, status, }) {
+        const transactionMeta = this.getTransaction(transactionId);
+        if (!transactionMeta) {
+            throw new Error(`Cannot update custodial transaction as no transaction metadata found`);
+        }
+        if (!transactionMeta.custodyId) {
+            throw new Error('Transaction must be a custodian transaction');
+        }
+        if (status &&
+            ![
+                TransactionStatus.submitted,
+                TransactionStatus.signed,
+                TransactionStatus.failed,
+            ].includes(status)) {
+            throw new Error(`Cannot update custodial transaction with status: ${status}`);
+        }
+        const updatedTransactionMeta = merge({}, transactionMeta, pickBy({ hash, status }));
+        if (updatedTransactionMeta.status === TransactionStatus.submitted) {
+            updatedTransactionMeta.submittedTime = new Date().getTime();
+        }
+        if (updatedTransactionMeta.status === TransactionStatus.failed) {
+            updatedTransactionMeta.error = normalizeTxError(new Error(errorMessage));
+        }
+        this.updateTransaction(updatedTransactionMeta, `${controllerName}:updateCustodialTransaction - Custodial transaction updated`);
+        if ([TransactionStatus.submitted, TransactionStatus.failed].includes(status)) {
+            this.messagingSystem.publish(`${controllerName}:transactionFinished`, updatedTransactionMeta);
+            __classPrivateFieldGet(this, _TransactionController_internalEvents, "f").emit(`${updatedTransactionMeta.id}:finished`, updatedTransactionMeta);
+        }
+    }
+    /**
+     * Search transaction metadata for matching entries.
+     *
+     * @param opts - Options bag.
+     * @param opts.searchCriteria - An object containing values or functions for transaction properties to filter transactions with.
+     * @param opts.initialList - The transactions to search. Defaults to the current state.
+     * @param opts.filterToCurrentNetwork - Whether to filter the results to the current network. Defaults to true.
+     * @param opts.limit - The maximum number of transactions to return. No limit by default.
+     * @returns An array of transactions matching the provided options.
+     */
+    getTransactions({ searchCriteria = {}, initialList, filterToCurrentNetwork = true, limit, } = {}) {
+        const chainId = this.getChainId();
+        // searchCriteria is an object that might have values that aren't predicate
+        // methods. When providing any other value type (string, number, etc), we
+        // consider this shorthand for "check the value at key for strict equality
+        // with the provided value". To conform this object to be only methods, we
+        // mapValues (lodash) such that every value on the object is a method that
+        // returns a boolean.
+        const predicateMethods = mapValues(searchCriteria, (predicate) => {
+            return typeof predicate === 'function'
+                ? predicate
+                : // TODO: Replace `any` with type
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    (v) => v === predicate;
+        });
+        const transactionsToFilter = initialList ?? this.state.transactions;
+        // Combine sortBy and pickBy to transform our state object into an array of
+        // matching transactions that are sorted by time.
+        const filteredTransactions = sortBy(pickBy(transactionsToFilter, (transaction) => {
+            if (filterToCurrentNetwork && transaction.chainId !== chainId) {
+                return false;
+            }
+            // iterate over the predicateMethods keys to check if the transaction
+            // matches the searchCriteria
+            for (const [key, predicate] of Object.entries(predicateMethods)) {
+                // We return false early as soon as we know that one of the specified
+                // search criteria do not match the transaction. This prevents
+                // needlessly checking all criteria when we already know the criteria
+                // are not fully satisfied. We check both txParams and the base
+                // object as predicate keys can be either.
+                if (key in transaction.txParams) {
+                    // TODO: Replace `any` with type
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    if (predicate(transaction.txParams[key]) === false) {
+                        return false;
+                    }
+                    // TODO: Replace `any` with type
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                }
+                else if (predicate(transaction[key]) === false) {
+                    return false;
+                }
+            }
+            return true;
+        }), 'time');
+        if (limit !== undefined) {
+            // We need to have all transactions of a given nonce in order to display
+            // necessary details in the UI. We use the size of this set to determine
+            // whether we have reached the limit provided, thus ensuring that all
+            // transactions of nonces we include will be sent to the UI.
+            const nonces = new Set();
+            const txs = [];
+            // By default, the transaction list we filter from is sorted by time ASC.
+            // To ensure that filtered results prefers the newest transactions we
+            // iterate from right to left, inserting transactions into front of a new
+            // array. The original order is preserved, but we ensure that newest txs
+            // are preferred.
+            for (let i = filteredTransactions.length - 1; i > -1; i--) {
+                const txMeta = filteredTransactions[i];
+                const { nonce } = txMeta.txParams;
+                if (!nonces.has(nonce)) {
+                    if (nonces.size < limit) {
+                        nonces.add(nonce);
+                    }
+                    else {
+                        continue;
+                    }
+                }
+                // Push transaction into the beginning of our array to ensure the
+                // original order is preserved.
+                txs.unshift(txMeta);
+            }
+            return txs;
+        }
+        return filteredTransactions;
+    }
+    async estimateGasFee({ transactionParams, chainId, networkClientId: requestNetworkClientId, }) {
+        const networkClientId = __classPrivateFieldGet(this, _TransactionController_instances, "m", _TransactionController_getNetworkClientId).call(this, {
+            networkClientId: requestNetworkClientId,
+            chainId,
+        });
+        const transactionMeta = {
+            txParams: transactionParams,
+            chainId,
+            networkClientId,
+        };
+        // Guaranteed as the default gas fee flow matches all transactions.
+        const gasFeeFlow = getGasFeeFlow(transactionMeta, this.gasFeeFlows);
+        const ethQuery = __classPrivateFieldGet(this, _TransactionController_multichainTrackingHelper, "f").getEthQuery({
+            networkClientId,
+            chainId,
+        });
+        const gasFeeControllerData = await this.getGasFeeEstimates({
+            networkClientId,
+        });
+        return gasFeeFlow.getGasFees({
+            ethQuery,
+            gasFeeControllerData,
+            transactionMeta,
+        });
+    }
+    /**
+     * Determine the layer 1 gas fee for the given transaction parameters.
+     *
+     * @param request - The request object.
+     * @param request.transactionParams - The transaction parameters to estimate the layer 1 gas fee for.
+     * @param request.chainId - The ID of the chain where the transaction will be executed.
+     * @param request.networkClientId - The ID of a specific network client to process the transaction.
+     */
+    async getLayer1GasFee({ transactionParams, chainId, networkClientId, }) {
+        const provider = __classPrivateFieldGet(this, _TransactionController_multichainTrackingHelper, "f").getProvider({
+            networkClientId,
+            chainId,
+        });
+        return await getTransactionLayer1GasFee({
+            layer1GasFeeFlows: this.layer1GasFeeFlows,
+            provider,
+            transactionMeta: {
+                txParams: transactionParams,
+                chainId,
+            },
+        });
+    }
+    async signExternalTransaction(chainId, transactionParams) {
+        if (!this.sign) {
+            throw new Error('No sign method defined.');
+        }
+        const normalizedTransactionParams = normalizeTransactionParams(transactionParams);
+        const type = isEIP1559Transaction(normalizedTransactionParams)
+            ? TransactionEnvelopeType.feeMarket
+            : TransactionEnvelopeType.legacy;
+        const updatedTransactionParams = {
+            ...normalizedTransactionParams,
+            type,
+            gasLimit: normalizedTransactionParams.gas,
+            chainId,
+        };
+        const { from } = updatedTransactionParams;
+        const common = this.getCommonConfiguration(chainId);
+        const unsignedTransaction = TransactionFactory.fromTxData(updatedTransactionParams, { common });
+        const signedTransaction = await this.sign(unsignedTransaction, from);
+        const rawTransaction = bufferToHex(signedTransaction.serialize());
+        return rawTransaction;
+    }
+    /**
+     * Removes unapproved transactions from state.
+     */
+    clearUnapprovedTransactions() {
+        const transactions = this.state.transactions.filter(({ status }) => status !== TransactionStatus.unapproved);
+        this.update((state) => {
+            state.transactions = this.trimTransactionsForState(transactions);
+        });
+    }
+    /**
+     * Stop the signing process for a specific transaction.
+     * Throws an error causing the transaction status to be set to failed.
+     * @param transactionId - The ID of the transaction to stop signing.
+     */
+    abortTransactionSigning(transactionId) {
+        const transactionMeta = this.getTransaction(transactionId);
+        if (!transactionMeta) {
+            throw new Error(`Cannot abort signing as no transaction metadata found`);
+        }
+        const abortCallback = this.signAbortCallbacks.get(transactionId);
+        if (!abortCallback) {
+            throw new Error(`Cannot abort signing as transaction is not waiting for signing`);
+        }
+        abortCallback();
+        this.signAbortCallbacks.delete(transactionId);
+    }
+    addMetadata(transactionMeta) {
+        validateTxParams(transactionMeta.txParams);
+        this.update((state) => {
+            state.transactions = this.trimTransactionsForState([
+                ...state.transactions,
+                transactionMeta,
+            ]);
+        });
+    }
+    async updateGasProperties(transactionMeta, { traceContext } = {}) {
+        const isEIP1559Compatible = transactionMeta.txParams.type !== TransactionEnvelopeType.legacy &&
+            (await this.getEIP1559Compatibility(transactionMeta.networkClientId));
+        const { networkClientId, chainId } = transactionMeta;
+        const isCustomNetwork = __classPrivateFieldGet(this, _TransactionController_instances, "m", _TransactionController_isCustomNetwork).call(this, networkClientId);
+        const ethQuery = __classPrivateFieldGet(this, _TransactionController_multichainTrackingHelper, "f").getEthQuery({
+            networkClientId,
+            chainId,
+        });
+        const provider = __classPrivateFieldGet(this, _TransactionController_multichainTrackingHelper, "f").getProvider({
+            networkClientId,
+            chainId,
+        });
+        await __classPrivateFieldGet(this, _TransactionController_trace, "f").call(this, { name: 'Update Gas', parentContext: traceContext }, async () => {
+            await updateGas({
+                ethQuery,
+                chainId,
+                isCustomNetwork,
+                txMeta: transactionMeta,
+            });
+        });
+        await __classPrivateFieldGet(this, _TransactionController_trace, "f").call(this, { name: 'Update Gas Fees', parentContext: traceContext }, async () => await updateGasFees({
+            eip1559: isEIP1559Compatible,
+            ethQuery,
+            gasFeeFlows: this.gasFeeFlows,
+            getGasFeeEstimates: this.getGasFeeEstimates,
+            getSavedGasFees: this.getSavedGasFees.bind(this),
+            txMeta: transactionMeta,
+        }));
+        await __classPrivateFieldGet(this, _TransactionController_trace, "f").call(this, { name: 'Update Layer 1 Gas Fees', parentContext: traceContext }, async () => await updateTransactionLayer1GasFee({
+            layer1GasFeeFlows: this.layer1GasFeeFlows,
+            provider,
+            transactionMeta,
+        }));
+    }
+    onBootCleanup() {
+        this.clearUnapprovedTransactions();
+        this.failIncompleteTransactions();
+    }
+    failIncompleteTransactions() {
+        const incompleteTransactions = this.state.transactions.filter((transaction) => [TransactionStatus.approved, TransactionStatus.signed].includes(transaction.status));
+        for (const transactionMeta of incompleteTransactions) {
+            this.failTransaction(transactionMeta, new Error('Transaction incomplete at startup'));
+        }
+    }
+    async processApproval(transactionMeta, { isExisting = false, requireApproval, shouldShowRequest = true, actionId, traceContext, }) {
+        const transactionId = transactionMeta.id;
+        let resultCallbacks;
+        const { meta, isCompleted } = this.isTransactionCompleted(transactionId);
+        const finishedPromise = isCompleted
+            ? Promise.resolve(meta)
+            : this.waitForTransactionFinished(transactionId);
+        if (meta && !isExisting && !isCompleted) {
+            try {
+                if (requireApproval !== false) {
+                    const acceptResult = await __classPrivateFieldGet(this, _TransactionController_trace, "f").call(this, { name: 'Await Approval', parentContext: traceContext }, (context) => this.requestApproval(transactionMeta, {
+                        shouldShowRequest,
+                        traceContext: context,
+                    }));
+                    resultCallbacks = acceptResult.resultCallbacks;
+                    const approvalValue = acceptResult.value;
+                    const updatedTransaction = approvalValue?.txMeta;
+                    if (updatedTransaction) {
+                        log('Updating transaction with approval data', {
+                            customNonce: updatedTransaction.customNonceValue,
+                            params: updatedTransaction.txParams,
+                        });
+                        this.updateTransaction(updatedTransaction, 'TransactionController#processApproval - Updated with approval data');
+                    }
+                }
+                const { isCompleted: isTxCompleted } = this.isTransactionCompleted(transactionId);
+                if (!isTxCompleted) {
+                    const approvalResult = await this.approveTransaction(transactionId, traceContext);
+                    if (approvalResult === ApprovalState.SkippedViaBeforePublishHook &&
+                        resultCallbacks) {
+                        resultCallbacks.success();
+                    }
+                    const updatedTransactionMeta = this.getTransaction(transactionId);
+                    this.messagingSystem.publish(`${controllerName}:transactionApproved`, {
+                        transactionMeta: updatedTransactionMeta,
+                        actionId,
+                    });
+                }
+                // TODO: Replace `any` with type
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            }
+            catch (error) {
+                const { isCompleted: isTxCompleted } = this.isTransactionCompleted(transactionId);
+                if (!isTxCompleted) {
+                    if (error?.code === errorCodes.provider.userRejectedRequest) {
+                        this.cancelTransaction(transactionId, actionId);
+                        throw providerErrors.userRejectedRequest('MetaMask Tx Signature: User denied transaction signature.');
+                    }
+                    else {
+                        this.failTransaction(meta, error, actionId);
+                    }
+                }
+            }
+        }
+        const finalMeta = await finishedPromise;
+        switch (finalMeta?.status) {
+            case TransactionStatus.failed:
+                resultCallbacks?.error(finalMeta.error);
+                throw rpcErrors.internal(finalMeta.error.message);
+            case TransactionStatus.submitted:
+                resultCallbacks?.success();
+                return finalMeta.hash;
+            default:
+                const internalError = rpcErrors.internal(`MetaMask Tx Signature: Unknown problem: ${JSON.stringify(finalMeta || transactionId)}`);
+                resultCallbacks?.error(internalError);
+                throw internalError;
+        }
+    }
+    /**
+     * Approves a transaction and updates it's status in state. If this is not a
+     * retry transaction, a nonce will be generated. The transaction is signed
+     * using the sign configuration property, then published to the blockchain.
+     * A `<tx.id>:finished` hub event is fired after success or failure.
+     *
+     * @param transactionId - The ID of the transaction to approve.
+     * @param traceContext - The parent context for any new traces.
+     */
+    async approveTransaction(transactionId, traceContext) {
+        const cleanupTasks = new Array();
+        cleanupTasks.push(await this.mutex.acquire());
+        let transactionMeta = this.getTransactionOrThrow(transactionId);
+        try {
+            if (!this.sign) {
+                this.failTransaction(transactionMeta, new Error('No sign method defined.'));
+                return ApprovalState.NotApproved;
+            }
+            else if (!transactionMeta.chainId) {
+                this.failTransaction(transactionMeta, new Error('No chainId defined.'));
+                return ApprovalState.NotApproved;
+            }
+            if (this.approvingTransactionIds.has(transactionId)) {
+                log('Skipping approval as signing in progress', transactionId);
+                return ApprovalState.NotApproved;
+            }
+            this.approvingTransactionIds.add(transactionId);
+            cleanupTasks.push(() => this.approvingTransactionIds.delete(transactionId));
+            const [nonce, releaseNonce] = await getNextNonce(transactionMeta, (address) => __classPrivateFieldGet(this, _TransactionController_multichainTrackingHelper, "f").getNonceLock(address, transactionMeta.networkClientId));
+            // must set transaction to submitted/failed before releasing lock
+            releaseNonce && cleanupTasks.push(releaseNonce);
+            transactionMeta = __classPrivateFieldGet(this, _TransactionController_instances, "m", _TransactionController_updateTransactionInternal).call(this, {
+                transactionId,
+                note: 'TransactionController#approveTransaction - Transaction approved',
+            }, (draftTxMeta) => {
+                const { txParams, chainId } = draftTxMeta;
+                draftTxMeta.status = TransactionStatus.approved;
+                draftTxMeta.txParams = {
+                    ...txParams,
+                    nonce,
+                    chainId,
+                    gasLimit: txParams.gas,
+                    ...(isEIP1559Transaction(txParams) && {
+                        type: TransactionEnvelopeType.feeMarket,
+                    }),
+                };
+            });
+            this.onTransactionStatusChange(transactionMeta);
+            const rawTx = await __classPrivateFieldGet(this, _TransactionController_trace, "f").call(this, { name: 'Sign', parentContext: traceContext }, () => this.signTransaction(transactionMeta, transactionMeta.txParams));
+            if (!this.beforePublish(transactionMeta)) {
+                log('Skipping publishing transaction based on hook');
+                this.messagingSystem.publish(`${controllerName}:transactionPublishingSkipped`, transactionMeta);
+                return ApprovalState.SkippedViaBeforePublishHook;
+            }
+            if (!rawTx) {
+                return ApprovalState.NotApproved;
+            }
+            const ethQuery = __classPrivateFieldGet(this, _TransactionController_multichainTrackingHelper, "f").getEthQuery({
+                networkClientId: transactionMeta.networkClientId,
+                chainId: transactionMeta.chainId,
+            });
+            let preTxBalance;
+            const shouldUpdatePreTxBalance = transactionMeta.type === TransactionType.swap;
+            if (shouldUpdatePreTxBalance) {
+                log('Determining pre-transaction balance');
+                preTxBalance = await query(ethQuery, 'getBalance', [
+                    transactionMeta.txParams.from,
+                ]);
+            }
+            log('Publishing transaction', transactionMeta.txParams);
+            let hash;
+            await __classPrivateFieldGet(this, _TransactionController_trace, "f").call(this, { name: 'Publish', parentContext: traceContext }, async () => {
+                ({ transactionHash: hash } = await this.publish(transactionMeta, rawTx));
+                if (hash === undefined) {
+                    hash = await this.publishTransaction(ethQuery, {
+                        ...transactionMeta,
+                        rawTx,
+                    });
+                }
+            });
+            log('Publish successful', hash);
+            transactionMeta = __classPrivateFieldGet(this, _TransactionController_instances, "m", _TransactionController_updateTransactionInternal).call(this, {
+                transactionId,
+                note: 'TransactionController#approveTransaction - Transaction submitted',
+            }, (draftTxMeta) => {
+                draftTxMeta.hash = hash;
+                draftTxMeta.status = TransactionStatus.submitted;
+                draftTxMeta.submittedTime = new Date().getTime();
+                if (shouldUpdatePreTxBalance) {
+                    draftTxMeta.preTxBalance = preTxBalance;
+                    log('Updated pre-transaction balance', preTxBalance);
+                }
+            });
+            this.messagingSystem.publish(`${controllerName}:transactionSubmitted`, {
+                transactionMeta,
+            });
+            this.messagingSystem.publish(`${controllerName}:transactionFinished`, transactionMeta);
+            __classPrivateFieldGet(this, _TransactionController_internalEvents, "f").emit(`${transactionId}:finished`, transactionMeta);
+            this.onTransactionStatusChange(transactionMeta);
+            return ApprovalState.Approved;
+            // TODO: Replace `any` with type
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        }
+        catch (error) {
+            this.failTransaction(transactionMeta, error);
+            return ApprovalState.NotApproved;
+        }
+        finally {
+            cleanupTasks.forEach((task) => task());
+        }
+    }
+    async publishTransaction(ethQuery, transactionMeta, { skipSubmitHistory } = {}) {
+        const transactionHash = await query(ethQuery, 'sendRawTransaction', [
+            transactionMeta.rawTx,
+        ]);
+        if (skipSubmitHistory !== true) {
+            __classPrivateFieldGet(this, _TransactionController_instances, "m", _TransactionController_updateSubmitHistory).call(this, transactionMeta, transactionHash);
+        }
+        return transactionHash;
+    }
+    /**
+     * Cancels a transaction based on its ID by setting its status to "rejected"
+     * and emitting a `<tx.id>:finished` hub event.
+     *
+     * @param transactionId - The ID of the transaction to cancel.
+     * @param actionId - The actionId passed from UI
+     */
+    cancelTransaction(transactionId, actionId) {
+        const transactionMeta = this.state.transactions.find(({ id }) => id === transactionId);
+        if (!transactionMeta) {
+            return;
+        }
+        this.update((state) => {
+            const transactions = state.transactions.filter(({ id }) => id !== transactionId);
+            state.transactions = this.trimTransactionsForState(transactions);
+        });
+        const updatedTransactionMeta = {
+            ...transactionMeta,
+            status: TransactionStatus.rejected,
+        };
+        this.messagingSystem.publish(`${controllerName}:transactionFinished`, updatedTransactionMeta);
+        __classPrivateFieldGet(this, _TransactionController_internalEvents, "f").emit(
+        // TODO: Either fix this lint violation or explain why it's necessary to ignore.
+        // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+        `${transactionMeta.id}:finished`, updatedTransactionMeta);
+        this.messagingSystem.publish(`${controllerName}:transactionRejected`, {
+            transactionMeta: updatedTransactionMeta,
+            actionId,
+        });
+        this.onTransactionStatusChange(updatedTransactionMeta);
+    }
+    /**
+     * Trim the amount of transactions that are set on the state. Checks
+     * if the length of the tx history is longer then desired persistence
+     * limit and then if it is removes the oldest confirmed or rejected tx.
+     * Pending or unapproved transactions will not be removed by this
+     * operation. For safety of presenting a fully functional transaction UI
+     * representation, this function will not break apart transactions with the
+     * same nonce, created on the same day, per network. Not accounting for
+     * transactions of the same nonce, same day and network combo can result in
+     * confusing or broken experiences in the UI.
+     *
+     * @param transactions - The transactions to be applied to the state.
+     * @returns The trimmed list of transactions.
+     */
+    trimTransactionsForState(transactions) {
+        const nonceNetworkSet = new Set();
+        const txsToKeep = [...transactions]
+            .sort((a, b) => (a.time > b.time ? -1 : 1)) // Descending time order
+            .filter((tx) => {
+            const { chainId, status, txParams, time } = tx;
+            if (txParams) {
+                // TODO: Either fix this lint violation or explain why it's necessary to ignore.
+                // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+                const key = `${String(txParams.nonce)}-${convertHexToDecimal(chainId)}-${new Date(time).toDateString()}`;
+                if (nonceNetworkSet.has(key)) {
+                    return true;
+                }
+                else if (nonceNetworkSet.size < __classPrivateFieldGet(this, _TransactionController_transactionHistoryLimit, "f") ||
+                    !this.isFinalState(status)) {
+                    nonceNetworkSet.add(key);
+                    return true;
+                }
+            }
+            return false;
+        });
+        txsToKeep.reverse(); // Ascending time order
+        return txsToKeep;
+    }
+    /**
+     * Determines if the transaction is in a final state.
+     *
+     * @param status - The transaction status.
+     * @returns Whether the transaction is in a final state.
+     */
+    isFinalState(status) {
+        return (status === TransactionStatus.rejected ||
+            status === TransactionStatus.confirmed ||
+            status === TransactionStatus.failed);
+    }
+    /**
+     * Whether the transaction has at least completed all local processing.
+     *
+     * @param status - The transaction status.
+     * @returns Whether the transaction is in a final state.
+     */
+    isLocalFinalState(status) {
+        return [
+            TransactionStatus.confirmed,
+            TransactionStatus.failed,
+            TransactionStatus.rejected,
+            TransactionStatus.submitted,
+        ].includes(status);
+    }
+    async requestApproval(txMeta, { shouldShowRequest, traceContext, }) {
+        const id = this.getApprovalId(txMeta);
+        const { origin } = txMeta;
+        const type = ApprovalType.Transaction;
+        const requestData = { txId: txMeta.id };
+        await __classPrivateFieldGet(this, _TransactionController_trace, "f").call(this, {
+            name: 'Notification Display',
+            id,
+            parentContext: traceContext,
+        });
+        return (await this.messagingSystem.call('ApprovalController:addRequest', {
+            id,
+            origin: origin || ORIGIN_METAMASK,
+            type,
+            requestData,
+            expectsResult: true,
+        }, shouldShowRequest));
+    }
+    getTransaction(transactionId) {
+        const { transactions } = this.state;
+        return transactions.find(({ id }) => id === transactionId);
+    }
+    getTransactionOrThrow(transactionId, errorMessagePrefix = 'TransactionController') {
+        const txMeta = this.getTransaction(transactionId);
+        if (!txMeta) {
+            throw new Error(`${errorMessagePrefix}: No transaction found with id ${transactionId}`);
+        }
+        return txMeta;
+    }
+    getApprovalId(txMeta) {
+        return String(txMeta.id);
+    }
+    isTransactionCompleted(transactionId) {
+        const transaction = this.getTransaction(transactionId);
+        if (!transaction) {
+            return { meta: undefined, isCompleted: false };
+        }
+        const isCompleted = this.isLocalFinalState(transaction.status);
+        return { meta: transaction, isCompleted };
+    }
+    getChainId(networkClientId) {
+        const globalChainId = __classPrivateFieldGet(this, _TransactionController_instances, "m", _TransactionController_getGlobalChainId).call(this);
+        const globalNetworkClientId = __classPrivateFieldGet(this, _TransactionController_instances, "m", _TransactionController_getGlobalNetworkClientId).call(this);
+        if (!networkClientId || networkClientId === globalNetworkClientId) {
+            return globalChainId;
+        }
+        return this.messagingSystem.call(`NetworkController:getNetworkClientById`, networkClientId).configuration.chainId;
+    }
+    prepareUnsignedEthTx(chainId, txParams) {
+        return TransactionFactory.fromTxData(txParams, {
+            freeze: false,
+            common: this.getCommonConfiguration(chainId),
+        });
+    }
+    /**
+     * `@ethereumjs/tx` uses `@ethereumjs/common` as a configuration tool for
+     * specifying which chain, network, hardfork and EIPs to support for
+     * a transaction. By referencing this configuration, and analyzing the fields
+     * specified in txParams, @ethereumjs/tx is able to determine which EIP-2718
+     * transaction type to use.
+     *
+     * @param chainId - The chainId to use for the configuration.
+     * @returns common configuration object
+     */
+    getCommonConfiguration(chainId) {
+        const customChainParams = {
+            chainId: parseInt(chainId, 16),
+            defaultHardfork: HARDFORK,
+        };
+        return Common.custom(customChainParams);
+    }
+    onIncomingTransactions({ added, updated, }) {
+        this.update((state) => {
+            const { transactions: currentTransactions } = state;
+            const updatedTransactions = [
+                ...added,
+                ...currentTransactions.map((originalTransaction) => {
+                    const updatedTransaction = updated.find(({ hash }) => hash === originalTransaction.hash);
+                    return updatedTransaction ?? originalTransaction;
+                }),
+            ];
+            state.transactions = this.trimTransactionsForState(updatedTransactions);
+        });
+    }
+    onUpdatedLastFetchedBlockNumbers({ lastFetchedBlockNumbers, blockNumber, }) {
+        this.update((state) => {
+            state.lastFetchedBlockNumbers = lastFetchedBlockNumbers;
+        });
+        this.messagingSystem.publish(`${controllerName}:incomingTransactionBlockReceived`, blockNumber);
+    }
+    generateDappSuggestedGasFees(txParams, origin) {
+        if (!origin || origin === ORIGIN_METAMASK) {
+            return undefined;
+        }
+        const { gasPrice, maxFeePerGas, maxPriorityFeePerGas, gas } = txParams;
+        if (gasPrice === undefined &&
+            maxFeePerGas === undefined &&
+            maxPriorityFeePerGas === undefined &&
+            gas === undefined) {
+            return undefined;
+        }
+        const dappSuggestedGasFees = {};
+        if (gasPrice !== undefined) {
+            dappSuggestedGasFees.gasPrice = gasPrice;
+        }
+        else if (maxFeePerGas !== undefined ||
+            maxPriorityFeePerGas !== undefined) {
+            dappSuggestedGasFees.maxFeePerGas = maxFeePerGas;
+            dappSuggestedGasFees.maxPriorityFeePerGas = maxPriorityFeePerGas;
+        }
+        if (gas !== undefined) {
+            dappSuggestedGasFees.gas = gas;
+        }
+        return dappSuggestedGasFees;
+    }
+    /**
+     * Validates and adds external provided transaction to state.
+     *
+     * @param transactionMeta - Nominated external transaction to be added to state.
+     * @returns The new transaction.
+     */
+    addExternalTransaction(transactionMeta) {
+        const { chainId } = transactionMeta;
+        const { transactions } = this.state;
+        const fromAddress = transactionMeta?.txParams?.from;
+        const sameFromAndNetworkTransactions = transactions.filter((transaction) => transaction.txParams.from === fromAddress &&
+            transaction.chainId === chainId);
+        const confirmedTxs = sameFromAndNetworkTransactions.filter((transaction) => transaction.status === TransactionStatus.confirmed);
+        const pendingTxs = sameFromAndNetworkTransactions.filter((transaction) => transaction.status === TransactionStatus.submitted);
+        validateConfirmedExternalTransaction(transactionMeta, confirmedTxs, pendingTxs);
+        // Make sure provided external transaction has non empty history array
+        const newTransactionMeta = (transactionMeta.history ?? []).length === 0 && !this.isHistoryDisabled
+            ? addInitialHistorySnapshot(transactionMeta)
+            : transactionMeta;
+        this.update((state) => {
+            state.transactions = this.trimTransactionsForState([
+                ...state.transactions,
+                newTransactionMeta,
+            ]);
+        });
+        return newTransactionMeta;
+    }
+    /**
+     * Sets other txMeta statuses to dropped if the txMeta that has been confirmed has other transactions
+     * in the transactions have the same nonce.
+     *
+     * @param transactionId - Used to identify original transaction.
+     */
+    markNonceDuplicatesDropped(transactionId) {
+        const transactionMeta = this.getTransaction(transactionId);
+        if (!transactionMeta) {
+            return;
+        }
+        const nonce = transactionMeta.txParams?.nonce;
+        const from = transactionMeta.txParams?.from;
+        const { chainId } = transactionMeta;
+        const sameNonceTransactions = this.state.transactions.filter((transaction) => transaction.id !== transactionId &&
+            transaction.txParams.from === from &&
+            transaction.txParams.nonce === nonce &&
+            transaction.chainId === chainId &&
+            transaction.type !== TransactionType.incoming);
+        const sameNonceTransactionIds = sameNonceTransactions.map((transaction) => transaction.id);
+        if (sameNonceTransactions.length === 0) {
+            return;
+        }
+        this.update((state) => {
+            for (const transaction of state.transactions) {
+                if (sameNonceTransactionIds.includes(transaction.id)) {
+                    transaction.replacedBy = transactionMeta?.hash;
+                    transaction.replacedById = transactionMeta?.id;
+                }
+            }
+        });
+        for (const transaction of this.state.transactions) {
+            if (sameNonceTransactionIds.includes(transaction.id) &&
+                transaction.status !== TransactionStatus.failed) {
+                this.setTransactionStatusDropped(transaction);
+            }
+        }
+    }
+    /**
+     * Method to set transaction status to dropped.
+     *
+     * @param transactionMeta - TransactionMeta of transaction to be marked as dropped.
+     */
+    setTransactionStatusDropped(transactionMeta) {
+        const updatedTransactionMeta = {
+            ...transactionMeta,
+            status: TransactionStatus.dropped,
+        };
+        this.messagingSystem.publish(`${controllerName}:transactionDropped`, {
+            transactionMeta: updatedTransactionMeta,
+        });
+        this.updateTransaction(updatedTransactionMeta, 'TransactionController#setTransactionStatusDropped - Transaction dropped');
+        this.onTransactionStatusChange(updatedTransactionMeta);
+    }
+    /**
+     * Get transaction with provided actionId.
+     *
+     * @param actionId - Unique ID to prevent duplicate requests
+     * @returns the filtered transaction
+     */
+    getTransactionWithActionId(actionId) {
+        return this.state.transactions.find((transaction) => actionId && transaction.actionId === actionId);
+    }
+    async waitForTransactionFinished(transactionId) {
+        return new Promise((resolve) => {
+            __classPrivateFieldGet(this, _TransactionController_internalEvents, "f").once(`${transactionId}:finished`, (txMeta) => {
+                resolve(txMeta);
+            });
+        });
+    }
+    /**
+     * Updates the r, s, and v properties of a TransactionMeta object
+     * with values from a signed transaction.
+     *
+     * @param transactionMeta - The TransactionMeta object to update.
+     * @param signedTx - The encompassing type for all transaction types containing r, s, and v values.
+     * @returns The updated TransactionMeta object.
+     */
+    updateTransactionMetaRSV(transactionMeta, signedTx) {
+        const transactionMetaWithRsv = cloneDeep(transactionMeta);
+        for (const key of ['r', 's', 'v']) {
+            const value = signedTx[key];
+            if (value === undefined || value === null) {
+                continue;
+            }
+            transactionMetaWithRsv[key] = add0x(value.toString(16));
+        }
+        return transactionMetaWithRsv;
+    }
+    async getEIP1559Compatibility(networkClientId) {
+        const currentNetworkIsEIP1559Compatible = await this.getCurrentNetworkEIP1559Compatibility(networkClientId);
+        const currentAccountIsEIP1559Compatible = await this.getCurrentAccountEIP1559Compatibility();
+        return (currentNetworkIsEIP1559Compatible && currentAccountIsEIP1559Compatible);
+    }
+    async signTransaction(transactionMeta, txParams) {
+        log('Signing transaction', txParams);
+        const unsignedEthTx = this.prepareUnsignedEthTx(transactionMeta.chainId, txParams);
+        this.approvingTransactionIds.add(transactionMeta.id);
+        const signedTx = await new Promise((resolve, reject) => {
+            this.sign?.(unsignedEthTx, txParams.from, ...this.getAdditionalSignArguments(transactionMeta)).then(resolve, reject);
+            this.signAbortCallbacks.set(transactionMeta.id, () => reject(new Error('Signing aborted by user')));
+        });
+        this.signAbortCallbacks.delete(transactionMeta.id);
+        if (!signedTx) {
+            log('Skipping signed status as no signed transaction');
+            return undefined;
+        }
+        const transactionMetaFromHook = cloneDeep(transactionMeta);
+        if (!this.afterSign(transactionMetaFromHook, signedTx)) {
+            this.updateTransaction(transactionMetaFromHook, 'TransactionController#signTransaction - Update after sign');
+            log('Skipping signed status based on hook');
+            return undefined;
+        }
+        const transactionMetaWithRsv = {
+            ...this.updateTransactionMetaRSV(transactionMetaFromHook, signedTx),
+            status: TransactionStatus.signed,
+        };
+        this.updateTransaction(transactionMetaWithRsv, 'TransactionController#approveTransaction - Transaction signed');
+        this.onTransactionStatusChange(transactionMetaWithRsv);
+        const rawTx = bufferToHex(signedTx.serialize());
+        const transactionMetaWithRawTx = merge({}, transactionMetaWithRsv, {
+            rawTx,
+        });
+        this.updateTransaction(transactionMetaWithRawTx, 'TransactionController#approveTransaction - RawTransaction added');
+        return rawTx;
+    }
+    onTransactionStatusChange(transactionMeta) {
+        this.messagingSystem.publish(`${controllerName}:transactionStatusUpdated`, {
+            transactionMeta,
+        });
+    }
+    getNonceTrackerTransactions(status, address, chainId = this.getChainId()) {
+        return getAndFormatTransactionsForNonceTracker(chainId, address, status, this.state.transactions);
+    }
+    onConfirmedTransaction(transactionMeta) {
+        log('Processing confirmed transaction', transactionMeta.id);
+        this.markNonceDuplicatesDropped(transactionMeta.id);
+        this.messagingSystem.publish(`${controllerName}:transactionConfirmed`, transactionMeta);
+        this.onTransactionStatusChange(transactionMeta);
+        // Intentional given potential duration of process.
+        this.updatePostBalance(transactionMeta).catch((error) => {
+            log('Error while updating post balance', error);
+            throw error;
+        });
+    }
+    async updatePostBalance(transactionMeta) {
+        try {
+            if (transactionMeta.type !== TransactionType.swap) {
+                return;
+            }
+            const ethQuery = __classPrivateFieldGet(this, _TransactionController_multichainTrackingHelper, "f").getEthQuery({
+                networkClientId: transactionMeta.networkClientId,
+                chainId: transactionMeta.chainId,
+            });
+            const { updatedTransactionMeta, approvalTransactionMeta } = await updatePostTransactionBalance(transactionMeta, {
+                ethQuery,
+                getTransaction: this.getTransaction.bind(this),
+                updateTransaction: this.updateTransaction.bind(this),
+            });
+            this.messagingSystem.publish(`${controllerName}:postTransactionBalanceUpdated`, {
+                transactionMeta: updatedTransactionMeta,
+                approvalTransactionMeta,
+            });
+        }
+        catch (error) {
+            /* istanbul ignore next */
+            log('Error while updating post transaction balance', error);
+        }
+    }
+    async publishTransactionForRetry(ethQuery, transactionMeta) {
+        try {
+            return await this.publishTransaction(ethQuery, transactionMeta);
+        }
+        catch (error) {
+            if (this.isTransactionAlreadyConfirmedError(error)) {
+                await this.pendingTransactionTracker.forceCheckTransaction(transactionMeta);
+                throw new Error('Previous transaction is already confirmed');
+            }
+            throw error;
+        }
+    }
+    /**
+     * Ensures that error is a nonce issue
+     *
+     * @param error - The error to check
+     * @returns Whether or not the error is a nonce issue
+     */
+    // TODO: Replace `any` with type
+    // Some networks are returning original error in the data field
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    isTransactionAlreadyConfirmedError(error) {
+        return (error?.message?.includes('nonce too low') ||
+            error?.data?.message?.includes('nonce too low'));
+    }
+}
+_TransactionController_internalEvents = new WeakMap(), _TransactionController_incomingTransactionOptions = new WeakMap(), _TransactionController_pendingTransactionOptions = new WeakMap(), _TransactionController_trace = new WeakMap(), _TransactionController_transactionHistoryLimit = new WeakMap(), _TransactionController_isSimulationEnabled = new WeakMap(), _TransactionController_testGasFeeFlows = new WeakMap(), _TransactionController_multichainTrackingHelper = new WeakMap(), _TransactionController_checkForPendingTransactionAndStartPolling = new WeakMap(), _TransactionController_instances = new WeakSet(), _TransactionController_retryTransaction = async function _TransactionController_retryTransaction({ actionId, afterSubmit, estimatedBaseFee, gasValues, label, prepareTransactionParams, rate, transactionId, transactionType, }) {
+    // If transaction is found for same action id, do not create a new transaction.
+    if (this.getTransactionWithActionId(actionId)) {
+        return;
+    }
+    if (gasValues) {
+        // Not good practice to reassign a parameter but temporarily avoiding a larger refactor.
+        gasValues = normalizeGasFeeValues(gasValues);
+        validateGasValues(gasValues);
+    }
+    log(`Creating ${label} transaction`, transactionId, gasValues);
+    const transactionMeta = this.getTransaction(transactionId);
+    /* istanbul ignore next */
+    if (!transactionMeta) {
+        return;
+    }
+    /* istanbul ignore next */
+    if (!this.sign) {
+        throw new Error('No sign method defined.');
+    }
+    const newTxParams = getTransactionParamsWithIncreasedGasFee(transactionMeta.txParams, rate, gasValues);
+    prepareTransactionParams?.(newTxParams);
+    const unsignedEthTx = this.prepareUnsignedEthTx(transactionMeta.chainId, newTxParams);
+    const signedTx = await this.sign(unsignedEthTx, transactionMeta.txParams.from);
+    const transactionMetaWithRsv = this.updateTransactionMetaRSV(transactionMeta, signedTx);
+    const rawTx = bufferToHex(signedTx.serialize());
+    const newFee = newTxParams.maxFeePerGas ?? newTxParams.gasPrice;
+    const oldFee = newTxParams.maxFeePerGas
+        ? transactionMetaWithRsv.txParams.maxFeePerGas
+        : transactionMetaWithRsv.txParams.gasPrice;
+    log(`Submitting ${label} transaction`, {
+        oldFee,
+        newFee,
+        txParams: newTxParams,
+    });
+    const ethQuery = __classPrivateFieldGet(this, _TransactionController_multichainTrackingHelper, "f").getEthQuery({
+        networkClientId: transactionMeta.networkClientId,
+        chainId: transactionMeta.chainId,
+    });
+    const newTransactionMeta = {
+        ...transactionMetaWithRsv,
+        actionId,
+        estimatedBaseFee,
+        id: random(),
+        originalGasEstimate: transactionMeta.txParams.gas,
+        originalType: transactionMeta.type,
+        rawTx,
+        time: Date.now(),
+        txParams: newTxParams,
+        type: transactionType,
+    };
+    const hash = await this.publishTransactionForRetry(ethQuery, {
+        ...newTransactionMeta,
+        origin: label,
+    });
+    newTransactionMeta.hash = hash;
+    this.addMetadata(newTransactionMeta);
+    // speedUpTransaction has no approval request, so we assume the user has already approved the transaction
+    this.messagingSystem.publish(`${controllerName}:transactionApproved`, {
+        transactionMeta: newTransactionMeta,
+        actionId,
+    });
+    this.messagingSystem.publish(`${controllerName}:transactionSubmitted`, {
+        transactionMeta: newTransactionMeta,
+        actionId,
+    });
+    afterSubmit?.(newTransactionMeta);
+}, _TransactionController_createNonceTracker = function _TransactionController_createNonceTracker({ provider, blockTracker, chainId, }) {
+    return new NonceTracker({
+        // TODO: Fix types
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        provider: provider,
+        // TODO: Fix types
+        blockTracker,
+        getPendingTransactions: __classPrivateFieldGet(this, _TransactionController_instances, "m", _TransactionController_getNonceTrackerPendingTransactions).bind(this, chainId),
+        getConfirmedTransactions: this.getNonceTrackerTransactions.bind(this, TransactionStatus.confirmed),
+    });
+}, _TransactionController_createIncomingTransactionHelper = function _TransactionController_createIncomingTransactionHelper({ blockTracker, etherscanRemoteTransactionSource, chainId, }) {
+    const incomingTransactionHelper = new IncomingTransactionHelper({
+        blockTracker,
+        getCurrentAccount: () => __classPrivateFieldGet(this, _TransactionController_instances, "m", _TransactionController_getSelectedAccount).call(this),
+        getLastFetchedBlockNumbers: () => this.state.lastFetchedBlockNumbers,
+        getLocalTransactions: () => this.state.transactions,
+        getChainId: chainId ? () => chainId : this.getChainId.bind(this),
+        isEnabled: __classPrivateFieldGet(this, _TransactionController_incomingTransactionOptions, "f").isEnabled,
+        queryEntireHistory: __classPrivateFieldGet(this, _TransactionController_incomingTransactionOptions, "f").queryEntireHistory,
+        remoteTransactionSource: etherscanRemoteTransactionSource,
+        transactionLimit: __classPrivateFieldGet(this, _TransactionController_transactionHistoryLimit, "f"),
+        updateTransactions: __classPrivateFieldGet(this, _TransactionController_incomingTransactionOptions, "f").updateTransactions,
+    });
+    __classPrivateFieldGet(this, _TransactionController_instances, "m", _TransactionController_addIncomingTransactionHelperListeners).call(this, incomingTransactionHelper);
+    return incomingTransactionHelper;
+}, _TransactionController_createPendingTransactionTracker = function _TransactionController_createPendingTransactionTracker({ provider, blockTracker, chainId, }) {
+    const ethQuery = new EthQuery(provider);
+    const getChainId = chainId ? () => chainId : this.getChainId.bind(this);
+    const pendingTransactionTracker = new PendingTransactionTracker({
+        blockTracker,
+        getChainId,
+        getEthQuery: () => ethQuery,
+        getTransactions: () => this.state.transactions,
+        isResubmitEnabled: __classPrivateFieldGet(this, _TransactionController_pendingTransactionOptions, "f").isResubmitEnabled,
+        getGlobalLock: () => __classPrivateFieldGet(this, _TransactionController_multichainTrackingHelper, "f").acquireNonceLockForChainIdKey({
+            chainId: getChainId(),
+        }),
+        publishTransaction: (_ethQuery, transactionMeta) => this.publishTransaction(_ethQuery, transactionMeta, {
+            skipSubmitHistory: true,
+        }),
+        hooks: {
+            beforeCheckPendingTransaction: this.beforeCheckPendingTransaction.bind(this),
+            beforePublish: this.beforePublish.bind(this),
+        },
+    });
+    __classPrivateFieldGet(this, _TransactionController_instances, "m", _TransactionController_addPendingTransactionTrackerListeners).call(this, pendingTransactionTracker);
+    return pendingTransactionTracker;
+}, _TransactionController_stopAllTracking = function _TransactionController_stopAllTracking() {
+    this.pendingTransactionTracker.stop();
+    __classPrivateFieldGet(this, _TransactionController_instances, "m", _TransactionController_removePendingTransactionTrackerListeners).call(this, this.pendingTransactionTracker);
+    this.incomingTransactionHelper.stop();
+    __classPrivateFieldGet(this, _TransactionController_instances, "m", _TransactionController_removeIncomingTransactionHelperListeners).call(this, this.incomingTransactionHelper);
+    __classPrivateFieldGet(this, _TransactionController_multichainTrackingHelper, "f").stopAllTracking();
+}, _TransactionController_removeIncomingTransactionHelperListeners = function _TransactionController_removeIncomingTransactionHelperListeners(incomingTransactionHelper) {
+    incomingTransactionHelper.hub.removeAllListeners('transactions');
+    incomingTransactionHelper.hub.removeAllListeners('updatedLastFetchedBlockNumbers');
+}, _TransactionController_addIncomingTransactionHelperListeners = function _TransactionController_addIncomingTransactionHelperListeners(incomingTransactionHelper) {
+    incomingTransactionHelper.hub.on('transactions', this.onIncomingTransactions.bind(this));
+    incomingTransactionHelper.hub.on('updatedLastFetchedBlockNumbers', this.onUpdatedLastFetchedBlockNumbers.bind(this));
+}, _TransactionController_removePendingTransactionTrackerListeners = function _TransactionController_removePendingTransactionTrackerListeners(pendingTransactionTracker) {
+    pendingTransactionTracker.hub.removeAllListeners('transaction-confirmed');
+    pendingTransactionTracker.hub.removeAllListeners('transaction-dropped');
+    pendingTransactionTracker.hub.removeAllListeners('transaction-failed');
+    pendingTransactionTracker.hub.removeAllListeners('transaction-updated');
+}, _TransactionController_addPendingTransactionTrackerListeners = function _TransactionController_addPendingTransactionTrackerListeners(pendingTransactionTracker) {
+    pendingTransactionTracker.hub.on('transaction-confirmed', this.onConfirmedTransaction.bind(this));
+    pendingTransactionTracker.hub.on('transaction-dropped', this.setTransactionStatusDropped.bind(this));
+    pendingTransactionTracker.hub.on('transaction-failed', this.failTransaction.bind(this));
+    pendingTransactionTracker.hub.on('transaction-updated', this.updateTransaction.bind(this));
+}, _TransactionController_getNonceTrackerPendingTransactions = function _TransactionController_getNonceTrackerPendingTransactions(chainId, address) {
+    const standardPendingTransactions = this.getNonceTrackerTransactions(TransactionStatus.submitted, address, chainId);
+    const externalPendingTransactions = this.getExternalPendingTransactions(address, chainId);
+    return [...standardPendingTransactions, ...externalPendingTransactions];
+}, _TransactionController_getGasFeeFlows = function _TransactionController_getGasFeeFlows() {
+    if (__classPrivateFieldGet(this, _TransactionController_testGasFeeFlows, "f")) {
+        return [new TestGasFeeFlow()];
+    }
+    return [new LineaGasFeeFlow(), new DefaultGasFeeFlow()];
+}, _TransactionController_getLayer1GasFeeFlows = function _TransactionController_getLayer1GasFeeFlows() {
+    return [new OptimismLayer1GasFeeFlow(), new ScrollLayer1GasFeeFlow()];
+}, _TransactionController_updateTransactionInternal = function _TransactionController_updateTransactionInternal({ transactionId, note, skipHistory, skipValidation, }, callback) {
+    let updatedTransactionParams = [];
+    this.update((state) => {
+        const index = state.transactions.findIndex(({ id }) => id === transactionId);
+        let transactionMeta = state.transactions[index];
+        // eslint-disable-next-line n/callback-return
+        transactionMeta = callback(transactionMeta) ?? transactionMeta;
+        if (skipValidation !== true) {
+            transactionMeta.txParams = normalizeTransactionParams(transactionMeta.txParams);
+            validateTxParams(transactionMeta.txParams);
+        }
+        updatedTransactionParams =
+            __classPrivateFieldGet(this, _TransactionController_instances, "m", _TransactionController_checkIfTransactionParamsUpdated).call(this, transactionMeta);
+        const shouldSkipHistory = this.isHistoryDisabled || skipHistory;
+        if (!shouldSkipHistory) {
+            transactionMeta = updateTransactionHistory(transactionMeta, note ?? 'Transaction updated');
+        }
+        state.transactions[index] = transactionMeta;
+    });
+    const transactionMeta = this.getTransaction(transactionId);
+    if (updatedTransactionParams.length > 0) {
+        __classPrivateFieldGet(this, _TransactionController_instances, "m", _TransactionController_onTransactionParamsUpdated).call(this, transactionMeta, updatedTransactionParams);
+    }
+    return transactionMeta;
+}, _TransactionController_checkIfTransactionParamsUpdated = function _TransactionController_checkIfTransactionParamsUpdated(newTransactionMeta) {
+    const { id: transactionId, txParams: newParams } = newTransactionMeta;
+    const originalParams = this.getTransaction(transactionId)?.txParams;
+    if (!originalParams || isEqual(originalParams, newParams)) {
+        return [];
+    }
+    const params = Object.keys(newParams);
+    const updatedProperties = params.filter((param) => newParams[param] !== originalParams[param]);
+    log('Transaction parameters have been updated', transactionId, updatedProperties, originalParams, newParams);
+    return updatedProperties;
+}, _TransactionController_onTransactionParamsUpdated = function _TransactionController_onTransactionParamsUpdated(transactionMeta, updatedParams) {
+    if (['to', 'value', 'data'].some((param) => updatedParams.includes(param))) {
+        log('Updating simulation data due to transaction parameter update');
+        __classPrivateFieldGet(this, _TransactionController_instances, "m", _TransactionController_updateSimulationData).call(this, transactionMeta).catch((error) => {
+            log('Error updating simulation data', error);
+            throw error;
+        });
+    }
+}, _TransactionController_updateSimulationData = async function _TransactionController_updateSimulationData(transactionMeta, { traceContext } = {}) {
+    const { id: transactionId, chainId, txParams } = transactionMeta;
+    const { from, to, value, data } = txParams;
+    let simulationData = {
+        error: {
+            code: SimulationErrorCode.Disabled,
+            message: 'Simulation disabled',
+        },
+        tokenBalanceChanges: [],
+    };
+    if (__classPrivateFieldGet(this, _TransactionController_isSimulationEnabled, "f").call(this)) {
+        __classPrivateFieldGet(this, _TransactionController_instances, "m", _TransactionController_updateTransactionInternal).call(this, { transactionId, skipHistory: true }, (txMeta) => {
+            txMeta.simulationData = undefined;
+        });
+        simulationData = await __classPrivateFieldGet(this, _TransactionController_trace, "f").call(this, { name: 'Simulate', parentContext: traceContext }, () => getSimulationData({
+            chainId,
+            from: from,
+            to: to,
+            value: value,
+            data: data,
+        }));
+    }
+    const finalTransactionMeta = this.getTransaction(transactionId);
+    /* istanbul ignore if */
+    if (!finalTransactionMeta) {
+        log('Cannot update simulation data as transaction not found', transactionId, simulationData);
+        return;
+    }
+    __classPrivateFieldGet(this, _TransactionController_instances, "m", _TransactionController_updateTransactionInternal).call(this, {
+        transactionId,
+        note: 'TransactionController#updateSimulationData - Update simulation data',
+    }, (txMeta) => {
+        txMeta.simulationData = simulationData;
+    });
+    log('Updated simulation data', transactionId, simulationData);
+}, _TransactionController_onGasFeePollerTransactionUpdate = function _TransactionController_onGasFeePollerTransactionUpdate({ transactionId, gasFeeEstimates, gasFeeEstimatesLoaded, layer1GasFee, }) {
+    __classPrivateFieldGet(this, _TransactionController_instances, "m", _TransactionController_updateTransactionInternal).call(this, { transactionId, skipHistory: true }, (txMeta) => {
+        if (gasFeeEstimates) {
+            txMeta.gasFeeEstimates = gasFeeEstimates;
+        }
+        if (gasFeeEstimatesLoaded !== undefined) {
+            txMeta.gasFeeEstimatesLoaded = gasFeeEstimatesLoaded;
+        }
+        if (layer1GasFee) {
+            txMeta.layer1GasFee = layer1GasFee;
+        }
+    });
+}, _TransactionController_getNetworkClientId = function _TransactionController_getNetworkClientId({ networkClientId: requestNetworkClientId, chainId, }) {
+    const globalChainId = __classPrivateFieldGet(this, _TransactionController_instances, "m", _TransactionController_getGlobalChainId).call(this);
+    const globalNetworkClientId = __classPrivateFieldGet(this, _TransactionController_instances, "m", _TransactionController_getGlobalNetworkClientId).call(this);
+    if (requestNetworkClientId) {
+        return requestNetworkClientId;
+    }
+    if (!chainId || chainId === globalChainId) {
+        return globalNetworkClientId;
+    }
+    return this.messagingSystem.call(`NetworkController:findNetworkClientIdByChainId`, chainId);
+}, _TransactionController_getGlobalNetworkClientId = function _TransactionController_getGlobalNetworkClientId() {
+    return this.getNetworkState().selectedNetworkClientId;
+}, _TransactionController_getGlobalChainId = function _TransactionController_getGlobalChainId() {
+    return this.messagingSystem.call(`NetworkController:getNetworkClientById`, this.getNetworkState().selectedNetworkClientId).configuration.chainId;
+}, _TransactionController_isCustomNetwork = function _TransactionController_isCustomNetwork(networkClientId) {
+    const globalNetworkClientId = __classPrivateFieldGet(this, _TransactionController_instances, "m", _TransactionController_getGlobalNetworkClientId).call(this);
+    if (!networkClientId || networkClientId === globalNetworkClientId) {
+        return !isInfuraNetworkType(this.getNetworkState().selectedNetworkClientId);
+    }
+    return (this.messagingSystem.call(`NetworkController:getNetworkClientById`, networkClientId).configuration.type === NetworkClientType.Custom);
+}, _TransactionController_getSelectedAccount = function _TransactionController_getSelectedAccount() {
+    return this.messagingSystem.call('AccountsController:getSelectedAccount');
+}, _TransactionController_updateSubmitHistory = function _TransactionController_updateSubmitHistory(transactionMeta, hash) {
+    const { chainId, networkClientId, origin, rawTx, txParams } = transactionMeta;
+    const { networkConfigurationsByChainId } = this.getNetworkState();
+    const networkConfiguration = networkConfigurationsByChainId[chainId];
+    const endpoint = networkConfiguration?.rpcEndpoints.find((currentEndpoint) => currentEndpoint.networkClientId === networkClientId);
+    const networkUrl = endpoint?.url;
+    const networkType = endpoint?.name ?? networkClientId;
+    const submitHistoryEntry = {
+        chainId,
+        hash,
+        networkType,
+        networkUrl,
+        origin,
+        rawTransaction: rawTx,
+        time: Date.now(),
+        transaction: txParams,
+    };
+    log('Updating submit history', submitHistoryEntry);
+    this.update((state) => {
+        const { submitHistory } = state;
+        if (submitHistory.length === SUBMIT_HISTORY_LIMIT) {
+            submitHistory.pop();
+        }
+        submitHistory.unshift(submitHistoryEntry);
+    });
 };
 //# sourceMappingURL=TransactionController.mjs.map