@metamask/bridge-status-controller 69.0.0 → 70.0.1

package/dist/utils/transaction.mjs

@@ -1,115 +1,129 @@
-import { ChainId, extractTradeData, isTronTrade, formatChainIdToCaip, formatChainIdToHex, isCrossChain } from "@metamask/bridge-controller";
+/* eslint-disable @typescript-eslint/explicit-function-return-type */
+import { ChainId, formatChainIdToHex, BRIDGE_PREFERRED_GAS_ESTIMATE } from "@metamask/bridge-controller";
 import { toHex } from "@metamask/controller-utils";
 import { TransactionStatus, TransactionType } from "@metamask/transaction-controller";
 import { createProjectLogger } from "@metamask/utils";
-import { v4 as uuid } from "uuid";
-import { calculateGasFees } from "./gas.mjs";
-import { createClientTransactionRequest } from "./snaps.mjs";
+import { BigNumber } from "bignumber.js";
+import { getAccountByAddress } from "./accounts.mjs";
+import { getNetworkClientIdByChainId } from "./network.mjs";
 import { APPROVAL_DELAY_MS } from "../constants.mjs";
-export const generateActionId = () => (Date.now() + Math.random()).toString();
-export const getStatusRequestParams = (quoteResponse) => {
+export const getGasFeeEstimates = async (messenger, args) => {
+    const { estimates } = await messenger.call('TransactionController:estimateGasFee', args);
+    if (BRIDGE_PREFERRED_GAS_ESTIMATE in estimates &&
+        typeof estimates[BRIDGE_PREFERRED_GAS_ESTIMATE] === 'object' &&
+        'maxFeePerGas' in estimates[BRIDGE_PREFERRED_GAS_ESTIMATE] &&
+        'maxPriorityFeePerGas' in estimates[BRIDGE_PREFERRED_GAS_ESTIMATE]) {
+        return estimates[BRIDGE_PREFERRED_GAS_ESTIMATE];
+    }
+    return {};
+};
+/**
+ * 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
+ */
+export 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 getGasFeeEstimates(messenger, estimateGasFeeParams);
+    /**
+     * @deprecated this is unused
+     */
+    const baseAndPriorityFeePerGas = maxPriorityFeePerGas
+        ? new 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,
     };
 };
-export const getTxMetaFields = (quoteResponse, approvalTxId) => {
-    // Handle destination chain ID - should always be convertible for EVM destinations
-    let destinationChainId;
-    try {
-        destinationChainId = formatChainIdToHex(quoteResponse.quote.destChainId);
+export 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 getTxGasEstimates(messenger, {
+        transactionParams,
+        networkClientId,
+        chainId,
+    });
+    const maxGasLimit = 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,
     };
 };
