@metamask/transaction-controller 15.0.0 → 17.0.0

package/dist/TransactionController.js

@@ -26,16 +26,19 @@ const events_1 = require("events");
 const lodash_1 = require("lodash");
 const nonce_tracker_1 = __importDefault(require("nonce-tracker"));
 const uuid_1 = require("uuid");
-const EtherscanRemoteTransactionSource_1 = require("./EtherscanRemoteTransactionSource");
-const external_transactions_1 = require("./external-transactions");
-const history_1 = require("./history");
-const IncomingTransactionHelper_1 = require("./IncomingTransactionHelper");
+const EtherscanRemoteTransactionSource_1 = require("./helpers/EtherscanRemoteTransactionSource");
+const IncomingTransactionHelper_1 = require("./helpers/IncomingTransactionHelper");
+const PendingTransactionTracker_1 = require("./helpers/PendingTransactionTracker");
 const logger_1 = require("./logger");
-const PendingTransactionTracker_1 = require("./PendingTransactionTracker");
-const transaction_type_1 = require("./transaction-type");
 const types_1 = require("./types");
-const utils_1 = require("./utils");
-const validation_1 = require("./validation");
+const external_transactions_1 = require("./utils/external-transactions");
+const gas_1 = require("./utils/gas");
+const gas_fees_1 = require("./utils/gas-fees");
+const history_1 = require("./utils/history");
+const swaps_1 = require("./utils/swaps");
+const transaction_type_1 = require("./utils/transaction-type");
+const utils_1 = require("./utils/utils");
+const validation_1 = require("./utils/validation");
 exports.HARDFORK = common_1.Hardfork.London;
 /**
  * Multiplier used to determine a transaction's increased gas fee during cancellation
@@ -60,8 +63,11 @@ class TransactionController extends base_controller_1.BaseController {
      * @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.getSavedGasFees - Gets the saved gas fee config.
      * @param options.getCurrentAccountEIP1559Compatibility - Whether or not the account supports EIP-1559.
      * @param options.getCurrentNetworkEIP1559Compatibility - Whether or not the network supports EIP-1559.
+     * @param options.getGasFeeEstimates - Callback to retrieve gas fee estimates.
      * @param options.getNetworkState - Gets the state of the network controller.
      * @param options.getPermittedAccounts - Get accounts that a given origin has permissions for.
      * @param options.getSelectedAddress - Gets the address of the currently selected account.
@@ -72,13 +78,23 @@ class TransactionController extends base_controller_1.BaseController {
      * @param options.incomingTransactions.updateTransactions - Whether to update local transactions using remote transaction data.
      * @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.pendingTransactions.isResubmitEnabled - Whether transaction publishing is automatically retried.
      * @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.hooks - The controller hooks.
+     * @param options.hooks.afterSign - Additional logic to execute after signing a transaction. Return false to not change the status to signed.
+     * @param options.hooks.beforeApproveOnInit - Additional logic to execute before starting an approval flow for a transaction during initialization. Return false to skip the transaction.
+     * @param options.hooks.beforeCheckPendingTransaction - Additional logic to execute before checking pending transactions. Return false to prevent the broadcast of the transaction.
+     * @param options.hooks.beforePublish - Additional logic to execute before publishing a transaction. Return false to prevent the broadcast of the transaction.
+     * @param options.hooks.getAdditionalSignArguments - Returns additional arguments required to sign a transaction.
      * @param config - Initial options used to configure this controller.
      * @param state - Initial state to set on this controller.
      */
