@metamask/bridge-status-controller 70.0.0 → 70.0.1

package/dist/utils/transaction.d.mts

@@ -1,176 +1,57 @@
 import type { QuoteMetadata, QuoteResponse, TxData } from "@metamask/bridge-controller";
 import { TransactionType } from "@metamask/transaction-controller";
-import type { BatchTransactionParams, TransactionMeta } from "@metamask/transaction-controller";
+import type { BatchTransactionParams, TransactionController, TransactionMeta, TransactionParams } from "@metamask/transaction-controller";
+import { Hex } from "@metamask/utils";
+import { BigNumber } from "bignumber.js";
 import type { BridgeStatusControllerMessenger } from "../types.mjs";
+export declare const getGasFeeEstimates: (messenger: BridgeStatusControllerMessenger, args: Parameters<TransactionController['estimateGasFee']>[0]) => Promise<{
+    maxFeePerGas?: string;
+    maxPriorityFeePerGas?: string;
+}>;
+/**
+ * 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 declare const getTxGasEstimates: (messenger: BridgeStatusControllerMessenger, estimateGasFeeParams: Parameters<TransactionController['estimateGasFee']>[0]) => Promise<{
+    baseAndPriorityFeePerGas: BigNumber | undefined;
+    maxFeePerGas: string | undefined;
+    maxPriorityFeePerGas: string | undefined;
+}>;
+export declare const calculateGasFees: (skipGasFields: boolean, messenger: BridgeStatusControllerMessenger, { chainId: _, gasLimit, ...trade }: TxData, networkClientId: string, chainId: Hex, txFee?: {
+    maxFeePerGas: string;
+    maxPriorityFeePerGas: string;
+}) => Promise<{
+    maxFeePerGas?: undefined;
+    maxPriorityFeePerGas?: undefined;
+    gas?: undefined;
+} | {
+    gas: string | undefined;
+    maxFeePerGas: string;
+    maxPriorityFeePerGas: string;
+} | {
+    maxFeePerGas: string | undefined;
+    maxPriorityFeePerGas: string | undefined;
+    gas: `0x${string}`;
+}>;
+export declare const getTransactions: (messenger: BridgeStatusControllerMessenger) => TransactionMeta[];
+export declare const getTransactionMetaById: (messenger: BridgeStatusControllerMessenger, txId?: string) => TransactionMeta | undefined;
+export declare const getTransactionMetaByHash: (messenger: BridgeStatusControllerMessenger, txHash?: string) => TransactionMeta | undefined;
+export declare const updateTransaction: (messenger: BridgeStatusControllerMessenger, txMeta: TransactionMeta, txMetaUpdates: Partial<TransactionMeta>, note: string) => void;
+export declare const checkIsDelegatedAccount: (messenger: BridgeStatusControllerMessenger, fromAddress: Hex, chainIds: Hex[]) => Promise<boolean>;
+export declare const addTransaction: (messenger: BridgeStatusControllerMessenger, txParams: TransactionParams, options: import("@metamask/transaction-controller").AddTransactionOptions) => Promise<TransactionMeta>;
 export declare const generateActionId: () => string;
-export declare const getStatusRequestParams: (quoteResponse: QuoteResponse) => {
-    bridgeId: string;
-    bridge: string;
-    srcChainId: number;
-    destChainId: number;
-    quote: {
-        srcChainId: number;
-        destChainId: number;
-        srcAsset: {
-            symbol: string;
-            chainId: number;
-            address: string;
-            assetId: `${string}:${string}/${string}:${string}`;
-            name: string;
-            decimals: number;
-            icon?: string | null | undefined;
-            iconUrl?: string | null | undefined;
-        };
-        destAsset: {
-            symbol: string;
-            chainId: number;
-            address: string;
-            assetId: `${string}:${string}/${string}:${string}`;
-            name: string;
-            decimals: number;
-            icon?: string | null | undefined;
-            iconUrl?: string | null | undefined;
-        };
-        requestId: string;
-        srcTokenAmount: string;
-        destTokenAmount: string;
-        minDestTokenAmount: string;
-        feeData: {
-            metabridge: {
-                amount: string;
-                asset: {
-                    symbol: string;
-                    chainId: number;
-                    address: string;
-                    assetId: `${string}:${string}/${string}:${string}`;
-                    name: string;
-                    decimals: number;
-                    icon?: string | null | undefined;
-                    iconUrl?: string | null | undefined;
-                };
-            };
-            txFee?: ({
-                amount: string;
-                asset: {
-                    symbol: string;
-                    chainId: number;
-                    address: string;
-                    assetId: `${string}:${string}/${string}:${string}`;
-                    name: string;
-                    decimals: number;
-                    icon?: string | null | undefined;
-                    iconUrl?: string | null | undefined;
-                };
-            } & {
-                maxFeePerGas: string;
-                maxPriorityFeePerGas: string;
-            }) | undefined;
-        };
-        bridgeId: string;
-        bridges: string[];
-        steps: {
-            action: import("@metamask/bridge-controller").ActionTypes;
-            srcChainId: number;
-            srcAsset: {
-                symbol: string;
-                chainId: number;
-                address: string;
-                assetId: `${string}:${string}/${string}:${string}`;
-                name: string;
-                decimals: number;
-                icon?: string | null | undefined;
-                iconUrl?: string | null | undefined;
-            };
-            destAsset: {
-                symbol: string;
-                chainId: number;
-                address: string;
-                assetId: `${string}:${string}/${string}:${string}`;
-                name: string;
-                decimals: number;
-                icon?: string | null | undefined;
-                iconUrl?: string | null | undefined;
-            };
-            srcAmount: string;
-            destAmount: string;
-            protocol: {
-                name: string;
-                icon?: string | undefined;
-                displayName?: string | undefined;
-            };
-            destChainId?: number | undefined;
-        }[];
-        refuel?: {
-            action: import("@metamask/bridge-controller").ActionTypes;
-            srcChainId: number;
-            srcAsset: {
-                symbol: string;
-                chainId: number;
-                address: string;
-                assetId: `${string}:${string}/${string}:${string}`;
-                name: string;
-                decimals: number;
-                icon?: string | null | undefined;
-                iconUrl?: string | null | undefined;
-            };
-            destAsset: {
-                symbol: string;
-                chainId: number;
-                address: string;
-                assetId: `${string}:${string}/${string}:${string}`;
-                name: string;
-                decimals: number;
-                icon?: string | null | undefined;
-                iconUrl?: string | null | undefined;
-            };
-            srcAmount: string;
-            destAmount: string;
-            protocol: {
-                name: string;
-                icon?: string | undefined;
-                displayName?: string | undefined;
-            };
-            destChainId?: number | undefined;
-        } | undefined;
-        gasIncluded?: boolean | undefined;
-        gasIncluded7702?: boolean | undefined;
-        priceData?: {
-            totalFromAmountUsd?: string | undefined;
-            totalToAmountUsd?: string | undefined;
-            priceImpact?: string | undefined;
-            totalFeeAmountUsd?: string | undefined;
-        } | undefined;
-        intent?: {
-            protocol: string;
-            order: {
-                sellToken: string;
-                buyToken: string;
-                validTo: string | number;
-                appData: string;
-                appDataHash: string;
-                feeAmount: string;
-                kind: "sell" | "buy";
-                partiallyFillable: boolean;
-                receiver?: string | undefined;
-                sellAmount?: string | undefined;
-                buyAmount?: string | undefined;
-                from?: string | undefined;
-            };
-            typedData: {
-                types: Record<string, {
-                    name: string;
-                    type: string;
-                }[]>;
-                primaryType: string;
-                domain: Record<string, any>;
-                message: Record<string, any>;
-            };
-            settlementContract?: string | undefined;
-        } | undefined;
-        gasSponsored?: boolean | undefined;
-    };
-    refuel: boolean;
-};
+/**
+ * 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 declare const addSyntheticTransaction: (messenger: BridgeStatusControllerMessenger, txParams: TransactionParams, options: import("@metamask/transaction-controller").AddTransactionOptions) => Promise<TransactionMeta>;
 export declare const handleApprovalDelay: (srcChainId: QuoteResponse['quote']['srcChainId']) => Promise<void>;
 /**
  * Adds a delay for hardware wallet transactions on mobile to fix an issue
@@ -180,6 +61,17 @@ export declare const handleApprovalDelay: (srcChainId: QuoteResponse['quote']['s
  * @param requireApproval - Whether the delay should be applied
  */
 export declare const handleMobileHardwareWalletDelay: (requireApproval: boolean) => Promise<void>;
