@metamask/bridge-status-controller 69.0.0 → 70.0.1

package/dist/utils/transaction.cjs

@@ -1,123 +1,144 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getIntentFromQuote = exports.getHistoryKey = exports.findAndUpdateTransactionsInBatch = exports.getAddTransactionBatchParams = exports.toBatchTxParams = exports.rekeyHistoryItemInState = exports.waitForTxConfirmation = exports.getClientRequest = exports.handleMobileHardwareWalletDelay = exports.handleApprovalDelay = exports.handleNonEvmTxResponse = exports.getTxMetaFields = exports.getStatusRequestParams = exports.generateActionId = void 0;
+exports.submitEvmTransaction = exports.addTransactionBatch = exports.findAndUpdateTransactionsInBatch = exports.getAddTransactionBatchParams = exports.toBatchTxParams = exports.waitForTxConfirmation = exports.handleMobileHardwareWalletDelay = exports.handleApprovalDelay = exports.addSyntheticTransaction = exports.generateActionId = exports.addTransaction = exports.checkIsDelegatedAccount = exports.updateTransaction = exports.getTransactionMetaByHash = exports.getTransactionMetaById = exports.getTransactions = exports.calculateGasFees = exports.getTxGasEstimates = exports.getGasFeeEstimates = void 0;
+/* eslint-disable @typescript-eslint/explicit-function-return-type */
 const bridge_controller_1 = require("@metamask/bridge-controller");
 const controller_utils_1 = require("@metamask/controller-utils");
 const transaction_controller_1 = require("@metamask/transaction-controller");
 const utils_1 = require("@metamask/utils");
-const uuid_1 = require("uuid");
-const gas_1 = require("./gas.cjs");
-const snaps_1 = require("./snaps.cjs");
+const bignumber_js_1 = require("bignumber.js");
+const accounts_1 = require("./accounts.cjs");
+const network_1 = require("./network.cjs");
 const constants_1 = require("../constants.cjs");
