@metamask/transaction-controller 8.0.0 → 9.0.0

package/dist/TransactionController.js

@@ -12,46 +12,24 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TransactionController = exports.SPEED_UP_RATE = exports.CANCEL_RATE = exports.WalletDevice = exports.TransactionStatus = exports.HARDFORK = void 0;
+exports.TransactionController = exports.SPEED_UP_RATE = exports.CANCEL_RATE = exports.HARDFORK = void 0;
 const common_1 = require("@ethereumjs/common");
 const tx_1 = require("@ethereumjs/tx");
 const base_controller_1 = require("@metamask/base-controller");
 const controller_utils_1 = require("@metamask/controller-utils");
+const eth_query_1 = __importDefault(require("@metamask/eth-query"));
 const async_mutex_1 = require("async-mutex");
 const eth_method_registry_1 = __importDefault(require("eth-method-registry"));
-const eth_query_1 = __importDefault(require("eth-query"));
 const eth_rpc_errors_1 = require("eth-rpc-errors");
 const ethereumjs_util_1 = require("ethereumjs-util");
 const events_1 = require("events");
 const nonce_tracker_1 = __importDefault(require("nonce-tracker"));
 const uuid_1 = require("uuid");
+const EtherscanRemoteTransactionSource_1 = require("./EtherscanRemoteTransactionSource");
+const IncomingTransactionHelper_1 = require("./IncomingTransactionHelper");
+const types_1 = require("./types");
 const utils_1 = require("./utils");
 exports.HARDFORK = common_1.Hardfork.London;
-/**
- * The status of the transaction. Each status represents the state of the transaction internally
- * in the wallet. Some of these correspond with the state of the transaction on the network, but
- * some are wallet-specific.
- */
-var TransactionStatus;
-(function (TransactionStatus) {
-    TransactionStatus["approved"] = "approved";
-    TransactionStatus["cancelled"] = "cancelled";
-    TransactionStatus["confirmed"] = "confirmed";
-    TransactionStatus["failed"] = "failed";
-    TransactionStatus["rejected"] = "rejected";
-    TransactionStatus["signed"] = "signed";
-    TransactionStatus["submitted"] = "submitted";
-    TransactionStatus["unapproved"] = "unapproved";
-})(TransactionStatus = exports.TransactionStatus || (exports.TransactionStatus = {}));
-/**
- * Options for wallet device.
- */
-var WalletDevice;
-(function (WalletDevice) {
-    WalletDevice["MM_MOBILE"] = "metamask_mobile";
-    WalletDevice["MM_EXTENSION"] = "metamask_extension";
-    WalletDevice["OTHER"] = "other_device";
-})(WalletDevice = exports.WalletDevice || (exports.WalletDevice = {}));
 /**
  * Multiplier used to determine a transaction's increased gas fee during cancellation
  */
