@sidhujag/sysweb3-keyring 2.1.5 → 2.1.6

package/cjs/transactions/ethereum.js

@@ -202,7 +202,7 @@ 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 (0, evm_submission_1.captureEvmSubmission)({
@@ -214,7 +214,7 @@ class EthereumTransactions {
                     slip44: network.slip44,
                     url: network.url,
                 },
-                ...(originalHash !== undefined ? { originalHash } : {}),
+                ...details,
             }, assertCurrent, this.captureSubmissionLifecycle);
         };
         this.authorizeHardwareTransaction = async (provider, assertCurrent, signal = this.abortController.signal) => {
@@ -584,7 +584,9 @@ 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`), {
@@ -593,7 +595,7 @@ 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;
@@ -650,7 +652,7 @@ class EthereumTransactions {
                 maxPriorityFeePerGas: ethers_v6_1.BigNumber.from(fee.maxPriorityFeePerGas),
             };
         };
-        this.calculateNewGasValues = (oldTxsParams, isForCancel, isLegacy) => {
+        this.calculateNewGasValues = (oldTxsParams, isForCancel, isLegacy, bounds) => {
             const newGasValues = {
                 maxFeePerGas: undefined,
                 maxPriorityFeePerGas: undefined,
@@ -658,8 +660,34 @@ class EthereumTransactions {
                 gasLimit: undefined,
             };
             const { maxFeePerGas, maxPriorityFeePerGas, gasLimit, gasPrice } = oldTxsParams;
+            if (!isForCancel) {
+                const originalGasLimit = (0, evm_fees_1.parseEvmFeeQuantity)(gasLimit, 'replacement gas limit');
+                const plan = isLegacy
+                    ? (0, evm_fees_1.planEvmSpeedUpFees)({
+                        ...bounds,
+                        type: 0,
+                        gasLimit: originalGasLimit,
+                        gasPrice: (0, evm_fees_1.parseEvmFeeQuantity)(gasPrice, 'replacement gas price'),
+                    })
+                    : (0, evm_fees_1.planEvmSpeedUpFees)({
+                        ...bounds,
+                        type: 2,
+                        gasLimit: originalGasLimit,
+                        maxFeePerGas: (0, evm_fees_1.parseEvmFeeQuantity)(maxFeePerGas, 'replacement fee cap'),
+                        maxPriorityFeePerGas: (0, evm_fees_1.parseEvmFeeQuantity)(maxPriorityFeePerGas, 'replacement priority fee'),
+                    });
+                newGasValues.gasLimit = ethers_v6_1.BigNumber.from(plan.gasLimit);
+                if (plan.type === 0)
+                    newGasValues.gasPrice = ethers_v6_1.BigNumber.from(plan.gasPrice);
+                else {
+                    newGasValues.maxFeePerGas = ethers_v6_1.BigNumber.from(plan.maxFeePerGas);
+                    newGasValues.maxPriorityFeePerGas = ethers_v6_1.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);
@@ -667,7 +695,6 @@ 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) {
@@ -678,14 +705,8 @@ 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 = ethers_v6_1.BigNumber.from(convertToHex);
-            }
-            if (!isForCancel) {
-                newGasValues.gasLimit = calculateAndConvertNewValue(gasLimitToNumber);
-            }
+            newGasValues.gasLimit = ethers_v6_1.BigNumber.from(42000);
+            (0, evm_fees_1.assertEvmGasLimit)(newGasValues.gasLimit.toBigInt(), bounds.chainId, bounds.sampledBlockGasLimit);
             return newGasValues;
         };
         this.cancelSentTransaction = async (txHash, isLegacy, fallbackNonce, options) => {
@@ -694,8 +715,13 @@ 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)) {
@@ -708,7 +734,6 @@ 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();
@@ -753,9 +778,22 @@ class EthereumTransactions {
                 assertKeyringContext();
             };
             assertSigningCurrent();
+            const retained = origin === undefined
+                ? undefined
+                : (0, evm_cancellation_1.authenticateRetainedCancellation)(origin, txHash.toLowerCase(), activeAccount.address, activeNetwork.chainId);
+            if (retained) {
+                const legacy = retained.feeFloor.type === 0;
+                if (activeNetwork.kind !== sysweb3_network_1.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);
@@ -767,64 +805,53 @@ 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 !== types_1.KeyringAccountType.Ledger &&
-                activeAccountType !== types_1.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: ethers_v6_1.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 !== types_1.KeyringAccountType.Ledger &&
+                    activeAccountType !== types_1.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: ethers_v6_1.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 = (0, evm_fees_1.parseEvmFeeQuantity)(await provider.getGasPrice(), 'cancellation gas price');
@@ -861,6 +888,16 @@ 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');
+                (0, evm_cancellation_1.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');
@@ -869,7 +906,7 @@ 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: ethers_v6_1.Zero,
@@ -895,7 +932,7 @@ class EthereumTransactions {
                     assertCurrent();
                     const formatParams = {
                         ...resolvedParams,
-                        nonce: resolvedParams.nonce
+                        nonce: resolvedParams.nonce != null
                             ? Number(resolvedParams.nonce.toString())
                             : undefined,
                     };
@@ -912,6 +949,8 @@ 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,
@@ -927,7 +966,7 @@ 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,
@@ -984,6 +1023,8 @@ class EthereumTransactions {
                     assertApprovedEnvelope(txFormattedForTrezor);
                     assertTransactionGasLimit(txFormattedForTrezor);
                     const expectedUnsignedTransaction = serializeTransaction(txFormattedForTrezor);
+                    if (retained)
+                        assertCancellationEnvelope(expectedUnsignedTransaction);
                     const signature = await this.requireTrezorSigner().signEthTransaction({
                         coin: trezorCoin,
                         tx: txFormattedForTrezor,
@@ -995,7 +1036,7 @@ 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,
@@ -1026,12 +1067,7 @@ class EthereumTransactions {
                     }
                     const transactionResponse = await (0, evm_local_signer_1.sendLocalEvmTransaction)(provider, decryptedPrivateKey, changedTxToCancel, assertCurrent, assertCurrent, (transaction) => {
                         assertApprovedEnvelope(transaction);
-                        (0, evm_cancellation_1.assertEvmCancellationEnvelope)(serializeTransaction(transaction), {
-                            payer: activeAccount.address,
-                            chainId: activeNetwork.chainId,
-                            nonce: softwareNonce,
-                            feePlan,
-                        });
+                        assertCancellationEnvelope(serializeTransaction(transaction));
                     }, submission);
                     if (transactionResponse) {
                         return {
@@ -1077,7 +1113,8 @@ 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) {
@@ -1088,7 +1125,7 @@ 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
@@ -1105,7 +1142,7 @@ 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();
@@ -1117,8 +1154,13 @@ 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 } = (0, prepared_evm_1.snapshotPreparedEvmRequest)({
                     account: {
@@ -1134,6 +1176,7 @@ class EthereumTransactions {
                     },
                     transaction: input,
                 });
+                assertApprovedNonce(Number(transaction.nonce));
                 const minimum = this.gasOverrides.minGasLimit;
                 if (transaction.data !== '0x' ||
                     BigInt(transaction.value) === 0n ||
@@ -1152,7 +1195,7 @@ class EthereumTransactions {
                     throw new Error('Reviewed native signer does not match the approved account');
                 assertCurrent();
                 const { signed, expectedUnsigned } = (0, prepared_evm_1.signPreparedEvmEnvelope)(transaction, decryptedPrivateKey);
-                return (0, evm_submission_1.submitSignedEvmTransaction)(signed.rawTransaction, (raw) => provider.sendTransaction(raw), submission, assertBeforeBroadcast, expectedUnsigned);
+                return (0, evm_submission_1.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.
@@ -1187,6 +1230,7 @@ class EthereumTransactions {
                 supplied.data = (0, utils_1.hexlify)(supplied.data);
             if (supplied.accessList != null)
                 supplied.accessList = (0, transaction_1.accessListify)(supplied.accessList);
+            assertApprovedNonce(supplied.nonce);
             params = supplied;
             assertCurrent();
             // Capture the reviewed nonce before any fee/RPC await. Hardware and the
@@ -1308,7 +1352,7 @@ 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) {
@@ -1398,7 +1442,7 @@ 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) {
@@ -1453,7 +1497,7 @@ 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);
@@ -1494,9 +1538,27 @@ 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_1.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();
@@ -1504,6 +1566,10 @@ class EthereumTransactions {
                     return null;
                 const authenticated = authenticateReplacementOriginal(transaction, requestedHash, expectedSender, activeNetwork.chainId);
                 const type = authenticated.type;
+                if (cancellation &&
+                    (type !== cancellation.type ||
+                        (0, evm_fees_1.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 &&
@@ -1532,9 +1598,20 @@ 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: (0, evm_fees_1.parseEvmFeeQuantity)(sampledBlock?.gasLimit, 'replacement block gas limit'),
+                sampledBaseFeePerGas: sampledBlock?.baseFeePerGas == null
+                    ? null
+                    : (0, evm_fees_1.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);
@@ -1543,15 +1620,6 @@ 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,
@@ -1565,26 +1633,33 @@ 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 = ethers_v6_1.BigNumber.from(feeData.maxFeePerGas || 0);
                 oldTxsGasValues.maxPriorityFeePerGas = ethers_v6_1.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 {
@@ -1651,7 +1726,7 @@ 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,
@@ -1732,7 +1807,7 @@ 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,
@@ -1818,7 +1893,7 @@ 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;
@@ -1835,7 +1910,7 @@ 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();
@@ -1845,7 +1920,6 @@ 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
@@ -1855,7 +1929,6 @@ class EthereumTransactions {
                     }
                     else {
                         const overrides = {
-                            nonce: await provider.getTransactionCount(activeAccountAddress, 'pending'),
                             maxPriorityFeePerGas,
                             maxFeePerGas,
                             gasLimit,
@@ -1865,6 +1938,7 @@ class EthereumTransactions {
                     }
                     return await (0, evm_local_signer_1.sendLocalEvmTransaction)(provider, decryptedPrivateKey, {
                         ...transferMethod,
+                        nonce,
                         chainId: activeNetwork.chainId,
                         from: activeAccountAddress,
                         value: '0x0',
@@ -1875,8 +1949,6 @@ class EthereumTransactions {
                 }
             };
             const sendERC20TokenOnLedger = async () => {
-                assertCurrent();
-                const transactionNonce = await provider.getTransactionCount(activeAccountAddress, 'pending');
                 assertCurrent();
                 try {
                     const _contract = new ethers_v6_1.Contract(tokenAddress, (0, sysweb3_utils_1.getErc20Abi)(), provider);
@@ -1892,7 +1964,7 @@ class EthereumTransactions {
                             gasLimit: gasLimit,
                             gasPrice,
                             data: txData,
-                            nonce: transactionNonce,
+                            nonce,
                             chainId: activeNetwork.chainId,
                             type: 0,
                         };
@@ -1905,7 +1977,7 @@ class EthereumTransactions {
                             maxFeePerGas,
                             maxPriorityFeePerGas,
                             data: txData,
-                            nonce: transactionNonce,
+                            nonce,
                             chainId: activeNetwork.chainId,
                             type: 2, // Need explicit type for hardware wallet serialization
                         };
@@ -1927,8 +1999,8 @@ 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);
@@ -1947,8 +2019,6 @@ class EthereumTransactions {
                 }
             };
             const sendERC20TokenOnTrezor = async () => {
-                assertCurrent();
-                const transactionNonce = await provider.getTransactionCount(activeAccountAddress, 'pending');
                 assertCurrent();
                 try {
                     const _contract = new ethers_v6_1.Contract(tokenAddress, (0, sysweb3_utils_1.getErc20Abi)(), provider);
@@ -1963,7 +2033,7 @@ 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,
                         };
@@ -1975,7 +2045,7 @@ 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,
                         };
@@ -2002,7 +2072,7 @@ class EthereumTransactions {
                                     gasLimit: gasLimit,
                                     gasPrice,
                                     data: txData,
-                                    nonce: transactionNonce,
+                                    nonce,
                                     chainId: activeNetwork.chainId,
                                     type: 0,
                                 };
@@ -2015,7 +2085,7 @@ class EthereumTransactions {
                                     maxFeePerGas,
                                     maxPriorityFeePerGas,
                                     data: txData,
-                                    nonce: transactionNonce,
+                                    nonce,
                                     chainId: activeNetwork.chainId,
                                     type: 2, // Need explicit type for hardware wallet serialization
                                 };
@@ -2023,8 +2093,8 @@ 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);
@@ -2052,7 +2122,7 @@ 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)
@@ -2069,7 +2139,7 @@ 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();
@@ -2079,7 +2149,6 @@ class EthereumTransactions {
                     const _contract = new ethers_v6_1.Contract(tokenAddress, (0, sysweb3_utils_1.getErc21Abi)(), provider);
                     if (isLegacy) {
                         const overrides = {
-                            nonce: await provider.getTransactionCount(activeAccountAddress, 'pending'),
                             gasPrice,
                             gasLimit,
                             type: 0, // Explicitly set Type 0 for legacy NFT transfers
@@ -2088,7 +2157,6 @@ class EthereumTransactions {
                     }
                     else {
                         const overrides = {
-                            nonce: await provider.getTransactionCount(activeAccountAddress, 'pending'),
                             maxPriorityFeePerGas,
                             maxFeePerGas,
                             gasLimit,
@@ -2097,6 +2165,7 @@ class EthereumTransactions {
                     }
                     return await (0, evm_local_signer_1.sendLocalEvmTransaction)(provider, decryptedPrivateKey, {
                         ...transferMethod,
+                        nonce,
                         chainId: activeNetwork.chainId,
                         from: activeAccountAddress,
                         value: '0x0',
@@ -2107,8 +2176,6 @@ class EthereumTransactions {
                 }
             };
             const sendERC721TokenOnLedger = async () => {
-                assertCurrent();
-                const transactionNonce = await provider.getTransactionCount(activeAccountAddress, 'pending');
                 assertCurrent();
                 try {
                     const _contract = new ethers_v6_1.Contract(tokenAddress, (0, sysweb3_utils_1.getErc21Abi)(), provider);
@@ -2125,7 +2192,7 @@ class EthereumTransactions {
                             gasLimit,
                             gasPrice,
                             data: txData,
-                            nonce: transactionNonce,
+                            nonce,
                             chainId: activeNetwork.chainId,
                             type: 0,
                         };
@@ -2138,7 +2205,7 @@ class EthereumTransactions {
                             maxFeePerGas,
                             maxPriorityFeePerGas,
                             data: txData,
-                            nonce: transactionNonce,
+                            nonce,
                             chainId: activeNetwork.chainId,
                             type: 2, // Need explicit type for hardware wallet serialization
                         };
@@ -2160,7 +2227,7 @@ 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) {
@@ -2176,8 +2243,6 @@ class EthereumTransactions {
                 }
             };
             const sendERC721TokenOnTrezor = async () => {
-                assertCurrent();
-                const transactionNonce = await provider.getTransactionCount(activeAccountAddress, 'pending');
                 assertCurrent();
                 try {
                     const _contract = new ethers_v6_1.Contract(tokenAddress, (0, sysweb3_utils_1.getErc21Abi)(), provider);
@@ -2193,7 +2258,7 @@ 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,
                         };
@@ -2206,7 +2271,7 @@ 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,
                         };
@@ -2235,7 +2300,7 @@ class EthereumTransactions {
                                     gasLimit,
                                     gasPrice,
                                     data: txData,
-                                    nonce: transactionNonce,
+                                    nonce,
                                     chainId: activeNetwork.chainId,
                                     type: 0,
                                 };
@@ -2248,7 +2313,7 @@ class EthereumTransactions {
                                     maxFeePerGas,
                                     maxPriorityFeePerGas,
                                     data: txData,
-                                    nonce: transactionNonce,
+                                    nonce,
                                     chainId: activeNetwork.chainId,
                                     type: 2, // Need explicit type for hardware wallet serialization
                                 };
@@ -2256,7 +2321,7 @@ 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) {
@@ -2283,7 +2348,7 @@ 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)
@@ -2303,7 +2368,7 @@ 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();
@@ -2315,7 +2380,6 @@ 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
@@ -2323,7 +2387,6 @@ class EthereumTransactions {
                     }
                     else {
                         overrides = {
-                            nonce: await provider.getTransactionCount(activeAccountAddress, 'pending'),
                             maxPriorityFeePerGas,
                             maxFeePerGas,
                             gasLimit,
@@ -2332,6 +2395,7 @@ class EthereumTransactions {
                     transferMethod = await _contract.safeTransferFrom.populateTransaction(activeAccountAddress, receiver, normalizedTokenId, amount, '0x', normalizeEthersOverrides(overrides));
                     return await (0, evm_local_signer_1.sendLocalEvmTransaction)(provider, decryptedPrivateKey, {
                         ...transferMethod,
+                        nonce,
                         chainId: activeNetwork.chainId,
                         from: activeAccountAddress,
                         value: '0x0',
@@ -2342,8 +2406,6 @@ class EthereumTransactions {
                 }
             };
             const sendERC1155TokenOnLedger = async () => {
-                assertCurrent();
-                const transactionNonce = await provider.getTransactionCount(activeAccountAddress, 'pending');
                 assertCurrent();
                 try {
                     const _contract = new ethers_v6_1.Contract(tokenAddress, (0, sysweb3_utils_1.getErc55Abi)(), provider);
@@ -2356,7 +2418,7 @@ class EthereumTransactions {
                             gasLimit,
                             gasPrice,
                             data: txData,
-                            nonce: transactionNonce,
+                            nonce,
                             chainId: activeNetwork.chainId,
                             type: 0,
                         };
@@ -2369,7 +2431,7 @@ class EthereumTransactions {
                             maxFeePerGas,
                             maxPriorityFeePerGas,
                             data: txData,
-                            nonce: transactionNonce,
+                            nonce,
                             chainId: activeNetwork.chainId,
                             type: 2, // Need explicit type for hardware wallet serialization
                         };
@@ -2391,7 +2453,7 @@ 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) {
@@ -2407,8 +2469,6 @@ class EthereumTransactions {
                 }
             };
             const sendERC1155TokenOnTrezor = async () => {
-                assertCurrent();
-                const transactionNonce = await provider.getTransactionCount(activeAccountAddress, 'pending');
                 assertCurrent();
                 try {
                     const _contract = new ethers_v6_1.Contract(tokenAddress, (0, sysweb3_utils_1.getErc55Abi)(), provider);
@@ -2420,7 +2480,7 @@ 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,
                         };
@@ -2432,7 +2492,7 @@ 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,
                         };
@@ -2459,7 +2519,7 @@ class EthereumTransactions {
                                     gasLimit,
                                     gasPrice,
                                     data: txData,
-                                    nonce: transactionNonce,
+                                    nonce,
                                     chainId: activeNetwork.chainId,
                                     type: 0,
                                 };
@@ -2472,7 +2532,7 @@ class EthereumTransactions {
                                     maxFeePerGas,
                                     maxPriorityFeePerGas,
                                     data: txData,
-                                    nonce: transactionNonce,
+                                    nonce,
                                     chainId: activeNetwork.chainId,
                                     type: 2, // Need explicit type for hardware wallet serialization
                                 };
@@ -2480,7 +2540,7 @@ 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) {