-/**
- * 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
- */
-export 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 = isCrossChain(quoteResponse.quote.srcChainId, quoteResponse.quote.destChainId);
-    let hexChainId;
+export const getTransactions = (messenger) => {
+    return messenger.call('TransactionController:getState').transactions ?? [];
+};
+export const getTransactionMetaById = (messenger, txId) => {
+    return getTransactions(messenger).find((tx) => tx.id === txId);
+};
+export const getTransactionMetaByHash = (messenger, txHash) => {
+    return getTransactions(messenger).find((tx) => tx.hash === txHash);
+};
+export const updateTransaction = (messenger, txMeta, txMetaUpdates, note) => {
+    return messenger.call('TransactionController:updateTransaction', { ...txMeta, ...txMetaUpdates }, note);
+};
+export const checkIsDelegatedAccount = async (messenger, fromAddress, chainIds) => {
     try {
-        hexChainId = 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 = extractTradeData(quoteResponse.trade);
-    // Create a transaction meta object with bridge-specific fields
-    return {
-        ...getTxMetaFields(quoteResponse),
-        time: Date.now(),
-        id: hash ?? uuid(),
-        chainId: hexChainId,
-        networkClientId: snapId ?? hexChainId,
-        txParams: { from: selectedAccountAddress, data: tradeData },
-        type: isBridgeTx ? TransactionType.bridge : TransactionType.swap,
-        status: 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,
-    };
+};
+const waitForHashAndReturnFinalTxMeta = async (messenger, hashPromise) => {
+    const txHash = await hashPromise;
+    const finalTransactionMeta = getTransactionMetaByHash(messenger, txHash);
+    if (!finalTransactionMeta) {
+        throw new Error('Failed to submit cross-chain swap tx: txMeta for txHash was not found');
+    }
+    return finalTransactionMeta;
+};
+export const addTransaction = async (messenger, ...args) => {
+    const { result } = await messenger.call('TransactionController:addTransaction', ...args);
+    return await waitForHashAndReturnFinalTxMeta(messenger, result);
+};
+export const generateActionId = () => (Date.now() + Math.random()).toString();
+/**
+ * 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
+ */
+export const addSyntheticTransaction = async (messenger, ...args) => {
+    const { transactionMeta } = await messenger.call('TransactionController:addTransaction', args[0], {
+        origin: 'metamask',
+        actionId: generateActionId(),
+        isStateOnly: true,
+        ...args[1],
+    });
+    return transactionMeta;
 };
 export const handleApprovalDelay = async (srcChainId) => {
     if ([ChainId.LINEA, ChainId.BASE].includes(srcChainId)) {
@@ -133,32 +147,20 @@ export const handleMobileHardwareWalletDelay = async (requireApproval) => {
     }
 };
 /**
- * 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
  */
-export const getClientRequest = (trade, srcChainId, selectedAccount) => {
-    const scope = formatChainIdToCaip(srcChainId);
-    const transactionData = extractTradeData(trade);
-    // Tron trades need the visible flag and contract type to be included in the request options
-    const options = isTronTrade(trade)
-        ? {
-            visible: trade.visible,
-            type: trade.raw_data?.contract?.[0]?.type,
-        }
-        : undefined;
-    // Use the new unified interface
-    return createClientTransactionRequest(selectedAccount.metadata.snap?.id, transactionData, scope, selectedAccount.id, options);
-};
 export 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 = getTransactionMetaById(messenger, txId);
         if (meta) {
             if (meta.status === TransactionStatus.confirmed) {
                 return meta;
@@ -175,26 +177,6 @@ export const waitForTxConfirmation = async (messenger, txId, { timeoutMs = 5 * 6
         await new Promise((resolve) => setTimeout(resolve, pollMs));
     }
 };
-export 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;
-};
 export const toBatchTxParams = (skipGasFields, { chainId, gasLimit, ...trade }, { maxFeePerGas, maxPriorityFeePerGas, gas, }) => {
     const params = {
         ...trade,
@@ -212,23 +194,28 @@ export const toBatchTxParams = (skipGasFields, { chainId, gasLimit, ...trade },
         maxPriorityFeePerGas: toHex(maxPriorityFeePerGas ?? 0),
     };
 };
-export const getAddTransactionBatchParams = async ({ messenger, isBridgeTx, approval, resetApproval, trade, quoteResponse: { quote: { feeData: { txFee }, gasIncluded, gasIncluded7702, gasSponsored, }, sentAmount, toTokenAmount, }, requireApproval = false, isDelegatedAccount = false, estimateGasFeeFn, }) => {
+export 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 = getAccountByAddress(messenger, trade.from);
     if (!selectedAccount) {
         throw new Error('Failed to submit cross-chain swap batch transaction: unknown account in trade data');
     }
     const hexChainId = formatChainIdToHex(trade.chainId);
-    const networkClientId = messenger.call('NetworkController:findNetworkClientIdByChainId', hexChainId);
+    const networkClientId = 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 calculateGasFees(skipGasFields, messenger, estimateGasFeeFn, resetApproval, networkClientId, hexChainId, isGasless ? txFee : undefined);
+        const gasFees = await calculateGasFees(skipGasFields, messenger, resetApproval, networkClientId, hexChainId, isGasless ? txFee : undefined);
         transactions.push({
             type: isBridgeTx
                 ? TransactionType.bridgeApproval
@@ -237,7 +224,7 @@ export const getAddTransactionBatchParams = async ({ messenger, isBridgeTx, appr
         });
     }
     if (approval) {
-        const gasFees = await calculateGasFees(skipGasFields, messenger, estimateGasFeeFn, approval, networkClientId, hexChainId, isGasless ? txFee : undefined);
+        const gasFees = await calculateGasFees(skipGasFields, messenger, approval, networkClientId, hexChainId, isGasless ? txFee : undefined);
         transactions.push({
             type: isBridgeTx
                 ? TransactionType.bridgeApproval
@@ -245,7 +232,7 @@ export const getAddTransactionBatchParams = async ({ messenger, isBridgeTx, appr
             params: toBatchTxParams(skipGasFields, approval, gasFees),
         });
     }
-    const gasFees = await calculateGasFees(skipGasFields, messenger, estimateGasFeeFn, trade, networkClientId, hexChainId, isGasless ? txFee : undefined);
+    const gasFees = await calculateGasFees(skipGasFields, messenger, trade, networkClientId, hexChainId, isGasless ? txFee : undefined);
     transactions.push({
         type: isBridgeTx ? TransactionType.bridge : TransactionType.swap,
         params: toBatchTxParams(skipGasFields, trade, gasFees),
@@ -266,15 +253,16 @@ export const getAddTransactionBatchParams = async ({ messenger, isBridgeTx, appr
     };
     return transactionParams;
 };
-export const findAndUpdateTransactionsInBatch = ({ messenger, updateTransactionFn, batchId, txDataByType, }) => {
-    const txs = messenger.call('TransactionController:getState').transactions;
+export const findAndUpdateTransactionsInBatch = ({ messenger, batchId, txDataByType, }) => {
+    const txs = 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;
@@ -309,42 +297,104 @@ export const findAndUpdateTransactionsInBatch = ({ messenger, updateTransactionF
         });
         if (txMeta) {
             const updatedTx = { ...txMeta, type: txType };
-            updateTransactionFn(updatedTx, `Update tx type to ${txType}`);
-            txBatch[[TransactionType.bridgeApproval, TransactionType.swapApproval].includes(txType)
-                ? 'approvalMeta'
-                : 'tradeMeta'] = updatedTx;
+            updateTransaction(messenger, txMeta, { type: txType }, `Update tx type to ${txType}`);
+            const txTypes = [
+                TransactionType.bridgeApproval,
+                TransactionType.swapApproval,
+            ];
+            txBatch[txTypes.includes(txType) ? 'approvalMeta' : 'tradeMeta'] =
+                updatedTx;
         }
     });
     return txBatch;
 };
-/**
- * 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
- */
-export 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');
+export const addTransactionBatch = async (messenger, addTransactionBatchFn, ...args) => {
+    const txDataByType = {
+        [TransactionType.bridgeApproval]: args[0].transactions.find(({ type }) => type === TransactionType.bridgeApproval)?.params.data,
+        [TransactionType.swapApproval]: args[0].transactions.find(({ type }) => type === TransactionType.swapApproval)?.params.data,
+        [TransactionType.bridge]: args[0].transactions.find(({ type }) => type === TransactionType.bridge)?.params.data,
+        [TransactionType.swap]: args[0].transactions.find(({ type }) => type === TransactionType.swap)?.params.data,
+    };
+    const { batchId } = await addTransactionBatchFn(...args);
+    const { approvalMeta, tradeMeta } = findAndUpdateTransactionsInBatch({
+        messenger,
+        batchId,
+        txDataByType,
+    });
+    if (!tradeMeta) {
+        throw new Error('Failed to update cross-chain swap transaction batch: tradeMeta not found');
+    }
+    return { approvalMeta, tradeMeta };
+};
+// 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: toHex(txFee.maxFeePerGas),
+            maxPriorityFeePerGas: toHex(txFee.maxPriorityFeePerGas),
+            gas: gas ? toHex(gas) : undefined,
+        };
     }
-    return historyKey;
-}
+    const { maxFeePerGas, maxPriorityFeePerGas } = await getTxGasEstimates(messenger, {
+        transactionParams,
+        chainId,
+        networkClientId,
+    });
+    return {
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        gas: gas ? 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
  */
-export function getIntentFromQuote(quoteResponse) {
-    const { intent } = quoteResponse.quote;
-    if (!intent) {
-        throw new Error('submitIntent: missing intent data');
+export const submitEvmTransaction = async ({ messenger, trade, transactionType, requireApproval = false, txFee, 
+// Use provided actionId (for pre-submission history) or generate one
+actionId = generateActionId(), }) => {
+    const selectedAccount = getAccountByAddress(messenger, trade.from);
+    if (!selectedAccount) {
+        throw new Error('Failed to submit cross-chain swap transaction: unknown account in trade data');
     }
-    return intent;
-}
+    const hexChainId = formatChainIdToHex(trade.chainId);
+    const networkClientId = 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 addTransaction(messenger, transactionParamsWithMaxGas, requestOptions);
+};
 //# sourceMappingURL=transaction.mjs.map