@sidhujag/sysweb3-keyring 2.1.5 → 2.1.6

package/esm/transactions/ethereum.js

@@ -5,10 +5,10 @@ import { accessListify, Transaction } from 'ethers/transaction';
 import { hexlify } from 'ethers/utils';
 import omit from 'lodash/omit';
 import { BigNumber, Contract, Zero, formatEther, formatUnits, isHexString, normalizeTransactionRequest, normalizeTxValue, resolveProperties, serializeTransaction as serializeUncheckedTransaction, } from '../ethers-v6';
-import { assertEvmGasLimit, bufferedEvmGasLimit, EvmGasLimitError, getEvmFeeData, parseEvmFeeQuantity, planEvmCancellationFees, } from '../evm-fees';
+import { assertEvmGasLimit, bufferedEvmGasLimit, EvmGasLimitError, getEvmFeeData, parseEvmFeeQuantity, planEvmCancellationFees, planEvmSpeedUpFees, } from '../evm-fees';
 import { CustomJsonRpcProvider, wrapTransactionResponse } from '../providers';
 import { KeyringAccountType, } from '../types';
-import { assertEvmCancellationEnvelope } from './evm-cancellation';
+import { assertEvmCancellationEnvelope, authenticateRetainedCancellation, } from './evm-cancellation';
 import { deriveEvmAccountFromMnemonic, parsePersonalMessage as parseLocalPersonalMessage, privateKeyToAccount, normalizeGasLimitedTransaction, sendLocalEvmTransaction, signDigestHex, signPersonalMessage as signLocalPersonalMessage, } from './evm-local-signer';
 import { captureEvmSubmission, submitSignedEvmTransaction, submitSignedHardwareEvmTransaction, evmSubmissionFailure, copyEvmSubmissionFailure, } from './evm-submission';
 import { signPreparedEvmEnvelope, snapshotPreparedEvmRequest, } from './prepared-evm';
@@ -196,7 +196,7 @@ export class EthereumTransactions {
                 assertCurrent,
             };
         };