-const generateActionId = () => (Date.now() + Math.random()).toString();
-exports.generateActionId = generateActionId;
-const getStatusRequestParams = (quoteResponse) => {
+const getGasFeeEstimates = async (messenger, args) => {
+    const { estimates } = await messenger.call('TransactionController:estimateGasFee', args);
+    if (bridge_controller_1.BRIDGE_PREFERRED_GAS_ESTIMATE in estimates &&
+        typeof estimates[bridge_controller_1.BRIDGE_PREFERRED_GAS_ESTIMATE] === 'object' &&
+        'maxFeePerGas' in estimates[bridge_controller_1.BRIDGE_PREFERRED_GAS_ESTIMATE] &&
+        'maxPriorityFeePerGas' in estimates[bridge_controller_1.BRIDGE_PREFERRED_GAS_ESTIMATE]) {
+        return estimates[bridge_controller_1.BRIDGE_PREFERRED_GAS_ESTIMATE];
+    }
+    return {};
+};
+exports.getGasFeeEstimates = getGasFeeEstimates;
+/**
+ * Get the gas fee estimates for a transaction
+ *
+ * @param messenger - The messenger for the gas fee estimates
+ * @param estimateGasFeeParams - The parameters for the {@link TransactionController.estimateGasFee} method
+ 
+ * @returns The gas fee estimates for the transaction
+ */
+const getTxGasEstimates = async (messenger, estimateGasFeeParams) => {
+    const { gasFeeEstimates } = messenger.call('GasFeeController:getState');
+    const estimatedBaseFee = 'estimatedBaseFee' in gasFeeEstimates
+        ? gasFeeEstimates.estimatedBaseFee
+        : '0';
+    // Get transaction's 1559 gas fee estimates
+    const { maxFeePerGas, maxPriorityFeePerGas } = await (0, exports.getGasFeeEstimates)(messenger, estimateGasFeeParams);
+    /**
+     * @deprecated this is unused
+     */
+    const baseAndPriorityFeePerGas = maxPriorityFeePerGas
+        ? new bignumber_js_1.BigNumber(estimatedBaseFee, 10)
+            .times(10 ** 9)
+            .plus(maxPriorityFeePerGas, 16)
+        : undefined;
     return {
-        bridgeId: quoteResponse.quote.bridgeId,
-        bridge: quoteResponse.quote.bridges[0],
-        srcChainId: quoteResponse.quote.srcChainId,
-        destChainId: quoteResponse.quote.destChainId,
-        quote: quoteResponse.quote,
-        refuel: Boolean(quoteResponse.quote.refuel),
+        baseAndPriorityFeePerGas,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
     };
 };
-exports.getStatusRequestParams = getStatusRequestParams;
-const getTxMetaFields = (quoteResponse, approvalTxId) => {
-    // Handle destination chain ID - should always be convertible for EVM destinations
-    let destinationChainId;
-    try {
-        destinationChainId = (0, bridge_controller_1.formatChainIdToHex)(quoteResponse.quote.destChainId);
+exports.getTxGasEstimates = getTxGasEstimates;
+const calculateGasFees = async (skipGasFields, messenger, { chainId: _, gasLimit, ...trade }, networkClientId, chainId, txFee) => {
+    if (skipGasFields) {
+        return {};
     }
-    catch {
-        // Fallback for non-EVM destination (shouldn't happen for BTC->EVM)
-        destinationChainId = '0x1'; // Default to mainnet
+    if (txFee) {
+        return { ...txFee, gas: gasLimit?.toString() };
     }
+    const transactionParams = {
+        ...trade,
+        gas: gasLimit?.toString(),
+        data: trade.data,
+        to: trade.to,
+        value: trade.value,
+    };
+    const { maxFeePerGas, maxPriorityFeePerGas } = await (0, exports.getTxGasEstimates)(messenger, {
+        transactionParams,
+        networkClientId,
+        chainId,
+    });
+    const maxGasLimit = (0, controller_utils_1.toHex)(transactionParams.gas ?? 0);
     return {
-        destinationChainId,
-        sourceTokenAmount: quoteResponse.quote.srcTokenAmount,
-        sourceTokenSymbol: quoteResponse.quote.srcAsset.symbol,
-        sourceTokenDecimals: quoteResponse.quote.srcAsset.decimals,
-        sourceTokenAddress: quoteResponse.quote.srcAsset.address,
-        destinationTokenAmount: quoteResponse.quote.destTokenAmount,
-        destinationTokenSymbol: quoteResponse.quote.destAsset.symbol,
-        destinationTokenDecimals: quoteResponse.quote.destAsset.decimals,
-        destinationTokenAddress: quoteResponse.quote.destAsset.address,
-        // chainId is now excluded from this function and handled by the caller
-        approvalTxId,
-        // this is the decimal (non atomic) amount (not USD value) of source token to swap
-        swapTokenValue: quoteResponse.sentAmount.amount,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        gas: maxGasLimit,
     };
 };
-exports.getTxMetaFields = getTxMetaFields;
-/**
- * Handles the response from non-EVM transaction submission
- * Works with the new unified ClientRequest:signAndSendTransaction interface
- * Supports Solana, Bitcoin, and other non-EVM chains
- *
- * @param snapResponse - The response from the snap after transaction submission
- * @param quoteResponse - The quote response containing trade details and metadata
- * @param selectedAccount - The selected account information
- * @returns The transaction metadata including non-EVM specific fields
- */
-const handleNonEvmTxResponse = (snapResponse, quoteResponse, selectedAccount) => {
-    const selectedAccountAddress = selectedAccount.address;
-    const snapId = selectedAccount.metadata.snap?.id;
-    let hash;
-    // Handle different response formats
-    if (typeof snapResponse === 'string') {
-        hash = snapResponse;
-    }
-    else if (snapResponse && typeof snapResponse === 'object') {
-        // Check for new unified interface response format first
-        if ('transactionId' in snapResponse && snapResponse.transactionId) {
-            hash = snapResponse.transactionId;
-        }
-        else if ('result' in snapResponse &&
-            snapResponse.result &&
-            typeof snapResponse.result === 'object') {
-            // Try to extract signature from common locations in response object
-            hash =
-                snapResponse.result.signature ||
-                    snapResponse.result.txid ||
-                    snapResponse.result.hash ||
-                    snapResponse.result.txHash;
-        }
-        else if ('signature' in snapResponse &&
-            snapResponse.signature &&
-            typeof snapResponse.signature === 'string') {
-            hash = snapResponse.signature;
-        }
-    }
-    const isBridgeTx = (0, bridge_controller_1.isCrossChain)(quoteResponse.quote.srcChainId, quoteResponse.quote.destChainId);
-    let hexChainId;
+exports.calculateGasFees = calculateGasFees;
+const getTransactions = (messenger) => {
+    return messenger.call('TransactionController:getState').transactions ?? [];
+};
+exports.getTransactions = getTransactions;
+const getTransactionMetaById = (messenger, txId) => {
+    return (0, exports.getTransactions)(messenger).find((tx) => tx.id === txId);
+};
+exports.getTransactionMetaById = getTransactionMetaById;
+const getTransactionMetaByHash = (messenger, txHash) => {
+    return (0, exports.getTransactions)(messenger).find((tx) => tx.hash === txHash);
+};
+exports.getTransactionMetaByHash = getTransactionMetaByHash;
+const updateTransaction = (messenger, txMeta, txMetaUpdates, note) => {
+    return messenger.call('TransactionController:updateTransaction', { ...txMeta, ...txMetaUpdates }, note);
+};
+exports.updateTransaction = updateTransaction;
+const checkIsDelegatedAccount = async (messenger, fromAddress, chainIds) => {
     try {
-        hexChainId = (0, bridge_controller_1.formatChainIdToHex)(quoteResponse.quote.srcChainId);
+        const atomicBatchSupport = await messenger.call('TransactionController:isAtomicBatchSupported', {
+            address: fromAddress,
+            chainIds,
+        });
+        return atomicBatchSupport.some((entry) => entry.isSupported && entry.delegationAddress);
     }
     catch {
-        // TODO: Fix chain ID activity list handling for Bitcoin
-        // Fallback to Ethereum mainnet for now
-        hexChainId = '0x1';
+        return false;
     }
-    // Extract the transaction data for storage
-    const tradeData = (0, bridge_controller_1.extractTradeData)(quoteResponse.trade);
-    // Create a transaction meta object with bridge-specific fields
-    return {
-        ...(0, exports.getTxMetaFields)(quoteResponse),
-        time: Date.now(),
-        id: hash ?? (0, uuid_1.v4)(),
-        chainId: hexChainId,
-        networkClientId: snapId ?? hexChainId,
-        txParams: { from: selectedAccountAddress, data: tradeData },
-        type: isBridgeTx ? transaction_controller_1.TransactionType.bridge : transaction_controller_1.TransactionType.swap,
-        status: transaction_controller_1.TransactionStatus.submitted,
-        hash, // Add the transaction signature as hash
-        origin: snapId,
-        // Add an explicit flag to mark this as a non-EVM transaction
-        isSolana: true, // TODO deprecate this and use chainId to detect non-EVM chains
-        isBridgeTx,
-    };
 };
-exports.handleNonEvmTxResponse = handleNonEvmTxResponse;
+exports.checkIsDelegatedAccount = checkIsDelegatedAccount;
+const waitForHashAndReturnFinalTxMeta = async (messenger, hashPromise) => {
+    const txHash = await hashPromise;
+    const finalTransactionMeta = (0, exports.getTransactionMetaByHash)(messenger, txHash);
+    if (!finalTransactionMeta) {
+        throw new Error('Failed to submit cross-chain swap tx: txMeta for txHash was not found');
+    }
+    return finalTransactionMeta;
+};
+const addTransaction = async (messenger, ...args) => {
+    const { result } = await messenger.call('TransactionController:addTransaction', ...args);
+    return await waitForHashAndReturnFinalTxMeta(messenger, result);
+};
+exports.addTransaction = addTransaction;
+const generateActionId = () => (Date.now() + Math.random()).toString();
+exports.generateActionId = generateActionId;
+/**
+ * Adds a synthetic transaction to the TransactionController to display pending intent orders in the UI
+ *
+ * @param messenger - The messenger to use for the transaction
+ * @param args - The arguments for the transaction
+ * @returns The transaction meta
+ */
+const addSyntheticTransaction = async (messenger, ...args) => {
+    const { transactionMeta } = await messenger.call('TransactionController:addTransaction', args[0], {
+        origin: 'metamask',
+        actionId: (0, exports.generateActionId)(),
+        isStateOnly: true,
+        ...args[1],
+    });
+    return transactionMeta;
+};
+exports.addSyntheticTransaction = addSyntheticTransaction;
 const handleApprovalDelay = async (srcChainId) => {
     if ([bridge_controller_1.ChainId.LINEA, bridge_controller_1.ChainId.BASE].includes(srcChainId)) {
         const debugLog = (0, utils_1.createProjectLogger)('bridge');
@@ -142,33 +163,20 @@ const handleMobileHardwareWalletDelay = async (requireApproval) => {
 };
 exports.handleMobileHardwareWalletDelay = handleMobileHardwareWalletDelay;
 /**
- * Creates a request to sign and send a transaction for non-EVM chains
- * Uses the new unified ClientRequest:signAndSendTransaction interface
+ * Waits until a given transaction (by id) reaches confirmed/finalized status or fails/times out.
  *
- * @param trade - The trade data
- * @param srcChainId - The source chain ID
- * @param selectedAccount - The selected account information
- * @returns The snap request object for signing and sending transaction
+ * @deprecated use addTransaction util
+ * @param messenger - the BridgeStatusControllerMessenger
+ * @param txId - the transaction ID
+ * @param options - the options for the timeout and poll
+ * @param options.timeoutMs - the timeout in milliseconds
+ * @param options.pollMs - the poll interval in milliseconds
+ * @returns the transaction meta
  */
-const getClientRequest = (trade, srcChainId, selectedAccount) => {
-    const scope = (0, bridge_controller_1.formatChainIdToCaip)(srcChainId);
-    const transactionData = (0, bridge_controller_1.extractTradeData)(trade);
-    // Tron trades need the visible flag and contract type to be included in the request options
-    const options = (0, bridge_controller_1.isTronTrade)(trade)
-        ? {
-            visible: trade.visible,
-            type: trade.raw_data?.contract?.[0]?.type,
-        }
-        : undefined;
-    // Use the new unified interface
-    return (0, snaps_1.createClientTransactionRequest)(selectedAccount.metadata.snap?.id, transactionData, scope, selectedAccount.id, options);
-};
-exports.getClientRequest = getClientRequest;
 const waitForTxConfirmation = async (messenger, txId, { timeoutMs = 5 * 60000, pollMs = 3000, } = {}) => {
     const start = Date.now();
     while (true) {
-        const { transactions } = messenger.call('TransactionController:getState');
-        const meta = transactions.find((tx) => tx.id === txId);
+        const meta = (0, exports.getTransactionMetaById)(messenger, txId);
         if (meta) {
             if (meta.status === transaction_controller_1.TransactionStatus.confirmed) {
                 return meta;
@@ -186,27 +194,6 @@ const waitForTxConfirmation = async (messenger, txId, { timeoutMs = 5 * 60000, p
     }
 };
 exports.waitForTxConfirmation = waitForTxConfirmation;
-const rekeyHistoryItemInState = (state, actionId, txMeta) => {
-    const historyItem = state.txHistory[actionId];
-    if (!historyItem) {
-        return false;
-    }
-    state.txHistory[txMeta.id] = {
-        ...historyItem,
-        txMetaId: txMeta.id,
-        originalTransactionId: historyItem.originalTransactionId ?? txMeta.id,
-        status: {
-            ...historyItem.status,
-            srcChain: {
-                ...historyItem.status.srcChain,
-                txHash: txMeta.hash ?? historyItem.status.srcChain?.txHash,
-            },
-        },
-    };
-    delete state.txHistory[actionId];
-    return true;
-};
-exports.rekeyHistoryItemInState = rekeyHistoryItemInState;
 const toBatchTxParams = (skipGasFields, { chainId, gasLimit, ...trade }, { maxFeePerGas, maxPriorityFeePerGas, gas, }) => {
     const params = {
         ...trade,
@@ -225,23 +212,28 @@ const toBatchTxParams = (skipGasFields, { chainId, gasLimit, ...trade }, { maxFe
     };
 };
 exports.toBatchTxParams = toBatchTxParams;
-const getAddTransactionBatchParams = async ({ messenger, isBridgeTx, approval, resetApproval, trade, quoteResponse: { quote: { feeData: { txFee }, gasIncluded, gasIncluded7702, gasSponsored, }, sentAmount, toTokenAmount, }, requireApproval = false, isDelegatedAccount = false, estimateGasFeeFn, }) => {
+const getAddTransactionBatchParams = async ({ messenger, isBridgeTx, approval, resetApproval, trade, quoteResponse: { quote: { feeData: { txFee }, gasIncluded, gasIncluded7702, gasSponsored, }, sentAmount, toTokenAmount, }, requireApproval = false, isDelegatedAccount = false, }) => {
+    // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
     const isGasless = gasIncluded || gasIncluded7702;
-    const selectedAccount = messenger.call('AccountsController:getAccountByAddress', trade.from);
+    const selectedAccount = (0, accounts_1.getAccountByAddress)(messenger, trade.from);
     if (!selectedAccount) {
         throw new Error('Failed to submit cross-chain swap batch transaction: unknown account in trade data');
     }
     const hexChainId = (0, bridge_controller_1.formatChainIdToHex)(trade.chainId);
-    const networkClientId = messenger.call('NetworkController:findNetworkClientIdByChainId', hexChainId);
+    const networkClientId = (0, network_1.getNetworkClientIdByChainId)(messenger, hexChainId);
     // Gas fields should be omitted only when gas is sponsored via 7702
     const skipGasFields = gasIncluded7702 === true;
     // Enable 7702 batching when the quote includes gasless 7702 support,
     // or when the account is already delegated (to avoid the in-flight
     // transaction limit for delegated accounts)
-    const disable7702 = !skipGasFields && !isDelegatedAccount;
+    let disable7702 = !skipGasFields && !isDelegatedAccount;
+    // For gasless transactions with STX/sendBundle we keep disabling 7702.
+    if (gasIncluded && !gasIncluded7702) {
+        disable7702 = true;
+    }
     const transactions = [];
     if (resetApproval) {
-        const gasFees = await (0, gas_1.calculateGasFees)(skipGasFields, messenger, estimateGasFeeFn, resetApproval, networkClientId, hexChainId, isGasless ? txFee : undefined);
+        const gasFees = await (0, exports.calculateGasFees)(skipGasFields, messenger, resetApproval, networkClientId, hexChainId, isGasless ? txFee : undefined);
         transactions.push({
             type: isBridgeTx
                 ? transaction_controller_1.TransactionType.bridgeApproval
@@ -250,7 +242,7 @@ const getAddTransactionBatchParams = async ({ messenger, isBridgeTx, approval, r
         });
     }
     if (approval) {
-        const gasFees = await (0, gas_1.calculateGasFees)(skipGasFields, messenger, estimateGasFeeFn, approval, networkClientId, hexChainId, isGasless ? txFee : undefined);
+        const gasFees = await (0, exports.calculateGasFees)(skipGasFields, messenger, approval, networkClientId, hexChainId, isGasless ? txFee : undefined);
         transactions.push({
             type: isBridgeTx
                 ? transaction_controller_1.TransactionType.bridgeApproval
@@ -258,7 +250,7 @@ const getAddTransactionBatchParams = async ({ messenger, isBridgeTx, approval, r
             params: (0, exports.toBatchTxParams)(skipGasFields, approval, gasFees),
         });
     }
-    const gasFees = await (0, gas_1.calculateGasFees)(skipGasFields, messenger, estimateGasFeeFn, trade, networkClientId, hexChainId, isGasless ? txFee : undefined);
+    const gasFees = await (0, exports.calculateGasFees)(skipGasFields, messenger, trade, networkClientId, hexChainId, isGasless ? txFee : undefined);
     transactions.push({
         type: isBridgeTx ? transaction_controller_1.TransactionType.bridge : transaction_controller_1.TransactionType.swap,
         params: (0, exports.toBatchTxParams)(skipGasFields, trade, gasFees),
@@ -280,15 +272,16 @@ const getAddTransactionBatchParams = async ({ messenger, isBridgeTx, approval, r
     return transactionParams;
 };
 exports.getAddTransactionBatchParams = getAddTransactionBatchParams;
-const findAndUpdateTransactionsInBatch = ({ messenger, updateTransactionFn, batchId, txDataByType, }) => {
-    const txs = messenger.call('TransactionController:getState').transactions;
+const findAndUpdateTransactionsInBatch = ({ messenger, batchId, txDataByType, }) => {
+    const txs = (0, exports.getTransactions)(messenger);
     const txBatch = {
         approvalMeta: undefined,
         tradeMeta: undefined,
     };
     // This is a workaround to update the tx type after the tx is signed
     // TODO: remove this once the tx type for batch txs is preserved in the tx controller
-    Object.entries(txDataByType).forEach(([txType, txData]) => {
+    const txEntries = Object.entries(txDataByType);
+    txEntries.forEach(([txType, txData]) => {
         // Skip types not present in the batch (e.g. swap entry is undefined for bridge txs)
         if (txData === undefined) {
             return;
@@ -323,45 +316,107 @@ const findAndUpdateTransactionsInBatch = ({ messenger, updateTransactionFn, batc
         });
         if (txMeta) {
             const updatedTx = { ...txMeta, type: txType };
-            updateTransactionFn(updatedTx, `Update tx type to ${txType}`);
-            txBatch[[transaction_controller_1.TransactionType.bridgeApproval, transaction_controller_1.TransactionType.swapApproval].includes(txType)
-                ? 'approvalMeta'
-                : 'tradeMeta'] = updatedTx;
+            (0, exports.updateTransaction)(messenger, txMeta, { type: txType }, `Update tx type to ${txType}`);
+            const txTypes = [
+                transaction_controller_1.TransactionType.bridgeApproval,
+                transaction_controller_1.TransactionType.swapApproval,
+            ];
+            txBatch[txTypes.includes(txType) ? 'approvalMeta' : 'tradeMeta'] =
+                updatedTx;
         }
     });
     return txBatch;
 };
 exports.findAndUpdateTransactionsInBatch = findAndUpdateTransactionsInBatch;
-/**
- * Determines the key to use for storing a bridge history item.
- * Uses actionId for pre-submission tracking, or bridgeTxMetaId for post-submission.
- *
- * @param actionId - The action ID used for pre-submission tracking
- * @param bridgeTxMetaId - The transaction meta ID from bridgeTxMeta
- * @returns The key to use for the history item
- * @throws Error if neither actionId nor bridgeTxMetaId is provided
- */
-function getHistoryKey(actionId, bridgeTxMetaId) {
-    const historyKey = actionId ?? bridgeTxMetaId;
-    if (!historyKey) {
-        throw new Error('Cannot add tx to history: either actionId or bridgeTxMeta.id must be provided');
+const addTransactionBatch = async (messenger, addTransactionBatchFn, ...args) => {
+    const txDataByType = {
+        [transaction_controller_1.TransactionType.bridgeApproval]: args[0].transactions.find(({ type }) => type === transaction_controller_1.TransactionType.bridgeApproval)?.params.data,
+        [transaction_controller_1.TransactionType.swapApproval]: args[0].transactions.find(({ type }) => type === transaction_controller_1.TransactionType.swapApproval)?.params.data,
+        [transaction_controller_1.TransactionType.bridge]: args[0].transactions.find(({ type }) => type === transaction_controller_1.TransactionType.bridge)?.params.data,
+        [transaction_controller_1.TransactionType.swap]: args[0].transactions.find(({ type }) => type === transaction_controller_1.TransactionType.swap)?.params.data,
+    };
+    const { batchId } = await addTransactionBatchFn(...args);
+    const { approvalMeta, tradeMeta } = (0, exports.findAndUpdateTransactionsInBatch)({
+        messenger,
+        batchId,
+        txDataByType,
+    });
+    if (!tradeMeta) {
+        throw new Error('Failed to update cross-chain swap transaction batch: tradeMeta not found');
     }
-    return historyKey;
-}
-exports.getHistoryKey = getHistoryKey;
+    return { approvalMeta, tradeMeta };
+};
+exports.addTransactionBatch = addTransactionBatch;
+// TODO rename
+const getGasFeesForSubmission = async (messenger, transactionParams, networkClientId, chainId, txFee) => {
+    const { gas } = transactionParams;
+    // If txFee is provided (gasIncluded case), use the quote's gas fees
+    // Convert to hex since txFee values from the quote are decimal strings
+    if (txFee) {
+        return {
+            maxFeePerGas: (0, controller_utils_1.toHex)(txFee.maxFeePerGas),
+            maxPriorityFeePerGas: (0, controller_utils_1.toHex)(txFee.maxPriorityFeePerGas),
+            gas: gas ? (0, controller_utils_1.toHex)(gas) : undefined,
+        };
+    }
+    const { maxFeePerGas, maxPriorityFeePerGas } = await (0, exports.getTxGasEstimates)(messenger, {
+        transactionParams,
+        chainId,
+        networkClientId,
+    });
+    return {
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        gas: gas ? (0, controller_utils_1.toHex)(gas) : undefined,
+    };
+};
 /**
- * Extracts and validates the intent data from a quote response.
+ * Submits an EVM transaction to the TransactionController
  *
- * @param quoteResponse - The quote response that may contain intent data
- * @returns The intent data from the quote
- * @throws Error if the quote does not contain intent data
+ * @param params - The parameters for the transaction
+ * @param params.transactionType - The type of transaction to submit
+ * @param params.trade - The trade data to confirm
+ * @param params.requireApproval - Whether to require approval for the transaction
+ * @param params.txFee - Optional gas fee parameters from the quote (used when gasIncluded is true)
+ * @param params.txFee.maxFeePerGas - The maximum fee per gas from the quote
+ * @param params.txFee.maxPriorityFeePerGas - The maximum priority fee per gas from the quote
+ * @param params.actionId - Optional actionId for pre-submission history (if not provided, one is generated)
+ * @param params.messenger - The messenger to use for the transaction
+ * @returns The transaction meta
  */
-function getIntentFromQuote(quoteResponse) {
-    const { intent } = quoteResponse.quote;
-    if (!intent) {
-        throw new Error('submitIntent: missing intent data');
+const submitEvmTransaction = async ({ messenger, trade, transactionType, requireApproval = false, txFee, 
+// Use provided actionId (for pre-submission history) or generate one
+actionId = (0, exports.generateActionId)(), }) => {
+    const selectedAccount = (0, accounts_1.getAccountByAddress)(messenger, trade.from);
+    if (!selectedAccount) {
+        throw new Error('Failed to submit cross-chain swap transaction: unknown account in trade data');
     }
-    return intent;
-}
-exports.getIntentFromQuote = getIntentFromQuote;
+    const hexChainId = (0, bridge_controller_1.formatChainIdToHex)(trade.chainId);
+    const networkClientId = (0, network_1.getNetworkClientIdByChainId)(messenger, hexChainId);
+    const requestOptions = {
+        actionId,
+        networkClientId,
+        requireApproval,
+        type: transactionType,
+        origin: 'metamask',
+    };
+    // Exclude gasLimit from trade to avoid type issues (it can be null)
+    const { gasLimit: tradeGasLimit, ...tradeWithoutGasLimit } = trade;
+    const transactionParams = {
+        ...tradeWithoutGasLimit,
+        chainId: hexChainId,
+        // Only add gasLimit and gas if they're valid (not undefined/null/zero)
+        ...(tradeGasLimit &&
+            tradeGasLimit !== 0 && {
+            gasLimit: tradeGasLimit.toString(),
+            gas: tradeGasLimit.toString(),
+        }),
+    };
+    const transactionParamsWithMaxGas = {
+        ...transactionParams,
+        ...(await getGasFeesForSubmission(messenger, transactionParams, networkClientId, hexChainId, txFee)),
+    };
+    return await (0, exports.addTransaction)(messenger, transactionParamsWithMaxGas, requestOptions);
+};
+exports.submitEvmTransaction = submitEvmTransaction;
 //# sourceMappingURL=transaction.cjs.map