@metamask/bridge-status-controller 71.2.0 → 72.0.0

package/dist/utils/transaction.mjs

@@ -1,80 +1,54 @@
 /* eslint-disable @typescript-eslint/explicit-function-return-type */
-import { ChainId, formatChainIdToHex, BRIDGE_PREFERRED_GAS_ESTIMATE } from "@metamask/bridge-controller";
+import { ChainId, formatChainIdToHex, BRIDGE_PREFERRED_GAS_ESTIMATE, isEvmTxData, FeeType, BatchSellTransactionType } from "@metamask/bridge-controller";
 import { toHex } from "@metamask/controller-utils";
-import { TransactionStatus, TransactionType } from "@metamask/transaction-controller";
+import { GasFeeEstimateType, TransactionStatus, TransactionType } from "@metamask/transaction-controller";
 import { createProjectLogger } from "@metamask/utils";
-import { BigNumber } from "bignumber.js";
 import { APPROVAL_DELAY_MS } from "../constants.mjs";
 import { getAccountByAddress } from "./accounts.mjs";
 import { getNetworkClientIdByChainId } from "./network.mjs";
-const isApprovalTx = (type) => type === TransactionType.bridgeApproval ||
+export const isApprovalTx = (type) => type === TransactionType.bridgeApproval ||
     type === TransactionType.swapApproval;
-const isTradeTx = (type) => type === TransactionType.bridge || type === TransactionType.swap;
+export const isTradeTx = (type) => type === TransactionType.bridge || type === TransactionType.swap;
 export const isCrossChainTx = (type) => isTradeTx(type) || isApprovalTx(type);
-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
+ * For 7702 delegated transactions, check for delegation-specific fields
+ * These transactions might have authorizationList or delegationAddress
  *
- * @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
+ * @param tx - The transaction meta
+ * @returns Whether the transaction is a 7702 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);
+export const is7702Tx = (tx) => {
+    return ((Array.isArray(tx.txParams.authorizationList) &&
+        tx.txParams.authorizationList.length > 0) ||
+        Boolean(tx.delegationAddress));
+};
+export const shouldDisable7702 = (gasIncluded7702 = false, gasIncluded = false, isDelegatedAccount = false) => {
+    // Enable 7702 batching when the quote includes gasless 7702 support
+    if (gasIncluded7702) {
+        return false;
+    }
+    // Enable batching when the account is already delegated (to avoid the in-flight transaction limit for delegated accounts)
+    if (isDelegatedAccount) {
+        return false;
+    }
+    // For gasless transactions with STX/sendBundle we keep disabling 7702
+    if (gasIncluded) {
+        return true;
+    }
     /**
-     * @deprecated this is unused
+     * Explicitly return default instead of falsy value (see TransactionBatchRequest.disable7702)
      */
-    const baseAndPriorityFeePerGas = maxPriorityFeePerGas
-        ? new BigNumber(estimatedBaseFee, 10)
-            .times(10 ** 9)
-            .plus(maxPriorityFeePerGas, 16)
-        : undefined;
-    return {
-        baseAndPriorityFeePerGas,
-        maxFeePerGas,
-        maxPriorityFeePerGas,
-    };
+    return true;
 };