-        this.captureSubmission = (operation, account, type, id, network, assertCurrent, originalHash) => {
+        this.captureSubmission = (operation, account, type, id, network, assertCurrent, details = {}) => {
             if (!this.captureSubmissionLifecycle)
                 throw new TypeError('A durable EVM submission lifecycle is required');
             return captureEvmSubmission({
@@ -208,7 +208,7 @@ export class EthereumTransactions {
                     slip44: network.slip44,
                     url: network.url,
                 },
-                ...(originalHash !== undefined ? { originalHash } : {}),
+                ...details,
             }, assertCurrent, this.captureSubmissionLifecycle);
         };
         this.authorizeHardwareTransaction = async (provider, assertCurrent, signal = this.abortController.signal) => {
@@ -578,7 +578,9 @@ export class EthereumTransactions {
                 typeof approval.assertCurrent !== 'function' ||
                 !(approval.signal instanceof AbortSignal))
                 throw new Error(`${standard} transaction approval required`);
-            const { assertCurrent, signal } = approval;
+            const { assertCurrent, signal, nonce } = approval;
+            if (!Number.isSafeInteger(nonce) || nonce < 0)
+                throw new Error(`Invalid ${standard} transaction approval nonce`);
             const assertApproval = () => {
                 if (signal.aborted)
                     throw Object.assign(new Error(`${standard} transaction approval expired`), {
@@ -587,7 +589,7 @@ export class EthereumTransactions {
                 assertSynchronousOriginalValidation(assertCurrent(), `${standard} transaction approval must be synchronous`);
             };
             assertApproval();
-            return { assertApproval, signal };
+            return { assertApproval, signal, nonce };
         };
         this.reviewedTokenFees = (request, chainId, standard) => {
             const { isLegacy } = request;
@@ -644,7 +646,7 @@ export class EthereumTransactions {
                 maxPriorityFeePerGas: BigNumber.from(fee.maxPriorityFeePerGas),
             };
         };
-        this.calculateNewGasValues = (oldTxsParams, isForCancel, isLegacy) => {
+        this.calculateNewGasValues = (oldTxsParams, isForCancel, isLegacy, bounds) => {
             const newGasValues = {
                 maxFeePerGas: undefined,
                 maxPriorityFeePerGas: undefined,
@@ -652,8 +654,34 @@ export class EthereumTransactions {
                 gasLimit: undefined,
             };
             const { maxFeePerGas, maxPriorityFeePerGas, gasLimit, gasPrice } = oldTxsParams;
+            if (!isForCancel) {
+                const originalGasLimit = parseEvmFeeQuantity(gasLimit, 'replacement gas limit');
+                const plan = isLegacy
+                    ? planEvmSpeedUpFees({
+                        ...bounds,
+                        type: 0,
+                        gasLimit: originalGasLimit,
+                        gasPrice: parseEvmFeeQuantity(gasPrice, 'replacement gas price'),
+                    })
+                    : planEvmSpeedUpFees({
+                        ...bounds,
+                        type: 2,
+                        gasLimit: originalGasLimit,
+                        maxFeePerGas: parseEvmFeeQuantity(maxFeePerGas, 'replacement fee cap'),
+                        maxPriorityFeePerGas: parseEvmFeeQuantity(maxPriorityFeePerGas, 'replacement priority fee'),
+                    });
+                newGasValues.gasLimit = BigNumber.from(plan.gasLimit);
+                if (plan.type === 0)
+                    newGasValues.gasPrice = BigNumber.from(plan.gasPrice);
+                else {
+                    newGasValues.maxFeePerGas = BigNumber.from(plan.maxFeePerGas);
+                    newGasValues.maxPriorityFeePerGas = BigNumber.from(plan.maxPriorityFeePerGas);
+                }
+                return newGasValues;
+            }
+            // Keep the legacy direct cancellation helper. The guarded cancellation
+            // transaction path already uses planEvmCancellationFees.
             const calculateAndConvertNewValue = (feeValue) => {
-                // Apply multiplier for replacement transaction (cancel or speedup)
                 const newValue = feeValue * multiplierToUse;
                 const calculateValue = String(newValue);
                 const convertValueToHex = '0x' + parseInt(calculateValue, 10).toString(16);
@@ -661,7 +689,6 @@ export class EthereumTransactions {
             };
             const maxFeePerGasToNumber = maxFeePerGas?.toNumber();
             const maxPriorityFeePerGasToNumber = maxPriorityFeePerGas?.toNumber();
-            const gasLimitToNumber = gasLimit?.toNumber();
             const gasPriceToNumber = gasPrice?.toNumber();
             const multiplierToUse = 1.2; //The same calculation we used in the edit fee modal, always using the 0.2 multiplier
             if (!isLegacy) {
@@ -672,14 +699,8 @@ export class EthereumTransactions {
             if (isLegacy) {
                 newGasValues.gasPrice = calculateAndConvertNewValue(gasPriceToNumber);
             }
-            if (isForCancel) {
-                const DEFAULT_GAS_LIMIT_VALUE = '42000';
-                const convertToHex = '0x' + parseInt(DEFAULT_GAS_LIMIT_VALUE, 10).toString(16);
-                newGasValues.gasLimit = BigNumber.from(convertToHex);
-            }
-            if (!isForCancel) {
-                newGasValues.gasLimit = calculateAndConvertNewValue(gasLimitToNumber);
-            }
+            newGasValues.gasLimit = BigNumber.from(42000);
+            assertEvmGasLimit(newGasValues.gasLimit.toBigInt(), bounds.chainId, bounds.sampledBlockGasLimit);
             return newGasValues;
         };
         this.cancelSentTransaction = async (txHash, isLegacy, fallbackNonce, options) => {
@@ -688,8 +709,13 @@ export class EthereumTransactions {
             if (typeof options?.assertCurrentContext !== 'function') {
                 throw new Error('Cancellation context required');
             }
-            if (typeof options.validateOriginal !== 'function') {
-                throw new Error('Cancellation original validator required');
+            const { assertCurrentContext, validateOriginal, origin } = options;
+            if (origin === undefined) {
+                if (typeof validateOriginal !== 'function')
+                    throw new Error('Cancellation original validator required');
+            }
+            else if (validateOriginal !== undefined || fallbackNonce !== undefined) {
+                throw new Error('Retained cancellation cannot use RPC fallback');
             }
             if (fallbackNonce !== undefined &&
                 (!Number.isSafeInteger(fallbackNonce) || fallbackNonce < 0)) {
@@ -702,7 +728,6 @@ export class EthereumTransactions {
                     !/^(0|[1-9][0-9]{0,77})$/.test(approvedMaximumFee))) {
                 throw new Error('Cancellation fee approval required');
             }
-            const { assertCurrentContext, validateOriginal } = options;
             const assertHostContext = () => assertSynchronousOriginalValidation(assertCurrentContext(), 'Transaction context guard must be synchronous');
             assertHostContext();
             const state = this.getState();
@@ -747,9 +772,22 @@ export class EthereumTransactions {
                 assertKeyringContext();
             };
             assertSigningCurrent();
+            const retained = origin === undefined
+                ? undefined
+                : authenticateRetainedCancellation(origin, txHash.toLowerCase(), activeAccount.address, activeNetwork.chainId);
+            if (retained) {
+                const legacy = retained.feeFloor.type === 0;
+                if (activeNetwork.kind !== INetworkType.Ethereum ||
+                    (isLegacy !== undefined && isLegacy !== legacy))
+                    throw new Error('Retained cancellation network or type changed');
+                isLegacy = legacy;
+            }
             const submission = previewOnly
                 ? undefined
-                : this.captureSubmission('cancel', activeAccount, activeAccountType, activeAccountId, activeNetwork, assertSigningCurrent, txHash);
+                : this.captureSubmission('cancel', activeAccount, activeAccountType, activeAccountId, activeNetwork, assertSigningCurrent, {
+                    originalHash: retained ? txHash.toLowerCase() : txHash,
+                    origin: retained,
+                });
             const assertCurrent = submission?.assertCurrent ?? assertSigningCurrent;
             const currentEip1559Fees = async () => {
                 const feeData = await this.getFeeDataWithDynamicMaxPriorityFeePerGas(provider);
@@ -761,64 +799,53 @@ export class EthereumTransactions {
                 }
                 return { maxFeePerGas, maxPriorityFeePerGas };
             };
-            const response = await provider.getTransaction(txHash);
-            assertCurrent();
-            if (response?.blockNumber != null || response?.blockHash != null) {
-                throw new Error('Original transaction is already mined');
-            }
-            let tx = response === null
-                ? null
-                : authenticateReplacementOriginal(response, txHash.toLowerCase(), activeAccount.address.toLowerCase(), activeNetwork.chainId);
-            const software = activeAccountType !== KeyringAccountType.Ledger &&
-                activeAccountType !== KeyringAccountType.Trezor;
-            const softwareNonce = software ? tx?.nonce ?? fallbackNonce : undefined;
-            // The host validator may retain the wrapped response and its fee objects.
-            const softwareOriginalFees = software && tx
-                ? {
-                    gasPrice: tx.gasPrice.toBigInt(),
-                    maxFeePerGas: tx.maxFeePerGas.toBigInt(),
-                    maxPriorityFeePerGas: tx.maxPriorityFeePerGas.toBigInt(),
-                }
-                : undefined;
-            assertSynchronousOriginalValidation(validateOriginal(tx));
-            assertCurrent();
-            // If transaction not found, create a minimal tx object with current gas prices
-            // This handles cases where tx with 0 gas never made it to the mempool
-            if (!tx && fallbackNonce !== undefined) {
-                // Fetch current network gas prices for the cancellation
-                if (isLegacy) {
-                    const currentGasPrice = nonNegativeFeeQuantity(await provider.getGasPrice(), 'cancellation gas price');
-                    assertCurrent();
-                    tx = {
-                        from: activeAccount.address,
-                        to: activeAccount.address,
-                        value: Zero,
-                        nonce: fallbackNonce,
-                        gasPrice: currentGasPrice,
-                        data: '0x',
-                    };
+            let cancellationNonce;
+            let originalFees;
+            if (retained) {
+                cancellationNonce = retained.nonce;
+                originalFees = retained.feeFloor;
+            }
+            else {
+                const response = await provider.getTransaction(txHash);
+                assertCurrent();
+                if (response?.blockNumber != null || response?.blockHash != null) {
+                    throw new Error('Original transaction is already mined');
+                }
+                const tx = response === null
+                    ? null
+                    : authenticateReplacementOriginal(response, txHash.toLowerCase(), activeAccount.address.toLowerCase(), activeNetwork.chainId);
+                const software = activeAccountType !== KeyringAccountType.Ledger &&
+                    activeAccountType !== KeyringAccountType.Trezor;
+                // The host validator may retain the wrapped response and its fee objects.
+                const softwareNonce = software ? tx?.nonce ?? fallbackNonce : undefined;
+                const softwareOriginalFees = software && tx
+                    ? {
+                        gasPrice: tx.gasPrice.toBigInt(),
+                        maxFeePerGas: tx.maxFeePerGas.toBigInt(),
+                        maxPriorityFeePerGas: tx.maxPriorityFeePerGas.toBigInt(),
+                    }
+                    : undefined;
+                assertSynchronousOriginalValidation(validateOriginal(tx));
+                assertCurrent();
+                if (tx) {
+                    cancellationNonce = software ? softwareNonce : tx.nonce;
+                    originalFees = softwareOriginalFees ?? tx;
                 }
                 else {
-                    const feeData = await currentEip1559Fees();
-                    tx = {
-                        from: activeAccount.address,
-                        to: activeAccount.address,
-                        value: Zero,
-                        nonce: fallbackNonce,
-                        maxFeePerGas: feeData.maxFeePerGas,
-                        maxPriorityFeePerGas: feeData.maxPriorityFeePerGas,
-                        data: '0x',
-                    };
+                    if (fallbackNonce === undefined)
+                        return { isCanceled: false, error: true };
+                    cancellationNonce = fallbackNonce;
+                    // Preserve the ordinary host's explicitly admitted missing-RPC path.
+                    if (isLegacy) {
+                        const gasPrice = nonNegativeFeeQuantity(await provider.getGasPrice(), 'cancellation gas price');
+                        assertCurrent();
+                        originalFees = { gasPrice };
+                    }
+                    else
+                        originalFees = await currentEip1559Fees();
                 }
             }
-            else if (!tx) {
-                // No fallback nonce provided and tx not found
-                return {
-                    isCanceled: false,
-                    error: true,
-                };
-            }
-            const { gasPrice: originalGasPrice, maxFeePerGas: originalMaxFeePerGas, maxPriorityFeePerGas: originalMaxPriorityFeePerGas, } = softwareOriginalFees ?? tx;
+            const { gasPrice: originalGasPrice, maxFeePerGas: originalMaxFeePerGas, maxPriorityFeePerGas: originalMaxPriorityFeePerGas, } = originalFees;
             let feePlan;
             if (isLegacy) {
                 const currentGasPrice = parseEvmFeeQuantity(await provider.getGasPrice(), 'cancellation gas price');
@@ -855,6 +882,16 @@ export class EthereumTransactions {
                 };
             if (maximumFee.gt(approvedMaximumFee))
                 throw new Error('Cancellation fee exceeds approval');
+            const assertCancellationEnvelope = (unsigned) => {
+                if (cancellationNonce === undefined)
+                    throw new Error('Cancellation nonce required');
+                assertEvmCancellationEnvelope(unsigned, {
+                    payer: activeAccount.address,
+                    chainId: activeNetwork.chainId,
+                    nonce: cancellationNonce,
+                    feePlan,
+                });
+            };
             const assertApprovedEnvelope = (transaction) => {
                 const gas = nonNegativeFeeQuantity(transaction.gasLimit, 'cancellation gas limit');
                 const cap = nonNegativeFeeQuantity(isLegacy ? transaction.gasPrice : transaction.maxFeePerGas, 'cancellation maximum fee');
@@ -863,7 +900,7 @@ export class EthereumTransactions {
             };
             // Base cancel transaction parameters (same for all wallet types)
             const baseCancelTx = {
-                nonce: software ? softwareNonce : tx.nonce,
+                nonce: cancellationNonce,
                 from: activeAccount.address,
                 to: activeAccount.address,
                 value: Zero,
@@ -889,7 +926,7 @@ export class EthereumTransactions {
                     assertCurrent();
                     const formatParams = {
                         ...resolvedParams,
-                        nonce: resolvedParams.nonce
+                        nonce: resolvedParams.nonce != null
                             ? Number(resolvedParams.nonce.toString())
                             : undefined,
                     };
@@ -906,6 +943,8 @@ export class EthereumTransactions {
                         };
                     assertApprovedEnvelope(txFormattedForEthers);
                     const rawTx = serializeTransaction(txFormattedForEthers);
+                    if (retained)
+                        assertCancellationEnvelope(rawTx);
                     const signature = await this.requireLedgerSigner().evm.signEVMTransaction({
                         rawTx: rawTx.replace('0x', ''),
                         accountIndex: activeAccountId,
@@ -921,7 +960,7 @@ export class EthereumTransactions {
                         const signedTx = serializeTransaction(txFormattedForEthers, formattedSignature);
                         assertCurrent();
                         assertHardwareTransactionSender(signedTx, activeAccount.address);
-                        const transactionResponse = await this.submitSignedHardwareTransaction(provider, signedTx, (raw) => provider.sendTransaction(raw), submission, undefined, rawTx);
+                        const transactionResponse = await this.submitSignedHardwareTransaction(provider, signedTx, ({ rawTransaction, admit }) => admit(() => provider.sendTransaction(rawTransaction)), submission, undefined, rawTx);
                         return {
                             isCanceled: true,
                             transaction: transactionResponse,
@@ -978,6 +1017,8 @@ export class EthereumTransactions {
                     assertApprovedEnvelope(txFormattedForTrezor);
                     assertTransactionGasLimit(txFormattedForTrezor);
                     const expectedUnsignedTransaction = serializeTransaction(txFormattedForTrezor);
+                    if (retained)
+                        assertCancellationEnvelope(expectedUnsignedTransaction);
                     const signature = await this.requireTrezorSigner().signEthTransaction({
                         coin: trezorCoin,
                         tx: txFormattedForTrezor,
@@ -989,7 +1030,7 @@ export class EthereumTransactions {
                         const signedTx = serializeTransaction(txFormattedForTrezor, trezorSignature(signature.payload));
                         assertCurrent();
                         assertHardwareTransactionSender(signedTx, activeAccount.address);
-                        const transactionResponse = await this.submitSignedHardwareTransaction(provider, signedTx, (raw) => provider.sendTransaction(raw), submission, undefined, expectedUnsignedTransaction);
+                        const transactionResponse = await this.submitSignedHardwareTransaction(provider, signedTx, ({ rawTransaction, admit }) => admit(() => provider.sendTransaction(rawTransaction)), submission, undefined, expectedUnsignedTransaction);
                         return {
                             isCanceled: true,
                             transaction: transactionResponse,
@@ -1020,12 +1061,7 @@ export class EthereumTransactions {
                     }
                     const transactionResponse = await sendLocalEvmTransaction(provider, decryptedPrivateKey, changedTxToCancel, assertCurrent, assertCurrent, (transaction) => {
                         assertApprovedEnvelope(transaction);
-                        assertEvmCancellationEnvelope(serializeTransaction(transaction), {
-                            payer: activeAccount.address,
-                            chainId: activeNetwork.chainId,
-                            nonce: softwareNonce,
-                            feePlan,
-                        });
+                        assertCancellationEnvelope(serializeTransaction(transaction));
                     }, submission);
                     if (transactionResponse) {
                         return {
@@ -1071,7 +1107,8 @@ export class EthereumTransactions {
                     throw new Error('Explicit transaction approval is required');
                 // Capture once; later caller mutations cannot replace this invocation's
                 // admission decision while chain checks or device approval are pending.
-                const { assertCurrent: assertHostCurrent, mode } = options;
+                const { assertCurrent: assertHostCurrent, mode, walletNonce } = options;
+                const nonceApproval = walletNonce === undefined ? undefined : { ...walletNonce };
                 const assertApproved = () => {
                     const result = assertHostCurrent();
                     if (result !== undefined) {
@@ -1082,7 +1119,7 @@ export class EthereumTransactions {
                 assertApproved();
                 return await this.sendFormattedTransactionInternal(params, isLegacy, () => {
                     broadcastAttempted = true;
-                }, assertApproved, mode);
+                }, assertApproved, mode, nonceApproval);
             }
             catch (error) {
                 // A broadcast transport error may mean the node accepted the signed
@@ -1099,7 +1136,7 @@ export class EthereumTransactions {
                 throw submissionError;
             }
         };
-        this.sendFormattedTransactionInternal = async (input, isLegacy, beforeBroadcast, assertHostCurrent, mode) => {
+        this.sendFormattedTransactionInternal = async (input, isLegacy, beforeBroadcast, assertHostCurrent, mode, walletNonce) => {
             // Hardware approval may outlive the selected account, network or unlocked
             // session. Keep immutable identities and one provider for this invocation.
             const { activeAccount, activeAccountType, activeAccountId, activeNetwork, provider, assertCurrent: assertKeyringCurrent, } = this.captureEvmSigningContext();
@@ -1111,8 +1148,13 @@ export class EthereumTransactions {
                 assertCurrent();
                 beforeBroadcast();
             };
-            const submission = this.captureSubmission('send', activeAccount, activeAccountType, activeAccountId, activeNetwork, assertSigningCurrent);
+            const submission = this.captureSubmission('send', activeAccount, activeAccountType, activeAccountId, activeNetwork, assertSigningCurrent, { walletNonce });
             const assertCurrent = submission.assertCurrent;
+            const approvedNonce = submission.context.walletNonce?.nonce;
+            const assertApprovedNonce = (nonce) => {
+                if (approvedNonce !== undefined && nonce !== approvedNonce)
+                    throw new Error('EVM transaction nonce does not match wallet approval');
+            };
             if (mode === 'reviewed-native') {
                 const { transaction } = snapshotPreparedEvmRequest({
                     account: {
@@ -1128,6 +1170,7 @@ export class EthereumTransactions {
                     },
                     transaction: input,
                 });
+                assertApprovedNonce(Number(transaction.nonce));
                 const minimum = this.gasOverrides.minGasLimit;
                 if (transaction.data !== '0x' ||
                     BigInt(transaction.value) === 0n ||
@@ -1146,7 +1189,7 @@ export class EthereumTransactions {
                     throw new Error('Reviewed native signer does not match the approved account');
                 assertCurrent();
                 const { signed, expectedUnsigned } = signPreparedEvmEnvelope(transaction, decryptedPrivateKey);
-                return submitSignedEvmTransaction(signed.rawTransaction, (raw) => provider.sendTransaction(raw), submission, assertBeforeBroadcast, expectedUnsigned);
+                return submitSignedEvmTransaction(signed.rawTransaction, ({ rawTransaction, admit }) => admit(() => provider.sendTransaction(rawTransaction)), submission, assertBeforeBroadcast, expectedUnsigned);
             }
             // Detach supplied values before any RPC/device await. Autofill updates only
             // this invocation; caller mutations cannot replace already supplied fields.
@@ -1181,6 +1224,7 @@ export class EthereumTransactions {
                 supplied.data = hexlify(supplied.data);
             if (supplied.accessList != null)
                 supplied.accessList = accessListify(supplied.accessList);
+            assertApprovedNonce(supplied.nonce);
             params = supplied;
             assertCurrent();
             // Capture the reviewed nonce before any fee/RPC await. Hardware and the
@@ -1302,7 +1346,7 @@ export class EthereumTransactions {
                     try {
                         const signedTx = serializeTransaction(txFormattedForEthers, formattedSignature);
                         assertHardwareTransactionSender(signedTx, activeAccount.address);
-                        const finalTx = await this.submitSignedHardwareTransaction(provider, signedTx, (raw) => provider.sendTransaction(raw), submission, assertBeforeBroadcast, rawTx);
+                        const finalTx = await this.submitSignedHardwareTransaction(provider, signedTx, ({ rawTransaction, admit }) => admit(() => provider.sendTransaction(rawTransaction)), submission, assertBeforeBroadcast, rawTx);
                         return finalTx;
                     }
                     catch (error) {
@@ -1392,7 +1436,7 @@ export class EthereumTransactions {
                             };
                         const signedTx = serializeTransaction(txFormattedForEthers, trezorSignature(signature.payload));
                         assertHardwareTransactionSender(signedTx, activeAccount.address);
-                        const finalTx = await this.submitSignedHardwareTransaction(provider, signedTx, (raw) => provider.sendTransaction(raw), submission, assertBeforeBroadcast, expectedUnsignedTransaction);
+                        const finalTx = await this.submitSignedHardwareTransaction(provider, signedTx, ({ rawTransaction, admit }) => admit(() => provider.sendTransaction(rawTransaction)), submission, assertBeforeBroadcast, expectedUnsignedTransaction);
                         return finalTx;
                     }
                     catch (error) {
@@ -1447,7 +1491,7 @@ export class EthereumTransactions {
                 throw new Error('Replacement context required');
             if (typeof options.validateOriginal !== 'function')
                 throw new Error('Replacement original validator required');
-            const { assertCurrentContext, validateOriginal, beforeBroadcast } = options;
+            const { assertCurrentContext, validateOriginal, beforeBroadcast, retainedCancellation, } = options;
             if (!previewOnly)
                 this.assertHardwareSignerAvailable(options.targetAccount);
             isLegacy ?? (isLegacy = false);
@@ -1488,9 +1532,27 @@ export class EthereumTransactions {
             const requestedHash = txHash.toLowerCase();
             const provider = this.web3Provider;
             assertSigningCurrent();
+            let cancellation;
+            if (retainedCancellation !== undefined) {
+                if (typeof retainedCancellation !== 'string' ||
+                    retainedCancellation.length > 1024)
+                    throw new Error('Invalid retained cancellation');
+                cancellation = Transaction.from(retainedCancellation);
+                if (!cancellation.isSigned() ||
+                    cancellation.serialized !== retainedCancellation ||
+                    cancellation.hash !== requestedHash ||
+                    cancellation.chainId !== BigInt(activeNetwork.chainId) ||
+                    cancellation.from?.toLowerCase() !== expectedSender ||
+                    cancellation.to?.toLowerCase() !== expectedSender ||
+                    cancellation.value !== 0n ||
+                    cancellation.data !== '0x' ||
+                    cancellation.accessList?.length ||
+                    (cancellation.type !== 0 && cancellation.type !== 2))
+                    throw new Error('Invalid retained cancellation');
+            }
             const submission = previewOnly
                 ? undefined
-                : this.captureSubmission('speed-up', activeAccount, activeAccountType, activeAccountId, activeNetwork, assertSigningCurrent, txHash);
+                : this.captureSubmission('speed-up', activeAccount, activeAccountType, activeAccountId, activeNetwork, assertSigningCurrent, { originalHash: txHash });
             const assertCurrent = submission?.assertCurrent ?? assertSigningCurrent;
             const validateLookup = (transaction) => {
                 assertCurrent();
@@ -1498,6 +1560,10 @@ export class EthereumTransactions {
                     return null;
                 const authenticated = authenticateReplacementOriginal(transaction, requestedHash, expectedSender, activeNetwork.chainId);
                 const type = authenticated.type;
+                if (cancellation &&
+                    (type !== cancellation.type ||
+                        parseEvmFeeQuantity(authenticated.gasLimit, 'retained cancellation gas limit') !== cancellation.gasLimit))
+                    throw new Error('Retained cancellation does not match original');
                 if (type !== 1)
                     isLegacy = type === 0;
                 if (isLegacy &&
@@ -1526,9 +1592,20 @@ export class EthereumTransactions {
                     };
                 }
             }
-            // Check if this might be a max send transaction by comparing total cost to balance
             const currentBalance = await provider.getBalance(activeAccount.address);
             assertCurrent();
+            const sampledBlock = await provider.getBlock('latest');
+            assertCurrent();
+            const bounds = Object.freeze({
+                chainId: BigInt(activeNetwork.chainId),
+                ...(cancellation
+                    ? { retainedCancellationGasLimit: cancellation.gasLimit }
+                    : {}),
+                sampledBlockGasLimit: parseEvmFeeQuantity(sampledBlock?.gasLimit, 'replacement block gas limit'),
+                sampledBaseFeePerGas: sampledBlock?.baseFeePerGas == null
+                    ? null
+                    : parseEvmFeeQuantity(sampledBlock.baseFeePerGas, 'replacement base fee'),
+            });
             // Ensure all transaction values are resolved from promises
             const gasLimit = await Promise.resolve(tx.gasLimit);
             const gasPrice = await Promise.resolve(tx.gasPrice || 0);
@@ -1537,15 +1614,6 @@ export class EthereumTransactions {
             const txValue = await Promise.resolve(tx.value);
             const txData = await Promise.resolve(tx.data || '0x');
             assertCurrent();
-            // Check if this is a contract call (has data)
-            const isContractCall = txData && txData !== '0x' && txData.length > 2;
-            const originalGasCost = isLegacy
-                ? gasLimit.mul(gasPrice || 0)
-                : gasLimit.mul(maxFeePerGas || 0);
-            const originalTotalCost = txValue.add(originalGasCost);
-            // If original transaction used >95% of balance, it's likely a max send
-            const balanceThreshold = currentBalance.mul(95).div(100);
-            const isLikelyMaxSend = originalTotalCost.gt(balanceThreshold);
             const oldTxsGasValues = {
                 maxFeePerGas: maxFeePerGas,
                 maxPriorityFeePerGas: maxPriorityFeePerGas,
@@ -1559,26 +1627,33 @@ export class EthereumTransactions {
                 assertCurrent();
             }
             else if (!isLegacy && oldTxsGasValues.maxFeePerGas.isZero()) {
-                const feeData = await this.getFeeDataWithDynamicMaxPriorityFeePerGas(provider);
+                const feeData = await this.getFeeDataWithDynamicMaxPriorityFeePerGas({
+                    getGasPrice: () => provider.getGasPrice(),
+                    getBlock: async () => sampledBlock,
+                    send: (method, params) => provider.send(method, params),
+                });
                 assertCurrent();
                 oldTxsGasValues.maxFeePerGas = BigNumber.from(feeData.maxFeePerGas || 0);
                 oldTxsGasValues.maxPriorityFeePerGas = BigNumber.from(feeData.maxPriorityFeePerGas || 0);
             }
-            const newGasValues = this.calculateNewGasValues(oldTxsGasValues, false, isLegacy);
+            const newGasValues = this.calculateNewGasValues(oldTxsGasValues, false, isLegacy, bounds);
             if (!newGasValues.gasLimit.gt(0))
                 throw new Error('Invalid replacement gas limit');
+            assertTransactionGasLimit({
+                gasLimit: newGasValues.gasLimit,
+                chainId: activeNetwork.chainId,
+            });
             if (!isLegacy &&
                 newGasValues.maxPriorityFeePerGas.gt(newGasValues.maxFeePerGas))
                 throw new Error('Invalid replacement fee');
             const maximumFee = newGasValues.gasLimit.mul(isLegacy ? newGasValues.gasPrice : newGasValues.maxFeePerGas);
-            if (isLikelyMaxSend && txValue.add(maximumFee).gt(currentBalance)) {
-                if (isContractCall) {
-                    console.error('[SpeedUp] Cannot adjust value for contract call - rejecting speedup');
+            if (txValue.add(maximumFee).gt(currentBalance)) {
+                if (txData.length > 2) {
                     return {
                         isSpeedUp: false,
                         error: true,
                         code: 'CONTRACT_CALL_MAX_SEND',
-                        message: 'Cannot speed up a likely max-send contract call; value cannot be adjusted to fit new gas',
+                        message: 'Add funds before speeding up this contract call; the original amount will not be changed',
                     };
                 }
                 return {
@@ -1645,7 +1720,7 @@ export class EthereumTransactions {
                         const signedTx = serializeTransaction(txFormattedForEthers, formattedSignature);
                         assertSignedSender(signedTx);
                         assertHardwareTransactionSender(signedTx, activeAccount.address);
-                        const transactionResponse = await this.submitSignedHardwareTransaction(provider, signedTx, (raw) => provider.sendTransaction(raw), submission, assertBeforeBroadcast, rawTx);
+                        const transactionResponse = await this.submitSignedHardwareTransaction(provider, signedTx, ({ rawTransaction, admit }) => admit(() => provider.sendTransaction(rawTransaction)), submission, assertBeforeBroadcast, rawTx);
                         return {
                             isSpeedUp: true,
                             transaction: transactionResponse,
@@ -1726,7 +1801,7 @@ export class EthereumTransactions {
                         const signedTx = serializeTransaction(txFormattedForTrezor, trezorSignature(signature.payload));
                         assertSignedSender(signedTx);
                         assertHardwareTransactionSender(signedTx, activeAccount.address);
-                        const transactionResponse = await this.submitSignedHardwareTransaction(provider, signedTx, (raw) => provider.sendTransaction(raw), submission, assertBeforeBroadcast, expectedUnsignedTransaction);
+                        const transactionResponse = await this.submitSignedHardwareTransaction(provider, signedTx, ({ rawTransaction, admit }) => admit(() => provider.sendTransaction(rawTransaction)), submission, assertBeforeBroadcast, expectedUnsignedTransaction);
                         return {
                             isSpeedUp: true,
                             transaction: transactionResponse,
@@ -1812,7 +1887,7 @@ export class EthereumTransactions {
             }
         };
         this.sendSignedErc20Transaction = async (request, approval) => {
-            const { assertApproval, signal } = this.captureReviewedTokenApproval(approval, 'ERC20');
+            const { assertApproval, signal, nonce } = this.captureReviewedTokenApproval(approval, 'ERC20');
             const { receiver, tokenAddress, tokenAmountUnits, saveTrezorTx, networkUrl, } = request;
             const { activeAccount, activeAccountType, activeAccountId, activeNetwork, provider, assertCurrent: assertSigningCurrent, } = this.captureEvmSigningContext();
             const activeAccountAddress = activeAccount.address;
@@ -1829,7 +1904,7 @@ export class EthereumTransactions {
             const submission = this.captureSubmission('erc20', activeAccount, activeAccountType, activeAccountId, activeNetwork, () => {
                 assertApproval();
                 assertSigningCurrent();
-            });
+            }, { walletNonce: { nonce, source: 'automatic' } });
             const assertCurrent = submission.assertCurrent;
             const sendERC20Token = async () => {
                 assertCurrent();
@@ -1839,7 +1914,6 @@ export class EthereumTransactions {
                     let transferMethod;
                     if (isLegacy) {
                         const overrides = {
-                            nonce: await provider.getTransactionCount(activeAccountAddress, 'pending'),
                             gasPrice,
                             gasLimit,
                             type: 0, // Explicitly set Type 0 for legacy token transfers
@@ -1849,7 +1923,6 @@ export class EthereumTransactions {
                     }
                     else {
                         const overrides = {
-                            nonce: await provider.getTransactionCount(activeAccountAddress, 'pending'),
                             maxPriorityFeePerGas,
                             maxFeePerGas,
                             gasLimit,
@@ -1859,6 +1932,7 @@ export class EthereumTransactions {
                     }
                     return await sendLocalEvmTransaction(provider, decryptedPrivateKey, {
                         ...transferMethod,
+                        nonce,
                         chainId: activeNetwork.chainId,
                         from: activeAccountAddress,
                         value: '0x0',
@@ -1869,8 +1943,6 @@ export class EthereumTransactions {
                 }
             };
             const sendERC20TokenOnLedger = async () => {
-                assertCurrent();
-                const transactionNonce = await provider.getTransactionCount(activeAccountAddress, 'pending');
                 assertCurrent();
                 try {
                     const _contract = new Contract(tokenAddress, getErc20Abi(), provider);
@@ -1886,7 +1958,7 @@ export class EthereumTransactions {
                             gasLimit: gasLimit,
                             gasPrice,
                             data: txData,
-                            nonce: transactionNonce,
+                            nonce,
                             chainId: activeNetwork.chainId,
                             type: 0,
                         };
@@ -1899,7 +1971,7 @@ export class EthereumTransactions {
                             maxFeePerGas,
                             maxPriorityFeePerGas,
                             data: txData,
-                            nonce: transactionNonce,
+                            nonce,
                             chainId: activeNetwork.chainId,
                             type: 2, // Need explicit type for hardware wallet serialization
                         };
@@ -1921,8 +1993,8 @@ export class EthereumTransactions {
                             const signedTx = serializeTransaction(txFormattedForEthers, formattedSignature);
                             assertCurrent();
                             assertHardwareTransactionSender(signedTx, activeAccount.address);
-                            const finalTx = await this.submitSignedHardwareTransaction(provider, signedTx, async (raw) => {
-                                const response = await provider.sendTransaction(raw);
+                            const finalTx = await this.submitSignedHardwareTransaction(provider, signedTx, async ({ rawTransaction, admit }) => {
+                                const response = await admit(() => provider.sendTransaction(rawTransaction));
                                 saveTrezorTx && saveTrezorTx(response);
                                 return response;
                             }, submission, undefined, rawTx);
@@ -1941,8 +2013,6 @@ export class EthereumTransactions {
                 }
             };
             const sendERC20TokenOnTrezor = async () => {
-                assertCurrent();
-                const transactionNonce = await provider.getTransactionCount(activeAccountAddress, 'pending');
                 assertCurrent();
                 try {
                     const _contract = new Contract(tokenAddress, getErc20Abi(), provider);
@@ -1957,7 +2027,7 @@ export class EthereumTransactions {
                             value: '0x0',
                             gasLimit: this.toHex0x(gasLimit, 'gasLimit'),
                             gasPrice: this.toHex0x(gasPrice, 'gasPrice'),
-                            nonce: this.toBigNumber(transactionNonce)._hex,
+                            nonce: this.toBigNumber(nonce)._hex,
                             chainId: activeNetwork.chainId,
                             data: txData,
                         };
@@ -1969,7 +2039,7 @@ export class EthereumTransactions {
                             gasLimit: this.toHex0x(gasLimit, 'gasLimit'),
                             maxFeePerGas: this.toHex0x(maxFeePerGas, 'maxFeePerGas'),
                             maxPriorityFeePerGas: this.toHex0x(maxPriorityFeePerGas, 'maxPriorityFeePerGas'),
-                            nonce: this.toBigNumber(transactionNonce)._hex,
+                            nonce: this.toBigNumber(nonce)._hex,
                             chainId: activeNetwork.chainId,
                             data: txData,
                         };
@@ -1996,7 +2066,7 @@ export class EthereumTransactions {
                                     gasLimit: gasLimit,
                                     gasPrice,
                                     data: txData,
-                                    nonce: transactionNonce,
+                                    nonce,
                                     chainId: activeNetwork.chainId,
                                     type: 0,
                                 };
@@ -2009,7 +2079,7 @@ export class EthereumTransactions {
                                     maxFeePerGas,
                                     maxPriorityFeePerGas,
                                     data: txData,
-                                    nonce: transactionNonce,
+                                    nonce,
                                     chainId: activeNetwork.chainId,
                                     type: 2, // Need explicit type for hardware wallet serialization
                                 };
@@ -2017,8 +2087,8 @@ export class EthereumTransactions {
                             const signedTx = serializeTransaction(txFormattedForEthers, trezorSignature(signature.payload));
                             assertCurrent();
                             assertHardwareTransactionSender(signedTx, activeAccount.address);
-                            const finalTx = await this.submitSignedHardwareTransaction(provider, signedTx, async (raw) => {
-                                const response = await provider.sendTransaction(raw);
+                            const finalTx = await this.submitSignedHardwareTransaction(provider, signedTx, async ({ rawTransaction, admit }) => {
+                                const response = await admit(() => provider.sendTransaction(rawTransaction));
                                 saveTrezorTx && saveTrezorTx(response);
                                 return response;
                             }, submission, undefined, expectedUnsignedTransaction);
@@ -2046,7 +2116,7 @@ export class EthereumTransactions {
             }
         };
         this.sendSignedErc721Transaction = async (request, approval) => {
-            const { assertApproval, signal } = this.captureReviewedTokenApproval(approval, 'ERC721');
+            const { assertApproval, signal, nonce } = this.captureReviewedTokenApproval(approval, 'ERC721');
             const { receiver, tokenAddress, tokenId, networkUrl } = request;
             const { activeAccount, activeAccountType, activeAccountId, activeNetwork, provider, assertCurrent: assertSigningCurrent, } = this.captureEvmSigningContext();
             if (networkUrl !== activeNetwork.url)
@@ -2063,7 +2133,7 @@ export class EthereumTransactions {
             const submission = this.captureSubmission('erc721', activeAccount, activeAccountType, activeAccountId, activeNetwork, () => {
                 assertApproval();
                 assertSigningCurrent();
-            });
+            }, { walletNonce: { nonce, source: 'automatic' } });
             const assertCurrent = submission.assertCurrent;
             const sendERC721Token = async () => {
                 assertCurrent();
@@ -2073,7 +2143,6 @@ export class EthereumTransactions {
                     const _contract = new Contract(tokenAddress, getErc21Abi(), provider);
                     if (isLegacy) {
                         const overrides = {
-                            nonce: await provider.getTransactionCount(activeAccountAddress, 'pending'),
                             gasPrice,
                             gasLimit,
                             type: 0, // Explicitly set Type 0 for legacy NFT transfers
@@ -2082,7 +2151,6 @@ export class EthereumTransactions {
                     }
                     else {
                         const overrides = {
-                            nonce: await provider.getTransactionCount(activeAccountAddress, 'pending'),
                             maxPriorityFeePerGas,
                             maxFeePerGas,
                             gasLimit,
@@ -2091,6 +2159,7 @@ export class EthereumTransactions {
                     }
                     return await sendLocalEvmTransaction(provider, decryptedPrivateKey, {
                         ...transferMethod,
+                        nonce,
                         chainId: activeNetwork.chainId,
                         from: activeAccountAddress,
                         value: '0x0',
@@ -2101,8 +2170,6 @@ export class EthereumTransactions {
                 }
             };
             const sendERC721TokenOnLedger = async () => {
-                assertCurrent();
-                const transactionNonce = await provider.getTransactionCount(activeAccountAddress, 'pending');
                 assertCurrent();
                 try {
                     const _contract = new Contract(tokenAddress, getErc21Abi(), provider);
@@ -2119,7 +2186,7 @@ export class EthereumTransactions {
                             gasLimit,
                             gasPrice,
                             data: txData,
-                            nonce: transactionNonce,
+                            nonce,
                             chainId: activeNetwork.chainId,
                             type: 0,
                         };
@@ -2132,7 +2199,7 @@ export class EthereumTransactions {
                             maxFeePerGas,
                             maxPriorityFeePerGas,
                             data: txData,
-                            nonce: transactionNonce,
+                            nonce,
                             chainId: activeNetwork.chainId,
                             type: 2, // Need explicit type for hardware wallet serialization
                         };
@@ -2154,7 +2221,7 @@ export class EthereumTransactions {
                             const signedTx = serializeTransaction(txFormattedForEthers, formattedSignature);
                             assertCurrent();
                             assertHardwareTransactionSender(signedTx, activeAccount.address);
-                            const finalTx = await this.submitSignedHardwareTransaction(provider, signedTx, (raw) => provider.sendTransaction(raw), submission, undefined, rawTx);
+                            const finalTx = await this.submitSignedHardwareTransaction(provider, signedTx, ({ rawTransaction, admit }) => admit(() => provider.sendTransaction(rawTransaction)), submission, undefined, rawTx);
                             return finalTx;
                         }
                         catch (error) {
@@ -2170,8 +2237,6 @@ export class EthereumTransactions {
                 }
             };
             const sendERC721TokenOnTrezor = async () => {
-                assertCurrent();
-                const transactionNonce = await provider.getTransactionCount(activeAccountAddress, 'pending');
                 assertCurrent();
                 try {
                     const _contract = new Contract(tokenAddress, getErc21Abi(), provider);
@@ -2187,7 +2252,7 @@ export class EthereumTransactions {
                             value: '0x0',
                             gasLimit: this.toHex0x(gasLimit, 'gasLimit'),
                             gasPrice: this.toHex0x(gasPrice, 'gasPrice'),
-                            nonce: this.toBigNumber(transactionNonce)._hex,
+                            nonce: this.toBigNumber(nonce)._hex,
                             chainId: activeNetwork.chainId,
                             data: txData,
                         };
@@ -2200,7 +2265,7 @@ export class EthereumTransactions {
                             gasLimit: this.toHex0x(gasLimit, 'gasLimit'),
                             maxFeePerGas: this.toHex0x(maxFeePerGas, 'maxFeePerGas'),
                             maxPriorityFeePerGas: this.toHex0x(maxPriorityFeePerGas, 'maxPriorityFeePerGas'),
-                            nonce: this.toBigNumber(transactionNonce)._hex,
+                            nonce: this.toBigNumber(nonce)._hex,
                             chainId: activeNetwork.chainId,
                             data: txData,
                         };
@@ -2229,7 +2294,7 @@ export class EthereumTransactions {
                                     gasLimit,
                                     gasPrice,
                                     data: txData,
-                                    nonce: transactionNonce,
+                                    nonce,
                                     chainId: activeNetwork.chainId,
                                     type: 0,
                                 };
@@ -2242,7 +2307,7 @@ export class EthereumTransactions {
                                     maxFeePerGas,
                                     maxPriorityFeePerGas,
                                     data: txData,
-                                    nonce: transactionNonce,
+                                    nonce,
                                     chainId: activeNetwork.chainId,
                                     type: 2, // Need explicit type for hardware wallet serialization
                                 };
@@ -2250,7 +2315,7 @@ export class EthereumTransactions {
                             const signedTx = serializeTransaction(txFormattedForEthers, trezorSignature(signature.payload));
                             assertCurrent();
                             assertHardwareTransactionSender(signedTx, activeAccount.address);
-                            const finalTx = await this.submitSignedHardwareTransaction(provider, signedTx, (raw) => provider.sendTransaction(raw), submission, undefined, expectedUnsignedTransaction);
+                            const finalTx = await this.submitSignedHardwareTransaction(provider, signedTx, ({ rawTransaction, admit }) => admit(() => provider.sendTransaction(rawTransaction)), submission, undefined, expectedUnsignedTransaction);
                             return finalTx;
                         }
                         catch (error) {
@@ -2277,7 +2342,7 @@ export class EthereumTransactions {
             }
         };
         this.sendSignedErc1155Transaction = async (request, approval) => {
-            const { assertApproval, signal } = this.captureReviewedTokenApproval(approval, 'ERC1155');
+            const { assertApproval, signal, nonce } = this.captureReviewedTokenApproval(approval, 'ERC1155');
             const { receiver, tokenAddress, tokenId, networkUrl } = request;
             const { activeAccount, activeAccountType, activeAccountId, activeNetwork, provider, assertCurrent: assertSigningCurrent, } = this.captureEvmSigningContext();
             if (networkUrl !== activeNetwork.url)
@@ -2297,7 +2362,7 @@ export class EthereumTransactions {
             const submission = this.captureSubmission('erc1155', activeAccount, activeAccountType, activeAccountId, activeNetwork, () => {
                 assertApproval();
                 assertSigningCurrent();
-            });
+            }, { walletNonce: { nonce, source: 'automatic' } });
             const assertCurrent = submission.assertCurrent;
             const sendERC1155Token = async () => {
                 assertCurrent();
@@ -2309,7 +2374,6 @@ export class EthereumTransactions {
                     let overrides;
                     if (isLegacy) {
                         overrides = {
-                            nonce: await provider.getTransactionCount(activeAccountAddress, 'pending'),
                             gasPrice,
                             gasLimit,
                             type: 0, // Explicitly set Type 0 for legacy ERC1155 transfers
@@ -2317,7 +2381,6 @@ export class EthereumTransactions {
                     }
                     else {
                         overrides = {
-                            nonce: await provider.getTransactionCount(activeAccountAddress, 'pending'),
                             maxPriorityFeePerGas,
                             maxFeePerGas,
                             gasLimit,
@@ -2326,6 +2389,7 @@ export class EthereumTransactions {
                     transferMethod = await _contract.safeTransferFrom.populateTransaction(activeAccountAddress, receiver, normalizedTokenId, amount, '0x', normalizeEthersOverrides(overrides));
                     return await sendLocalEvmTransaction(provider, decryptedPrivateKey, {
                         ...transferMethod,
+                        nonce,
                         chainId: activeNetwork.chainId,
                         from: activeAccountAddress,
                         value: '0x0',
@@ -2336,8 +2400,6 @@ export class EthereumTransactions {
                 }
             };
             const sendERC1155TokenOnLedger = async () => {
-                assertCurrent();
-                const transactionNonce = await provider.getTransactionCount(activeAccountAddress, 'pending');
                 assertCurrent();
                 try {
                     const _contract = new Contract(tokenAddress, getErc55Abi(), provider);
@@ -2350,7 +2412,7 @@ export class EthereumTransactions {
                             gasLimit,
                             gasPrice,
                             data: txData,
-                            nonce: transactionNonce,
+                            nonce,
                             chainId: activeNetwork.chainId,
                             type: 0,
                         };
@@ -2363,7 +2425,7 @@ export class EthereumTransactions {
                             maxFeePerGas,
                             maxPriorityFeePerGas,
                             data: txData,
-                            nonce: transactionNonce,
+                            nonce,
                             chainId: activeNetwork.chainId,
                             type: 2, // Need explicit type for hardware wallet serialization
                         };
@@ -2385,7 +2447,7 @@ export class EthereumTransactions {
                             const signedTx = serializeTransaction(txFormattedForEthers, formattedSignature);
                             assertCurrent();
                             assertHardwareTransactionSender(signedTx, activeAccount.address);
-                            const finalTx = await this.submitSignedHardwareTransaction(provider, signedTx, (raw) => provider.sendTransaction(raw), submission, undefined, rawTx);
+                            const finalTx = await this.submitSignedHardwareTransaction(provider, signedTx, ({ rawTransaction, admit }) => admit(() => provider.sendTransaction(rawTransaction)), submission, undefined, rawTx);
                             return finalTx;
                         }
                         catch (error) {
@@ -2401,8 +2463,6 @@ export class EthereumTransactions {
                 }
             };
             const sendERC1155TokenOnTrezor = async () => {
-                assertCurrent();
-                const transactionNonce = await provider.getTransactionCount(activeAccountAddress, 'pending');
                 assertCurrent();
                 try {
                     const _contract = new Contract(tokenAddress, getErc55Abi(), provider);
@@ -2414,7 +2474,7 @@ export class EthereumTransactions {
                             value: '0x0',
                             gasLimit: this.toHex0x(gasLimit, 'gasLimit'),
                             gasPrice: this.toHex0x(gasPrice, 'gasPrice'),
-                            nonce: this.toBigNumber(transactionNonce)._hex,
+                            nonce: this.toBigNumber(nonce)._hex,
                             chainId: activeNetwork.chainId,
                             data: txData,
                         };
@@ -2426,7 +2486,7 @@ export class EthereumTransactions {
                             gasLimit: this.toHex0x(gasLimit, 'gasLimit'),
                             maxFeePerGas: this.toHex0x(maxFeePerGas, 'maxFeePerGas'),
                             maxPriorityFeePerGas: this.toHex0x(maxPriorityFeePerGas, 'maxPriorityFeePerGas'),
-                            nonce: this.toBigNumber(transactionNonce)._hex,
+                            nonce: this.toBigNumber(nonce)._hex,
                             chainId: activeNetwork.chainId,
                             data: txData,
                         };
@@ -2453,7 +2513,7 @@ export class EthereumTransactions {
                                     gasLimit,
                                     gasPrice,
                                     data: txData,
-                                    nonce: transactionNonce,
+                                    nonce,
                                     chainId: activeNetwork.chainId,
                                     type: 0,
                                 };
@@ -2466,7 +2526,7 @@ export class EthereumTransactions {
                                     maxFeePerGas,
                                     maxPriorityFeePerGas,
                                     data: txData,
-                                    nonce: transactionNonce,
+                                    nonce,
                                     chainId: activeNetwork.chainId,
                                     type: 2, // Need explicit type for hardware wallet serialization
                                 };
@@ -2474,7 +2534,7 @@ export class EthereumTransactions {
                             const signedTx = serializeTransaction(txFormattedForEthers, trezorSignature(signature.payload));
                             assertCurrent();
                             assertHardwareTransactionSender(signedTx, activeAccount.address);
-                            const finalTx = await this.submitSignedHardwareTransaction(provider, signedTx, (raw) => provider.sendTransaction(raw), submission, undefined, expectedUnsignedTransaction);
+                            const finalTx = await this.submitSignedHardwareTransaction(provider, signedTx, ({ rawTransaction, admit }) => admit(() => provider.sendTransaction(rawTransaction)), submission, undefined, expectedUnsignedTransaction);
                             return finalTx;
                         }
                         catch (error) {