-    constructor({ blockTracker, disableHistory, disableSendFlowHistory, getCurrentAccountEIP1559Compatibility, getCurrentNetworkEIP1559Compatibility, getNetworkState, getPermittedAccounts, getSelectedAddress, incomingTransactions = {}, messenger, onNetworkStateChange, provider, securityProviderRequest, }, config, state) {
+    constructor({ blockTracker, disableHistory, disableSendFlowHistory, disableSwaps, getSavedGasFees, getCurrentAccountEIP1559Compatibility, getCurrentNetworkEIP1559Compatibility, getGasFeeEstimates, getNetworkState, getPermittedAccounts, getSelectedAddress, incomingTransactions = {}, messenger, onNetworkStateChange, pendingTransactions = {}, provider, securityProviderRequest, hooks = {}, }, config, state) {
+        var _a, _b, _c, _d, _e;
         super(config, state);
+        this.inProcessOfSigning = new Set();
         this.mutex = new async_mutex_1.Mutex();
         /**
          * EventEmitter instance used to listen to specific transactional events
@@ -100,18 +116,30 @@ class TransactionController extends base_controller_1.BaseController {
         this.provider = provider;
         this.messagingSystem = messenger;
         this.getNetworkState = getNetworkState;
-        // @ts-expect-error TODO: Provider type alignment
         this.ethQuery = new eth_query_1.default(provider);
         this.isSendFlowHistoryDisabled = disableSendFlowHistory !== null && disableSendFlowHistory !== void 0 ? disableSendFlowHistory : false;
         this.isHistoryDisabled = disableHistory !== null && disableHistory !== void 0 ? disableHistory : false;
+        this.isSwapsDisabled = disableSwaps !== null && disableSwaps !== void 0 ? disableSwaps : false;
         this.registry = new eth_method_registry_1.default({ provider });
+        this.getSavedGasFees = getSavedGasFees !== null && getSavedGasFees !== void 0 ? getSavedGasFees : ((_chainId) => undefined);
         this.getCurrentAccountEIP1559Compatibility =
             getCurrentAccountEIP1559Compatibility;
         this.getCurrentNetworkEIP1559Compatibility =
             getCurrentNetworkEIP1559Compatibility;
+        this.getGasFeeEstimates =
+            getGasFeeEstimates || (() => Promise.resolve({}));
         this.getPermittedAccounts = getPermittedAccounts;
         this.getSelectedAddress = getSelectedAddress;
         this.securityProviderRequest = securityProviderRequest;
+        this.afterSign = (_a = hooks === null || hooks === void 0 ? void 0 : hooks.afterSign) !== null && _a !== void 0 ? _a : (() => true);
+        this.beforeApproveOnInit = (_b = hooks === null || hooks === void 0 ? void 0 : hooks.beforeApproveOnInit) !== null && _b !== void 0 ? _b : (() => true);
+        this.beforeCheckPendingTransaction =
+            (_c = hooks === null || hooks === void 0 ? void 0 : hooks.beforeCheckPendingTransaction) !== null && _c !== void 0 ? _c : 
+            /* istanbul ignore next */
+            (() => true);
+        this.beforePublish = (_d = hooks === null || hooks === void 0 ? void 0 : hooks.beforePublish) !== null && _d !== void 0 ? _d : (() => true);
+        this.getAdditionalSignArguments =
+            (_e = hooks === null || hooks === void 0 ? void 0 : hooks.getAdditionalSignArguments) !== null && _e !== void 0 ? _e : (() => []);
         this.nonceTracker = new nonce_tracker_1.default({
             provider,
             blockTracker,
@@ -134,23 +162,35 @@ class TransactionController extends base_controller_1.BaseController {
         this.incomingTransactionHelper.hub.on('transactions', this.onIncomingTransactions.bind(this));
         this.incomingTransactionHelper.hub.on('updatedLastFetchedBlockNumbers', this.onUpdatedLastFetchedBlockNumbers.bind(this));
         this.pendingTransactionTracker = new PendingTransactionTracker_1.PendingTransactionTracker({
+            approveTransaction: this.approveTransaction.bind(this),
             blockTracker,
-            failTransaction: this.failTransaction.bind(this),
             getChainId: this.getChainId.bind(this),
             getEthQuery: () => this.ethQuery,
             getTransactions: () => this.state.transactions,
+            isResubmitEnabled: pendingTransactions.isResubmitEnabled,
+            nonceTracker: this.nonceTracker,
+            onStateChange: this.subscribe.bind(this),
+            publishTransaction: this.publishTransaction.bind(this),
+            hooks: {
+                beforeCheckPendingTransaction: this.beforeCheckPendingTransaction.bind(this),
+                beforePublish: this.beforePublish.bind(this),
+            },
         });
-        this.pendingTransactionTracker.hub.on('transactions', this.onPendingTransactionsUpdate.bind(this));
-        this.pendingTransactionTracker.hub.on('transaction-confirmed', (transactionMeta) => this.hub.emit(`${transactionMeta.id}:confirmed`, transactionMeta));
+        this.addPendingTransactionTrackerListeners();
         onNetworkStateChange(() => {
-            // @ts-expect-error TODO: Provider type alignment
             this.ethQuery = new eth_query_1.default(this.provider);
             this.registry = new eth_method_registry_1.default({ provider: this.provider });
+            this.onBootCleanup();
         });
-        this.pendingTransactionTracker.start();
+        this.onBootCleanup();
     }
-    failTransaction(transactionMeta, error) {
-        const newTransactionMeta = Object.assign(Object.assign({}, transactionMeta), { error, status: types_1.TransactionStatus.failed });
+    failTransaction(transactionMeta, error, actionId) {
+        const newTransactionMeta = Object.assign(Object.assign({}, transactionMeta), { error: (0, utils_1.normalizeTxError)(error), status: types_1.TransactionStatus.failed });
+        this.hub.emit('transaction-failed', {
+            actionId,
+            error: error.message,
+            transactionMeta: newTransactionMeta,
+        });
         this.updateTransaction(newTransactionMeta, 'TransactionController#failTransaction - Add error message and set status to failed');
         this.hub.emit(`${transactionMeta.id}:finished`, newTransactionMeta);
     }
@@ -202,12 +242,14 @@ class TransactionController extends base_controller_1.BaseController {
      * @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.
      * @returns Object containing a promise resolving to the transaction hash if approved.
      */
-    addTransaction(txParams, { actionId, deviceConfirmedOn, method, origin, requireApproval, securityAlertResponse, sendFlowHistory, type, } = {}) {
+    addTransaction(txParams, { actionId, deviceConfirmedOn, method, origin, requireApproval, securityAlertResponse, sendFlowHistory, swaps = {}, type, } = {}) {
         return __awaiter(this, void 0, void 0, function* () {
             const chainId = this.getChainId();
-            const { transactions } = this.state;
             txParams = (0, utils_1.normalizeTxParams)(txParams);
             const isEIP1559Compatible = yield this.getEIP1559Compatibility();
             (0, validation_1.validateTxParams)(txParams, isEIP1559Compatible);
@@ -234,16 +276,7 @@ class TransactionController extends base_controller_1.BaseController {
                 verifiedOnBlockchain: false,
                 type: transactionType,
             };
-            try {
-                const { gas, estimateGasError } = yield this.estimateGas(txParams);
-                txParams.gas = gas;
-                txParams.estimateGasError = estimateGasError;
-                transactionMeta.originalGasEstimate = gas;
-            }
-            catch (error) {
-                this.failTransaction(transactionMeta, error);
-                return Promise.reject(error);
-            }
+            yield this.updateGasProperties(transactionMeta);
             // Checks if a transaction already exists with a given actionId
             if (!existingTransactionMeta) {
                 // Set security provider response
@@ -258,16 +291,19 @@ class TransactionController extends base_controller_1.BaseController {
                 if (!this.isHistoryDisabled) {
                     (0, history_1.addInitialHistorySnapshot)(transactionMeta);
                 }
-                transactions.push(transactionMeta);
-                this.update({
-                    transactions: this.trimTransactionsForState(transactions),
+                yield (0, swaps_1.updateSwapsTransaction)(transactionMeta, transactionType, swaps, {
+                    isSwapsDisabled: this.isSwapsDisabled,
+                    cancelTransaction: this.cancelTransaction.bind(this),
+                    controllerHubEmitter: this.hub.emit.bind(this.hub),
                 });
+                this.addMetadata(transactionMeta);
                 this.hub.emit(`unapprovedTransaction`, transactionMeta);
             }
             return {
                 result: this.processApproval(transactionMeta, {
                     isExisting: Boolean(existingTransactionMeta),
                     requireApproval,
+                    actionId,
                 }),
                 transactionMeta,
             };
@@ -284,22 +320,6 @@ class TransactionController extends base_controller_1.BaseController {
             yield this.incomingTransactionHelper.update();
         });
     }
-    /**
-     * Creates approvals for all unapproved transactions persisted.
-     */
-    initApprovals() {
-        const chainId = this.getChainId();
-        const unapprovedTxs = this.state.transactions.filter((transaction) => transaction.status === types_1.TransactionStatus.unapproved &&
-            transaction.chainId === chainId);
-        for (const txMeta of unapprovedTxs) {
-            this.processApproval(txMeta, {
-                shouldShowRequest: false,
-            }).catch((error) => {
-                /* istanbul ignore next */
-                console.error('Error during persisted transaction approval', error);
-            });
-        }
-    }
     /**
      * Attempts to cancel a transaction based on its ID by setting its status to "rejected"
      * and emitting a `<tx.id>:finished` hub event.
@@ -307,15 +327,20 @@ class TransactionController extends base_controller_1.BaseController {
      * @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.
      */
-    stopTransaction(transactionId, gasValues, { estimatedBaseFee } = {}) {
+    stopTransaction(transactionId, gasValues, { estimatedBaseFee, actionId, } = {}) {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
+            // If transaction is found for same action id, do not create a cancel transaction.
+            if (this.getTransactionWithActionId(actionId)) {
+                return;
+            }
             if (gasValues) {
                 (0, utils_1.validateGasValues)(gasValues);
             }
-            const transactionMeta = this.state.transactions.find(({ id }) => id === transactionId);
+            const transactionMeta = this.getTransaction(transactionId);
             if (!transactionMeta) {
                 return;
             }
@@ -342,13 +367,13 @@ class TransactionController extends base_controller_1.BaseController {
             const newMaxPriorityFeePerGas = (maxPriorityFeePerGasValues &&
                 (0, utils_1.validateMinimumIncrease)(maxPriorityFeePerGasValues, minMaxPriorityFeePerGas)) ||
                 (existingMaxPriorityFeePerGas && minMaxPriorityFeePerGas);
-            const txParams = newMaxFeePerGas && newMaxPriorityFeePerGas
+            const newTxParams = newMaxFeePerGas && newMaxPriorityFeePerGas
                 ? {
                     from: transactionMeta.txParams.from,
                     gasLimit: transactionMeta.txParams.gas,
                     maxFeePerGas: newMaxFeePerGas,
                     maxPriorityFeePerGas: newMaxPriorityFeePerGas,
-                    type: 2,
+                    type: '2',
                     nonce: transactionMeta.txParams.nonce,
                     to: transactionMeta.txParams.from,
                     value: '0x0',
@@ -361,14 +386,33 @@ class TransactionController extends base_controller_1.BaseController {
                     to: transactionMeta.txParams.from,
                     value: '0x0',
                 };
-            const unsignedEthTx = this.prepareUnsignedEthTx(txParams);
+            const unsignedEthTx = this.prepareUnsignedEthTx(newTxParams);
             const signedTx = yield this.sign(unsignedEthTx, transactionMeta.txParams.from);
-            yield this.updateTransactionMetaRSV(transactionMeta, signedTx);
             const rawTx = (0, ethereumjs_util_1.bufferToHex)(signedTx.serialize());
-            yield (0, controller_utils_1.query)(this.ethQuery, 'sendRawTransaction', [rawTx]);
-            transactionMeta.estimatedBaseFee = estimatedBaseFee;
-            transactionMeta.status = types_1.TransactionStatus.cancelled;
-            this.hub.emit(`${transactionMeta.id}:finished`, transactionMeta);
+            const hash = yield this.publishTransaction(rawTx);
+            const cancelTransactionMeta = {
+                actionId,
+                chainId: transactionMeta.chainId,
+                estimatedBaseFee,
+                hash,
+                id: (0, uuid_1.v1)(),
+                originalGasEstimate: transactionMeta.txParams.gas,
+                status: types_1.TransactionStatus.submitted,
+                time: Date.now(),
+                type: types_1.TransactionType.cancel,
+                txParams: newTxParams,
+            };
+            this.addMetadata(cancelTransactionMeta);
+            // stopTransaction has no approval request, so we assume the user has already approved the transaction
+            this.hub.emit('transaction-approved', {
+                transactionMeta: cancelTransactionMeta,
+                actionId,
+            });
+            this.hub.emit('transaction-submitted', {
+                transactionMeta: cancelTransactionMeta,
+                actionId,
+            });
+            this.hub.emit(`${cancelTransactionMeta.id}:finished`, cancelTransactionMeta);
         });
     }
     /**
@@ -399,7 +443,6 @@ class TransactionController extends base_controller_1.BaseController {
             if (!this.sign) {
                 throw new Error('No sign method defined.');
             }
-            const { transactions } = this.state;
             // gasPrice (legacy non EIP1559)
             const minGasPrice = (0, utils_1.getIncreasedPriceFromExisting)(transactionMeta.txParams.gasPrice, exports.SPEED_UP_RATE);
             const gasPriceFromValues = (0, utils_1.isGasPriceValue)(gasValues) && gasValues.gasPrice;
@@ -421,18 +464,26 @@ class TransactionController extends base_controller_1.BaseController {
                 (0, utils_1.validateMinimumIncrease)(maxPriorityFeePerGasValues, minMaxPriorityFeePerGas)) ||
                 (existingMaxPriorityFeePerGas && minMaxPriorityFeePerGas);
             const txParams = newMaxFeePerGas && newMaxPriorityFeePerGas
-                ? Object.assign(Object.assign({}, transactionMeta.txParams), { gasLimit: transactionMeta.txParams.gas, maxFeePerGas: newMaxFeePerGas, maxPriorityFeePerGas: newMaxPriorityFeePerGas, type: 2 }) : Object.assign(Object.assign({}, transactionMeta.txParams), { gasLimit: transactionMeta.txParams.gas, gasPrice: newGasPrice });
+                ? Object.assign(Object.assign({}, transactionMeta.txParams), { gasLimit: transactionMeta.txParams.gas, maxFeePerGas: newMaxFeePerGas, maxPriorityFeePerGas: newMaxPriorityFeePerGas, type: '2' }) : Object.assign(Object.assign({}, transactionMeta.txParams), { gasLimit: transactionMeta.txParams.gas, gasPrice: newGasPrice });
             const unsignedEthTx = this.prepareUnsignedEthTx(txParams);
             const signedTx = yield this.sign(unsignedEthTx, transactionMeta.txParams.from);
             yield this.updateTransactionMetaRSV(transactionMeta, signedTx);
             const rawTx = (0, ethereumjs_util_1.bufferToHex)(signedTx.serialize());
             const hash = yield (0, controller_utils_1.query)(this.ethQuery, 'sendRawTransaction', [rawTx]);
             const baseTransactionMeta = Object.assign(Object.assign({}, transactionMeta), { estimatedBaseFee, id: (0, uuid_1.v1)(), time: Date.now(), hash,
-                actionId, originalGasEstimate: transactionMeta.txParams.gas, type: types_1.TransactionType.retry });
+                actionId, originalGasEstimate: transactionMeta.txParams.gas, type: types_1.TransactionType.retry, originalType: transactionMeta.type });
             const newTransactionMeta = newMaxFeePerGas && newMaxPriorityFeePerGas
                 ? Object.assign(Object.assign({}, baseTransactionMeta), { txParams: Object.assign(Object.assign({}, transactionMeta.txParams), { maxFeePerGas: newMaxFeePerGas, maxPriorityFeePerGas: newMaxPriorityFeePerGas }) }) : Object.assign(Object.assign({}, baseTransactionMeta), { txParams: Object.assign(Object.assign({}, transactionMeta.txParams), { gasPrice: newGasPrice }) });
-            transactions.push(newTransactionMeta);
-            this.update({ transactions: this.trimTransactionsForState(transactions) });
+            this.addMetadata(newTransactionMeta);
+            // speedUpTransaction has no approval request, so we assume the user has already approved the transaction
+            this.hub.emit('transaction-approved', {
+                transactionMeta: newTransactionMeta,
+                actionId,
+            });
+            this.hub.emit('transaction-submitted', {
+                transactionMeta: newTransactionMeta,
+                actionId,
+            });
             this.hub.emit(`${transactionMeta.id}:speedup`, newTransactionMeta);
         });
     }
@@ -444,67 +495,24 @@ class TransactionController extends base_controller_1.BaseController {
      */
     estimateGas(transaction) {
         return __awaiter(this, void 0, void 0, function* () {
-            const estimatedTransaction = Object.assign({}, transaction);
-            const { gas, gasPrice: providedGasPrice, to, value, data, } = estimatedTransaction;
-            const gasPrice = typeof providedGasPrice === 'undefined'
-                ? yield (0, controller_utils_1.query)(this.ethQuery, 'gasPrice')
-                : providedGasPrice;
-            const { providerConfig } = this.getNetworkState();
-            const isCustomNetwork = providerConfig.type === controller_utils_1.NetworkType.rpc;
-            // 1. If gas is already defined on the transaction, use it
-            if (typeof gas !== 'undefined') {
-                return { gas, gasPrice };
-            }
-            const { gasLimit } = yield (0, controller_utils_1.query)(this.ethQuery, 'getBlockByNumber', [
-                'latest',
-                false,
-            ]);
-            // 2. If to is not defined or this is not a contract address, and there is no data use 0x5208 / 21000.
-            // If the network is a custom network then bypass this check and fetch 'estimateGas'.
-            /* istanbul ignore next */
-            const code = to ? yield (0, controller_utils_1.query)(this.ethQuery, 'getCode', [to]) : undefined;
-            /* istanbul ignore next */
-            if (!isCustomNetwork &&
-                (!to || (to && !data && (!code || code === '0x')))) {
-                return { gas: '0x5208', gasPrice };
-            }
-            // if data, should be hex string format
-            estimatedTransaction.data = !data
-                ? data
-                : /* istanbul ignore next */ (0, ethereumjs_util_1.addHexPrefix)(data);
-            // 3. If this is a contract address, safely estimate gas using RPC
-            estimatedTransaction.value =
-                typeof value === 'undefined' ? '0x0' : /* istanbul ignore next */ value;
-            const gasLimitBN = (0, controller_utils_1.hexToBN)(gasLimit);
-            estimatedTransaction.gas = (0, controller_utils_1.BNToHex)((0, controller_utils_1.fractionBN)(gasLimitBN, 19, 20));
-            let gasHex;
-            let estimateGasError;
-            try {
-                gasHex = yield (0, controller_utils_1.query)(this.ethQuery, 'estimateGas', [
-                    estimatedTransaction,
-                ]);
-            }
-            catch (error) {
-                estimateGasError = utils_1.ESTIMATE_GAS_ERROR;
-            }
-            // 4. Pad estimated gas without exceeding the most recent block gasLimit. If the network is a
-            // a custom network then return the eth_estimateGas value.
-            const gasBN = (0, controller_utils_1.hexToBN)(gasHex);
-            const maxGasBN = gasLimitBN.muln(0.9);
-            const paddedGasBN = gasBN.muln(1.5);
-            /* istanbul ignore next */
-            if (gasBN.gt(maxGasBN) || isCustomNetwork) {
-                return { gas: (0, ethereumjs_util_1.addHexPrefix)(gasHex), gasPrice, estimateGasError };
-            }
-            /* istanbul ignore next */
-            if (paddedGasBN.lt(maxGasBN)) {
-                return {
-                    gas: (0, ethereumjs_util_1.addHexPrefix)((0, controller_utils_1.BNToHex)(paddedGasBN)),
-                    gasPrice,
-                    estimateGasError,
-                };
-            }
-            return { gas: (0, ethereumjs_util_1.addHexPrefix)((0, controller_utils_1.BNToHex)(maxGasBN)), gasPrice, estimateGasError };
+            const { estimatedGas, simulationFails } = yield (0, gas_1.estimateGas)(transaction, this.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.
+     */
+    estimateGasBuffered(transaction, multiplier) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { blockGasLimit, estimatedGas, simulationFails } = yield (0, gas_1.estimateGas)(transaction, this.ethQuery);
+            const gas = (0, gas_1.addGasBuffer)(estimatedGas, blockGasLimit, multiplier);
+            return {
+                gas,
+                simulationFails,
+            };
         });
     }
     /**
@@ -524,6 +532,23 @@ class TransactionController extends base_controller_1.BaseController {
         transactions[index] = transactionMeta;
         this.update({ transactions: this.trimTransactionsForState(transactions) });
     }
+    /**
+     * 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 updatedMeta = (0, lodash_1.merge)(transactionMeta, { securityAlertResponse });
+        this.updateTransaction(updatedMeta, 'TransactionController:updatesecurityAlertResponse - securityAlertResponse updated');
+    }
     /**
      * Removes all transactions from state, optionally based on the current network.
      *
@@ -581,6 +606,26 @@ class TransactionController extends base_controller_1.BaseController {
                 this.markNonceDuplicatesDropped(transactionId);
                 // Update external provided transaction with updated gas values and confirmed status.
                 this.updateTransaction(transactionMeta, 'TransactionController:confirmExternalTransaction - Add external transaction');
+                if (transactionMeta.type === types_1.TransactionType.swap) {
+                    (0, swaps_1.updatePostTransactionBalance)(transactionMeta, {
+                        ethQuery: this.ethQuery,
+                        getTransaction: this.getTransaction.bind(this),
+                        updateTransaction: this.updateTransaction.bind(this),
+                    })
+                        .then(({ updatedTransactionMeta, approvalTransactionMeta }) => {
+                        this.hub.emit('post-transaction-balance-updated', {
+                            transactionMeta: updatedTransactionMeta,
+                            approvalTransactionMeta,
+                        });
+                    })
+                        .catch((error) => {
+                        /* istanbul ignore next */
+                        (0, logger_1.projectLogger)('Error while updating post transaction balance', error);
+                    });
+                }
+                this.hub.emit('transaction-confirmed', {
+                    transactionMeta,
+                });
             }
             catch (error) {
                 console.error(error);
@@ -662,7 +707,250 @@ class TransactionController extends base_controller_1.BaseController {
         this.updateTransaction(updatedMeta, 'TransactionController:updateTransactionGasFees - gas values updated');
         return this.getTransaction(transactionId);
     }
-    processApproval(transactionMeta, { isExisting = false, requireApproval, shouldShowRequest = true, }) {
+    /**
+     * 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`);
+        }
+        (0, utils_1.validateIfTransactionUnapproved)(transactionMeta, 'updatePreviousGasParams');
+        const transactionPreviousGas = {
+            previousGas: {
+                gasLimit,
+                maxFeePerGas,
+                maxPriorityFeePerGas,
+            },
+        };
+        // only update what is defined
+        transactionPreviousGas.previousGas = (0, lodash_1.pickBy)(transactionPreviousGas.previousGas);
+        // merge updated previous gas values with existing transaction meta
+        const updatedMeta = (0, lodash_1.merge)(transactionMeta, transactionPreviousGas);
+        this.updateTransaction(updatedMeta, 'TransactionController:updatePreviousGasParams - Previous gas values updated');
+        return this.getTransaction(transactionId);
+    }
+    /**
+     * Gets the next nonce according to the nonce-tracker.
+     * Ensure `releaseLock` is called once processing of the `nonce` value is complete.
+     *
+     * @param address - The hex string address for the transaction.
+     * @returns object with the `nextNonce` `nonceDetails`, and the releaseLock.
+     */
+    getNonceLock(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.nonceTracker.getNonceLock(address);
+        });
+    }
+    /**
+     * Signs and returns the raw transaction data for provided transaction params list.
+     *
+     * @param listOfTxParams - The list of transaction params to approve.
+     * @returns The raw transactions.
+     */
+    approveTransactionsWithSameNonce(listOfTxParams = []) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (listOfTxParams.length === 0) {
+                return '';
+            }
+            const initialTx = listOfTxParams[0];
+            const common = this.getCommonConfiguration();
+            const initialTxAsEthTx = tx_1.TransactionFactory.fromTxData(initialTx, {
+                common,
+            });
+            const initialTxAsSerializedHex = (0, ethereumjs_util_1.bufferToHex)(initialTxAsEthTx.serialize());
+            if (this.inProcessOfSigning.has(initialTxAsSerializedHex)) {
+                return '';
+            }
+            this.inProcessOfSigning.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;
+                nonceLock = yield this.nonceTracker.getNonceLock(fromAddress);
+                const nonce = nonceLock.nextNonce;
+                rawTransactions = yield Promise.all(listOfTxParams.map((txParams) => {
+                    txParams.nonce = (0, ethereumjs_util_1.addHexPrefix)(nonce.toString(16));
+                    return this.signExternalTransaction(txParams);
+                }));
+            }
+            catch (err) {
+                (0, logger_1.projectLogger)('Error while signing transactions with same nonce', err);
+                // Must set transaction to submitted/failed before releasing lock
+                // continue with error chain
+                throw err;
+            }
+            finally {
+                if (nonceLock) {
+                    nonceLock.releaseLock();
+                }
+                this.inProcessOfSigning.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.custodyStatus - The new custody status value to be assigned.
+     * @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, { custodyStatus, errorMessage, hash, status, }) {
+        let transactionMeta;
+        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 &&
+            ![
+                types_1.TransactionStatus.submitted,
+                types_1.TransactionStatus.signed,
+                types_1.TransactionStatus.failed,
+            ].includes(status)) {
+            throw new Error(`Cannot update custodial transaction with status: ${status}`);
+        }
+        if (status === types_1.TransactionStatus.signed) {
+            transactionMeta.status = status;
+        }
+        if (status === types_1.TransactionStatus.submitted) {
+            transactionMeta.submittedTime = new Date().getTime();
+            transactionMeta.status = status;
+        }
+        if (status === types_1.TransactionStatus.failed) {
+            transactionMeta = Object.assign(Object.assign({}, transactionMeta), { error: (0, utils_1.normalizeTxError)(new Error(errorMessage)), status: types_1.TransactionStatus.failed });
+        }
+        if (custodyStatus) {
+            transactionMeta.custodyStatus = custodyStatus;
+        }
+        if (hash) {
+            transactionMeta.hash = hash;
+        }
+        this.updateTransaction(transactionMeta, `TransactionController:updateCustodialTransaction - Custodial transaction updated`);
+    }
+    signExternalTransaction(transactionParams) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.sign) {
+                throw new Error('No sign method defined.');
+            }
+            const normalizedTransactionParams = (0, utils_1.normalizeTxParams)(transactionParams);
+            const chainId = this.getChainId();
+            const type = (0, utils_1.isEIP1559Transaction)(normalizedTransactionParams)
+                ? types_1.TransactionEnvelopeType.feeMarket
+                : types_1.TransactionEnvelopeType.legacy;
+            const updatedTransactionParams = Object.assign(Object.assign({}, normalizedTransactionParams), { type, gasLimit: normalizedTransactionParams.gas, chainId });
+            const { from } = updatedTransactionParams;
+            const common = this.getCommonConfiguration();
+            const unsignedTransaction = tx_1.TransactionFactory.fromTxData(updatedTransactionParams, { common });
+            const signedTransaction = yield this.sign(unsignedTransaction, from);
+            const rawTransaction = (0, ethereumjs_util_1.bufferToHex)(signedTransaction.serialize());
+            return rawTransaction;
+        });
+    }
+    /**
+     * Removes unapproved transactions from state.
+     */
+    clearUnapprovedTransactions() {
+        const transactions = this.state.transactions.filter(({ status }) => status !== types_1.TransactionStatus.unapproved);
+        this.update({ transactions: this.trimTransactionsForState(transactions) });
+    }
+    addMetadata(transactionMeta) {
+        const { transactions } = this.state;
+        transactions.push(transactionMeta);
+        this.update({ transactions: this.trimTransactionsForState(transactions) });
+    }
+    updateGasProperties(transactionMeta) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const isEIP1559Compatible = yield this.getEIP1559Compatibility();
+            const chainId = this.getChainId();
+            yield (0, gas_1.updateGas)({
+                ethQuery: this.ethQuery,
+                providerConfig: this.getNetworkState().providerConfig,
+                txMeta: transactionMeta,
+            });
+            yield (0, gas_fees_1.updateGasFees)({
+                eip1559: isEIP1559Compatible,
+                ethQuery: this.ethQuery,
+                getSavedGasFees: this.getSavedGasFees.bind(this, chainId),
+                getGasFeeEstimates: this.getGasFeeEstimates.bind(this),
+                txMeta: transactionMeta,
+            });
+        });
+    }
+    getCurrentChainTransactionsByStatus(status) {
+        const chainId = this.getChainId();
+        return this.state.transactions.filter((transaction) => transaction.status === status && transaction.chainId === chainId);
+    }
+    onBootCleanup() {
+        this.createApprovalsForUnapprovedTransactions();
+        this.loadGasValuesForUnapprovedTransactions();
+        this.submitApprovedTransactions();
+    }
+    /**
+     * Create approvals for all unapproved transactions on current chain.
+     */
+    createApprovalsForUnapprovedTransactions() {
+        const unapprovedTransactions = this.getCurrentChainTransactionsByStatus(types_1.TransactionStatus.unapproved);
+        for (const transactionMeta of unapprovedTransactions) {
+            this.processApproval(transactionMeta, {
+                shouldShowRequest: false,
+            }).catch((error) => {
+                if ((error === null || error === void 0 ? void 0 : error.code) === rpc_errors_1.errorCodes.provider.userRejectedRequest) {
+                    return;
+                }
+                /* istanbul ignore next */
+                console.error('Error during persisted transaction approval', error);
+            });
+        }
+    }
+    /**
+     * Update the gas values of all unapproved transactions on current chain.
+     */
+    loadGasValuesForUnapprovedTransactions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const unapprovedTransactions = this.getCurrentChainTransactionsByStatus(types_1.TransactionStatus.unapproved);
+            const results = yield Promise.allSettled(unapprovedTransactions.map((transactionMeta) => __awaiter(this, void 0, void 0, function* () {
+                yield this.updateGasProperties(transactionMeta);
+                this.updateTransaction(transactionMeta, 'TransactionController:loadGasValuesForUnapprovedTransactions - Gas values updated');
+            })));
+            for (const [index, result] of results.entries()) {
+                if (result.status === 'rejected') {
+                    const transactionMeta = unapprovedTransactions[index];
+                    this.failTransaction(transactionMeta, result.reason);
+                    /* istanbul ignore next */
+                    console.error('Error while loading gas values for persisted transaction id: ', transactionMeta.id, result.reason);
+                }
+            }
+        });
+    }
+    /**
+     * Force to submit approved transactions on current chain.
+     */
+    submitApprovedTransactions() {
+        const approvedTransactions = this.getCurrentChainTransactionsByStatus(types_1.TransactionStatus.approved);
+        for (const transactionMeta of approvedTransactions) {
+            if (this.beforeApproveOnInit(transactionMeta)) {
+                this.approveTransaction(transactionMeta.id).catch((error) => {
+                    /* istanbul ignore next */
+                    console.error('Error while submitting persisted transaction', error);
+                });
+            }
+        }
+    }
+    processApproval(transactionMeta, { isExisting = false, requireApproval, shouldShowRequest = true, actionId, }) {
         return __awaiter(this, void 0, void 0, function* () {
             const transactionId = transactionMeta.id;
             let resultCallbacks;
@@ -681,17 +969,22 @@ class TransactionController extends base_controller_1.BaseController {
                     const { isCompleted: isTxCompleted } = this.isTransactionCompleted(transactionId);
                     if (!isTxCompleted) {
                         yield this.approveTransaction(transactionId);
+                        const updatedTransactionMeta = this.getTransaction(transactionId);
+                        this.hub.emit('transaction-approved', {
+                            transactionMeta: updatedTransactionMeta,
+                            actionId,
+                        });
                     }
                 }
                 catch (error) {
                     const { isCompleted: isTxCompleted } = this.isTransactionCompleted(transactionId);
                     if (!isTxCompleted) {
-                        if (error.code === rpc_errors_1.errorCodes.provider.userRejectedRequest) {
-                            this.cancelTransaction(transactionId);
-                            throw rpc_errors_1.providerErrors.userRejectedRequest('User rejected the transaction');
+                        if ((error === null || error === void 0 ? void 0 : error.code) === rpc_errors_1.errorCodes.provider.userRejectedRequest) {
+                            this.cancelTransaction(transactionId, actionId);
+                            throw rpc_errors_1.providerErrors.userRejectedRequest('MetaMask Tx Signature: User denied transaction signature.');
                         }
                         else {
-                            this.failTransaction(meta, error);
+                            this.failTransaction(meta, error, actionId);
                         }
                     }
                 }
@@ -701,10 +994,6 @@ class TransactionController extends base_controller_1.BaseController {
                 case types_1.TransactionStatus.failed:
                     resultCallbacks === null || resultCallbacks === void 0 ? void 0 : resultCallbacks.error(finalMeta.error);
                     throw rpc_errors_1.rpcErrors.internal(finalMeta.error.message);
-                case types_1.TransactionStatus.cancelled:
-                    const cancelError = rpc_errors_1.rpcErrors.internal('User cancelled the transaction');
-                    resultCallbacks === null || resultCallbacks === void 0 ? void 0 : resultCallbacks.error(cancelError);
-                    throw cancelError;
                 case types_1.TransactionStatus.submitted:
                     resultCallbacks === null || resultCallbacks === void 0 ? void 0 : resultCallbacks.success();
                     return finalMeta.hash;
@@ -743,6 +1032,10 @@ class TransactionController extends base_controller_1.BaseController {
                     this.failTransaction(transactionMeta, new Error('No chainId defined.'));
                     return;
                 }
+                if (this.inProcessOfSigning.has(transactionId)) {
+                    (0, logger_1.projectLogger)('Skipping approval as signing in progress', transactionId);
+                    return;
+                }
                 const { approved: status } = types_1.TransactionStatus;
                 let nonceToUse = nonce;
                 // if a nonce already exists on the transactionMeta it means this is a speedup or cancel transaction
@@ -755,27 +1048,31 @@ class TransactionController extends base_controller_1.BaseController {
                 transactionMeta.txParams.nonce = nonceToUse;
                 transactionMeta.txParams.chainId = chainId;
                 const baseTxParams = Object.assign(Object.assign({}, transactionMeta.txParams), { gasLimit: transactionMeta.txParams.gas });
+                this.updateTransaction(transactionMeta, 'TransactionController#approveTransaction - Transaction approved');
                 const isEIP1559 = (0, utils_1.isEIP1559Transaction)(transactionMeta.txParams);
                 const txParams = isEIP1559
                     ? Object.assign(Object.assign({}, baseTxParams), { maxFeePerGas: transactionMeta.txParams.maxFeePerGas, maxPriorityFeePerGas: transactionMeta.txParams.maxPriorityFeePerGas, estimatedBaseFee: transactionMeta.txParams.estimatedBaseFee, 
                         // specify type 2 if maxFeePerGas and maxPriorityFeePerGas are set
-                        type: 2 }) : baseTxParams;
+                        type: '2' }) : baseTxParams;
                 // delete gasPrice if maxFeePerGas and maxPriorityFeePerGas are set
                 if (isEIP1559) {
                     delete txParams.gasPrice;
                 }
-                const unsignedEthTx = this.prepareUnsignedEthTx(txParams);
-                const signedTx = yield this.sign(unsignedEthTx, from);
-                yield this.updateTransactionMetaRSV(transactionMeta, signedTx);
-                transactionMeta.status = types_1.TransactionStatus.signed;
-                this.updateTransaction(transactionMeta, 'TransactionController#approveTransaction - Transaction signed');
-                const rawTx = (0, ethereumjs_util_1.bufferToHex)(signedTx.serialize());
-                transactionMeta.rawTx = rawTx;
-                this.updateTransaction(transactionMeta, 'TransactionController#approveTransaction - RawTransaction added');
-                const hash = yield (0, controller_utils_1.query)(this.ethQuery, 'sendRawTransaction', [rawTx]);
+                const rawTx = yield this.signTransaction(transactionMeta);
+                if (!this.beforePublish(transactionMeta)) {
+                    (0, logger_1.projectLogger)('Skipping publishing transaction based on hook');
+                    return;
+                }
+                if (!rawTx) {
+                    return;
+                }
+                const hash = yield this.publishTransaction(rawTx);
                 transactionMeta.hash = hash;
                 transactionMeta.status = types_1.TransactionStatus.submitted;
                 transactionMeta.submittedTime = new Date().getTime();
+                this.hub.emit('transaction-submitted', {
+                    transactionMeta,
+                });
                 this.updateTransaction(transactionMeta, 'TransactionController#approveTransaction - Transaction submitted');
                 this.hub.emit(`${transactionMeta.id}:finished`, transactionMeta);
             }
@@ -783,6 +1080,7 @@ class TransactionController extends base_controller_1.BaseController {
                 this.failTransaction(transactionMeta, error);
             }
             finally {
+                this.inProcessOfSigning.delete(transactionId);
                 // must set transaction to submitted/failed before releasing lock
                 if (nonceLock) {
                     nonceLock.releaseLock();
@@ -791,19 +1089,29 @@ class TransactionController extends base_controller_1.BaseController {
             }
         });
     }
+    publishTransaction(rawTransaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, controller_utils_1.query)(this.ethQuery, 'sendRawTransaction', [rawTransaction]);
+        });
+    }
     /**
      * 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) {
+    cancelTransaction(transactionId, actionId) {
         const transactionMeta = this.state.transactions.find(({ id }) => id === transactionId);
         if (!transactionMeta) {
             return;
         }
         transactionMeta.status = types_1.TransactionStatus.rejected;
         this.hub.emit(`${transactionMeta.id}:finished`, transactionMeta);
+        this.hub.emit('transaction-rejected', {
+            transactionMeta,
+            actionId,
+        });
         const transactions = this.state.transactions.filter(({ id }) => id !== transactionId);
         this.update({ transactions: this.trimTransactionsForState(transactions) });
     }
@@ -852,8 +1160,7 @@ class TransactionController extends base_controller_1.BaseController {
     isFinalState(status) {
         return (status === types_1.TransactionStatus.rejected ||
             status === types_1.TransactionStatus.confirmed ||
-            status === types_1.TransactionStatus.failed ||
-            status === types_1.TransactionStatus.cancelled);
+            status === types_1.TransactionStatus.failed);
     }
     /**
      * Whether the transaction has at least completed all local processing.
@@ -863,7 +1170,6 @@ class TransactionController extends base_controller_1.BaseController {
      */
     isLocalFinalState(status) {
         return [
-            types_1.TransactionStatus.cancelled,
             types_1.TransactionStatus.confirmed,
             types_1.TransactionStatus.failed,
             types_1.TransactionStatus.rejected,
@@ -950,10 +1256,6 @@ class TransactionController extends base_controller_1.BaseController {
         this.update({ lastFetchedBlockNumbers });
         this.hub.emit('incomingTransactionBlock', blockNumber);
     }
-    onPendingTransactionsUpdate(transactions) {
-        (0, logger_1.pendingTransactionsLogger)('Updated pending transactions');
-        this.update({ transactions: this.trimTransactionsForState(transactions) });
-    }
     generateDappSuggestedGasFees(txParams, origin) {
         if (!origin || origin === controller_utils_1.ORIGIN_METAMASK) {
             return undefined;
@@ -1045,6 +1347,9 @@ class TransactionController extends base_controller_1.BaseController {
      */
     setTransactionStatusDropped(transactionMeta) {
         transactionMeta.status = types_1.TransactionStatus.dropped;
+        this.hub.emit('transaction-dropped', {
+            transactionMeta,
+        });
         this.updateTransaction(transactionMeta, 'TransactionController#setTransactionStatusDropped - Transaction dropped');
     }
     /**
@@ -1093,6 +1398,39 @@ class TransactionController extends base_controller_1.BaseController {
             return (currentNetworkIsEIP1559Compatible && currentAccountIsEIP1559Compatible);
         });
     }
+    addPendingTransactionTrackerListeners() {
+        this.pendingTransactionTracker.hub.on('transaction-confirmed', (transactionMeta) => {
+            this.hub.emit('transaction-confirmed', { transactionMeta });
+            this.hub.emit(`${transactionMeta.id}:confirmed`, transactionMeta);
+        });
+        this.pendingTransactionTracker.hub.on('transaction-dropped', this.setTransactionStatusDropped.bind(this));
+        this.pendingTransactionTracker.hub.on('transaction-failed', this.failTransaction.bind(this));
+        this.pendingTransactionTracker.hub.on('transaction-updated', this.updateTransaction.bind(this));
+    }
+    signTransaction(transactionMeta) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const { txParams } = transactionMeta;
+            const unsignedEthTx = this.prepareUnsignedEthTx(txParams);
+            this.inProcessOfSigning.add(transactionMeta.id);
+            const signedTx = yield ((_a = this.sign) === null || _a === void 0 ? void 0 : _a.call(this, unsignedEthTx, txParams.from, ...this.getAdditionalSignArguments(transactionMeta)));
+            if (!signedTx) {
+                (0, logger_1.projectLogger)('Skipping signed status as no signed transaction');
+                return undefined;
+            }
+            if (!this.afterSign(transactionMeta, signedTx)) {
+                (0, logger_1.projectLogger)('Skipping signed status based on hook');
+                return undefined;
+            }
+            yield this.updateTransactionMetaRSV(transactionMeta, signedTx);
+            transactionMeta.status = types_1.TransactionStatus.signed;
+            this.updateTransaction(transactionMeta, 'TransactionController#approveTransaction - Transaction signed');
+            const rawTx = (0, ethereumjs_util_1.bufferToHex)(signedTx.serialize());
+            transactionMeta.rawTx = rawTx;
+            this.updateTransaction(transactionMeta, 'TransactionController#approveTransaction - RawTransaction added');
+            return rawTx;
+        });
+    }
 }
 exports.TransactionController = TransactionController;
 exports.default = TransactionController;