@sidhujag/sysweb3-keyring 2.1.2 → 2.1.4

package/cjs/transactions/ethereum.js

@@ -14,8 +14,10 @@ const ethers_v6_1 = require("../ethers-v6");
 const evm_fees_1 = require("../evm-fees");
 const providers_1 = require("../providers");
 const types_1 = require("../types");
+const evm_cancellation_1 = require("./evm-cancellation");
 const evm_local_signer_1 = require("./evm-local-signer");
 const evm_submission_1 = require("./evm-submission");
+const prepared_evm_1 = require("./prepared-evm");
 const derivation_paths_1 = require("../utils/derivation-paths");
 const hardwareSignerUnavailable = (hardware) => Object.assign(new Error(`${hardware} signer is unavailable in this host`), {
     code: 'HARDWARE_SIGNER_UNAVAILABLE',
@@ -115,14 +117,16 @@ const authenticateReplacementOriginal = (transaction, requestedHash, expectedSen
     });
 };
 const assertSynchronousOriginalValidation = (result, message = 'Original transaction validator must be synchronous') => {
+    if (result === undefined)
+        return;
     if (result !== null &&
         (typeof result === 'object' || typeof result === 'function') &&
         typeof result.then === 'function') {
         // A void callback type also accepts async functions. Decline their pending
         // decision and consume a later rejection without allowing signing to start.
         void Promise.resolve(result).catch(() => undefined);
-        throw new Error(message);
     }
+    throw new Error(message);
 };
 class EthereumTransactions {
     constructor(getNetwork, getDecryptedPrivateKey, getState, ledgerSigner, trezorSigner, captureSigningContext, captureSubmissionLifecycle) {
@@ -148,6 +152,14 @@ class EthereumTransactions {
             if (type === types_1.KeyringAccountType.Trezor || account?.isTrezorWallet)
                 this.requireTrezorSigner();
         };
+        this.captureSessionGuard = () => {
+            const guard = this.captureSigningContext();
+            if (typeof guard !== 'function') {
+                void Promise.resolve(guard).catch(() => undefined);
+                throw new TypeError('Signing context must return a synchronous guard');
+            }
+            return () => assertSynchronousOriginalValidation(guard(), 'Signing context guard must be synchronous');
+        };
         this.captureEvmSigningContext = (target) => {
             this.assertHardwareSignerAvailable(target);
             const state = this.getState();
@@ -161,10 +173,10 @@ class EthereumTransactions {
                 throw new Error('Active account not found');
             const account = { address: selectedAccount.address };
             const network = { ...state.activeNetwork };
-            const assertSession = this.captureSigningContext?.();
+            const assertSession = this.captureSessionGuard();
             const provider = this.web3Provider;
             const assertCurrent = () => {
-                assertSession?.();
+                assertSession();
                 const current = this.getState();
                 const currentAccount = current.accounts[activeAccountType]?.[activeAccountId];
                 if (current.activeAccountId !== selectedId ||
@@ -190,17 +202,30 @@ class EthereumTransactions {
                 assertCurrent,
             };
         };
-        this.captureSubmission = (operation, account, type, id, network, assertCurrent, originalHash) => (0, evm_submission_1.captureEvmSubmission)({
-            operation,
-            account: { address: account.address, type, id },
-            network: {
-                kind: network.kind,
-                chainId: network.chainId,
-                slip44: network.slip44,
-                url: network.url,
-            },
-            ...(originalHash !== undefined ? { originalHash } : {}),
-        }, assertCurrent, this.captureSubmissionLifecycle);
+        this.captureSubmission = (operation, account, type, id, network, assertCurrent, originalHash) => {
+            if (!this.captureSubmissionLifecycle)
+                throw new TypeError('A durable EVM submission lifecycle is required');
+            return (0, evm_submission_1.captureEvmSubmission)({
+                operation,
+                account: { address: account.address, type, id },
+                network: {
+                    kind: network.kind,
+                    chainId: network.chainId,
+                    slip44: network.slip44,
+                    url: network.url,
+                },
+                ...(originalHash !== undefined ? { originalHash } : {}),
+            }, assertCurrent, this.captureSubmissionLifecycle);
+        };
+        this.authorizeHardwareTransaction = async (provider, assertCurrent, signal = this.abortController.signal) => {
+            assertCurrent();
+            await provider.verifyConfiguredChainId();
+            assertCurrent();
+            return { assertCurrent, signal };
+        };
+        this.submitSignedHardwareTransaction = (provider, raw, broadcast, submission, beforeBroadcast, expectedUnsigned) => (0, evm_submission_1.submitSignedHardwareEvmTransaction)(raw, broadcast, submission, beforeBroadcast, expectedUnsigned, 
+        // A device confirmation or journal write can outlast the earlier check.
+        () => provider.verifyConfiguredChainId(true));
         this.signTypedData = async (addr, typedData, version) => {
             const { address, decryptedPrivateKey } = this.getDecryptedPrivateKey();
             const { activeAccountType, accounts, activeAccountId } = this.getState();
@@ -554,35 +579,45 @@ class EthereumTransactions {
                 throw new Error(`Invalid numeric field "${fieldName}" for EVM tx: ${String(value)}`);
             }
         };
-        this.resolveEvmFeeParams = async ({ gasPrice, isLegacy = false, maxFeePerGas, maxPriorityFeePerGas, }, provider = this.web3Provider) => {
-            if (isLegacy) {
-                return {
-                    gasPrice: gasPrice || (await provider.getGasPrice()),
-                    isLegacy: true,
-                    maxFeePerGas: undefined,
-                    maxPriorityFeePerGas: undefined,
-                };
-            }
-            if (!maxFeePerGas || maxPriorityFeePerGas == null) {
-                const feeData = await provider.getFeeData();
-                maxFeePerGas = maxFeePerGas || feeData.maxFeePerGas || feeData.gasPrice;
-                maxPriorityFeePerGas =
-                    maxPriorityFeePerGas ?? feeData.maxPriorityFeePerGas;
-                if (!maxFeePerGas || maxPriorityFeePerGas == null) {
-                    return {
-                        gasPrice: feeData.gasPrice || (await provider.getGasPrice()),
-                        isLegacy: true,
-                        maxFeePerGas: undefined,
-                        maxPriorityFeePerGas: undefined,
-                    };
-                }
-            }
-            return {
-                gasPrice: undefined,
-                isLegacy: false,
-                maxFeePerGas,
-                maxPriorityFeePerGas,
+        this.captureReviewedTokenApproval = (approval, standard) => {
+            if (!approval ||
+                typeof approval.assertCurrent !== 'function' ||
+                !(approval.signal instanceof AbortSignal))
+                throw new Error(`${standard} transaction approval required`);
+            const { assertCurrent, signal } = approval;
+            const assertApproval = () => {
+                if (signal.aborted)
+                    throw Object.assign(new Error(`${standard} transaction approval expired`), {
+                        transactionNotBroadcast: true,
+                    });
+                assertSynchronousOriginalValidation(assertCurrent(), `${standard} transaction approval must be synchronous`);
             };
+            assertApproval();
+            return { assertApproval, signal };
+        };
+        this.reviewedTokenFees = (request, chainId, standard) => {
+            const { isLegacy } = request;
+            if (typeof isLegacy !== 'boolean' ||
+                (isLegacy
+                    ? request.maxFeePerGas !== undefined ||
+                        request.maxPriorityFeePerGas !== undefined
+                    : request.gasPrice !== undefined))
+                throw new Error(`Invalid ${standard} transaction fee model`);
+            const gasLimit = ethers_v6_1.BigNumber.from((0, evm_fees_1.assertEvmGasLimit)((0, evm_fees_1.parseEvmFeeQuantity)(request.gasLimit, `${standard} gas limit`), BigInt(chainId)));
+            const gasPrice = isLegacy
+                ? ethers_v6_1.BigNumber.from((0, evm_fees_1.parseEvmFeeQuantity)(request.gasPrice, `${standard} gas price`))
+                : undefined;
+            const maxFeePerGas = !isLegacy
+                ? ethers_v6_1.BigNumber.from((0, evm_fees_1.parseEvmFeeQuantity)(request.maxFeePerGas, `${standard} maximum fee`))
+                : undefined;
+            const maxPriorityFeePerGas = !isLegacy
+                ? ethers_v6_1.BigNumber.from((0, evm_fees_1.parseEvmFeeQuantity)(request.maxPriorityFeePerGas, `${standard} priority fee`))
+                : undefined;
+            if (gasPrice?.isZero() ||
+                (maxFeePerGas &&
+                    (maxFeePerGas.isZero() || maxPriorityFeePerGas.gt(maxFeePerGas))))
+                throw new Error(`Invalid ${standard} fees`);
+            return { gasLimit, isLegacy, gasPrice, maxFeePerGas, maxPriorityFeePerGas };
         };
         this.getData = ({ contractAddress, receivingAddress, value, }) => {
             const abi = (0, sysweb3_utils_1.getErc20Abi)();
@@ -673,7 +708,8 @@ class EthereumTransactions {
                     !/^(0|[1-9][0-9]{0,77})$/.test(approvedMaximumFee))) {
                 throw new Error('Cancellation fee approval required');
             }
-            const assertHostContext = options.assertCurrentContext;
+            const { assertCurrentContext, validateOriginal } = options;
+            const assertHostContext = () => assertSynchronousOriginalValidation(assertCurrentContext(), 'Transaction context guard must be synchronous');
             assertHostContext();
             const state = this.getState();
             const selectedType = state.activeAccountType;
@@ -696,9 +732,9 @@ class EthereumTransactions {
             if (!previewOnly)
                 this.assertHardwareSignerAvailable(targetAccount);
             const provider = this.web3Provider;
-            const assertSession = this.captureSigningContext?.();
+            const assertSession = this.captureSessionGuard();
             const assertKeyringContext = () => {
-                assertSession?.();
+                assertSession();
                 const current = this.getState();
                 if (current.activeAccountType !== selectedType ||
                     current.activeAccountId !== selectedId ||
@@ -712,14 +748,15 @@ class EthereumTransactions {
                     throw new Error('Wallet signing context changed');
                 }
             };
-            const assertCurrent = () => {
+            const assertSigningCurrent = () => {
                 assertHostContext();
                 assertKeyringContext();
             };
-            assertCurrent();
+            assertSigningCurrent();
             const submission = previewOnly
                 ? undefined
-                : this.captureSubmission('cancel', activeAccount, activeAccountType, activeAccountId, activeNetwork, assertCurrent, txHash);
+                : this.captureSubmission('cancel', activeAccount, activeAccountType, activeAccountId, activeNetwork, assertSigningCurrent, txHash);
+            const assertCurrent = submission?.assertCurrent ?? assertSigningCurrent;
             const currentEip1559Fees = async () => {
                 const feeData = await this.getFeeDataWithDynamicMaxPriorityFeePerGas(provider);
                 assertCurrent();
@@ -738,7 +775,18 @@ class EthereumTransactions {
             let tx = response === null
                 ? null
                 : authenticateReplacementOriginal(response, txHash.toLowerCase(), activeAccount.address.toLowerCase(), activeNetwork.chainId);
-            assertSynchronousOriginalValidation(options.validateOriginal(tx));
+            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
@@ -753,7 +801,6 @@ class EthereumTransactions {
                         value: ethers_v6_1.Zero,
                         nonce: fallbackNonce,
                         gasPrice: currentGasPrice,
-                        gasLimit: ethers_v6_1.BigNumber.from(42000),
                         data: '0x',
                     };
                 }
@@ -766,7 +813,6 @@ class EthereumTransactions {
                         nonce: fallbackNonce,
                         maxFeePerGas: feeData.maxFeePerGas,
                         maxPriorityFeePerGas: feeData.maxPriorityFeePerGas,
-                        gasLimit: ethers_v6_1.BigNumber.from(42000),
                         data: '0x',
                     };
                 }
@@ -778,67 +824,36 @@ class EthereumTransactions {
                     error: true,
                 };
             }
-            // If the original tx has 0 or very low gas price, fetch current network gas prices
-            const oldTxsGasValues = {
-                maxFeePerGas: tx.maxFeePerGas,
-                maxPriorityFeePerGas: tx.maxPriorityFeePerGas,
-                gasPrice: tx.gasPrice,
-                gasLimit: tx.gasLimit,
-            };
+            const { gasPrice: originalGasPrice, maxFeePerGas: originalMaxFeePerGas, maxPriorityFeePerGas: originalMaxPriorityFeePerGas, } = softwareOriginalFees ?? tx;
+            let feePlan;
             if (isLegacy) {
-                const currentGasPrice = nonNegativeFeeQuantity(await provider.getGasPrice(), 'cancellation gas price');
+                const currentGasPrice = (0, evm_fees_1.parseEvmFeeQuantity)(await provider.getGasPrice(), 'cancellation gas price');
                 assertCurrent();
-                if (oldTxsGasValues.gasPrice != null) {
-                    oldTxsGasValues.gasPrice = nonNegativeFeeQuantity(oldTxsGasValues.gasPrice, 'original gas price');
-                }
-                if (!oldTxsGasValues.gasPrice ||
-                    oldTxsGasValues.gasPrice.isZero() ||
-                    oldTxsGasValues.gasPrice.lt(currentGasPrice)) {
-                    oldTxsGasValues.gasPrice = currentGasPrice;
-                }
+                feePlan = (0, evm_fees_1.planEvmCancellationFees)({
+                    type: 0,
+                    currentGasPrice,
+                    originalGasPrice: originalGasPrice == null
+                        ? undefined
+                        : (0, evm_fees_1.parseEvmFeeQuantity)(originalGasPrice, 'original gas price'),
+                });
             }
             else {
-                const { maxFeePerGas: currentMaxFeePerGas, maxPriorityFeePerGas: currentMaxPriorityFeePerGas, } = await currentEip1559Fees();
-                if (oldTxsGasValues.maxFeePerGas != null) {
-                    oldTxsGasValues.maxFeePerGas = nonNegativeFeeQuantity(oldTxsGasValues.maxFeePerGas, 'original maximum fee');
-                }
-                if (oldTxsGasValues.maxPriorityFeePerGas != null) {
-                    oldTxsGasValues.maxPriorityFeePerGas = nonNegativeFeeQuantity(oldTxsGasValues.maxPriorityFeePerGas, 'original priority fee');
-                }
-                if (!oldTxsGasValues.maxFeePerGas ||
-                    oldTxsGasValues.maxFeePerGas.isZero() ||
-                    oldTxsGasValues.maxFeePerGas.lt(currentMaxFeePerGas)) {
-                    oldTxsGasValues.maxFeePerGas = currentMaxFeePerGas;
-                }
-                if (!oldTxsGasValues.maxPriorityFeePerGas ||
-                    oldTxsGasValues.maxPriorityFeePerGas.lt(currentMaxPriorityFeePerGas)) {
-                    oldTxsGasValues.maxPriorityFeePerGas = currentMaxPriorityFeePerGas;
-                }
-                if (oldTxsGasValues.maxFeePerGas.lt(oldTxsGasValues.maxPriorityFeePerGas)) {
-                    oldTxsGasValues.maxFeePerGas = oldTxsGasValues.maxPriorityFeePerGas;
-                }
-            }
-            // Preserve the existing 20% replacement policy with exact integer math.
-            // Nodes also require a strictly larger cap and tip than an old pending
-            // transaction; zero/small fees therefore need at least a one-wei bump.
-            // This is a replacement bump, not a fabricated network priority floor.
-            const bumpCancelFee = (fee) => {
-                const percentageBump = fee.mul(120).div(100);
-                const strictBump = fee.add(1);
-                return percentageBump.gt(strictBump) ? percentageBump : strictBump;
-            };
-            const newGasValues = {
-                gasLimit: ethers_v6_1.BigNumber.from(42000),
-                ...(isLegacy
-                    ? { gasPrice: bumpCancelFee(oldTxsGasValues.gasPrice) }
-                    : {
-                        maxFeePerGas: bumpCancelFee(oldTxsGasValues.maxFeePerGas),
-                        maxPriorityFeePerGas: bumpCancelFee(oldTxsGasValues.maxPriorityFeePerGas),
-                    }),
-            };
-            const maximumFee = newGasValues.gasLimit.mul(isLegacy ? newGasValues.gasPrice : newGasValues.maxFeePerGas);
+                const currentFees = await currentEip1559Fees();
+                feePlan = (0, evm_fees_1.planEvmCancellationFees)({
+                    type: 2,
+                    currentMaxFeePerGas: currentFees.maxFeePerGas.toBigInt(),
+                    currentMaxPriorityFeePerGas: currentFees.maxPriorityFeePerGas.toBigInt(),
+                    originalMaxFeePerGas: originalMaxFeePerGas == null
+                        ? undefined
+                        : (0, evm_fees_1.parseEvmFeeQuantity)(originalMaxFeePerGas, 'original maximum fee'),
+                    originalMaxPriorityFeePerGas: originalMaxPriorityFeePerGas == null
+                        ? undefined
+                        : (0, evm_fees_1.parseEvmFeeQuantity)(originalMaxPriorityFeePerGas, 'original priority fee'),
+                });
+            }
+            const maximumFee = ethers_v6_1.BigNumber.from(feePlan.maximumFee);
             assertCurrent();
-            if (previewOnly)
+            if (!submission)
                 return {
                     isCanceled: false,
                     error: false,
@@ -849,27 +864,27 @@ class EthereumTransactions {
             const assertApprovedEnvelope = (transaction) => {
                 const gas = nonNegativeFeeQuantity(transaction.gasLimit, 'cancellation gas limit');
                 const cap = nonNegativeFeeQuantity(isLegacy ? transaction.gasPrice : transaction.maxFeePerGas, 'cancellation maximum fee');
-                if (!gas.eq(42000) || gas.mul(cap).gt(approvedMaximumFee))
+                if (!gas.eq(feePlan.gasLimit) || gas.mul(cap).gt(approvedMaximumFee))
                     throw new Error('Cancellation fee exceeds approval');
             };
             // Base cancel transaction parameters (same for all wallet types)
             const baseCancelTx = {
-                nonce: tx.nonce,
+                nonce: software ? softwareNonce : tx.nonce,
                 from: activeAccount.address,
                 to: activeAccount.address,
                 value: ethers_v6_1.Zero,
-                gasLimit: newGasValues.gasLimit,
+                gasLimit: ethers_v6_1.BigNumber.from(feePlan.gasLimit),
             };
-            const changedTxToCancel = isLegacy
+            const changedTxToCancel = feePlan.type === 0
                 ? {
                     ...baseCancelTx,
-                    gasPrice: newGasValues.gasPrice,
+                    gasPrice: ethers_v6_1.BigNumber.from(feePlan.gasPrice),
                     type: 0, // Force Type 0 for legacy cancel
                 }
                 : {
                     ...baseCancelTx,
-                    maxFeePerGas: newGasValues.maxFeePerGas,
-                    maxPriorityFeePerGas: newGasValues.maxPriorityFeePerGas,
+                    maxFeePerGas: ethers_v6_1.BigNumber.from(feePlan.maxFeePerGas),
+                    maxPriorityFeePerGas: ethers_v6_1.BigNumber.from(feePlan.maxPriorityFeePerGas),
                     // Don't set type - let ethers auto-detect
                 };
             // Ledger cancel handler
@@ -901,7 +916,7 @@ class EthereumTransactions {
                         rawTx: rawTx.replace('0x', ''),
                         accountIndex: activeAccountId,
                         expectedAddress: activeAccount.address,
-                    });
+                    }, await this.authorizeHardwareTransaction(provider, assertCurrent));
                     assertCurrent();
                     const formattedSignature = {
                         r: `0x${signature.r}`,
@@ -912,7 +927,7 @@ class EthereumTransactions {
                         const signedTx = serializeTransaction(txFormattedForEthers, formattedSignature);
                         assertCurrent();
                         assertHardwareTransactionSender(signedTx, activeAccount.address);
-                        const transactionResponse = await (0, evm_submission_1.submitSignedEvmTransaction)(signedTx, (raw) => provider.sendTransaction(raw), submission, undefined, rawTx);
+                        const transactionResponse = await this.submitSignedHardwareTransaction(provider, signedTx, (raw) => provider.sendTransaction(raw), submission, undefined, rawTx);
                         return {
                             isCanceled: true,
                             transaction: transactionResponse,
@@ -974,13 +989,13 @@ class EthereumTransactions {
                         tx: txFormattedForTrezor,
                         index: activeAccountId.toString(),
                         slip44: activeNetwork.slip44,
-                    });
+                    }, await this.authorizeHardwareTransaction(provider, assertCurrent));
                     assertCurrent();
                     if (signature.success) {
                         const signedTx = serializeTransaction(txFormattedForTrezor, trezorSignature(signature.payload));
                         assertCurrent();
                         assertHardwareTransactionSender(signedTx, activeAccount.address);
-                        const transactionResponse = await (0, evm_submission_1.submitSignedEvmTransaction)(signedTx, (raw) => provider.sendTransaction(raw), submission, undefined, expectedUnsignedTransaction);
+                        const transactionResponse = await this.submitSignedHardwareTransaction(provider, signedTx, (raw) => provider.sendTransaction(raw), submission, undefined, expectedUnsignedTransaction);
                         return {
                             isCanceled: true,
                             transaction: transactionResponse,
@@ -1009,7 +1024,15 @@ class EthereumTransactions {
                     if (address?.toLowerCase() !== activeAccount.address.toLowerCase()) {
                         throw new Error('Wallet signing context changed');
                     }
-                    const transactionResponse = await (0, evm_local_signer_1.sendLocalEvmTransaction)(provider, decryptedPrivateKey, changedTxToCancel, assertCurrent, assertCurrent, assertApprovedEnvelope, submission);
+                    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,
+                        });
+                    }, submission);
                     if (transactionResponse) {
                         return {
                             isCanceled: true,
@@ -1041,21 +1064,31 @@ class EthereumTransactions {
             }
         };
         //TODO: This function needs to be refactored
-        this.sendFormattedTransaction = async (params, isLegacy, options) => {
+        this.sendFormattedTransaction = async (...args) => {
+            const [params, isLegacy, options] = args;
             let broadcastAttempted = false;
             try {
-                if (options !== undefined &&
-                    (!options || typeof options !== 'object' || Array.isArray(options)))
-                    throw new Error('Invalid transaction context options');
+                if (!options ||
+                    typeof options !== 'object' ||
+                    Array.isArray(options) ||
+                    (options.mode !== 'reviewed-native' &&
+                        options.mode !== 'specialized') ||
+                    typeof options.assertCurrent !== 'function')
+                    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 assertHostCurrent = options?.assertCurrent;
-                if (assertHostCurrent !== undefined &&
-                    typeof assertHostCurrent !== 'function')
-                    throw new Error('Invalid transaction context guard');
+                const { assertCurrent: assertHostCurrent, mode } = options;
+                const assertApproved = () => {
+                    const result = assertHostCurrent();
+                    if (result !== undefined) {
+                        assertSynchronousOriginalValidation(result, 'Transaction context guard must be synchronous');
+                        throw new Error('Transaction context guard must return undefined');
+                    }
+                };
+                assertApproved();
                 return await this.sendFormattedTransactionInternal(params, isLegacy, () => {
                     broadcastAttempted = true;
-                }, assertHostCurrent);
+                }, assertApproved, mode);
             }
             catch (error) {
                 // A broadcast transport error may mean the node accepted the signed
@@ -1072,26 +1105,58 @@ class EthereumTransactions {
                 throw submissionError;
             }
         };
-        this.sendFormattedTransactionInternal = async (params, isLegacy, beforeBroadcast, assertHostCurrent) => {
+        this.sendFormattedTransactionInternal = async (input, isLegacy, beforeBroadcast, assertHostCurrent, mode) => {
             // 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();
-            const assertCurrent = () => {
-                const result = assertHostCurrent?.();
-                if (result !== undefined) {
-                    assertSynchronousOriginalValidation(result, 'Transaction context guard must be synchronous');
-                    throw new Error('Transaction context guard must return undefined');
-                }
+            const assertSigningCurrent = () => {
+                assertHostCurrent();
                 assertKeyringCurrent();
             };
             const assertBeforeBroadcast = () => {
                 assertCurrent();
                 beforeBroadcast();
             };
-            assertCurrent();
-            const submission = this.captureSubmission('send', activeAccount, activeAccountType, activeAccountId, activeNetwork, assertCurrent);
+            const submission = this.captureSubmission('send', activeAccount, activeAccountType, activeAccountId, activeNetwork, assertSigningCurrent);
+            const assertCurrent = submission.assertCurrent;
+            if (mode === 'reviewed-native') {
+                const { transaction } = (0, prepared_evm_1.snapshotPreparedEvmRequest)({
+                    account: {
+                        id: activeAccountId,
+                        type: activeAccountType,
+                        expectedAddress: activeAccount.address,
+                    },
+                    network: {
+                        kind: activeNetwork.kind,
+                        chainId: String(activeNetwork.chainId),
+                        slip44: activeNetwork.slip44,
+                        url: activeNetwork.url,
+                    },
+                    transaction: input,
+                });
+                const minimum = this.gasOverrides.minGasLimit;
+                if (transaction.data !== '0x' ||
+                    BigInt(transaction.value) === 0n ||
+                    BigInt(transaction.gasLimit) < 21000n ||
+                    (transaction.type === 2 && BigInt(transaction.maxFeePerGas) === 0n) ||
+                    (minimum && BigInt(transaction.gasLimit) < minimum.toBigInt()) ||
+                    (isLegacy !== undefined && isLegacy !== (transaction.type === 0)))
+                    throw new Error('Invalid reviewed native transfer approval');
+                assertCurrent();
+                await provider.verifyConfiguredChainId();
+                assertCurrent();
+                if (this.gasOverrides.minGasLimit !== minimum)
+                    throw new Error('Reviewed native gas policy changed');
+                const { address, decryptedPrivateKey } = this.getDecryptedPrivateKey();
+                if (address.toLowerCase() !== transaction.from.toLowerCase())
+                    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);
+            }
             // Detach supplied values before any RPC/device await. Autofill updates only
             // this invocation; caller mutations cannot replace already supplied fields.
+            let params = input;
             if (!params || typeof params !== 'object' || Array.isArray(params))
                 throw new TypeError('Invalid EVM transaction request');
             const supplied = { ...params };
@@ -1232,7 +1297,7 @@ class EthereumTransactions {
                     rawTx: rawTx.replace('0x', ''),
                     accountIndex: activeAccountId,
                     expectedAddress: activeAccount.address,
-                });
+                }, await this.authorizeHardwareTransaction(provider, assertCurrent));
                 assertCurrent();
                 const formattedSignature = {
                     r: `0x${signature.r}`,
@@ -1243,7 +1308,7 @@ class EthereumTransactions {
                     try {
                         const signedTx = serializeTransaction(txFormattedForEthers, formattedSignature);
                         assertHardwareTransactionSender(signedTx, activeAccount.address);
-                        const finalTx = await (0, evm_submission_1.submitSignedEvmTransaction)(signedTx, (raw) => provider.sendTransaction(raw), submission, assertBeforeBroadcast, rawTx);
+                        const finalTx = await this.submitSignedHardwareTransaction(provider, signedTx, (raw) => provider.sendTransaction(raw), submission, assertBeforeBroadcast, rawTx);
                         return finalTx;
                     }
                     catch (error) {
@@ -1314,7 +1379,7 @@ class EthereumTransactions {
                     tx: txFormattedForTrezor,
                     coin: activeNetwork.currency,
                     slip44: activeNetwork.slip44,
-                });
+                }, await this.authorizeHardwareTransaction(provider, assertCurrent));
                 assertCurrent();
                 if (signature.success) {
                     try {
@@ -1333,7 +1398,7 @@ class EthereumTransactions {
                             };
                         const signedTx = serializeTransaction(txFormattedForEthers, trezorSignature(signature.payload));
                         assertHardwareTransactionSender(signedTx, activeAccount.address);
-                        const finalTx = await (0, evm_submission_1.submitSignedEvmTransaction)(signedTx, (raw) => provider.sendTransaction(raw), submission, assertBeforeBroadcast, expectedUnsignedTransaction);
+                        const finalTx = await this.submitSignedHardwareTransaction(provider, signedTx, (raw) => provider.sendTransaction(raw), submission, assertBeforeBroadcast, expectedUnsignedTransaction);
                         return finalTx;
                     }
                     catch (error) {
@@ -1377,35 +1442,37 @@ class EthereumTransactions {
                     return await sendEVMTransaction();
             }
         };
-        this.sendTransactionWithEditedFee = async (txHash, isLegacy = false, options = {}) => {
-            const { assertCurrentContext, validateOriginal, beforeBroadcast, approvedMaximumFee, } = options;
-            const previewOnly = options.previewOnly === true;
-            if (!previewOnly)
-                this.assertHardwareSignerAvailable(options.targetAccount);
+        this.sendTransactionWithEditedFee = async (txHash, isLegacy, options) => {
+            const previewOnly = options?.previewOnly === true;
+            const approvedMaximumFee = options?.approvedMaximumFee;
             if (!previewOnly &&
                 (typeof approvedMaximumFee !== 'string' ||
-                    !/^\d{1,78}$/.test(approvedMaximumFee))) {
+                    !/^(0|[1-9][0-9]{0,77})$/.test(approvedMaximumFee)))
                 throw new Error('Replacement fee approval required');
-            }
-            let signing;
-            const assertCurrent = () => {
-                const result = assertCurrentContext?.();
-                assertSynchronousOriginalValidation(result, 'Transaction context guard must be synchronous');
-                if (result !== undefined)
-                    throw new Error('Transaction context guard must return undefined');
-                signing?.assertCurrent();
+            if (typeof options?.assertCurrentContext !== 'function')
+                throw new Error('Replacement context required');
+            if (typeof options.validateOriginal !== 'function')
+                throw new Error('Replacement original validator required');
+            const { assertCurrentContext, validateOriginal, beforeBroadcast } = options;
+            if (!previewOnly)
+                this.assertHardwareSignerAvailable(options.targetAccount);
+            isLegacy ?? (isLegacy = false);
+            let assertCapturedSignerCurrent;
+            const assertSigningCurrent = () => {
+                assertSynchronousOriginalValidation(assertCurrentContext(), 'Transaction context guard must be synchronous');
+                assertCapturedSignerCurrent?.();
             };
             const assertBeforeBroadcast = () => {
-                assertCurrent();
-                beforeBroadcast?.();
-                assertCurrent();
+                assertSigningCurrent();
+                assertSynchronousOriginalValidation(beforeBroadcast?.(), 'Transaction broadcast guard must be synchronous');
+                assertSigningCurrent();
             };
             const assertSignedSender = (signedTx) => {
                 if (transaction_1.Transaction.from(signedTx).from?.toLowerCase() !== expectedSender) {
                     throw new Error('Replacement signature does not match account');
                 }
             };
-            assertCurrent();
+            assertSigningCurrent();
             const state = this.getState();
             const activeAccountType = options.targetAccount?.type ?? state.activeAccountType;
             const activeAccountId = options.targetAccount?.id ?? state.activeAccountId;
@@ -1421,14 +1488,16 @@ class EthereumTransactions {
                 throw new Error('Replacement signing account is unavailable');
             }
             if (!previewOnly)
-                signing = this.captureEvmSigningContext(targetAccount);
+                assertCapturedSignerCurrent =
+                    this.captureEvmSigningContext(targetAccount).assertCurrent;
             const expectedSender = activeAccount.address.toLowerCase();
             const requestedHash = txHash.toLowerCase();
             const provider = this.web3Provider;
-            assertCurrent();
+            assertSigningCurrent();
             const submission = previewOnly
                 ? undefined
-                : this.captureSubmission('speed-up', activeAccount, activeAccountType, activeAccountId, activeNetwork, assertCurrent, txHash);
+                : this.captureSubmission('speed-up', activeAccount, activeAccountType, activeAccountId, activeNetwork, assertSigningCurrent, txHash);
+            const assertCurrent = submission?.assertCurrent ?? assertSigningCurrent;
             const validateLookup = (transaction) => {
                 assertCurrent();
                 if (!transaction)
@@ -1442,7 +1511,7 @@ class EthereumTransactions {
                     activeAccountType === types_1.KeyringAccountType.Trezor) {
                     throw new Error('Trezor does not support type 1 replacement signing');
                 }
-                assertSynchronousOriginalValidation(validateOriginal?.(authenticated));
+                assertSynchronousOriginalValidation(validateOriginal(authenticated));
                 assertCurrent();
                 return authenticated;
             };
@@ -1541,7 +1610,7 @@ class EthereumTransactions {
                         maxPriorityFeePerGas: newGasValues.maxPriorityFeePerGas,
                     }),
             };
-            if (previewOnly)
+            if (!submission)
                 return { isSpeedUp: false, maximumFee: maximumFee.toString() };
             if (maximumFee.gt(approvedMaximumFee))
                 throw new Error('Replacement fee exceeds approval');
@@ -1572,7 +1641,7 @@ class EthereumTransactions {
                         rawTx: rawTx.replace('0x', ''),
                         accountIndex: activeAccountId,
                         expectedAddress: activeAccount.address,
-                    });
+                    }, await this.authorizeHardwareTransaction(provider, assertCurrent));
                     const formattedSignature = {
                         r: `0x${signature.r}`,
                         s: `0x${signature.s}`,
@@ -1582,7 +1651,7 @@ class EthereumTransactions {
                         const signedTx = serializeTransaction(txFormattedForEthers, formattedSignature);
                         assertSignedSender(signedTx);
                         assertHardwareTransactionSender(signedTx, activeAccount.address);
-                        const transactionResponse = await (0, evm_submission_1.submitSignedEvmTransaction)(signedTx, (raw) => provider.sendTransaction(raw), submission, assertBeforeBroadcast, rawTx);
+                        const transactionResponse = await this.submitSignedHardwareTransaction(provider, signedTx, (raw) => provider.sendTransaction(raw), submission, assertBeforeBroadcast, rawTx);
                         return {
                             isSpeedUp: true,
                             transaction: transactionResponse,
@@ -1658,12 +1727,12 @@ class EthereumTransactions {
                         tx: txFormattedForTrezor,
                         index: activeAccountId.toString(),
                         slip44: activeNetwork.slip44,
-                    });
+                    }, await this.authorizeHardwareTransaction(provider, assertCurrent));
                     if (signature.success) {
                         const signedTx = serializeTransaction(txFormattedForTrezor, trezorSignature(signature.payload));
                         assertSignedSender(signedTx);
                         assertHardwareTransactionSender(signedTx, activeAccount.address);
-                        const transactionResponse = await (0, evm_submission_1.submitSignedEvmTransaction)(signedTx, (raw) => provider.sendTransaction(raw), submission, assertBeforeBroadcast, expectedUnsignedTransaction);
+                        const transactionResponse = await this.submitSignedHardwareTransaction(provider, signedTx, (raw) => provider.sendTransaction(raw), submission, assertBeforeBroadcast, expectedUnsignedTransaction);
                         return {
                             isSpeedUp: true,
                             transaction: transactionResponse,
@@ -1748,44 +1817,51 @@ class EthereumTransactions {
                     return await speedUpWithPrivateKey();
             }
         };
-        this.sendSignedErc20Transaction = async ({ receiver, tokenAddress, tokenAmount, isLegacy = false, maxPriorityFeePerGas, maxFeePerGas, gasPrice, decimals, gasLimit, saveTrezorTx, }) => {
-            const { activeAccount, activeAccountType, activeAccountId, activeNetwork, provider, assertCurrent, } = this.captureEvmSigningContext();
+        this.sendSignedErc20Transaction = async (request, approval) => {
+            const { assertApproval, signal } = 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;
-            const submission = this.captureSubmission('erc20', activeAccount, activeAccountType, activeAccountId, activeNetwork, assertCurrent);
-            ({ gasPrice, isLegacy, maxFeePerGas, maxPriorityFeePerGas } =
-                await this.resolveEvmFeeParams({
-                    gasPrice,
-                    isLegacy,
-                    maxFeePerGas,
-                    maxPriorityFeePerGas,
-                }, provider));
-            assertCurrent();
+            if (networkUrl !== activeNetwork.url)
+                throw new Error('ERC20 transaction approval network changed');
+            if ('tokenAmount' in request ||
+                'decimals' in request ||
+                'tokenId' in request ||
+                typeof tokenAmountUnits !== 'string' ||
+                !/^(0|[1-9][0-9]{0,77})$/.test(tokenAmountUnits))
+                throw new Error('Invalid ERC20 amount');
+            const exactTokenAmount = (0, evm_fees_1.parseEvmFeeQuantity)(tokenAmountUnits, 'ERC20 amount');
+            const { gasLimit, isLegacy, gasPrice, maxFeePerGas, maxPriorityFeePerGas } = this.reviewedTokenFees(request, activeNetwork.chainId, 'ERC20');
+            const submission = this.captureSubmission('erc20', activeAccount, activeAccountType, activeAccountId, activeNetwork, () => {
+                assertApproval();
+                assertSigningCurrent();
+            });
+            const assertCurrent = submission.assertCurrent;
             const sendERC20Token = async () => {
                 assertCurrent();
                 const { decryptedPrivateKey } = this.getDecryptedPrivateKey();
                 try {
                     const _contract = new ethers_v6_1.Contract(tokenAddress, (0, sysweb3_utils_1.getErc20Abi)(), provider);
-                    // Preserve zero-decimal tokens: use provided decimals when defined (including 0).
-                    const resolvedDecimals = decimals === undefined || decimals === null ? 18 : Number(decimals);
-                    const calculatedTokenAmount = (0, ethers_v6_1.parseUnits)(tokenAmount, resolvedDecimals).toBigInt();
                     let transferMethod;
                     if (isLegacy) {
                         const overrides = {
                             nonce: await provider.getTransactionCount(activeAccountAddress, 'pending'),
                             gasPrice,
-                            ...(gasLimit && { gasLimit }),
+                            gasLimit,
                             type: 0, // Explicitly set Type 0 for legacy token transfers
                         };
-                        transferMethod = await _contract.transfer.populateTransaction(receiver, calculatedTokenAmount, normalizeEthersOverrides(overrides));
+                        assertCurrent();
+                        transferMethod = await _contract.transfer.populateTransaction(receiver, exactTokenAmount, normalizeEthersOverrides(overrides));
                     }
                     else {
                         const overrides = {
                             nonce: await provider.getTransactionCount(activeAccountAddress, 'pending'),
                             maxPriorityFeePerGas,
                             maxFeePerGas,
-                            ...(gasLimit && { gasLimit }),
+                            gasLimit,
                         };
-                        transferMethod = await _contract.transfer.populateTransaction(receiver, calculatedTokenAmount, normalizeEthersOverrides(overrides));
+                        assertCurrent();
+                        transferMethod = await _contract.transfer.populateTransaction(receiver, exactTokenAmount, normalizeEthersOverrides(overrides));
                     }
                     return await (0, evm_local_signer_1.sendLocalEvmTransaction)(provider, decryptedPrivateKey, {
                         ...transferMethod,
@@ -1804,20 +1880,16 @@ class EthereumTransactions {
                 assertCurrent();
                 try {
                     const _contract = new ethers_v6_1.Contract(tokenAddress, (0, sysweb3_utils_1.getErc20Abi)(), provider);
-                    const resolvedDecimals = decimals === undefined || decimals === null ? 18 : Number(decimals);
-                    const calculatedTokenAmount = (0, ethers_v6_1.parseUnits)(tokenAmount, resolvedDecimals).toBigInt();
                     const txData = _contract.interface.encodeFunctionData('transfer', [
                         receiver,
-                        calculatedTokenAmount,
+                        exactTokenAmount,
                     ]);
-                    // Use fallback gas limit if not provided (for auto-estimation)
-                    const effectiveGasLimit = gasLimit || this.toBigNumber('100000'); // ERC20 fallback
                     let txFormattedForEthers;
                     if (isLegacy) {
                         txFormattedForEthers = {
                             to: tokenAddress,
                             value: '0x0',
-                            gasLimit: effectiveGasLimit,
+                            gasLimit: gasLimit,
                             gasPrice,
                             data: txData,
                             nonce: transactionNonce,
@@ -1829,7 +1901,7 @@ class EthereumTransactions {
                         txFormattedForEthers = {
                             to: tokenAddress,
                             value: '0x0',
-                            gasLimit: effectiveGasLimit,
+                            gasLimit: gasLimit,
                             maxFeePerGas,
                             maxPriorityFeePerGas,
                             data: txData,
@@ -1843,7 +1915,7 @@ class EthereumTransactions {
                         rawTx: rawTx.replace('0x', ''),
                         accountIndex: activeAccountId,
                         expectedAddress: activeAccount.address,
-                    });
+                    }, await this.authorizeHardwareTransaction(provider, assertCurrent, signal));
                     assertCurrent();
                     const formattedSignature = {
                         r: `0x${signature.r}`,
@@ -1855,7 +1927,7 @@ class EthereumTransactions {
                             const signedTx = serializeTransaction(txFormattedForEthers, formattedSignature);
                             assertCurrent();
                             assertHardwareTransactionSender(signedTx, activeAccount.address);
-                            const finalTx = await (0, evm_submission_1.submitSignedEvmTransaction)(signedTx, async (raw) => {
+                            const finalTx = await this.submitSignedHardwareTransaction(provider, signedTx, async (raw) => {
                                 const response = await provider.sendTransaction(raw);
                                 saveTrezorTx && saveTrezorTx(response);
                                 return response;
@@ -1880,20 +1952,16 @@ class EthereumTransactions {
                 assertCurrent();
                 try {
                     const _contract = new ethers_v6_1.Contract(tokenAddress, (0, sysweb3_utils_1.getErc20Abi)(), provider);
-                    const resolvedDecimals = decimals === undefined || decimals === null ? 18 : Number(decimals);
-                    const calculatedTokenAmount = (0, ethers_v6_1.parseUnits)(tokenAmount, resolvedDecimals).toBigInt();
                     const txData = _contract.interface.encodeFunctionData('transfer', [
                         receiver,
-                        calculatedTokenAmount,
+                        exactTokenAmount,
                     ]);
-                    // Use fallback gas limit if not provided (for auto-estimation)
-                    const effectiveGasLimit = gasLimit || this.toBigNumber('100000'); // ERC20 fallback
                     let txToBeSignedByTrezor;
                     if (isLegacy) {
                         txToBeSignedByTrezor = {
                             to: tokenAddress,
                             value: '0x0',
-                            gasLimit: this.toHex0x(effectiveGasLimit, 'gasLimit'),
+                            gasLimit: this.toHex0x(gasLimit, 'gasLimit'),
                             gasPrice: this.toHex0x(gasPrice, 'gasPrice'),
                             nonce: this.toBigNumber(transactionNonce)._hex,
                             chainId: activeNetwork.chainId,
@@ -1904,7 +1972,7 @@ class EthereumTransactions {
                         txToBeSignedByTrezor = {
                             to: tokenAddress,
                             value: '0x0',
-                            gasLimit: this.toHex0x(effectiveGasLimit, 'gasLimit'),
+                            gasLimit: this.toHex0x(gasLimit, 'gasLimit'),
                             maxFeePerGas: this.toHex0x(maxFeePerGas, 'maxFeePerGas'),
                             maxPriorityFeePerGas: this.toHex0x(maxPriorityFeePerGas, 'maxPriorityFeePerGas'),
                             nonce: this.toBigNumber(transactionNonce)._hex,
@@ -1922,7 +1990,7 @@ class EthereumTransactions {
                         tx: txToBeSignedByTrezor,
                         coin: activeNetwork.currency,
                         slip44: activeNetwork.slip44,
-                    });
+                    }, await this.authorizeHardwareTransaction(provider, assertCurrent, signal));
                     assertCurrent();
                     if (signature.success) {
                         try {
@@ -1931,7 +1999,7 @@ class EthereumTransactions {
                                 txFormattedForEthers = {
                                     to: tokenAddress,
                                     value: '0x0',
-                                    gasLimit: effectiveGasLimit,
+                                    gasLimit: gasLimit,
                                     gasPrice,
                                     data: txData,
                                     nonce: transactionNonce,
@@ -1943,7 +2011,7 @@ class EthereumTransactions {
                                 txFormattedForEthers = {
                                     to: tokenAddress,
                                     value: '0x0',
-                                    gasLimit: effectiveGasLimit,
+                                    gasLimit: gasLimit,
                                     maxFeePerGas,
                                     maxPriorityFeePerGas,
                                     data: txData,
@@ -1955,7 +2023,7 @@ class EthereumTransactions {
                             const signedTx = serializeTransaction(txFormattedForEthers, trezorSignature(signature.payload));
                             assertCurrent();
                             assertHardwareTransactionSender(signedTx, activeAccount.address);
-                            const finalTx = await (0, evm_submission_1.submitSignedEvmTransaction)(signedTx, async (raw) => {
+                            const finalTx = await this.submitSignedHardwareTransaction(provider, signedTx, async (raw) => {
                                 const response = await provider.sendTransaction(raw);
                                 saveTrezorTx && saveTrezorTx(response);
                                 return response;
@@ -1983,22 +2051,26 @@ class EthereumTransactions {
                     return (await sendERC20Token());
             }
         };
-        this.sendSignedErc721Transaction = async ({ receiver, tokenAddress, tokenId, isLegacy, maxPriorityFeePerGas, maxFeePerGas, gasPrice, gasLimit, }) => {
-            const { activeAccount, activeAccountType, activeAccountId, activeNetwork, provider, assertCurrent, } = this.captureEvmSigningContext();
+        this.sendSignedErc721Transaction = async (request, approval) => {
+            const { assertApproval, signal } = this.captureReviewedTokenApproval(approval, 'ERC721');
+            const { receiver, tokenAddress, tokenId, networkUrl } = request;
+            const { activeAccount, activeAccountType, activeAccountId, activeNetwork, provider, assertCurrent: assertSigningCurrent, } = this.captureEvmSigningContext();
+            if (networkUrl !== activeNetwork.url)
+                throw new Error('ERC721 transaction approval network changed');
+            if ('tokenAmountUnits' in request || 'decimals' in request)
+                throw new Error('ERC20 amount is not allowed for NFT transfers');
+            if (typeof tokenId !== 'string' || !/^(0|[1-9][0-9]{0,77})$/.test(tokenId))
+                throw new Error('Invalid ERC721 token ID');
+            const normalizedTokenId = (0, evm_fees_1.parseEvmFeeQuantity)(tokenId, 'ERC721 token ID');
+            if ('tokenAmount' in request)
+                throw new Error('ERC721 transfer must contain one token');
+            const { gasLimit, isLegacy, gasPrice, maxFeePerGas, maxPriorityFeePerGas } = this.reviewedTokenFees(request, activeNetwork.chainId, 'ERC721');
             const activeAccountAddress = activeAccount.address;
-            const submission = this.captureSubmission('erc721', activeAccount, activeAccountType, activeAccountId, activeNetwork, assertCurrent);
-            if (tokenId === undefined || tokenId === null) {
-                throw new Error('ERC721 tokenId is required');
-            }
-            ({ gasPrice, isLegacy, maxFeePerGas, maxPriorityFeePerGas } =
-                await this.resolveEvmFeeParams({
-                    gasPrice,
-                    isLegacy,
-                    maxFeePerGas,
-                    maxPriorityFeePerGas,
-                }, provider));
-            assertCurrent();
-            const normalizedTokenId = ethers_v6_1.BigNumber.from(tokenId).toBigInt();
+            const submission = this.captureSubmission('erc721', activeAccount, activeAccountType, activeAccountId, activeNetwork, () => {
+                assertApproval();
+                assertSigningCurrent();
+            });
+            const assertCurrent = submission.assertCurrent;
             const sendERC721Token = async () => {
                 assertCurrent();
                 const { decryptedPrivateKey } = this.getDecryptedPrivateKey();
@@ -2009,7 +2081,7 @@ class EthereumTransactions {
                         const overrides = {
                             nonce: await provider.getTransactionCount(activeAccountAddress, 'pending'),
                             gasPrice,
-                            ...(gasLimit && { gasLimit }),
+                            gasLimit,
                             type: 0, // Explicitly set Type 0 for legacy NFT transfers
                         };
                         transferMethod = await _contract.transferFrom.populateTransaction(activeAccountAddress, receiver, normalizedTokenId, normalizeEthersOverrides(overrides));
@@ -2019,7 +2091,7 @@ class EthereumTransactions {
                             nonce: await provider.getTransactionCount(activeAccountAddress, 'pending'),
                             maxPriorityFeePerGas,
                             maxFeePerGas,
-                            ...(gasLimit && { gasLimit }),
+                            gasLimit,
                         };
                         transferMethod = await _contract.transferFrom.populateTransaction(activeAccountAddress, receiver, normalizedTokenId, normalizeEthersOverrides(overrides));
                     }
@@ -2045,14 +2117,12 @@ class EthereumTransactions {
                         receiver,
                         normalizedTokenId,
                     ]);
-                    // Use fallback gas limit if not provided (for auto-estimation)
-                    const effectiveGasLimit = gasLimit || this.toBigNumber('150000'); // ERC721 fallback
                     let txFormattedForEthers;
                     if (isLegacy) {
                         txFormattedForEthers = {
                             to: tokenAddress,
                             value: '0x0',
-                            gasLimit: effectiveGasLimit,
+                            gasLimit,
                             gasPrice,
                             data: txData,
                             nonce: transactionNonce,
@@ -2064,7 +2134,7 @@ class EthereumTransactions {
                         txFormattedForEthers = {
                             to: tokenAddress,
                             value: '0x0',
-                            gasLimit: effectiveGasLimit,
+                            gasLimit,
                             maxFeePerGas,
                             maxPriorityFeePerGas,
                             data: txData,
@@ -2078,7 +2148,7 @@ class EthereumTransactions {
                         rawTx: rawTx.replace('0x', ''),
                         accountIndex: activeAccountId,
                         expectedAddress: activeAccount.address,
-                    });
+                    }, await this.authorizeHardwareTransaction(provider, assertCurrent, signal));
                     assertCurrent();
                     const formattedSignature = {
                         r: `0x${signature.r}`,
@@ -2090,7 +2160,7 @@ class EthereumTransactions {
                             const signedTx = serializeTransaction(txFormattedForEthers, formattedSignature);
                             assertCurrent();
                             assertHardwareTransactionSender(signedTx, activeAccount.address);
-                            const finalTx = await (0, evm_submission_1.submitSignedEvmTransaction)(signedTx, (raw) => provider.sendTransaction(raw), submission, undefined, rawTx);
+                            const finalTx = await this.submitSignedHardwareTransaction(provider, signedTx, (raw) => provider.sendTransaction(raw), submission, undefined, rawTx);
                             return finalTx;
                         }
                         catch (error) {
@@ -2116,14 +2186,12 @@ class EthereumTransactions {
                         receiver,
                         normalizedTokenId,
                     ]);
-                    // Use fallback gas limit if not provided (for auto-estimation)
-                    const effectiveGasLimit = gasLimit || this.toBigNumber('150000'); // ERC721 fallback
                     let txToBeSignedByTrezor;
                     if (isLegacy) {
                         txToBeSignedByTrezor = {
                             to: tokenAddress,
                             value: '0x0',
-                            gasLimit: this.toHex0x(effectiveGasLimit, 'gasLimit'),
+                            gasLimit: this.toHex0x(gasLimit, 'gasLimit'),
                             gasPrice: this.toHex0x(gasPrice, 'gasPrice'),
                             nonce: this.toBigNumber(transactionNonce)._hex,
                             chainId: activeNetwork.chainId,
@@ -2135,7 +2203,7 @@ class EthereumTransactions {
                         txToBeSignedByTrezor = {
                             to: tokenAddress,
                             value: '0x0',
-                            gasLimit: this.toHex0x(effectiveGasLimit, 'gasLimit'),
+                            gasLimit: this.toHex0x(gasLimit, 'gasLimit'),
                             maxFeePerGas: this.toHex0x(maxFeePerGas, 'maxFeePerGas'),
                             maxPriorityFeePerGas: this.toHex0x(maxPriorityFeePerGas, 'maxPriorityFeePerGas'),
                             nonce: this.toBigNumber(transactionNonce)._hex,
@@ -2155,7 +2223,7 @@ class EthereumTransactions {
                         tx: txToBeSignedByTrezor,
                         coin: trezorCoin,
                         slip44: activeNetwork.slip44,
-                    });
+                    }, await this.authorizeHardwareTransaction(provider, assertCurrent, signal));
                     assertCurrent();
                     if (signature.success) {
                         try {
@@ -2164,7 +2232,7 @@ class EthereumTransactions {
                                 txFormattedForEthers = {
                                     to: tokenAddress,
                                     value: '0x0',
-                                    gasLimit: effectiveGasLimit,
+                                    gasLimit,
                                     gasPrice,
                                     data: txData,
                                     nonce: transactionNonce,
@@ -2176,7 +2244,7 @@ class EthereumTransactions {
                                 txFormattedForEthers = {
                                     to: tokenAddress,
                                     value: '0x0',
-                                    gasLimit: effectiveGasLimit,
+                                    gasLimit,
                                     maxFeePerGas,
                                     maxPriorityFeePerGas,
                                     data: txData,
@@ -2188,7 +2256,7 @@ class EthereumTransactions {
                             const signedTx = serializeTransaction(txFormattedForEthers, trezorSignature(signature.payload));
                             assertCurrent();
                             assertHardwareTransactionSender(signedTx, activeAccount.address);
-                            const finalTx = await (0, evm_submission_1.submitSignedEvmTransaction)(signedTx, (raw) => provider.sendTransaction(raw), submission, undefined, expectedUnsignedTransaction);
+                            const finalTx = await this.submitSignedHardwareTransaction(provider, signedTx, (raw) => provider.sendTransaction(raw), submission, undefined, expectedUnsignedTransaction);
                             return finalTx;
                         }
                         catch (error) {
@@ -2214,18 +2282,29 @@ class EthereumTransactions {
                     return (await sendERC721Token());
             }
         };
-        this.sendSignedErc1155Transaction = async ({ receiver, tokenAddress, tokenId, tokenAmount, isLegacy, maxPriorityFeePerGas, maxFeePerGas, gasPrice, gasLimit, }) => {
-            const { activeAccount, activeAccountType, activeAccountId, activeNetwork, provider, assertCurrent, } = this.captureEvmSigningContext();
+        this.sendSignedErc1155Transaction = async (request, approval) => {
+            const { assertApproval, signal } = this.captureReviewedTokenApproval(approval, 'ERC1155');
+            const { receiver, tokenAddress, tokenId, networkUrl } = request;
+            const { activeAccount, activeAccountType, activeAccountId, activeNetwork, provider, assertCurrent: assertSigningCurrent, } = this.captureEvmSigningContext();
+            if (networkUrl !== activeNetwork.url)
+                throw new Error('ERC1155 transaction approval network changed');
+            if ('tokenAmountUnits' in request || 'decimals' in request)
+                throw new Error('ERC20 amount is not allowed for NFT transfers');
+            if (typeof tokenId !== 'string' || !/^(0|[1-9][0-9]{0,77})$/.test(tokenId))
+                throw new Error('Invalid ERC1155 token ID');
+            const normalizedTokenId = (0, evm_fees_1.parseEvmFeeQuantity)(tokenId, 'ERC1155 token ID');
+            const { tokenAmount } = request;
+            if (typeof tokenAmount !== 'string' ||
+                !/^[1-9][0-9]{0,77}$/.test(tokenAmount))
+                throw new Error('Invalid ERC1155 amount');
+            const amount = (0, evm_fees_1.parseEvmFeeQuantity)(tokenAmount, 'ERC1155 amount');
+            const { gasLimit, isLegacy, gasPrice, maxFeePerGas, maxPriorityFeePerGas } = this.reviewedTokenFees(request, activeNetwork.chainId, 'ERC1155');
             const activeAccountAddress = activeAccount.address;
-            const submission = this.captureSubmission('erc1155', activeAccount, activeAccountType, activeAccountId, activeNetwork, assertCurrent);
-            ({ gasPrice, isLegacy, maxFeePerGas, maxPriorityFeePerGas } =
-                await this.resolveEvmFeeParams({
-                    gasPrice,
-                    isLegacy,
-                    maxFeePerGas,
-                    maxPriorityFeePerGas,
-                }, provider));
-            assertCurrent();
+            const submission = this.captureSubmission('erc1155', activeAccount, activeAccountType, activeAccountId, activeNetwork, () => {
+                assertApproval();
+                assertSigningCurrent();
+            });
+            const assertCurrent = submission.assertCurrent;
             const sendERC1155Token = async () => {
                 assertCurrent();
                 const { decryptedPrivateKey } = this.getDecryptedPrivateKey();
@@ -2233,13 +2312,12 @@ class EthereumTransactions {
                 try {
                     const _contract = new ethers_v6_1.Contract(tokenAddress, (0, sysweb3_utils_1.getErc55Abi)(), provider);
                     // Use BigNumber to avoid JS number overflow/precision loss
-                    const amount = ethers_v6_1.BigNumber.from(tokenAmount ?? '1');
                     let overrides;
                     if (isLegacy) {
                         overrides = {
                             nonce: await provider.getTransactionCount(activeAccountAddress, 'pending'),
                             gasPrice,
-                            ...(gasLimit && { gasLimit }),
+                            gasLimit,
                             type: 0, // Explicitly set Type 0 for legacy ERC1155 transfers
                         };
                     }
@@ -2248,10 +2326,10 @@ class EthereumTransactions {
                             nonce: await provider.getTransactionCount(activeAccountAddress, 'pending'),
                             maxPriorityFeePerGas,
                             maxFeePerGas,
-                            ...(gasLimit && { gasLimit }),
+                            gasLimit,
                         };
                     }
-                    transferMethod = await _contract.safeTransferFrom.populateTransaction(activeAccountAddress, receiver, tokenId, amount.toBigInt(), '0x', normalizeEthersOverrides(overrides));
+                    transferMethod = await _contract.safeTransferFrom.populateTransaction(activeAccountAddress, receiver, normalizedTokenId, amount, '0x', normalizeEthersOverrides(overrides));
                     return await (0, evm_local_signer_1.sendLocalEvmTransaction)(provider, decryptedPrivateKey, {
                         ...transferMethod,
                         chainId: activeNetwork.chainId,
@@ -2269,16 +2347,13 @@ class EthereumTransactions {
                 assertCurrent();
                 try {
                     const _contract = new ethers_v6_1.Contract(tokenAddress, (0, sysweb3_utils_1.getErc55Abi)(), provider);
-                    const amount = ethers_v6_1.BigNumber.from(tokenAmount ?? '1');
-                    const txData = _contract.interface.encodeFunctionData('safeTransferFrom', [activeAccountAddress, receiver, tokenId, amount.toBigInt(), '0x']);
-                    // Use fallback gas limit if not provided (for auto-estimation)
-                    const effectiveGasLimit = gasLimit || this.toBigNumber('200000'); // ERC1155 fallback
+                    const txData = _contract.interface.encodeFunctionData('safeTransferFrom', [activeAccountAddress, receiver, normalizedTokenId, amount, '0x']);
                     let txFormattedForEthers;
                     if (isLegacy) {
                         txFormattedForEthers = {
                             to: tokenAddress,
                             value: '0x0',
-                            gasLimit: effectiveGasLimit,
+                            gasLimit,
                             gasPrice,
                             data: txData,
                             nonce: transactionNonce,
@@ -2290,7 +2365,7 @@ class EthereumTransactions {
                         txFormattedForEthers = {
                             to: tokenAddress,
                             value: '0x0',
-                            gasLimit: effectiveGasLimit,
+                            gasLimit,
                             maxFeePerGas,
                             maxPriorityFeePerGas,
                             data: txData,
@@ -2304,7 +2379,7 @@ class EthereumTransactions {
                         rawTx: rawTx.replace('0x', ''),
                         accountIndex: activeAccountId,
                         expectedAddress: activeAccount.address,
-                    });
+                    }, await this.authorizeHardwareTransaction(provider, assertCurrent, signal));
                     assertCurrent();
                     const formattedSignature = {
                         r: `0x${signature.r}`,
@@ -2316,7 +2391,7 @@ class EthereumTransactions {
                             const signedTx = serializeTransaction(txFormattedForEthers, formattedSignature);
                             assertCurrent();
                             assertHardwareTransactionSender(signedTx, activeAccount.address);
-                            const finalTx = await (0, evm_submission_1.submitSignedEvmTransaction)(signedTx, (raw) => provider.sendTransaction(raw), submission, undefined, rawTx);
+                            const finalTx = await this.submitSignedHardwareTransaction(provider, signedTx, (raw) => provider.sendTransaction(raw), submission, undefined, rawTx);
                             return finalTx;
                         }
                         catch (error) {
@@ -2337,16 +2412,13 @@ class EthereumTransactions {
                 assertCurrent();
                 try {
                     const _contract = new ethers_v6_1.Contract(tokenAddress, (0, sysweb3_utils_1.getErc55Abi)(), provider);
-                    const amount = ethers_v6_1.BigNumber.from(tokenAmount ?? '1');
-                    const txData = _contract.interface.encodeFunctionData('safeTransferFrom', [activeAccountAddress, receiver, tokenId, amount.toBigInt(), '0x']);
-                    // Use fallback gas limit if not provided (for auto-estimation)
-                    const effectiveGasLimit = gasLimit || this.toBigNumber('200000'); // ERC1155 fallback
+                    const txData = _contract.interface.encodeFunctionData('safeTransferFrom', [activeAccountAddress, receiver, normalizedTokenId, amount, '0x']);
                     let txToBeSignedByTrezor;
                     if (isLegacy) {
                         txToBeSignedByTrezor = {
                             to: tokenAddress,
                             value: '0x0',
-                            gasLimit: this.toHex0x(effectiveGasLimit, 'gasLimit'),
+                            gasLimit: this.toHex0x(gasLimit, 'gasLimit'),
                             gasPrice: this.toHex0x(gasPrice, 'gasPrice'),
                             nonce: this.toBigNumber(transactionNonce)._hex,
                             chainId: activeNetwork.chainId,
@@ -2357,7 +2429,7 @@ class EthereumTransactions {
                         txToBeSignedByTrezor = {
                             to: tokenAddress,
                             value: '0x0',
-                            gasLimit: this.toHex0x(effectiveGasLimit, 'gasLimit'),
+                            gasLimit: this.toHex0x(gasLimit, 'gasLimit'),
                             maxFeePerGas: this.toHex0x(maxFeePerGas, 'maxFeePerGas'),
                             maxPriorityFeePerGas: this.toHex0x(maxPriorityFeePerGas, 'maxPriorityFeePerGas'),
                             nonce: this.toBigNumber(transactionNonce)._hex,
@@ -2375,7 +2447,7 @@ class EthereumTransactions {
                         tx: txToBeSignedByTrezor,
                         coin: activeNetwork.currency,
                         slip44: activeNetwork.slip44,
-                    });
+                    }, await this.authorizeHardwareTransaction(provider, assertCurrent, signal));
                     assertCurrent();
                     if (signature.success) {
                         try {
@@ -2384,7 +2456,7 @@ class EthereumTransactions {
                                 txFormattedForEthers = {
                                     to: tokenAddress,
                                     value: '0x0',
-                                    gasLimit: effectiveGasLimit,
+                                    gasLimit,
                                     gasPrice,
                                     data: txData,
                                     nonce: transactionNonce,
@@ -2396,7 +2468,7 @@ class EthereumTransactions {
                                 txFormattedForEthers = {
                                     to: tokenAddress,
                                     value: '0x0',
-                                    gasLimit: effectiveGasLimit,
+                                    gasLimit,
                                     maxFeePerGas,
                                     maxPriorityFeePerGas,
                                     data: txData,
@@ -2408,7 +2480,7 @@ class EthereumTransactions {
                             const signedTx = serializeTransaction(txFormattedForEthers, trezorSignature(signature.payload));
                             assertCurrent();
                             assertHardwareTransactionSender(signedTx, activeAccount.address);
-                            const finalTx = await (0, evm_submission_1.submitSignedEvmTransaction)(signedTx, (raw) => provider.sendTransaction(raw), submission, undefined, expectedUnsignedTransaction);
+                            const finalTx = await this.submitSignedHardwareTransaction(provider, signedTx, (raw) => provider.sendTransaction(raw), submission, undefined, expectedUnsignedTransaction);
                             return finalTx;
                         }
                         catch (error) {
@@ -2608,6 +2680,11 @@ class EthereumTransactions {
                 maxPriorityFeePerGas: feeData.maxPriorityFeePerGas,
             };
         };
+        if (typeof captureSigningContext !== 'function')
+            throw new TypeError('Ethereum transactions require a signing context');
+        if (captureSubmissionLifecycle !== null &&
+            typeof captureSubmissionLifecycle !== 'function')
+            throw new TypeError('Ethereum transactions require an explicit submission capability');
         this.getNetwork = getNetwork;
         this.getDecryptedPrivateKey = (targetAccount) => {
             this.assertHardwareSignerAvailable(targetAccount);
@@ -2634,11 +2711,13 @@ class EthereumTransactions {
         // RPC/network than `activeNetwork`, nodes will reject broadcasts with chain-id mismatch errors.
         try {
             const currentNetwork = this.getNetwork();
-            const currentUrl = currentNetwork?.url;
-            const currentKey = `${currentNetwork?.chainId ?? 'unknown'}|${currentUrl ?? ''}`;
-            const needsInit = !this._web3Provider ||
-                !this._web3ProviderKey ||
-                (currentUrl && this._web3ProviderKey !== currentKey);
+            if (currentNetwork?.kind !== sysweb3_network_1.INetworkType.Ethereum) {
+                if (this._web3Provider)
+                    this.setWeb3Provider(currentNetwork);
+                return;
+            }
+            const currentKey = `${currentNetwork.chainId}|${currentNetwork.url ?? ''}`;
+            const needsInit = !this._web3Provider || this._web3ProviderKey !== currentKey;
             if (needsInit) {
                 this.setWeb3Provider(currentNetwork);
             }
@@ -2649,31 +2728,16 @@ class EthereumTransactions {
             console.log('[EthereumTransactions] Deferring provider initialization:', error?.message || error);
         }
     }
-    // Helper method to detect UTXO networks
-    isUtxoNetwork(network) {
-        // Generic UTXO network detection patterns:
-        // 1. URL contains blockbook or trezor (most reliable)
-        // 2. Network kind is explicitly set to 'syscoin'
-        const hasBlockbookUrl = !!(network.url?.includes('blockbook') || network.url?.includes('trezor'));
-        const hasUtxoKind = network.kind === sysweb3_network_1.INetworkType.Syscoin;
-        return hasBlockbookUrl || hasUtxoKind;
-    }
     setWeb3Provider(network) {
         this.abortController.abort();
         this.abortController = new AbortController();
-        // Check if network is a UTXO network to avoid creating web3 providers for blockbook URLs
-        const isUtxoNetwork = this.isUtxoNetwork(network);
-        if (isUtxoNetwork) {
-            // For UTXO networks, don't create web3 providers at all since they won't be used
-            console.log('[EthereumTransactions] setWeb3Provider: Skipping web3Provider creation for UTXO network:', network.url);
-            // Clear any existing providers for UTXO networks
+        if (network?.kind !== sysweb3_network_1.INetworkType.Ethereum) {
             this._web3Provider = undefined;
             this._web3ProviderKey = undefined;
+            return;
         }
-        else {
-            this._web3Provider = new providers_1.CustomJsonRpcProvider(this.abortController.signal, network.url, network.chainId);
-            this._web3ProviderKey = `${network.chainId}|${network.url ?? ''}`;
-        }
+        this._web3Provider = new providers_1.CustomJsonRpcProvider(this.abortController.signal, network.url, network.chainId);
+        this._web3ProviderKey = `${network.chainId}|${network.url ?? ''}`;
     }
     // Method to configure gas overrides for networks with validation issues
     setGasOverrides(overrides) {