+/**
+ * Waits until a given transaction (by id) reaches confirmed/finalized status or fails/times out.
+ *
+ * @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 declare const waitForTxConfirmation: (messenger: BridgeStatusControllerMessenger, txId: string, { timeoutMs, pollMs, }?: {
     timeoutMs?: number | undefined;
     pollMs?: number | undefined;
@@ -237,6 +129,7 @@ export declare const findAndUpdateTransactionsInBatch: ({ messenger, batchId, tx
         perpsDeposit?: string | undefined;
         perpsDepositAndOrder?: string | undefined;
         perpsRelayDeposit?: string | undefined;
+        perpsWithdraw?: string | undefined;
         personal_sign?: string | undefined;
         predictAcrossDeposit?: string | undefined;
         predictBuy?: string | undefined;
@@ -270,4 +163,33 @@ export declare const findAndUpdateTransactionsInBatch: ({ messenger, batchId, tx
     approvalMeta?: TransactionMeta | undefined;
     tradeMeta?: TransactionMeta | undefined;
 };
+export declare const addTransactionBatch: (messenger: BridgeStatusControllerMessenger, addTransactionBatchFn: TransactionController['addTransactionBatch'], request: import("@metamask/transaction-controller").TransactionBatchRequest) => Promise<{
+    approvalMeta: TransactionMeta | undefined;
+    tradeMeta: TransactionMeta;
+}>;
+/**
+ * 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 declare const submitEvmTransaction: ({ messenger, trade, transactionType, requireApproval, txFee, actionId, }: {
+    messenger: BridgeStatusControllerMessenger;
+    transactionType: TransactionType;
+    trade: TxData;
+    requireApproval?: boolean | undefined;
+    txFee?: {
+        maxFeePerGas: string;
+        maxPriorityFeePerGas: string;
+    } | undefined;
+    actionId?: string | undefined;
+}) => Promise<TransactionMeta>;
 //# sourceMappingURL=transaction.d.mts.map

package/dist/utils/transaction.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"transaction.d.mts","sourceRoot":"","sources":["../../src/utils/transaction.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,aAAa,EACb,aAAa,EACb,MAAM,EACP,oCAAoC;AAErC,OAAO,EAEL,eAAe,EAChB,yCAAyC;AAC1C,OAAO,KAAK,EACV,sBAAsB,EAEtB,eAAe,EAChB,yCAAyC;AAQ1C,OAAO,KAAK,EAAE,+BAA+B,EAAE,qBAAiB;AAEhE,eAAO,MAAM,gBAAgB,cAAgD,CAAC;AAE9E,eAAO,MAAM,sBAAsB,kBAAmB,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CASlE,CAAC;AAEF,eAAO,MAAM,mBAAmB,eAClB,aAAa,CAAC,OAAO,CAAC,CAAC,YAAY,CAAC,kBAYjD,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,+BAA+B,oBACzB,OAAO,kBAQzB,CAAC;AAEF,eAAO,MAAM,qBAAqB,qDAE1B,MAAM;;;MAKX,QAAQ,eAAe,CAyBzB,CAAC;AAEF,eAAO,MAAM,eAAe,kBACX,OAAO,mCACW,MAAM;;;;MAMtC,sBAiBF,CAAC;AAEF,eAAO,MAAM,4BAA4B;;gBAoB3B,OAAO;WACZ,MAAM;mBACE,KAAK,aAAa,EAAE,UAAU,GAAG,OAAO,CAAC,GACtD,QAAQ,aAAa,CAAC;;;;;;;;;;;;;;;;;;;;;iFAqFzB,CAAC;AAEF,eAAO,MAAM,gCAAgC;;aAMlC,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2EhB,CAAC"}
+{"version":3,"file":"transaction.d.mts","sourceRoot":"","sources":["../../src/utils/transaction.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EACV,aAAa,EACb,aAAa,EACb,MAAM,EACP,oCAAoC;AAErC,OAAO,EAEL,eAAe,EAChB,yCAAyC;AAC1C,OAAO,KAAK,EACV,sBAAsB,EAEtB,qBAAqB,EACrB,eAAe,EAEf,iBAAiB,EAClB,yCAAyC;AAC1C,OAAO,EAAuB,GAAG,EAAE,wBAAwB;AAC3D,OAAO,EAAE,SAAS,EAAE,qBAAqB;AAKzC,OAAO,KAAK,EAAE,+BAA+B,EAAE,qBAAiB;AAEhE,eAAO,MAAM,kBAAkB,qDAEvB,WAAW,qBAAqB,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAC,KAC3D,QAAQ;IAAE,YAAY,CAAC,EAAE,MAAM,CAAC;IAAC,oBAAoB,CAAC,EAAE,MAAM,CAAA;CAAE,CAclE,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,qEAEN,WAAW,qBAAqB,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAC;;;;EA4B7E,CAAC;AAEF,eAAO,MAAM,gBAAgB,kBACZ,OAAO,kFAEc,MAAM,mBACzB,MAAM,WACd,GAAG,UACJ;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,oBAAoB,EAAE,MAAM,CAAA;CAAE;;;;;;kBAAtC,MAAM;0BAAwB,MAAM;;;;;EA8B7D,CAAC;AAEF,eAAO,MAAM,eAAe,mEAE3B,CAAC;AAEF,eAAO,MAAM,sBAAsB,sDAE1B,MAAM,gCAKd,CAAC;AAEF,eAAO,MAAM,wBAAwB,wDAE1B,MAAM,gCAKhB,CAAC;AAEF,eAAO,MAAM,iBAAiB,uDAEpB,eAAe,iBACR,QAAQ,eAAe,CAAC,QACjC,MAAM,SAOb,CAAC;AAEF,eAAO,MAAM,uBAAuB,4DAErB,GAAG,YACN,GAAG,EAAE,KACd,QAAQ,OAAO,CAgBjB,CAAC;AAkBF,eAAO,MAAM,cAAc,kLAS1B,CAAC;AAEF,eAAO,MAAM,gBAAgB,cAAgD,CAAC;AAE9E;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,kLAenC,CAAC;AAEF,eAAO,MAAM,mBAAmB,eAClB,aAAa,CAAC,OAAO,CAAC,CAAC,YAAY,CAAC,kBAYjD,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,+BAA+B,oBACzB,OAAO,kBAQzB,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,qBAAqB,qDAE1B,MAAM;;;MAKX,QAAQ,eAAe,CAwBzB,CAAC;AAEF,eAAO,MAAM,eAAe,kBACX,OAAO,mCACW,MAAM;;;;MAMtC,sBAiBF,CAAC;AAEF,eAAO,MAAM,4BAA4B;;gBAoB3B,OAAO;WACZ,MAAM;mBACE,KAAK,aAAa,EAAE,UAAU,GAAG,OAAO,CAAC,GACtD,QAAQ,aAAa,CAAC;;;;;;;;;;;;;;;;;;;;;iFA4FzB,CAAC;AAEF,eAAO,MAAM,gCAAgC;;aAMlC,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4EhB,CAAC;AAEF,eAAO,MAAM,mBAAmB,sEAEP,qBAAqB,CAAC,qBAAqB,CAAC;;;EAiCpE,CAAC;AAyCF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,oBAAoB;;qBAUd,eAAe;WACzB,MAAM;;;sBAEW,MAAM;8BAAwB,MAAM;;;MAE1D,QAAQ,eAAe,CAgD1B,CAAC"}

package/dist/utils/transaction.mjs

@@ -1,23 +1,130 @@
 /* eslint-disable @typescript-eslint/explicit-function-return-type */