-export const calculateGasFees = async (skipGasFields, messenger, { chainId: _, gasLimit, ...trade }, networkClientId, chainId, txFee) => {
-    if (skipGasFields) {
-        return {};
-    }
-    if (txFee) {
-        return { ...txFee, gas: gasLimit?.toString() };
+export const hasNestedSwapTransactions = (txMeta) => {
+    return Boolean(txMeta?.nestedTransactions?.some((tx) => tx.type === TransactionType.swap));
+};
+export const getGasFeeEstimates = async (messenger, args) => {
+    const { estimates } = await messenger.call('TransactionController:estimateGasFee', args);
+    if (estimates?.type === GasFeeEstimateType.FeeMarket) {
+        return estimates[BRIDGE_PREFERRED_GAS_ESTIMATE];
     }
-    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 {
-        maxFeePerGas,
-        maxPriorityFeePerGas,
-        gas: maxGasLimit,
-    };
+    return undefined;
 };
 export const getTransactions = (messenger) => {
     return messenger.call('TransactionController:getState').transactions ?? [];
@@ -182,222 +156,215 @@ export const waitForTxConfirmation = async (messenger, txId, { timeoutMs = 5 * 6
         await new Promise((resolve) => setTimeout(resolve, pollMs));
     }
 };
-export const toBatchTxParams = (skipGasFields, { chainId, gasLimit, ...trade }, { maxFeePerGas, maxPriorityFeePerGas, gas, }) => {
-    const params = {
-        ...trade,
-        data: trade.data,
-        to: trade.to,
-        value: trade.value,
-    };
-    if (skipGasFields) {
-        return params;
-    }
-    return {
-        ...params,
-        gas: toHex(gas ?? 0),
-        maxFeePerGas: toHex(maxFeePerGas ?? 0),
-        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, }) => {
-    // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
-    const isGasless = gasIncluded || gasIncluded7702;
-    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 = 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)
-    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, resetApproval, networkClientId, hexChainId, isGasless ? txFee : undefined);
-        transactions.push({
-            type: isBridgeTx
-                ? TransactionType.bridgeApproval
-                : TransactionType.swapApproval,
-            params: toBatchTxParams(skipGasFields, resetApproval, gasFees),
+export const toQuoteAndTxMetadata = ({ quoteResponse, isBridgeTx, }) => {
+    const tradeData = [];
+    const approvalTxType = isBridgeTx
+        ? TransactionType.bridgeApproval
+        : TransactionType.swapApproval;
+    if (quoteResponse.resetApproval) {
+        tradeData.push({
+            quoteResponse,
+            tx: quoteResponse.resetApproval,
+            type: approvalTxType,
+            txFee: quoteResponse.quote.feeData[FeeType.TX_FEE],
         });
     }
-    if (approval) {
-        const gasFees = await calculateGasFees(skipGasFields, messenger, approval, networkClientId, hexChainId, isGasless ? txFee : undefined);
-        transactions.push({
-            type: isBridgeTx
-                ? TransactionType.bridgeApproval
-                : TransactionType.swapApproval,
-            params: toBatchTxParams(skipGasFields, approval, gasFees),
+    if (quoteResponse.approval && isEvmTxData(quoteResponse.approval)) {
+        tradeData.push({
+            quoteResponse,
+            tx: quoteResponse.approval,
+            type: approvalTxType,
+            txFee: quoteResponse.quote.feeData[FeeType.TX_FEE],
         });
     }
-    const gasFees = await calculateGasFees(skipGasFields, messenger, trade, networkClientId, hexChainId, isGasless ? txFee : undefined);
-    transactions.push({
+    tradeData.push({
+        quoteResponse,
+        tx: quoteResponse.trade,
         type: isBridgeTx ? TransactionType.bridge : TransactionType.swap,
-        params: toBatchTxParams(skipGasFields, trade, gasFees),
         assetsFiatValues: {
-            sending: sentAmount?.valueInCurrency?.toString(),
-            receiving: toTokenAmount?.valueInCurrency?.toString(),
+            sending: quoteResponse.sentAmount?.valueInCurrency?.toString(),
+            receiving: quoteResponse.toTokenAmount?.valueInCurrency?.toString(),
         },
+        txFee: quoteResponse.quote.feeData[FeeType.TX_FEE],
     });
-    const transactionParams = {
-        disable7702,
-        isGasFeeIncluded: Boolean(gasIncluded7702),
-        isGasFeeSponsored: Boolean(gasSponsored),
-        networkClientId,
-        requireApproval,
-        origin: 'metamask',
-        isInternal: true,
-        from: trade.from,
-        transactions,
-    };
-    return transactionParams;
+    return tradeData;
 };
-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
-    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;
+/**
+ * Build the trade+quote metadata array for the batch sell transaction
+ * This ties together the quote, the tx params and the txMeta after submission
+ *
+ * @param options - The options for the batch sell transaction
+ * @param options.quoteResponses - The quote responses for the batch sell transaction
+ * @param options.batchSellTrades - The batch sell trades for the batch sell transaction
+ * @returns The trade+quote metadata array for the batch sell transaction
+ */
+export const toQuoteAndTxMetadataBatch = ({ quoteResponses, batchSellTrades, }) => {
+    const tradeData = [];
+    const { transactions, gasIncluded7702, gasIncluded, gasSponsored = false, } = batchSellTrades;
+    for (const transaction of transactions) {
+        const { type, maxFeePerGas, maxPriorityFeePerGas, ...tx } = transaction;
+        // Match the trade or approval tx data with the quote response
+        const matchingQuoteResponse = quoteResponses.find(({ approval, trade }) => trade?.data.toLowerCase() === tx.data.toLowerCase() ||
+            approval?.data.toLowerCase() === tx.data.toLowerCase()) ?? quoteResponses[0];
+        // Include gasIncluded and gasIncluded7702 from the gasless batch
+        const normalizedQuote = {
+            ...matchingQuoteResponse,
+            quote: {
+                ...matchingQuoteResponse.quote,
+                gasIncluded,
+                gasIncluded7702,
+                gasSponsored,
+            },
+        };
+        const commonTradeData = {
+            tx,
+            quoteResponse: normalizedQuote,
+            txFee: { maxFeePerGas, maxPriorityFeePerGas },
+        };
+        if (type === BatchSellTransactionType.TRADE) {
+            tradeData.push({
+                ...commonTradeData,
+                type: TransactionType.swap,
+                assetsFiatValues: {
+                    sending: matchingQuoteResponse.sentAmount?.valueInCurrency?.toString(),
+                    receiving: matchingQuoteResponse.toTokenAmount?.valueInCurrency?.toString(),
+                },
+            });
         }
-        // Find transaction by batchId and either matching data or delegation characteristics
-        const txMeta = txs.find((tx) => {
-            if (tx.batchId !== batchId) {
-                return false;
-            }
-            // For 7702 delegated transactions, check for delegation-specific fields
-            // These transactions might have authorizationList or delegationAddress
-            const is7702Transaction = (Array.isArray(tx.txParams.authorizationList) &&
-                tx.txParams.authorizationList.length > 0) ||
-                Boolean(tx.delegationAddress);
-            if (is7702Transaction) {
-                // For 7702 transactions, we need to match based on transaction type
-                // since the data field might be different (batch execute call)
-                if (isTradeTx(txType) && tx.type === TransactionType.batch) {
-                    return true;
-                }
-                // Also check if it's an approval transaction for 7702
-                if (isApprovalTx(txType) && tx.txParams.data === txData) {
-                    return true;
-                }
-            }
-            // Default matching logic for non-7702 transactions
-            return tx.txParams.data === txData;
-        });
-        if (txMeta) {
-            const updatedTx = { ...txMeta, type: txType };
-            updateTransaction(messenger, txMeta, { type: txType }, `Update tx type to ${txType}`);
-            const txTypes = [
-                TransactionType.bridgeApproval,
-                TransactionType.swapApproval,
-            ];
-            txBatch[txTypes.includes(txType) ? 'approvalMeta' : 'tradeMeta'] =
-                updatedTx;
+        else {
+            tradeData.push({
+                ...commonTradeData,
+                type: type === BatchSellTransactionType.APPROVAL
+                    ? TransactionType.swapApproval
+                    : TransactionType.tokenMethodTransfer,
+            });
         }
-    });
-    return txBatch;
-};
-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 };
+    return tradeData;
 };
-// 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) {
+/**
+ * Appends the gas fee estimates for a transaction and normalizes the trade data
+ *
+ * @param messenger - The messenger for the gas fee estimates
+ * @param trade - the trade data to append gas fees to
+ * @param trade.chainId - ignored, use chainId instead
+ * @param trade.gasLimit - the gas limit to use for the gas fee estimates
+ * @param networkClientId - the network client ID to use for the gas fee estimates
+ * @param chainId - the chain ID to use for the gas fee estimates
+ * @param simulatedGasFeeLimits - either the txFee from the quote or the simulated gas fee limits for the batch sell
+ * @returns The gas fee estimates for the transaction
+ */
+export const toTransactionParams = async (messenger, { chainId: tradeChainId, gasLimit, ...trade }, networkClientId, chainId, simulatedGasFeeLimits) => {
+    const normalizedTrade = {
+        ...trade,
+        data: trade.data,
+        to: trade.to,
+        from: trade.from,
+        value: trade.value,
+    };
+    const transactionParams = {
+        ...normalizedTrade,
+        // Only add gasLimit and gas if they're truthy
+        gas: gasLimit ? toHex(gasLimit) : undefined,
+    };
+    // Use bridge-api's provided gas fee estimates
+    if (simulatedGasFeeLimits) {
         return {
-            maxFeePerGas: toHex(txFee.maxFeePerGas),
-            maxPriorityFeePerGas: toHex(txFee.maxPriorityFeePerGas),
-            gas: gas ? toHex(gas) : undefined,
+            ...transactionParams,
+            maxFeePerGas: toHex(simulatedGasFeeLimits.maxFeePerGas),
+            maxPriorityFeePerGas: toHex(simulatedGasFeeLimits.maxPriorityFeePerGas),
         };
     }
-    const { maxFeePerGas, maxPriorityFeePerGas } = await getTxGasEstimates(messenger, {
+    // Get transaction's 1559 gas fee estimates
+    const gasFeeEstimates = await getGasFeeEstimates(messenger, {
         transactionParams,
-        chainId,
         networkClientId,
+        chainId,
     });
     return {
-        maxFeePerGas,
-        maxPriorityFeePerGas,
-        gas: gas ? toHex(gas) : undefined,
+        ...transactionParams,
+        maxFeePerGas: gasFeeEstimates?.maxFeePerGas,
+        maxPriorityFeePerGas: gasFeeEstimates?.maxPriorityFeePerGas,
     };
 };
-/**
- * Submits an EVM transaction to the TransactionController
- *
- * @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 const submitEvmTransaction = async ({ messenger, trade, transactionType, requireApproval = false, txFee, 
-// Use provided actionId (for pre-submission history) or generate one
-actionId = generateActionId(), }) => {
+export const getAddTransactionBatchParams = async ({ messenger, tradeData, requireApproval = false, isDelegatedAccount, ...addTransactionBatchParams }) => {
+    const trade = tradeData[0].tx;
     const selectedAccount = getAccountByAddress(messenger, trade.from);
     if (!selectedAccount) {
-        throw new Error('Failed to submit cross-chain swap transaction: unknown account in trade data');
+        throw new Error('Failed to submit cross-chain swap batch transaction: unknown account in trade data');
     }
     const hexChainId = formatChainIdToHex(trade.chainId);
     const networkClientId = getNetworkClientIdByChainId(messenger, hexChainId);
-    const requestOptions = {
-        actionId,
+    const transactions = await Promise.all(tradeData.map(async ({ tx, txFee, assetsFiatValues, type }) => ({
+        params: await toTransactionParams(messenger, tx, networkClientId, hexChainId, txFee),
+        assetsFiatValues,
+        type,
+    })));
+    return {
         networkClientId,
         requireApproval,
-        type: transactionType,
         origin: 'metamask',
+        from: selectedAccount.address,
         isInternal: true,
+        transactions,
+        ...addTransactionBatchParams,
     };
-    // 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);
+};
+export const findAllTransactionsInBatch = ({ messenger, batchId, tradeData, }) => {
+    // Filter for transactions with batchId
+    const txs = getTransactions(messenger).filter((tx) => tx.batchId === batchId);
+    return tradeData.map((tradeWithMetadata) => {
+        const { tx, type } = tradeWithMetadata;
+        return {
+            ...tradeWithMetadata,
+            txMeta: txs.find((txMeta) => {
+                if (is7702Tx(txMeta)) {
+                    // For 7702 transactions, we need to match based on transaction type
+                    // since the data field might be different (batch execute call)
+                    if (isTradeTx(type) && txMeta.type === TransactionType.batch) {
+                        return true;
+                    }
+                    // Also check if it's an approval transaction for 7702
+                    if (isApprovalTx(type) && txMeta.txParams.data === tx.data) {
+                        return true;
+                    }
+                }
+                // Default matching logic for non-7702 transactions
+                if (txMeta.txParams.data === tx.data) {
+                    return true;
+                }
+                return false;
+            }),
+        };
+    });
+};
+/**
+ * This is a workaround to update the tx type after submission. Batch txs are submitted with
+ * the "batch" type, but we need to update to swap/bridge for display purposes.
+ *
+ * @param params - The parameters for the transaction search
+ * @param params.messenger - The messenger to use for the transaction
+ * @param params.allTradesWithMetadata - The quote, tx data and type for each transaction in the batch
+ * @returns A list of transaction metas for each trade in the batch]
+ *
+ * @example
+ * [
+ *   {...tradeData[0], tradeMeta: TransactionMeta}
+ *   {...tradeData[1], tradeMeta: TransactionMeta}
+ *   {...tradeData[2], tradeMeta: TransactionMeta}
+ *   {...tradeData[3], tradeMeta: TransactionMeta}
+ * ]
+ */
+export const updateTransactionsInBatch = ({ messenger, allTradesWithMetadata, }) => {
+    return allTradesWithMetadata.map((tradeWithMetadata) => {
+        const { txMeta, type } = tradeWithMetadata;
+        if (txMeta) {
+            // Update the tx type from batch to swap/bridge
+            updateTransaction(messenger, txMeta, { type }, `Update tx type to ${type}`);
+            const updatedTx = { ...txMeta, type };
+            return { ...tradeWithMetadata, txMeta: updatedTx, type };
+        }
+        return tradeWithMetadata;
+    });
 };
 //# sourceMappingURL=transaction.mjs.map