@@ -72,45 +50,23 @@ class TransactionController extends base_controller_1.BaseController {
      * Creates a TransactionController instance.
      *
      * @param options - The controller options.
+     * @param options.blockTracker - The block tracker used to poll for new blocks data.
      * @param options.getNetworkState - Gets the state of the network controller.
+     * @param options.getSelectedAddress - Gets the address of the currently selected account.
+     * @param options.incomingTransactions - Configuration options for incoming transaction support.
+     * @param options.incomingTransactions.apiKey - An optional API key to use when fetching remote transaction data.
+     * @param options.incomingTransactions.includeTokenTransfers - Whether or not to include ERC20 token transfers.
+     * @param options.incomingTransactions.isEnabled - Whether or not incoming transaction retrieval is enabled.
+     * @param options.incomingTransactions.updateTransactions - Whether or not 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.provider - The provider used to create the underlying EthQuery instance.
-     * @param options.blockTracker - The block tracker used to poll for new blocks data.
-     * @param options.messenger - The controller messenger.
      * @param config - Initial options used to configure this controller.
      * @param state - Initial state to set on this controller.
      */
-    constructor({ getNetworkState, onNetworkStateChange, provider, blockTracker, messenger, }, config, state) {
+    constructor({ blockTracker, getNetworkState, getSelectedAddress, incomingTransactions = {}, messenger, onNetworkStateChange, provider, }, config, state) {
         super(config, state);
         this.mutex = new async_mutex_1.Mutex();
-        this.normalizeTokenTx = (txMeta, currentNetworkID, currentChainId) => {
-            const time = parseInt(txMeta.timeStamp, 10) * 1000;
-            const { to, from, gas, gasPrice, gasUsed, hash, contractAddress, tokenDecimal, tokenSymbol, value, } = txMeta;
-            return {
-                id: (0, uuid_1.v1)({ msecs: time }),
-                isTransfer: true,
-                networkID: currentNetworkID,
-                chainId: currentChainId,
-                status: TransactionStatus.confirmed,
-                time,
-                transaction: {
-                    chainId: currentChainId,
-                    from,
-                    gas,
-                    gasPrice,
-                    gasUsed,
-                    to,
-                    value,
-                },
-                transactionHash: hash,
-                transferInformation: {
-                    contractAddress,
-                    decimals: Number(tokenDecimal),
-                    symbol: tokenSymbol,
-                },
-                verifiedOnBlockchain: false,
-            };
-        };
         /**
          * EventEmitter instance used to listen to specific transactional events
          */
@@ -126,6 +82,7 @@ class TransactionController extends base_controller_1.BaseController {
         this.defaultState = {
             methodData: {},
             transactions: [],
+            lastFetchedBlockNumbers: {},
         };
         this.initialize();
         this.provider = provider;
@@ -136,9 +93,23 @@ class TransactionController extends base_controller_1.BaseController {
         this.nonceTracker = new nonce_tracker_1.default({
             provider,
             blockTracker,
-            getPendingTransactions: (address) => (0, utils_1.getAndFormatTransactionsForNonceTracker)(address, TransactionStatus.submitted, this.state.transactions),
-            getConfirmedTransactions: (address) => (0, utils_1.getAndFormatTransactionsForNonceTracker)(address, TransactionStatus.confirmed, this.state.transactions),
+            getPendingTransactions: (address) => (0, utils_1.getAndFormatTransactionsForNonceTracker)(address, types_1.TransactionStatus.submitted, this.state.transactions),
+            getConfirmedTransactions: (address) => (0, utils_1.getAndFormatTransactionsForNonceTracker)(address, types_1.TransactionStatus.confirmed, this.state.transactions),
         });
+        this.incomingTransactionHelper = new IncomingTransactionHelper_1.IncomingTransactionHelper({
+            blockTracker,
+            getCurrentAccount: getSelectedAddress,
+            getNetworkState,
+            isEnabled: incomingTransactions.isEnabled,
+            remoteTransactionSource: new EtherscanRemoteTransactionSource_1.EtherscanRemoteTransactionSource({
+                apiKey: incomingTransactions.apiKey,
+                includeTokenTransfers: incomingTransactions.includeTokenTransfers,
+            }),
+            transactionLimit: this.config.txHistoryLimit,
+            updateTransactions: incomingTransactions.updateTransactions,
+        });
+        this.incomingTransactionHelper.hub.on('transactions', this.onIncomingTransactions.bind(this));
+        this.incomingTransactionHelper.hub.on('updatedLastFetchedBlockNumbers', this.onUpdatedLastFetchedBlockNumbers.bind(this));
         onNetworkStateChange(() => {
             this.ethQuery = new eth_query_1.default(this.provider);
             this.registry = new eth_method_registry_1.default({ provider: this.provider });
@@ -146,7 +117,7 @@ class TransactionController extends base_controller_1.BaseController {
         this.poll();
     }
     failTransaction(transactionMeta, error) {
-        const newTransactionMeta = Object.assign(Object.assign({}, transactionMeta), { error, status: TransactionStatus.failed });
+        const newTransactionMeta = Object.assign(Object.assign({}, transactionMeta), { error, status: types_1.TransactionStatus.failed });
         this.updateTransaction(newTransactionMeta);
         this.hub.emit(`${transactionMeta.id}:finished`, newTransactionMeta);
     }
@@ -157,43 +128,6 @@ class TransactionController extends base_controller_1.BaseController {
             return { registryMethod, parsedRegistryMethod };
         });
     }
-    /**
-     * Normalizes the transaction information from etherscan
-     * to be compatible with the TransactionMeta interface.
-     *
-     * @param txMeta - The transaction.
-     * @param currentNetworkID - The current network ID.
-     * @param currentChainId - The current chain ID.
-     * @returns The normalized transaction.
-     */
-    normalizeTx(txMeta, currentNetworkID, currentChainId) {
-        const time = parseInt(txMeta.timeStamp, 10) * 1000;
-        const normalizedTransactionBase = {
-            blockNumber: txMeta.blockNumber,
-            id: (0, uuid_1.v1)({ msecs: time }),
-            networkID: currentNetworkID,
-            chainId: currentChainId,
-            time,
-            transaction: {
-                data: txMeta.input,
-                from: txMeta.from,
-                gas: (0, controller_utils_1.BNToHex)(new ethereumjs_util_1.BN(txMeta.gas)),
-                gasPrice: (0, controller_utils_1.BNToHex)(new ethereumjs_util_1.BN(txMeta.gasPrice)),
-                gasUsed: (0, controller_utils_1.BNToHex)(new ethereumjs_util_1.BN(txMeta.gasUsed)),
-                nonce: (0, controller_utils_1.BNToHex)(new ethereumjs_util_1.BN(txMeta.nonce)),
-                to: txMeta.to,
-                value: (0, controller_utils_1.BNToHex)(new ethereumjs_util_1.BN(txMeta.value)),
-            },
-            transactionHash: txMeta.hash,
-            verifiedOnBlockchain: false,
-        };
-        /* istanbul ignore else */
-        if (txMeta.isError === '0') {
-            return Object.assign(Object.assign({}, normalizedTransactionBase), { status: TransactionStatus.confirmed });
-        }
-        /* istanbul ignore next */
-        return Object.assign(Object.assign({}, normalizedTransactionBase), { error: new Error('Transaction failed'), status: TransactionStatus.failed });
-    }
     /**
      * Starts a new polling interval.
      *
@@ -241,26 +175,30 @@ class TransactionController extends base_controller_1.BaseController {
      * if not provided. If A `<tx.id>:unapproved` hub event will be emitted once added.
      *
      * @param transaction - The transaction object to add.
-     * @param origin - The domain origin to append to the generated TransactionMeta.
-     * @param deviceConfirmedOn - An enum to indicate what device the transaction was confirmed to append to the generated TransactionMeta.
+     * @param opts - Additional options to control how the transaction is added.
+     * @param opts.deviceConfirmedOn - An enum to indicate what device confirmed 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.
      * @returns Object containing a promise resolving to the transaction hash if approved.
      */
-    addTransaction(transaction, origin, deviceConfirmedOn) {
+    addTransaction(transaction, { deviceConfirmedOn, origin, requireApproval, } = {}) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { providerConfig, networkId } = this.getNetworkState();
+            const { chainId, networkId } = this.getChainAndNetworkId();
             const { transactions } = this.state;
             transaction = (0, utils_1.normalizeTransaction)(transaction);
             (0, utils_1.validateTransaction)(transaction);
+            const dappSuggestedGasFees = this.generateDappSuggestedGasFees(transaction, origin);
             const transactionMeta = {
                 id: (0, uuid_1.v1)(),
                 networkID: networkId !== null && networkId !== void 0 ? networkId : undefined,
-                chainId: providerConfig.chainId,
+                chainId,
                 origin,
-                status: TransactionStatus.unapproved,
+                status: types_1.TransactionStatus.unapproved,
                 time: Date.now(),
                 transaction,
                 deviceConfirmedOn,
                 verifiedOnBlockchain: false,
+                dappSuggestedGasFees,
             };
             try {
                 const { gas, estimateGasError } = yield this.estimateGas(transaction);
@@ -275,40 +213,39 @@ class TransactionController extends base_controller_1.BaseController {
             this.update({ transactions: this.trimTransactionsForState(transactions) });
             this.hub.emit(`unapprovedTransaction`, transactionMeta);
             return {
-                result: this.processApproval(transactionMeta),
+                result: this.processApproval(transactionMeta, {
+                    requireApproval,
+                }),
                 transactionMeta,
             };
         });
     }
-    prepareUnsignedEthTx(txParams) {
-        return tx_1.TransactionFactory.fromTxData(txParams, {
-            common: this.getCommonConfiguration(),
-            freeze: false,
+    startIncomingTransactionPolling() {
+        this.incomingTransactionHelper.start();
+    }
+    stopIncomingTransactionPolling() {
+        this.incomingTransactionHelper.stop();
+    }
+    updateIncomingTransactions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.incomingTransactionHelper.update();
         });
     }
     /**
-     * `@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.
-     *
-     * @returns {Common} common configuration object
+     * Creates approvals for all unapproved transactions persisted.
      */
-    getCommonConfiguration() {
-        const { networkId, providerConfig: { type: chain, chainId, nickname: name }, } = this.getNetworkState();
-        if (chain !== controller_utils_1.RPC &&
-            chain !== controller_utils_1.NetworkType['linea-goerli'] &&
-            chain !== controller_utils_1.NetworkType['linea-mainnet']) {
-            return new common_1.Common({ chain, hardfork: exports.HARDFORK });
+    initApprovals() {
+        const { networkId, chainId } = this.getChainAndNetworkId();
+        const unapprovedTxs = this.state.transactions.filter((transaction) => transaction.status === types_1.TransactionStatus.unapproved &&
+            (0, utils_1.transactionMatchesNetwork)(transaction, chainId, networkId));
+        for (const txMeta of unapprovedTxs) {
+            this.processApproval(txMeta, {
+                shouldShowRequest: false,
+            }).catch((error) => {
+                /* istanbul ignore next */
+                console.error('Error during persisted transaction approval', error);
+            });
         }
-        const customChainParams = {
-            name,
-            chainId: parseInt(chainId, 16),
-            networkId: networkId === null ? NaN : parseInt(networkId, undefined),
-            defaultHardfork: exports.HARDFORK,
-        };
-        return common_1.Common.custom(customChainParams);
     }
     /**
      * Attempts to cancel a transaction based on its ID by setting its status to "rejected"
@@ -373,7 +310,7 @@ class TransactionController extends base_controller_1.BaseController {
             const signedTx = yield this.sign(unsignedEthTx, transactionMeta.transaction.from);
             const rawTransaction = (0, ethereumjs_util_1.bufferToHex)(signedTx.serialize());
             yield (0, controller_utils_1.query)(this.ethQuery, 'sendRawTransaction', [rawTransaction]);
-            transactionMeta.status = TransactionStatus.cancelled;
+            transactionMeta.status = types_1.TransactionStatus.cancelled;
             this.hub.emit(`${transactionMeta.id}:finished`, transactionMeta);
         });
     }
@@ -513,8 +450,7 @@ class TransactionController extends base_controller_1.BaseController {
     queryTransactionStatuses() {
         return __awaiter(this, void 0, void 0, function* () {
             const { transactions } = this.state;
-            const { providerConfig, networkId: currentNetworkID } = this.getNetworkState();
-            const { chainId: currentChainId } = providerConfig;
+            const { chainId: currentChainId, networkId: currentNetworkID } = this.getChainAndNetworkId();
             let gotUpdates = false;
             yield (0, controller_utils_1.safelyExecute)(() => Promise.all(transactions.map((meta, index) => __awaiter(this, void 0, void 0, function* () {
                 // Using fallback to networkID only when there is no chainId present.
@@ -555,96 +491,49 @@ class TransactionController extends base_controller_1.BaseController {
      *
      * @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) {
+    wipeTransactions(ignoreNetwork, address) {
         /* istanbul ignore next */
-        if (ignoreNetwork) {
+        if (ignoreNetwork && !address) {
             this.update({ transactions: [] });
             return;
         }
-        const { providerConfig, networkId: currentNetworkID } = this.getNetworkState();
-        const { chainId: currentChainId } = providerConfig;
-        const newTransactions = this.state.transactions.filter(({ networkID, chainId }) => {
+        const { chainId: currentChainId, networkId: currentNetworkID } = this.getChainAndNetworkId();
+        const newTransactions = this.state.transactions.filter(({ networkID, chainId, transaction }) => {
+            var _a;
             // Using fallback to networkID only when there is no chainId present. Should be removed when networkID is completely removed.
-            const isCurrentNetwork = chainId === currentChainId ||
+            const isMatchingNetwork = ignoreNetwork ||
+                chainId === currentChainId ||
                 (!chainId && networkID === currentNetworkID);
-            return !isCurrentNetwork;
+            if (!isMatchingNetwork) {
+                return true;
+            }
+            const isMatchingAddress = !address || ((_a = transaction.from) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === address.toLowerCase();
+            return !isMatchingAddress;
         });
         this.update({
             transactions: this.trimTransactionsForState(newTransactions),
         });
     }
-    /**
-     * Get transactions from Etherscan for the given address. By default all transactions are
-     * returned, but the `fromBlock` option can be given to filter just for transactions from a
-     * specific block onward.
-     *
-     * @param address - The address to fetch the transactions for.
-     * @param opt - Object containing optional data, fromBlock and Etherscan API key.
-     * @returns The block number of the latest incoming transaction.
-     */
-    fetchAll(address, opt) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { providerConfig, networkId: currentNetworkID } = this.getNetworkState();
-            const { chainId: currentChainId, type: networkType } = providerConfig;
-            const { transactions } = this.state;
-            const supportedNetworkIds = ['1', '5', '11155111'];
-            /* istanbul ignore next */
-            if (currentNetworkID === null ||
-                !supportedNetworkIds.includes(currentNetworkID)) {
-                return undefined;
-            }
-            const [etherscanTxResponse, etherscanTokenResponse] = yield (0, utils_1.handleTransactionFetch)(networkType, address, this.config.txHistoryLimit, opt);
-            const normalizedTxs = etherscanTxResponse.result.map((tx) => this.normalizeTx(tx, currentNetworkID, currentChainId));
-            const normalizedTokenTxs = etherscanTokenResponse.result.map((tx) => this.normalizeTokenTx(tx, currentNetworkID, currentChainId));
-            const [updateRequired, allTxs] = this.etherscanTransactionStateReconciler([...normalizedTxs, ...normalizedTokenTxs], transactions);
-            allTxs.sort((a, b) => (a.time < b.time ? -1 : 1));
-            let latestIncomingTxBlockNumber;
-            allTxs.forEach((tx) => __awaiter(this, void 0, void 0, function* () {
-                /* istanbul ignore next */
-                if (
-                // Using fallback to networkID only when there is no chainId present. Should be removed when networkID is completely removed.
-                (tx.chainId === currentChainId ||
-                    (!tx.chainId && tx.networkID === currentNetworkID)) &&
-                    tx.transaction.to &&
-                    tx.transaction.to.toLowerCase() === address.toLowerCase()) {
-                    if (tx.blockNumber &&
-                        (!latestIncomingTxBlockNumber ||
-                            parseInt(latestIncomingTxBlockNumber, 10) <
-                                parseInt(tx.blockNumber, 10))) {
-                        latestIncomingTxBlockNumber = tx.blockNumber;
-                    }
-                }
-                /* istanbul ignore else */
-                if (tx.toSmartContract === undefined) {
-                    // If not `to` is a contract deploy, if not `data` is send eth
-                    if (tx.transaction.to &&
-                        (!tx.transaction.data || tx.transaction.data !== '0x')) {
-                        const code = yield (0, controller_utils_1.query)(this.ethQuery, 'getCode', [
-                            tx.transaction.to,
-                        ]);
-                        tx.toSmartContract = (0, controller_utils_1.isSmartContractCode)(code);
-                    }
-                    else {
-                        tx.toSmartContract = false;
-                    }
-                }
-            }));
-            // Update state only if new transactions were fetched or
-            // the status or gas data of a transaction has changed
-            if (updateRequired) {
-                this.update({ transactions: this.trimTransactionsForState(allTxs) });
-            }
-            return latestIncomingTxBlockNumber;
-        });
+    startIncomingTransactionProcessing() {
+        this.incomingTransactionHelper.start();
+    }
+    stopIncomingTransactionProcessing() {
+        this.incomingTransactionHelper.stop();
     }
-    processApproval(transactionMeta) {
+    processApproval(transactionMeta, { requireApproval, shouldShowRequest = true, }) {
         return __awaiter(this, void 0, void 0, function* () {
             const transactionId = transactionMeta.id;
             let resultCallbacks;
             try {
-                const acceptResult = yield this.requestApproval(transactionMeta);
-                resultCallbacks = acceptResult.resultCallbacks;
+                if (requireApproval !== false) {
+                    const acceptResult = yield this.requestApproval(transactionMeta, {
+                        shouldShowRequest,
+                    });
+                    resultCallbacks = acceptResult.resultCallbacks;
+                }
                 const { meta, isCompleted } = this.isTransactionCompleted(transactionId);
                 if (meta && !isCompleted) {
                     yield this.approveTransaction(transactionId);
@@ -664,14 +553,14 @@ class TransactionController extends base_controller_1.BaseController {
             }
             const finalMeta = this.getTransaction(transactionId);
             switch (finalMeta === null || finalMeta === void 0 ? void 0 : finalMeta.status) {
-                case TransactionStatus.failed:
+                case types_1.TransactionStatus.failed:
                     resultCallbacks === null || resultCallbacks === void 0 ? void 0 : resultCallbacks.error(finalMeta.error);
                     throw eth_rpc_errors_1.ethErrors.rpc.internal(finalMeta.error.message);
-                case TransactionStatus.cancelled:
+                case types_1.TransactionStatus.cancelled:
                     const cancelError = eth_rpc_errors_1.ethErrors.rpc.internal('User cancelled the transaction');
                     resultCallbacks === null || resultCallbacks === void 0 ? void 0 : resultCallbacks.error(cancelError);
                     throw cancelError;
-                case TransactionStatus.submitted:
+                case types_1.TransactionStatus.submitted:
                     resultCallbacks === null || resultCallbacks === void 0 ? void 0 : resultCallbacks.success();
                     return finalMeta.transactionHash;
                 default:
@@ -693,8 +582,7 @@ class TransactionController extends base_controller_1.BaseController {
         return __awaiter(this, void 0, void 0, function* () {
             const { transactions } = this.state;
             const releaseLock = yield this.mutex.acquire();
-            const { providerConfig } = this.getNetworkState();
-            const { chainId } = providerConfig;
+            const { chainId } = this.getChainAndNetworkId();
             const index = transactions.findIndex(({ id }) => transactionID === id);
             const transactionMeta = transactions[index];
             const { transaction: { nonce, from }, } = transactionMeta;
@@ -710,7 +598,7 @@ class TransactionController extends base_controller_1.BaseController {
                     this.failTransaction(transactionMeta, new Error('No chainId defined.'));
                     return;
                 }
-                const { approved: status } = TransactionStatus;
+                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
                 // so we want to reuse that nonce and hope that it beats the previous attempt to chain. Otherwise use a new locked nonce
@@ -733,7 +621,7 @@ class TransactionController extends base_controller_1.BaseController {
                 }
                 const unsignedEthTx = this.prepareUnsignedEthTx(txParams);
                 const signedTx = yield this.sign(unsignedEthTx, from);
-                transactionMeta.status = TransactionStatus.signed;
+                transactionMeta.status = types_1.TransactionStatus.signed;
                 this.updateTransaction(transactionMeta);
                 const rawTransaction = (0, ethereumjs_util_1.bufferToHex)(signedTx.serialize());
                 transactionMeta.rawTransaction = rawTransaction;
@@ -742,7 +630,7 @@ class TransactionController extends base_controller_1.BaseController {
                     rawTransaction,
                 ]);
                 transactionMeta.transactionHash = transactionHash;
-                transactionMeta.status = TransactionStatus.submitted;
+                transactionMeta.status = types_1.TransactionStatus.submitted;
                 this.updateTransaction(transactionMeta);
                 this.hub.emit(`${transactionMeta.id}:finished`, transactionMeta);
             }
@@ -769,7 +657,7 @@ class TransactionController extends base_controller_1.BaseController {
         if (!transactionMeta) {
             return;
         }
-        transactionMeta.status = TransactionStatus.rejected;
+        transactionMeta.status = types_1.TransactionStatus.rejected;
         this.hub.emit(`${transactionMeta.id}:finished`, transactionMeta);
         const transactions = this.state.transactions.filter(({ id }) => id !== transactionID);
         this.update({ transactions: this.trimTransactionsForState(transactions) });
@@ -815,10 +703,10 @@ class TransactionController extends base_controller_1.BaseController {
      * @returns Whether the transaction is in a final state.
      */
     isFinalState(status) {
-        return (status === TransactionStatus.rejected ||
-            status === TransactionStatus.confirmed ||
-            status === TransactionStatus.failed ||
-            status === TransactionStatus.cancelled);
+        return (status === types_1.TransactionStatus.rejected ||
+            status === types_1.TransactionStatus.confirmed ||
+            status === types_1.TransactionStatus.failed ||
+            status === types_1.TransactionStatus.cancelled);
     }
     /**
      * Whether the transaction has at least completed all local processing.
@@ -828,11 +716,11 @@ class TransactionController extends base_controller_1.BaseController {
      */
     isLocalFinalState(status) {
         return [
-            TransactionStatus.cancelled,
-            TransactionStatus.confirmed,
-            TransactionStatus.failed,
-            TransactionStatus.rejected,
-            TransactionStatus.submitted,
+            types_1.TransactionStatus.cancelled,
+            types_1.TransactionStatus.confirmed,
+            types_1.TransactionStatus.failed,
+            types_1.TransactionStatus.rejected,
+            types_1.TransactionStatus.submitted,
         ].includes(status);
     }
     /**
@@ -845,15 +733,20 @@ class TransactionController extends base_controller_1.BaseController {
         return __awaiter(this, void 0, void 0, function* () {
             const { status, transactionHash } = meta;
             switch (status) {
-                case TransactionStatus.confirmed:
+                case types_1.TransactionStatus.confirmed:
                     const txReceipt = yield (0, controller_utils_1.query)(this.ethQuery, 'getTransactionReceipt', [
                         transactionHash,
                     ]);
                     if (!txReceipt) {
                         return [meta, false];
                     }
+                    const txBlock = yield (0, controller_utils_1.query)(this.ethQuery, 'getBlockByHash', [
+                        txReceipt.blockHash,
+                    ]);
                     meta.verifiedOnBlockchain = true;
                     meta.transaction.gasUsed = txReceipt.gasUsed;
+                    meta.txReceipt = txReceipt;
+                    meta.baseFeePerGas = txBlock === null || txBlock === void 0 ? void 0 : txBlock.baseFeePerGas;
                     // According to the Web3 docs:
                     // TRUE if the transaction was successful, FALSE if the EVM reverted the transaction.
                     if (Number(txReceipt.status) === 0) {
@@ -862,7 +755,7 @@ class TransactionController extends base_controller_1.BaseController {
                         return [meta, false];
                     }
                     return [meta, true];
-                case TransactionStatus.submitted:
+                case types_1.TransactionStatus.submitted:
                     const txObj = yield (0, controller_utils_1.query)(this.ethQuery, 'getTransactionByHash', [
                         transactionHash,
                     ]);
@@ -877,7 +770,7 @@ class TransactionController extends base_controller_1.BaseController {
                     }
                     /* istanbul ignore next */
                     if (txObj === null || txObj === void 0 ? void 0 : txObj.blockNumber) {
-                        meta.status = TransactionStatus.confirmed;
+                        meta.status = types_1.TransactionStatus.confirmed;
                         this.hub.emit(`${meta.id}:confirmed`, meta);
                         return [meta, true];
                     }
@@ -908,90 +801,7 @@ class TransactionController extends base_controller_1.BaseController {
             return Number(txReceipt.status) === 0;
         });
     }
-    /**
-     * Method to verify the state of transactions using Etherscan as a source of truth.
-     *
-     * @param remoteTxs - Transactions to reconcile that are from a remote source.
-     * @param localTxs - Transactions to reconcile that are local.
-     * @returns A tuple containing a boolean indicating whether or not an update was required, and the updated transaction.
-     */
-    etherscanTransactionStateReconciler(remoteTxs, localTxs) {
-        const updatedTxs = this.getUpdatedTransactions(remoteTxs, localTxs);
-        const newTxs = this.getNewTransactions(remoteTxs, localTxs);
-        const updatedLocalTxs = localTxs.map((tx) => {
-            const txIdx = updatedTxs.findIndex(({ transactionHash }) => transactionHash === tx.transactionHash);
-            return txIdx === -1 ? tx : updatedTxs[txIdx];
-        });
-        const updateRequired = newTxs.length > 0 || updatedLocalTxs.length > 0;
-        return [updateRequired, [...newTxs, ...updatedLocalTxs]];
-    }
-    /**
-     * Get all transactions that are in the remote transactions array
-     * but not in the local transactions array.
-     *
-     * @param remoteTxs - Array of transactions from remote source.
-     * @param localTxs - Array of transactions stored locally.
-     * @returns The new transactions.
-     */
-    getNewTransactions(remoteTxs, localTxs) {
-        return remoteTxs.filter((tx) => {
-            const alreadyInTransactions = localTxs.find(({ transactionHash }) => transactionHash === tx.transactionHash);
-            return !alreadyInTransactions;
-        });
-    }
-    /**
-     * Get all the transactions that are locally outdated with respect
-     * to a remote source (etherscan or blockchain). The returned array
-     * contains the transactions with the updated data.
-     *
-     * @param remoteTxs - Array of transactions from remote source.
-     * @param localTxs - Array of transactions stored locally.
-     * @returns The updated transactions.
-     */
-    getUpdatedTransactions(remoteTxs, localTxs) {
-        return remoteTxs.filter((remoteTx) => {
-            const isTxOutdated = localTxs.find((localTx) => {
-                return (remoteTx.transactionHash === localTx.transactionHash &&
-                    this.isTransactionOutdated(remoteTx, localTx));
-            });
-            return isTxOutdated;
-        });
-    }
-    /**
-     * Verifies if a local transaction is outdated with respect to the remote transaction.
-     *
-     * @param remoteTx - The remote transaction from Etherscan.
-     * @param localTx - The local transaction.
-     * @returns Whether the transaction is outdated.
-     */
-    isTransactionOutdated(remoteTx, localTx) {
-        const statusOutdated = this.isStatusOutdated(remoteTx.transactionHash, localTx.transactionHash, remoteTx.status, localTx.status);
-        const gasDataOutdated = this.isGasDataOutdated(remoteTx.transaction.gasUsed, localTx.transaction.gasUsed);
-        return statusOutdated || gasDataOutdated;
-    }
-    /**
-     * Verifies if the status of a local transaction is outdated with respect to the remote transaction.
-     *
-     * @param remoteTxHash - Remote transaction hash.
-     * @param localTxHash - Local transaction hash.
-     * @param remoteTxStatus - Remote transaction status.
-     * @param localTxStatus - Local transaction status.
-     * @returns Whether the status is outdated.
-     */
-    isStatusOutdated(remoteTxHash, localTxHash, remoteTxStatus, localTxStatus) {
-        return remoteTxHash === localTxHash && remoteTxStatus !== localTxStatus;
-    }
-    /**
-     * Verifies if the gas data of a local transaction is outdated with respect to the remote transaction.
-     *
-     * @param remoteGasUsed - Remote gas used in the transaction.
-     * @param localGasUsed - Local gas used in the transaction.
-     * @returns Whether the gas data is outdated.
-     */
-    isGasDataOutdated(remoteGasUsed, localGasUsed) {
-        return remoteGasUsed !== localGasUsed;
-    }
-    requestApproval(txMeta) {
+    requestApproval(txMeta, { shouldShowRequest }) {
         return __awaiter(this, void 0, void 0, function* () {
             const id = this.getApprovalId(txMeta);
             const { origin } = txMeta;
@@ -1003,7 +813,7 @@ class TransactionController extends base_controller_1.BaseController {
                 type,
                 requestData,
                 expectsResult: true,
-            }, true));
+            }, shouldShowRequest));
         });
     }
     getTransaction(transactionID) {
@@ -1021,6 +831,83 @@ class TransactionController extends base_controller_1.BaseController {
         const isCompleted = this.isLocalFinalState(transaction.status);
         return { meta: transaction, isCompleted };
     }
+    getChainAndNetworkId() {
+        const { networkId, providerConfig } = this.getNetworkState();
+        const chainId = providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.chainId;
+        return { networkId, chainId };
+    }
+    prepareUnsignedEthTx(txParams) {
+        return tx_1.TransactionFactory.fromTxData(txParams, {
+            common: this.getCommonConfiguration(),
+            freeze: false,
+        });
+    }
+    /**
+     * `@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.
+     *
+     * @returns common configuration object
+     */
+    getCommonConfiguration() {
+        const { networkId, providerConfig: { type: chain, chainId, nickname: name }, } = this.getNetworkState();
+        if (chain !== controller_utils_1.RPC &&
+            chain !== controller_utils_1.NetworkType['linea-goerli'] &&
+            chain !== controller_utils_1.NetworkType['linea-mainnet']) {
+            return new common_1.Common({ chain, hardfork: exports.HARDFORK });
+        }
+        const customChainParams = {
+            name,
+            chainId: parseInt(chainId, 16),
+            networkId: networkId === null ? NaN : parseInt(networkId, undefined),
+            defaultHardfork: exports.HARDFORK,
+        };
+        return common_1.Common.custom(customChainParams);
+    }
+    onIncomingTransactions({ added, updated, }) {
+        const { transactions: currentTransactions } = this.state;
+        const updatedTransactions = [
+            ...added,
+            ...currentTransactions.map((originalTransaction) => {
+                const updatedTransaction = updated.find(({ transactionHash }) => transactionHash === originalTransaction.transactionHash);
+                return updatedTransaction !== null && updatedTransaction !== void 0 ? updatedTransaction : originalTransaction;
+            }),
+        ];
+        this.update({
+            transactions: this.trimTransactionsForState(updatedTransactions),
+        });
+    }
+    onUpdatedLastFetchedBlockNumbers({ lastFetchedBlockNumbers, blockNumber, }) {
+        this.update({ lastFetchedBlockNumbers });
+        this.hub.emit('incomingTransactionBlock', blockNumber);
+    }
+    generateDappSuggestedGasFees(transaction, origin) {
+        if (!origin || origin === controller_utils_1.ORIGIN_METAMASK) {
+            return undefined;
+        }
+        const { gasPrice, maxFeePerGas, maxPriorityFeePerGas, gas } = transaction;
+        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;
+    }
 }
 exports.TransactionController = TransactionController;
 exports.default = TransactionController;