@metamask-previews/transaction-controller 69.6.1-preview-4f4c98e → 69.6.1-preview-eb263b0ee

package/dist/TransactionController.d.mts

@@ -0,0 +1,751 @@
+import type { AccountsControllerGetSelectedAccountAction, AccountsControllerGetStateAction, AccountsControllerSelectedAccountChangeEvent } from "@metamask/accounts-controller";
+import type { ApprovalControllerAddRequestAction } from "@metamask/approval-controller";
+import type { ControllerGetStateAction, ControllerStateChangeEvent } from "@metamask/base-controller";
+import { BaseController } from "@metamask/base-controller";
+import type { TraceCallback } from "@metamask/controller-utils";
+import type { AccountActivityServiceStatusChangedEvent, AccountActivityServiceTransactionUpdatedEvent, BackendWebSocketServiceConnectionStateChangedEvent } from "@metamask/core-backend";
+import type { GasFeeControllerFetchGasFeeEstimatesAction } from "@metamask/gas-fee-controller";
+import type { KeyringControllerGetStateAction, KeyringControllerSignEip7702AuthorizationAction, KeyringControllerSignTransactionAction } from "@metamask/keyring-controller";
+import type { Messenger } from "@metamask/messenger";
+import type { NetworkClientId, NetworkControllerStateChangeEvent, NetworkControllerFindNetworkClientIdByChainIdAction, NetworkControllerGetNetworkClientByIdAction, NetworkControllerGetNetworkClientRegistryAction, NetworkControllerGetStateAction, NetworkControllerGetEIP1559CompatibilityAction } from "@metamask/network-controller";
+import type { NonceLock } from "@metamask/nonce-tracker";
+import type { RemoteFeatureFlagControllerGetStateAction } from "@metamask/remote-feature-flag-controller";
+import type { Hex } from "@metamask/utils";
+import type { TransactionControllerMethodActions } from "./TransactionController-method-action-types.mjs";
+import type { SavedGasFees, SendFlowHistoryEntry, TransactionParams, TransactionMeta, TransactionReceipt, SecurityAlertResponse, GasFeeFlowResponse, GasPriceValue, FeeMarketEIP1559Values, SubmitHistoryEntry, TransactionBatchRequest, TransactionBatchResult, BatchTransactionParams, UpdateCustodialTransactionRequest, PublishBatchHook, GasFeeToken, IsAtomicBatchSupportedResult, IsAtomicBatchSupportedRequest, AfterAddHook, TransactionBatchMeta, BeforeSignHook, GetSimulationConfig, AddTransactionOptions, GetGasFeeTokensRequest } from "./types.mjs";
+import { TransactionContainerType } from "./types.mjs";
+import type { EstimateGasBatchResult } from "./utils/gas.mjs";
+/**
+ * Object with new transaction's meta and a promise resolving to the
+ * transaction hash if successful.
+ */
+export interface Result {
+    /** Promise resolving to a new transaction hash. */
+    result: Promise<string>;
+    /** Meta information about this new transaction. */
+    transactionMeta: TransactionMeta;
+}
+/**
+ * Method data registry object
+ */
+export type MethodData = {
+    /** Registry method raw string. */
+    registryMethod: string;
+    /** Registry method object, containing name and method arguments. */
+    parsedRegistryMethod: {
+        name: string;
+        args: {
+            type: string;
+        }[];
+    } | {
+        name?: any;
+        args?: any;
+    };
+};
+/**
+ * Transaction controller state
+ */
+export type TransactionControllerState = {
+    /** A list of TransactionMeta objects. */
+    transactions: TransactionMeta[];
+    /** A list of TransactionBatchMeta objects. */
+    transactionBatches: TransactionBatchMeta[];
+    /** Object containing all known method data information. */
+    methodData: Record<string, MethodData>;
+    /** Cache to optimise incoming transaction queries. */
+    lastFetchedBlockNumbers: {
+        [key: string]: number | string;
+    };
+    /** History of all transactions submitted from the wallet. */
+    submitHistory: SubmitHistoryEntry[];
+};
+/**
+ * Multiplier used to determine a transaction's increased gas fee during cancellation
+ */
+export declare const CANCEL_RATE = 1.1;
+/**
+ * Multiplier used to determine a transaction's increased gas fee during speed up
+ */
+export declare const SPEED_UP_RATE = 1.1;
+/**
+ * Represents the `TransactionController:getState` action.
+ */
+export type TransactionControllerGetStateAction = ControllerGetStateAction<typeof controllerName, TransactionControllerState>;
+/**
+ * The internal actions available to the TransactionController.
+ */
+export type TransactionControllerActions = TransactionControllerGetStateAction | TransactionControllerMethodActions;
+/**
+ * @deprecated Incoming transaction support has been removed. These options are ignored.
+ */
+export type IncomingTransactionCompatibilityOptions = {
+    client?: string;
+    includeTokenTransfers?: boolean;
+    isEnabled?: () => boolean;
+    updateTransactions?: boolean;
+    /** @deprecated Ignored as incoming transaction support has been removed. */
+    etherscanApiKeysByChainId?: Record<Hex, string>;
+};
+/** TransactionController constructor options. */
+export type TransactionControllerOptions = {
+    /** Whether to disable additional processing on swaps transactions. */
+    disableSwaps: boolean;
+    /** Get accounts that a given origin has permissions for. */
+    getPermittedAccounts?: (origin?: string) => Promise<string[]>;
+    /** Gets the saved gas fee config. */
+    getSavedGasFees?: (transactionMeta: TransactionMeta) => SavedGasFees | undefined;
+    /**
+     * Gets the transaction simulation configuration.
+     */
+    getSimulationConfig?: GetSimulationConfig;
+    /**
+     * @deprecated Incoming transaction support has been removed. This option is ignored.
+     */
+    incomingTransactions?: IncomingTransactionCompatibilityOptions;
+    /**
+     * Callback to determine whether gas fee updates should be enabled for a given transaction.
+     * Returns true to enable updates, false to disable them.
+     */
+    isAutomaticGasFeeUpdateEnabled?: (transactionMeta: TransactionMeta) => boolean;
+    /** Whether simulation should return EIP-7702 gas fee tokens. */
+    isEIP7702GasFeeTokensEnabled?: (transactionMeta: TransactionMeta) => Promise<boolean>;
+    /** Whether the first time interaction check is enabled. */
+    isFirstTimeInteractionEnabled?: () => boolean;
+    /** Whether new transactions will be automatically simulated. */
+    isSimulationEnabled?: (transactionMeta?: TransactionMeta) => boolean;
+    /** Whether timeout checking is enabled for a transaction. */
+    isTimeoutEnabled?: (transactionMeta: TransactionMeta) => boolean;
+    /** The controller messenger. */
+    messenger: TransactionControllerMessenger;
+    /** Public key used to validate EIP-7702 contract signatures in feature flags. */
+    publicKeyEIP7702?: Hex;
+    /** Initial state to set on this controller. */
+    state?: Partial<TransactionControllerState>;
+    testGasFeeFlows?: boolean;
+    trace?: TraceCallback;
+    /** The controller hooks. */
+    hooks: {
+        /** Additional logic to execute after adding a transaction. */
+        afterAdd?: AfterAddHook;
+        /**
+         * Additional logic to execute before checking pending transactions.
+         * Return false to prevent the broadcast of the transaction.
+         */
+        beforeCheckPendingTransaction?: (transactionMeta: TransactionMeta) => Promise<boolean>;
+        /**
+         * Additional logic to execute before publishing a transaction.
+         * Return false to prevent the broadcast of the transaction.
+         */
+        beforePublish?: (transactionMeta: TransactionMeta) => Promise<boolean>;
+        /**
+         * Additional logic to execute before signing a transaction.
+         */
+        beforeSign?: BeforeSignHook;
+        /** Alternate logic to publish a transaction. */
+        publish?: (transactionMeta: TransactionMeta) => Promise<{
+            transactionHash: string;
+        }>;
+        publishBatch?: PublishBatchHook;
+    };
+};
+/**
+ * The name of the {@link TransactionController}.
+ */
+declare const controllerName = "TransactionController";
+/**
+ * The external actions available to the {@link TransactionController}.
+ */
+export type AllowedActions = AccountsControllerGetSelectedAccountAction | AccountsControllerGetStateAction | ApprovalControllerAddRequestAction | GasFeeControllerFetchGasFeeEstimatesAction | KeyringControllerGetStateAction | KeyringControllerSignEip7702AuthorizationAction | KeyringControllerSignTransactionAction | NetworkControllerFindNetworkClientIdByChainIdAction | NetworkControllerGetEIP1559CompatibilityAction | NetworkControllerGetNetworkClientByIdAction | NetworkControllerGetNetworkClientRegistryAction | NetworkControllerGetStateAction | RemoteFeatureFlagControllerGetStateAction;
+/**
+ * The external events available to the {@link TransactionController}.
+ */
+export type AllowedEvents = AccountActivityServiceStatusChangedEvent | AccountActivityServiceTransactionUpdatedEvent | AccountsControllerSelectedAccountChangeEvent | BackendWebSocketServiceConnectionStateChangedEvent | NetworkControllerStateChangeEvent;
+/**
+ * Represents the `TransactionController:stateChange` event.
+ */
+export type TransactionControllerStateChangeEvent = ControllerStateChangeEvent<typeof controllerName, TransactionControllerState>;
+/**
+ * Represents the `TransactionController:postTransactionBalanceUpdated` event.
+ */
+export type TransactionControllerPostTransactionBalanceUpdatedEvent = {
+    type: `${typeof controllerName}:postTransactionBalanceUpdated`;
+    payload: [
+        {
+            transactionMeta: TransactionMeta;
+            approvalTransactionMeta?: TransactionMeta;
+        }
+    ];
+};
+/**
+ * Represents the `TransactionController:speedUpTransactionAdded` event.
+ */
+export type TransactionControllerSpeedupTransactionAddedEvent = {
+    type: `${typeof controllerName}:speedupTransactionAdded`;
+    payload: [transactionMeta: TransactionMeta];
+};
+/**
+ * Represents the `TransactionController:transactionApproved` event.
+ */
+export type TransactionControllerTransactionApprovedEvent = {
+    type: `${typeof controllerName}:transactionApproved`;
+    payload: [
+        {
+            transactionMeta: TransactionMeta;
+            actionId?: string;
+        }
+    ];
+};
+/**
+ * Represents the `TransactionController:transactionConfirmed` event.
+ */
+export type TransactionControllerTransactionConfirmedEvent = {
+    type: `${typeof controllerName}:transactionConfirmed`;
+    payload: [transactionMeta: TransactionMeta];
+};
+/**
+ * Represents the `TransactionController:transactionDropped` event.
+ */
+export type TransactionControllerTransactionDroppedEvent = {
+    type: `${typeof controllerName}:transactionDropped`;
+    payload: [{
+        transactionMeta: TransactionMeta;
+    }];
+};
+/**
+ * Represents the `TransactionController:transactionFailed` event.
+ */
+export type TransactionControllerTransactionFailedEvent = {
+    type: `${typeof controllerName}:transactionFailed`;
+    payload: [
+        {
+            actionId?: string;
+            error: string;
+            transactionMeta: TransactionMeta;
+        }
+    ];
+};
+/**
+ * Represents the `TransactionController:transactionFinished` event.
+ */
+export type TransactionControllerTransactionFinishedEvent = {
+    type: `${typeof controllerName}:transactionFinished`;
+    payload: [transactionMeta: TransactionMeta];
+};
+/**
+ * Represents the `TransactionController:transactionNewSwapApproval` event.
+ */
+export type TransactionControllerTransactionNewSwapApprovalEvent = {
+    type: `${typeof controllerName}:transactionNewSwapApproval`;
+    payload: [{
+        transactionMeta: TransactionMeta;
+    }];
+};
+/**
+ * Represents the `TransactionController:transactionNewSwap` event.
+ */
+export type TransactionControllerTransactionNewSwapEvent = {
+    type: `${typeof controllerName}:transactionNewSwap`;
+    payload: [{
+        transactionMeta: TransactionMeta;
+    }];
+};
+/**
+ * Represents the `TransactionController:transactionNewSwapApproval` event.
+ */
+export type TransactionControllerTransactionNewSwapAndSendEvent = {
+    type: `${typeof controllerName}:transactionNewSwapAndSend`;
+    payload: [{
+        transactionMeta: TransactionMeta;
+    }];
+};
+/**
+ * Represents the `TransactionController:transactionPublishingSkipped` event.
+ */
+export type TransactionControllerTransactionPublishingSkipped = {
+    type: `${typeof controllerName}:transactionPublishingSkipped`;
+    payload: [transactionMeta: TransactionMeta];
+};
+/**
+ * Represents the `TransactionController:transactionRejected` event.
+ */
+export type TransactionControllerTransactionRejectedEvent = {
+    type: `${typeof controllerName}:transactionRejected`;
+    payload: [
+        {
+            transactionMeta: TransactionMeta;
+            actionId?: string;
+        }
+    ];
+};
+/**
+ * Represents the `TransactionController:transactionStatusUpdated` event.
+ */
+export type TransactionControllerTransactionStatusUpdatedEvent = {
+    type: `${typeof controllerName}:transactionStatusUpdated`;
+    payload: [
+        {
+            transactionMeta: TransactionMeta;
+        }
+    ];
+};
+/**
+ * Represents the `TransactionController:transactionSubmitted` event.
+ */
+export type TransactionControllerTransactionSubmittedEvent = {
+    type: `${typeof controllerName}:transactionSubmitted`;
+    payload: [
+        {
+            transactionMeta: TransactionMeta;
+            actionId?: string;
+        }
+    ];
+};
+/**
+ * Represents the `TransactionController:unapprovedTransactionAdded` event.
+ */
+export type TransactionControllerUnapprovedTransactionAddedEvent = {
+    type: `${typeof controllerName}:unapprovedTransactionAdded`;
+    payload: [transactionMeta: TransactionMeta];
+};
+/**
+ * The internal events available to the {@link TransactionController}.
+ */
+export type TransactionControllerEvents = TransactionControllerPostTransactionBalanceUpdatedEvent | TransactionControllerSpeedupTransactionAddedEvent | TransactionControllerStateChangeEvent | TransactionControllerTransactionApprovedEvent | TransactionControllerTransactionConfirmedEvent | TransactionControllerTransactionDroppedEvent | TransactionControllerTransactionFailedEvent | TransactionControllerTransactionFinishedEvent | TransactionControllerTransactionNewSwapApprovalEvent | TransactionControllerTransactionNewSwapEvent | TransactionControllerTransactionNewSwapAndSendEvent | TransactionControllerTransactionPublishingSkipped | TransactionControllerTransactionRejectedEvent | TransactionControllerTransactionStatusUpdatedEvent | TransactionControllerTransactionSubmittedEvent | TransactionControllerUnapprovedTransactionAddedEvent;
+/**
+ * The messenger of the {@link TransactionController}.
+ */
+export type TransactionControllerMessenger = Messenger<typeof controllerName, TransactionControllerActions | AllowedActions, TransactionControllerEvents | AllowedEvents>;
+/**
+ * Possible states of the approve transaction step.
+ */
+export declare enum ApprovalState {
+    Approved = "approved",
+    NotApproved = "not-approved",
+    SkippedViaBeforePublishHook = "skipped-via-before-publish-hook"
+}
+/**
+ * Controller responsible for submitting and managing transactions.
+ */
+export declare class TransactionController extends BaseController<typeof controllerName, TransactionControllerState, TransactionControllerMessenger> {
+    #private;
+    /**
+     * Constructs a TransactionController.
+     *
+     * @param options - The controller options.
+     */
+    constructor(options: TransactionControllerOptions);
+    /**
+     * Stops polling and removes listeners to prepare the controller for garbage collection.
+     */
+    destroy(): void;
+    /**
+     * @deprecated Incoming transaction support has been removed. This method is retained as a no-op for backwards compatibility.
+     */
+    startIncomingTransactionPolling(): void;
+    /**
+     * @deprecated Incoming transaction support has been removed. This method is retained as a no-op for backwards compatibility.
+     */
+    stopIncomingTransactionPolling(): void;
+    /**
+     * Handle new method data request.
+     *
+     * @param fourBytePrefix - The method prefix.
+     * @param networkClientId - The ID of the network client used to fetch the method data.
+     * @returns The method data object corresponding to the given signature prefix.
+     */
+    handleMethodData(fourBytePrefix: string, networkClientId: NetworkClientId): Promise<MethodData>;
+    /**
+     * Add a batch of transactions to be submitted after approval.
+     *
+     * @param request - Request object containing the transactions to add.
+     * @returns Result object containing the generated batch ID.
+     */
+    addTransactionBatch(request: TransactionBatchRequest): Promise<TransactionBatchResult>;
+    /**
+     * Determine which chains support atomic batch transactions with the given account address.
+     *
+     * @param request - Request object containing the account address and other parameters.
+     * @returns  Result object containing the supported chains and related information.
+     */
+    isAtomicBatchSupported(request: IsAtomicBatchSupportedRequest): Promise<IsAtomicBatchSupportedResult>;
+    /**
+     * Add a new unapproved transaction to state. Parameters will be validated, a
+     * unique transaction ID will be generated, and `gas` and `gasPrice` will be calculated
+     * if not provided. A `<tx.id>:unapproved` hub event will be emitted once added.
+     *
+     * @param txParams - Standard parameters for an Ethereum transaction.
+     * @param options - Additional options to control how the transaction is added.
+     * @returns Object containing a promise resolving to the transaction hash if approved.
+     */
+    addTransaction(txParams: TransactionParams, options: AddTransactionOptions): Promise<Result>;
+    /**
+     * Attempts to cancel a transaction based on its ID by setting its status to "rejected"
+     * and emitting a `<tx.id>:finished` hub event.
+     *
+     * @param transactionId - The ID of the transaction to cancel.
+     * @param gasValues - The gas values to use for the cancellation transaction.
+     * @param options - The options for the cancellation transaction.
+     * @param options.actionId - Unique ID persisted on transaction metadata.
+     * @param options.estimatedBaseFee - The estimated base fee of the transaction.
+     */
+    stopTransaction(transactionId: string, gasValues?: GasPriceValue | FeeMarketEIP1559Values, { estimatedBaseFee, actionId, }?: {
+        estimatedBaseFee?: string;
+        actionId?: string;
+    }): Promise<void>;
+    /**
+     * Attempts to speed up a transaction increasing transaction gasPrice by ten percent.
+     *
+     * @param transactionId - The ID of the transaction to speed up.
+     * @param gasValues - The gas values to use for the speed up transaction.
+     * @param options - The options for the speed up transaction.
+     * @param options.actionId - Unique ID persisted on transaction metadata.
+     * @param options.estimatedBaseFee - The estimated base fee of the transaction.
+     */
+    speedUpTransaction(transactionId: string, gasValues?: GasPriceValue | FeeMarketEIP1559Values, { actionId, estimatedBaseFee, }?: {
+        actionId?: string;
+        estimatedBaseFee?: string;
+    }): Promise<void>;
+    /**
+     * Estimates required gas for a given transaction.
+     *
+     * @param transaction - The transaction to estimate gas for.
+     * @param networkClientId - The network client id to use for the estimate.
+     * @param options - Additional options for the estimate.
+     * @param options.ignoreDelegationSignatures - Ignore signature errors if submitting delegations to the DelegationManager.
+     * @returns The gas and gas price.
+     */
+    estimateGas(transaction: TransactionParams, networkClientId: NetworkClientId, { ignoreDelegationSignatures, }?: {
+        ignoreDelegationSignatures?: boolean;
+    }): Promise<{
+        gas: string;
+        simulationFails: TransactionMeta['simulationFails'];
+    }>;
+    /**
+     * Estimates required gas for a batch of transactions.
+     *
+     * @param request - Request object.
+     * @param request.chainId - Chain ID of the transactions.
+     * @param request.from - Address of the sender.
+     * @param request.transactions - Array of transactions within a batch request.
+     * @returns Object containing the gas limit.
+     */
+    estimateGasBatch({ chainId, from, transactions, }: {
+        chainId: Hex;
+        from: Hex;
+        transactions: BatchTransactionParams[];
+    }): Promise<EstimateGasBatchResult>;
+    /**
+     * Estimates required gas for a given transaction and add additional gas buffer with the given multiplier.
+     *
+     * @param transaction - The transaction params to estimate gas for.
+     * @param multiplier - The multiplier to use for the gas buffer.
+     * @param networkClientId - The network client id to use for the estimate.
+     * @returns The buffered estimated gas and whether the estimation failed.
+     */
+    estimateGasBuffered(transaction: TransactionParams, multiplier: number, networkClientId: NetworkClientId): Promise<{
+        gas: string;
+        simulationFails: TransactionMeta['simulationFails'];
+    }>;
+    /**
+     * Updates an existing transaction in state.
+     *
+     * @param transactionMeta - The new transaction to store in state.
+     * @param note - A note or update reason to be logged.
+     */
+    updateTransaction(transactionMeta: TransactionMeta, note: string): void;
+    /**
+     * Updates transaction metadata.
+     *
+     * @param options - Update options.
+     * @param options.transactionId - ID of the transaction to update.
+     * @param options.callback - Function that mutates the transaction metadata.
+     * @param options.skipResimulate - Whether to skip automatic re-simulation.
+     * @returns The updated transaction metadata.
+     */
+    updateTransactionMetadata({ transactionId, callback, skipResimulate, }: {
+        transactionId: string;
+        callback: (transactionMeta: TransactionMeta) => void;
+        skipResimulate?: boolean;
+    }): Readonly<TransactionMeta>;
+    /**
+     * Mark a transaction as failed, transitioning it through the standard failure
+     * path.
+     *
+     * Unlike `updateTransaction`, this emits the transaction lifecycle events
+     * (`transactionFailed`, `transactionStatusUpdated`, `transactionFinished`), so
+     * downstream subscribers such as the bridge status controller and metrics are
+     * notified. Intended for callers that finalize a transaction out-of-band, for
+     * example the smart transactions controller when the relay cancels a smart
+     * transaction that never landed on chain.
+     *
+     * @param transactionId - The ID of the transaction to mark as failed.
+     * @param error - The error describing why the transaction failed.
+     */
+    failTransaction(transactionId: string, error: Error): void;
+    /**
+     * Update the security alert response for a transaction.
+     *
+     * @param transactionId - ID of the transaction.
+     * @param securityAlertResponse - The new security alert response for the transaction.
+     */
+    updateSecurityAlertResponse(transactionId: string, securityAlertResponse: SecurityAlertResponse): void;
+    /**
+     * Remove transactions from state.
+     *
+     * @param options - The options bag.
+     * @param options.address - Remove transactions from this account only. Defaults to all accounts.
+     * @param options.chainId - Remove transactions for the specified chain only. Defaults to all chains.
+     */
+    wipeTransactions({ address, chainId, }?: {
+        address?: string;
+        chainId?: string;
+    }): void;
+    /**
+     * @deprecated No longer used. Kept only to avoid breaking changes. It now performs no operations.
+     * @param transactionID - The ID of the transaction to update.
+     * @param _currentSendFlowHistoryLength - The length of the current sendFlowHistory array.
+     * @param _sendFlowHistoryToAdd - The sendFlowHistory entries to add.
+     * @returns The transactionMeta.
+     */
+    updateTransactionSendFlowHistory(transactionID: string, _currentSendFlowHistoryLength: number, _sendFlowHistoryToAdd: SendFlowHistoryEntry[]): TransactionMeta;
+    /**
+     * Adds external provided transaction to state as confirmed transaction.
+     *
+     * @param transactionMeta - TransactionMeta to add transactions.
+     * @param transactionReceipt - TransactionReceipt of the external transaction.
+     * @param baseFeePerGas - Base fee per gas of the external transaction.
+     */
+    confirmExternalTransaction(transactionMeta: TransactionMeta, transactionReceipt: TransactionReceipt, baseFeePerGas: Hex): Promise<void>;
+    /**
+     * Update the gas values of a transaction.
+     *
+     * @param transactionId - The ID of the transaction to update.
+     * @param gasValues - Gas values to update.
+     * @param gasValues.gas - Same as transaction.gasLimit.
+     * @param gasValues.gasLimit - Maxmimum number of units of gas to use for this transaction.
+     * @param gasValues.gasPrice - Price per gas for legacy transactions.
+     * @param gasValues.maxPriorityFeePerGas - Maximum amount per gas to give to validator as incentive.
+     * @param gasValues.maxFeePerGas - Maximum amount per gas to pay for the transaction, including the priority fee.
+     * @param gasValues.estimateUsed - Which estimate level was used.
+     * @param gasValues.estimateSuggested - Which estimate level that the API suggested.
+     * @param gasValues.defaultGasEstimates - The default estimate for gas.
+     * @param gasValues.originalGasEstimate - Original estimate for gas.
+     * @param gasValues.userEditedGasLimit - The gas limit supplied by user.
+     * @param gasValues.userFeeLevel - Estimate level user selected.
+     * @returns The updated transactionMeta.
+     */
+    updateTransactionGasFees(transactionId: string, { defaultGasEstimates, estimateUsed, estimateSuggested, gas, gasLimit, gasPrice, maxPriorityFeePerGas, maxFeePerGas, originalGasEstimate, userEditedGasLimit, userFeeLevel: userFeeLevelParam, }: {
+        defaultGasEstimates?: string;
+        estimateUsed?: string;
+        estimateSuggested?: string;
+        gas?: string;
+        gasLimit?: string;
+        gasPrice?: string;
+        maxPriorityFeePerGas?: string;
+        maxFeePerGas?: string;
+        originalGasEstimate?: string;
+        userEditedGasLimit?: boolean;
+        userFeeLevel?: string;
+    }): TransactionMeta;
+    /**
+     * Update the previous gas values of a transaction.
+     *
+     * @param transactionId - The ID of the transaction to update.
+     * @param previousGas - Previous gas values to update.
+     * @param previousGas.gasLimit - Maximum number of units of gas to use for this transaction.
+     * @param previousGas.maxFeePerGas - Maximum amount per gas to pay for the transaction, including the priority fee.
+     * @param previousGas.maxPriorityFeePerGas - Maximum amount per gas to give to validator as incentive.
+     * @returns The updated transactionMeta.
+     */
+    updatePreviousGasParams(transactionId: string, { gasLimit, maxFeePerGas, maxPriorityFeePerGas, }: {
+        gasLimit?: string;
+        maxFeePerGas?: string;
+        maxPriorityFeePerGas?: string;
+    }): TransactionMeta;
+    /**
+     * Acquires a nonce lock for the given address on the specified network,
+     * ensuring that nonces are assigned sequentially without conflicts.
+     *
+     * @param address - The account address for which to acquire the nonce lock.
+     * @param networkClientId - The ID of the network client to use.
+     * @returns A promise that resolves to a nonce lock containing the next nonce and a release function.
+     */
+    getNonceLock(address: string, networkClientId: NetworkClientId): Promise<NonceLock>;
+    /**
+     * Updates the editable parameters of a transaction.
+     *
+     * @param txId - The ID of the transaction to update.
+     * @param params - The editable parameters to update.
+     * @param params.containerTypes - Container types applied to the parameters.
+     * @param params.data - Data to pass with the transaction.
+     * @param params.from - Address to send the transaction from.
+     * @param params.gas - Maximum number of units of gas to use for the transaction.
+     * @param params.gasPrice - Price per gas for legacy transactions.
+     * @param params.maxFeePerGas - Maximum amount per gas to pay for the transaction, including the priority fee.
+     * @param params.maxPriorityFeePerGas - Maximum amount per gas to give to validator as incentive.
+     * @param params.updateType - Whether to update the transaction type. Defaults to `true`.
+     * @param params.to - Address to send the transaction to.
+     * @param params.value - Value associated with the transaction.
+     * @returns The updated transaction metadata.
+     */
+    updateEditableParams(txId: string, { containerTypes, data, from, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, to, updateType, value, }: {
+        containerTypes?: TransactionContainerType[];
+        data?: string;
+        from?: string;
+        gas?: string;
+        gasPrice?: string;
+        maxFeePerGas?: string;
+        maxPriorityFeePerGas?: string;
+        to?: string;
+        updateType?: boolean;
+        value?: string;
+    }): Promise<Readonly<TransactionMeta> | undefined>;
+    /**
+     * Update the isActive state of a transaction.
+     *
+     * @param transactionId - The ID of the transaction to update.
+     * @param isActive - The active state.
+     */
+    setTransactionActive(transactionId: string, isActive: boolean): void;
+    /**
+     * Signs and returns the raw transaction data for provided transaction params list.
+     *
+     * @param listOfTxParams - The list of transaction params to approve.
+     * @param opts - Options bag.
+     * @param opts.hasNonce - Whether the transactions already have a nonce.
+     * @returns The raw transactions.
+     */
+    approveTransactionsWithSameNonce(listOfTxParams?: (TransactionParams & {
+        chainId: Hex;
+    })[], { hasNonce }?: {
+        hasNonce?: boolean;
+    }): Promise<string | string[]>;
+    /**
+     * Update a custodial transaction.
+     *
+     * @param request - The custodial transaction update request.
+     *
+     * @returns The updated transaction metadata.
+     */
+    updateCustodialTransaction(request: UpdateCustodialTransactionRequest): TransactionMeta;
+    /**
+     * Search transaction metadata for matching entries.
+     *
+     * @param opts - Options bag.
+     * @param opts.initialList - The transactions to search. Defaults to the current state.
+     * @param opts.limit - The maximum number of transactions to return. No limit by default.
+     * @param opts.searchCriteria - An object containing values or functions for transaction properties to filter transactions with.
+     * @returns An array of transactions matching the provided options.
+     */
+    getTransactions({ initialList, limit, searchCriteria, }?: {
+        initialList?: TransactionMeta[];
+        limit?: number;
+        searchCriteria?: any;
+    }): TransactionMeta[];
+    /**
+     * Estimates the gas fees for a transaction.
+     *
+     * @param args - The arguments for estimating gas fees.
+     * @param args.transactionParams - The transaction parameters to estimate fees for.
+     * @param args.chainId - The chain ID to use. If not provided, the network client ID is used to determine the chain.
+     * @param args.networkClientId - The network client ID to use for the estimation.
+     * @returns A promise that resolves to the estimated gas fee response.
+     */
+    estimateGasFee({ transactionParams, chainId, networkClientId: requestNetworkClientId, }: {
+        transactionParams: TransactionParams;
+        chainId?: Hex;
+        networkClientId?: NetworkClientId;
+    }): Promise<GasFeeFlowResponse>;
+    /**
+     * Determine the layer 1 gas fee for the given transaction parameters.
+     *
+     * @param request - The request object.
+     * @param request.transactionParams - The transaction parameters to estimate the layer 1 gas fee for.
+     * @param request.chainId - The ID of the chain where the transaction will be executed.
+     * @param request.networkClientId - The ID of a specific network client to process the transaction.
+     * @returns The layer 1 gas fee.
+     */
+    getLayer1GasFee({ transactionParams, chainId, networkClientId, }: {
+        transactionParams: TransactionParams;
+        chainId?: Hex;
+        networkClientId?: NetworkClientId;
+    }): Promise<Hex | undefined>;
+    /**
+     * Removes unapproved transactions from state.
+     */
+    clearUnapprovedTransactions(): void;
+    /**
+     * Stop the signing process for a specific transaction.
+     * Throws an error causing the transaction status to be set to failed.
+     *
+     * @param transactionId - The ID of the transaction to stop signing.
+     */
+    abortTransactionSigning(transactionId: string): void;
+    /**
+     * Update the transaction data of a single nested transaction within an atomic batch transaction.
+     *
+     * @param options - The options bag.
+     * @param options.transactionId - ID of the atomic batch transaction.
+     * @param options.transactionIndex - Index of the nested transaction within the atomic batch transaction.
+     * @param options.transactionData - New data to set for the nested transaction.
+     * @returns The updated data for the atomic batch transaction.
+     */
+    updateAtomicBatchData({ transactionId, transactionIndex, transactionData, }: {
+        transactionId: string;
+        transactionIndex: number;
+        transactionData: Hex;
+    }): Promise<Hex>;
+    /**
+     * Update the batch transactions associated with a transaction.
+     * These transactions will be submitted with the main transaction as a batch.
+     *
+     * @param request - The request object.
+     * @param request.transactionId - The ID of the transaction to update.
+     * @param request.batchTransactions - The new batch transactions.
+     */
+    updateBatchTransactions({ transactionId, batchTransactions, }: {
+        transactionId: string;
+        batchTransactions: BatchTransactionParams[];
+    }): void;
+    /**
+     * Update the selected gas fee token for a transaction.
+     *
+     * @param transactionId - The ID of the transaction to update.
+     * @param contractAddress - The contract address of the selected gas fee token.
+     */
+    updateSelectedGasFeeToken(transactionId: string, contractAddress: Hex | undefined): void;
+    /**
+     * Update the required transaction IDs for a transaction.
+     *
+     * @param request - The request object.
+     * @param request.transactionId - The ID of the transaction to update.
+     * @param request.requiredTransactionIds - The additional required transaction IDs.
+     * @param request.append - Whether to append the IDs to any existing values. Defaults to true.
+     */
+    updateRequiredTransactionIds({ transactionId, requiredTransactionIds, append, }: {
+        transactionId: string;
+        requiredTransactionIds: string[];
+        append?: boolean;
+    }): void;
+    /**
+     * Emulate a new transaction.
+     *
+     * @param transactionId - The transaction ID.
+     */
+    emulateNewTransaction(transactionId: string): void;
+    /**
+     * Emulate a transaction update.
+     *
+     * @param transactionMeta - Transaction metadata.
+     */
+    emulateTransactionUpdate(transactionMeta: TransactionMeta): void;
+    /**
+     * Retrieve available gas fee tokens for a transaction.
+     *
+     * @param request - The request object containing transaction details.
+     * @returns The list of available gas fee tokens.
+     */
+    getGasFeeTokens(request: GetGasFeeTokensRequest): Promise<GasFeeToken[]>;
+}
+export {};
+//# sourceMappingURL=TransactionController.d.mts.map