-import { ChainId, formatChainIdToHex } from "@metamask/bridge-controller";
+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 { BigNumber } from "bignumber.js";
 import { getAccountByAddress } from "./accounts.mjs";
-import { calculateGasFees } from "./gas.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 {
+        baseAndPriorityFeePerGas,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+    };
+};
+export const calculateGasFees = async (skipGasFields, messenger, { chainId: _, gasLimit, ...trade }, networkClientId, chainId, txFee) => {
+    if (skipGasFields) {
+        return {};
+    }
+    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 {
-        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),
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        gas: maxGasLimit,
     };
 };
+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 {
+        const atomicBatchSupport = await messenger.call('TransactionController:isAtomicBatchSupported', {
+            address: fromAddress,
+            chainIds,
+        });
+        return atomicBatchSupport.some((entry) => entry.isSupported && entry.delegationAddress);
+    }
+    catch {
+        return false;
+    }
+};
+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)) {
         const debugLog = createProjectLogger('bridge');
@@ -39,11 +146,21 @@ export const handleMobileHardwareWalletDelay = async (requireApproval) => {
         await mobileHardwareWalletDelay;
     }
 };
+/**
+ * Waits until a given transaction (by id) reaches confirmed/finalized status or fails/times out.
+ *
+ * @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 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;
@@ -78,6 +195,7 @@ export const toBatchTxParams = (skipGasFields, { chainId, gasLimit, ...trade },
     };
 };
 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) {
@@ -90,7 +208,11 @@ export const getAddTransactionBatchParams = async ({ messenger, isBridgeTx, appr
     // 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, resetApproval, networkClientId, hexChainId, isGasless ? txFee : undefined);
@@ -132,14 +254,15 @@ export const getAddTransactionBatchParams = async ({ messenger, isBridgeTx, appr
     return transactionParams;
 };
 export const findAndUpdateTransactionsInBatch = ({ messenger, batchId, txDataByType, }) => {
-    const txs = messenger.call('TransactionController:getState').transactions;
+    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;
@@ -174,12 +297,104 @@ export const findAndUpdateTransactionsInBatch = ({ messenger, batchId, txDataByT
         });
         if (txMeta) {
             const updatedTx = { ...txMeta, type: txType };
-            messenger.call('TransactionController:updateTransaction', 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;
 };
+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,
+        };
+    }
+    const { maxFeePerGas, maxPriorityFeePerGas } = await getTxGasEstimates(messenger, {
+        transactionParams,
+        chainId,
+        networkClientId,
+    });
+    return {
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        gas: gas ? toHex(gas) : undefined,
+    };
+};
+/**
+ * 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(), }) => {
+    const selectedAccount = getAccountByAddress(messenger, trade.from);
+    if (!selectedAccount) {
+        throw new Error('Failed to submit cross-chain swap transaction: unknown account in trade data');
+    }
+    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