@sidhujag/sysweb3-keyring 2.1.0 → 2.1.2

package/cjs/transactions/ethereum.js

@@ -8,11 +8,14 @@ const eth_sig_util_1 = require("@metamask/eth-sig-util");
 const sysweb3_network_1 = require("@sidhujag/sysweb3-network");
 const sysweb3_utils_1 = require("@sidhujag/sysweb3-utils");
 const transaction_1 = require("ethers/transaction");
+const utils_1 = require("ethers/utils");
 const omit_1 = __importDefault(require("lodash/omit"));
 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_local_signer_1 = require("./evm-local-signer");
+const evm_submission_1 = require("./evm-submission");
 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',
@@ -25,7 +28,11 @@ const assertHardwareTransactionSender = (signedTx, expectedAddress) => {
         });
     }
 };
-const stripHexPrefix = (value) => value.startsWith('0x') || value.startsWith('0X') ? value.slice(2) : value;
+const stripHexPrefix = (value) => {
+    return value.startsWith('0x') || value.startsWith('0X')
+        ? value.slice(2)
+        : value;
+};
 // Connect returns hexadecimal signature fields; normalize their encoding
 // without mutating the response or reparsing an already numeric recovery v.
 const trezorSignature = (signature) => {
@@ -47,55 +54,14 @@ const trezorSignature = (signature) => {
     };
 };
 const normalizeEthersOverrideValue = (value) => (0, ethers_v6_1.normalizeTxValue)(value);
-const nonNegativeFeeQuantity = (value, label) => {
-    // Match the exported BigNumberish object contract without trusting a
-    // private marker or BigNumber.from's null/empty-to-zero coercions. Normalize
-    // once so validation and conversion use the same integer representation.
-    if (value !== null && typeof value === 'object') {
-        const objectValue = value;
-        value =
-            objectValue._hex ??
-                objectValue.hex ??
-                (typeof objectValue.toString === 'function'
-                    ? objectValue.toString()
-                    : undefined);
-        if (typeof value !== 'string')
-            throw new Error(`Invalid ${label}`);
-    }
-    if (!((typeof value === 'string' && /^(?:0x[\da-f]+|\d+)$/i.test(value)) ||
-        (typeof value === 'number' &&
-            Number.isSafeInteger(value) &&
-            value >= 0) ||
-        (typeof value === 'bigint' && value >= 0n)))
-        throw new Error(`Invalid ${label}`);
-    const quantity = ethers_v6_1.BigNumber.from(value);
-    if (quantity.isNegative())
-        throw new Error(`Invalid ${label}`);
-    return quantity;
-};
-const isUnsupportedPriorityFeeRpc = (error) => {
-    const unsupportedCode = (code) => code === -32601 || code === 4200;
-    if (unsupportedCode(error?.code))
-        return true;
-    // Ethers' HTTP normalizer retains the matched JSON-RPC error and request
-    // under one of these two shapes. A generic outer unsupported/network error
-    // is not evidence that this particular RPC method is unavailable.
-    if (!['UNKNOWN_ERROR', 'UNSUPPORTED_OPERATION'].includes(error?.code)) {
-        return false;
-    }
-    if (error?.operation != null &&
-        error.operation !== 'eth_maxPriorityFeePerGas') {
-        return false;
-    }
-    return [
-        { cause: error.error, payload: error.payload },
-        { cause: error.info?.error, payload: error.info?.payload },
-    ].some(({ cause, payload }) => cause?.name !== 'AbortError' &&
-        unsupportedCode(cause?.code) &&
-        payload?.method === 'eth_maxPriorityFeePerGas' &&
-        Array.isArray(payload.params) &&
-        payload.params.length === 0);
+// The same protocol bound applies to software and external-device envelopes.
+// Keep this at serialization as well as before handing a request to a device.
+const assertTransactionGasLimit = (transaction) => (0, evm_fees_1.assertEvmGasLimit)((0, evm_fees_1.parseEvmFeeQuantity)(transaction.gasLimit, 'gas limit'), (0, evm_fees_1.parseEvmFeeQuantity)(transaction.chainId ?? 0, 'chain ID'));
+const serializeTransaction = (...args) => {
+    const snapshot = (0, evm_local_signer_1.normalizeGasLimitedTransaction)(args[0]);
+    return (0, ethers_v6_1.serializeTransaction)(snapshot, args[1]);
 };
+const nonNegativeFeeQuantity = (value, label) => ethers_v6_1.BigNumber.from((0, evm_fees_1.parseEvmFeeQuantity)(value, label));
 const normalizeEthersOverrides = (overrides) => {
     const normalized = { ...overrides };
     for (const field of [
@@ -159,7 +125,7 @@ const assertSynchronousOriginalValidation = (result, message = 'Original transac
     }
 };
 class EthereumTransactions {
-    constructor(getNetwork, getDecryptedPrivateKey, getState, ledgerSigner, trezorSigner, captureSigningContext) {
+    constructor(getNetwork, getDecryptedPrivateKey, getState, ledgerSigner, trezorSigner, captureSigningContext, captureSubmissionLifecycle) {
         // Allow manual override of gas parameters when automatic estimation fails
         this.gasOverrides = {};
         this.requireLedgerSigner = () => {
@@ -182,22 +148,29 @@ class EthereumTransactions {
             if (type === types_1.KeyringAccountType.Trezor || account?.isTrezorWallet)
                 this.requireTrezorSigner();
         };
-        this.captureEvmSigningContext = () => {
-            this.assertHardwareSignerAvailable();
-            const { activeAccountType, activeAccountId, accounts, activeNetwork } = this.getState();
-            const selectedAccount = accounts[activeAccountType]?.[activeAccountId];
-            if (!selectedAccount)
+        this.captureEvmSigningContext = (target) => {
+            this.assertHardwareSignerAvailable(target);
+            const state = this.getState();
+            const selectedType = state.activeAccountType;
+            const selectedId = state.activeAccountId;
+            const selectedAddress = state.accounts[selectedType]?.[selectedId]?.address;
+            const activeAccountType = target?.type ?? selectedType;
+            const activeAccountId = target?.id ?? selectedId;
+            const selectedAccount = state.accounts[activeAccountType]?.[activeAccountId];
+            if (!selectedAccount || !selectedAddress)
                 throw new Error('Active account not found');
             const account = { address: selectedAccount.address };
-            const network = { ...activeNetwork };
+            const network = { ...state.activeNetwork };
             const assertSession = this.captureSigningContext?.();
             const provider = this.web3Provider;
             const assertCurrent = () => {
                 assertSession?.();
                 const current = this.getState();
-                const currentAccount = current.accounts[current.activeAccountType]?.[current.activeAccountId];
-                if (current.activeAccountId !== activeAccountId ||
-                    current.activeAccountType !== activeAccountType ||
+                const currentAccount = current.accounts[activeAccountType]?.[activeAccountId];
+                if (current.activeAccountId !== selectedId ||
+                    current.activeAccountType !== selectedType ||
+                    current.accounts[selectedType]?.[selectedId]?.address?.toLowerCase() !==
+                        selectedAddress.toLowerCase() ||
                     currentAccount?.address?.toLowerCase() !==
                         account.address.toLowerCase() ||
                     [current.activeNetwork, this.getNetwork()].some((selected) => selected.kind !== network.kind ||
@@ -217,6 +190,17 @@ 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.signTypedData = async (addr, typedData, version) => {
             const { address, decryptedPrivateKey } = this.getDecryptedPrivateKey();
             const { activeAccountType, accounts, activeAccountId } = this.getState();
@@ -615,68 +599,21 @@ class EthereumTransactions {
             }
         };
         this.getFeeDataWithDynamicMaxPriorityFeePerGas = async (provider = this.web3Provider) => {
-            // Keep the actual legacy-price recommendation separate from the buffered
-            // EIP-1559 maximum. A failed read is not evidence of a zero/legacy fee.
-            const gasPrice = nonNegativeFeeQuantity(await provider.getGasPrice(), 'gas price');
-            const block = await provider.getBlock('latest');
-            if (!block)
-                throw new Error('Block not found');
-            if (block.baseFeePerGas == null) {
-                return {
-                    gasPrice,
-                    maxFeePerGas: ethers_v6_1.BigNumber.from(0),
-                    maxPriorityFeePerGas: ethers_v6_1.BigNumber.from(0),
-                };
-            }
-            const baseFeePerGas = nonNegativeFeeQuantity(block.baseFeePerGas, 'base fee');
-            let maxPriorityFeePerGas;
-            try {
-                maxPriorityFeePerGas = nonNegativeFeeQuantity(await provider.send('eth_maxPriorityFeePerGas', []), 'priority fee');
-            }
-            catch (error) {
-                if (error?.code === 'SYSWEB3_RPC_RESPONSE_INVALID' ||
-                    error?.name === 'AbortError' ||
-                    this.abortController.signal.aborted ||
-                    provider.signal?.aborted ||
-                    !isUnsupportedPriorityFeeRpc(error))
-                    throw error;
-                // An explicitly unsupported method may use actual observed history,
-                // including zero rewards. Missing/corrupt history never invents a tip.
-                const history = await provider.send('eth_feeHistory', [
-                    '0x5',
-                    'latest',
-                    [25, 50, 75],
-                ]);
-                if (!Array.isArray(history?.reward) || history.reward.length === 0)
-                    throw new Error('Priority fee history unavailable');
-                const recentFees = history.reward
-                    .map((reward) => {
-                    if (!Array.isArray(reward) || reward.length !== 3)
-                        throw new Error('Invalid priority fee history');
-                    return nonNegativeFeeQuantity(reward[1], 'priority fee history');
-                })
-                    .sort((a, b) => (a.lt(b) ? -1 : a.gt(b) ? 1 : 0));
-                maxPriorityFeePerGas = recentFees[Math.floor(recentFees.length / 2)]
-                    .mul(150)
-                    .div(100);
-            }
-            if (this.gasOverrides.minPriorityFee &&
-                maxPriorityFeePerGas.lt(this.gasOverrides.minPriorityFee))
-                maxPriorityFeePerGas = this.gasOverrides.minPriorityFee;
-            const baselineMaxFee = gasPrice.mul(120).div(100);
-            const calculatedMaxFee = baseFeePerGas
-                .mul(this.gasOverrides.feeMultiplier || 250)
-                .div(100)
-                .add(maxPriorityFeePerGas);
-            let maxFeePerGas = calculatedMaxFee.gt(baselineMaxFee)
-                ? calculatedMaxFee
-                : baselineMaxFee;
-            const minMaxFee = maxPriorityFeePerGas.mul(120).div(100);
-            if (maxFeePerGas.lt(minMaxFee))
-                maxFeePerGas = minMaxFee;
-            if (maxFeePerGas.isZero())
-                throw new Error('Invalid EIP-1559 maximum fee');
-            return { gasPrice, baseFeePerGas, maxFeePerGas, maxPriorityFeePerGas };
+            const fee = await (0, evm_fees_1.getEvmFeeData)(provider, {
+                signal: this.abortController.signal,
+                minPriorityFee: this.gasOverrides.minPriorityFee,
+                feeMultiplier: this.gasOverrides.feeMultiplier,
+            });
+            return {
+                gasPrice: ethers_v6_1.BigNumber.from(fee.gasPrice),
+                ...(fee.baseFeePerGas === undefined
+                    ? {}
+                    : {
+                        baseFeePerGas: ethers_v6_1.BigNumber.from(fee.baseFeePerGas),
+                    }),
+                maxFeePerGas: ethers_v6_1.BigNumber.from(fee.maxFeePerGas),
+                maxPriorityFeePerGas: ethers_v6_1.BigNumber.from(fee.maxPriorityFeePerGas),
+            };
         };
         this.calculateNewGasValues = (oldTxsParams, isForCancel, isLegacy) => {
             const newGasValues = {
@@ -780,6 +717,9 @@ class EthereumTransactions {
                 assertKeyringContext();
             };
             assertCurrent();
+            const submission = previewOnly
+                ? undefined
+                : this.captureSubmission('cancel', activeAccount, activeAccountType, activeAccountId, activeNetwork, assertCurrent, txHash);
             const currentEip1559Fees = async () => {
                 const feeData = await this.getFeeDataWithDynamicMaxPriorityFeePerGas(provider);
                 assertCurrent();
@@ -956,7 +896,7 @@ class EthereumTransactions {
                             type: 2, // Need explicit type for hardware wallet serialization
                         };
                     assertApprovedEnvelope(txFormattedForEthers);
-                    const rawTx = (0, ethers_v6_1.serializeTransaction)(txFormattedForEthers);
+                    const rawTx = serializeTransaction(txFormattedForEthers);
                     const signature = await this.requireLedgerSigner().evm.signEVMTransaction({
                         rawTx: rawTx.replace('0x', ''),
                         accountIndex: activeAccountId,
@@ -969,10 +909,10 @@ class EthereumTransactions {
                         v: parseInt(signature.v, 16),
                     };
                     if (signature) {
-                        const signedTx = (0, ethers_v6_1.serializeTransaction)(txFormattedForEthers, formattedSignature);
+                        const signedTx = serializeTransaction(txFormattedForEthers, formattedSignature);
                         assertCurrent();
                         assertHardwareTransactionSender(signedTx, activeAccount.address);
-                        const transactionResponse = await provider.sendTransaction(signedTx);
+                        const transactionResponse = await (0, evm_submission_1.submitSignedEvmTransaction)(signedTx, (raw) => provider.sendTransaction(raw), submission, undefined, rawTx);
                         return {
                             isCanceled: true,
                             transaction: transactionResponse,
@@ -987,6 +927,7 @@ class EthereumTransactions {
                 }
                 catch (error) {
                     return {
+                        ...(0, evm_submission_1.evmSubmissionFailure)(error),
                         isCanceled: false,
                         error: true,
                     };
@@ -1026,6 +967,8 @@ class EthereumTransactions {
                                 : this.toHex0x(formattedTx.maxPriorityFeePerGas, 'maxPriorityFeePerGas');
                     }
                     assertApprovedEnvelope(txFormattedForTrezor);
+                    assertTransactionGasLimit(txFormattedForTrezor);
+                    const expectedUnsignedTransaction = serializeTransaction(txFormattedForTrezor);
                     const signature = await this.requireTrezorSigner().signEthTransaction({
                         coin: trezorCoin,
                         tx: txFormattedForTrezor,
@@ -1034,10 +977,10 @@ class EthereumTransactions {
                     });
                     assertCurrent();
                     if (signature.success) {
-                        const signedTx = (0, ethers_v6_1.serializeTransaction)(txFormattedForTrezor, trezorSignature(signature.payload));
+                        const signedTx = serializeTransaction(txFormattedForTrezor, trezorSignature(signature.payload));
                         assertCurrent();
                         assertHardwareTransactionSender(signedTx, activeAccount.address);
-                        const transactionResponse = await provider.sendTransaction(signedTx);
+                        const transactionResponse = await (0, evm_submission_1.submitSignedEvmTransaction)(signedTx, (raw) => provider.sendTransaction(raw), submission, undefined, expectedUnsignedTransaction);
                         return {
                             isCanceled: true,
                             transaction: transactionResponse,
@@ -1052,6 +995,7 @@ class EthereumTransactions {
                 }
                 catch (error) {
                     return {
+                        ...(0, evm_submission_1.evmSubmissionFailure)(error),
                         isCanceled: false,
                         error: true,
                     };
@@ -1065,7 +1009,7 @@ 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);
+                    const transactionResponse = await (0, evm_local_signer_1.sendLocalEvmTransaction)(provider, decryptedPrivateKey, changedTxToCancel, assertCurrent, assertCurrent, assertApprovedEnvelope, submission);
                     if (transactionResponse) {
                         return {
                             isCanceled: true,
@@ -1080,6 +1024,7 @@ class EthereumTransactions {
                 }
                 catch (error) {
                     return {
+                        ...(0, evm_submission_1.evmSubmissionFailure)(error),
                         isCanceled: false,
                         error: true,
                     };
@@ -1115,11 +1060,15 @@ class EthereumTransactions {
             catch (error) {
                 // A broadcast transport error may mean the node accepted the signed
                 // transaction. Derive this marker from this invocation, never RPC data.
-                const submissionError = Object.assign(new Error(error instanceof Error ? error.message : String(error)), error, { transactionNotBroadcast: !broadcastAttempted });
+                const submissionError = Object.assign(new Error(error instanceof Error ? error.message : String(error)), error, {
+                    transactionNotBroadcast: !broadcastAttempted ||
+                        (0, evm_submission_1.evmSubmissionFailure)(error).transactionNotBroadcast,
+                });
                 if (error instanceof Error) {
                     submissionError.name = error.name;
                     submissionError.stack = error.stack;
                 }
+                (0, evm_submission_1.copyEvmSubmissionFailure)(error, submissionError);
                 throw submissionError;
             }
         };
@@ -1140,6 +1089,54 @@ class EthereumTransactions {
                 beforeBroadcast();
             };
             assertCurrent();
+            const submission = this.captureSubmission('send', activeAccount, activeAccountType, activeAccountId, activeNetwork, assertCurrent);
+            // Detach supplied values before any RPC/device await. Autofill updates only
+            // this invocation; caller mutations cannot replace already supplied fields.
+            if (!params || typeof params !== 'object' || Array.isArray(params))
+                throw new TypeError('Invalid EVM transaction request');
+            const supplied = { ...params };
+            // Validate original scalar spellings before conversion. Normalization's
+            // permissive zero coercion must not bypass the bounded wire parser.
+            for (const field of [
+                'chainId',
+                'nonce',
+                'gasLimit',
+                'gasPrice',
+                'maxFeePerGas',
+                'maxPriorityFeePerGas',
+                'value',
+                'type',
+            ]) {
+                if (supplied[field] != null) {
+                    const value = (0, evm_fees_1.parseEvmFeeQuantity)(supplied[field], field);
+                    if (field === 'nonce' || field === 'type') {
+                        if (value > BigInt(Number.MAX_SAFE_INTEGER))
+                            throw new Error(`Invalid transaction ${field}`);
+                        supplied[field] = Number(value);
+                    }
+                    else
+                        supplied[field] = value;
+                }
+            }
+            if (supplied.data != null)
+                supplied.data = (0, utils_1.hexlify)(supplied.data);
+            if (supplied.accessList != null)
+                supplied.accessList = (0, transaction_1.accessListify)(supplied.accessList);
+            params = supplied;
+            assertCurrent();
+            // Capture the reviewed nonce before any fee/RPC await. Hardware and the
+            // final serializer must use the same immutable integer, including zero.
+            let explicitHardwareNonce;
+            if (activeAccountType === types_1.KeyringAccountType.Ledger ||
+                activeAccountType === types_1.KeyringAccountType.Trezor) {
+                const suppliedNonce = params.nonce;
+                if (suppliedNonce != null) {
+                    const nonce = (0, evm_fees_1.parseEvmFeeQuantity)(suppliedNonce, 'transaction nonce');
+                    if (nonce > BigInt(Number.MAX_SAFE_INTEGER))
+                        throw new Error('Invalid transaction nonce');
+                    explicitHardwareNonce = Number(nonce);
+                }
+            }
             const explicitEip1559 = params.type != null && ethers_v6_1.BigNumber.from(params.type).eq(2);
             const requestedEip1559 = explicitEip1559 ||
                 params.maxFeePerGas != null ||
@@ -1160,7 +1157,7 @@ class EthereumTransactions {
                 validateEip1559Fees();
             // Only apply a minimum gas limit when a network-specific override is set.
             // Otherwise keep the user/dapp-approved gas limit unchanged.
-            if (params.gasLimit && this.gasOverrides.minGasLimit) {
+            if (params.gasLimit != null && this.gasOverrides.minGasLimit) {
                 const minGasLimit = this.gasOverrides.minGasLimit;
                 const currentGasLimit = ethers_v6_1.BigNumber.from(params.gasLimit);
                 if (currentGasLimit.lt(minGasLimit)) {
@@ -1176,12 +1173,16 @@ class EthereumTransactions {
                     ...params,
                     from: params.from || activeAccount.address,
                 }, ['gasPrice']);
-            if (!params.gasLimit) {
+            if (params.gasLimit == null) {
                 params.gasLimit = await provider.estimateGas(txForEstimation);
                 assertCurrent();
             }
+            assertTransactionGasLimit({
+                gasLimit: params.gasLimit,
+                chainId: activeNetwork.chainId,
+            });
             if (isLegacy) {
-                if (!params.gasPrice) {
+                if (params.gasPrice == null) {
                     params.gasPrice = await provider.getGasPrice();
                     assertCurrent();
                 }
@@ -1207,7 +1208,8 @@ class EthereumTransactions {
                 validateEip1559Fees();
             const sendEVMLedgerTransaction = async () => {
                 assertCurrent();
-                const transactionNonce = await provider.getTransactionCount(activeAccount.address, 'pending');
+                const transactionNonce = explicitHardwareNonce ??
+                    (await provider.getTransactionCount(activeAccount.address, 'pending'));
                 assertCurrent();
                 const formatParams = isLegacy
                     ? (0, omit_1.default)(params, 'from')
@@ -1225,7 +1227,7 @@ class EthereumTransactions {
                         chainId: activeNetwork.chainId,
                         type: 2, // Need explicit type for hardware wallet serialization
                     };
-                const rawTx = (0, ethers_v6_1.serializeTransaction)(txFormattedForEthers);
+                const rawTx = serializeTransaction(txFormattedForEthers);
                 const signature = await this.requireLedgerSigner().evm.signEVMTransaction({
                     rawTx: rawTx.replace('0x', ''),
                     accountIndex: activeAccountId,
@@ -1239,10 +1241,9 @@ class EthereumTransactions {
                 };
                 if (signature) {
                     try {
-                        const signedTx = (0, ethers_v6_1.serializeTransaction)(txFormattedForEthers, formattedSignature);
+                        const signedTx = serializeTransaction(txFormattedForEthers, formattedSignature);
                         assertHardwareTransactionSender(signedTx, activeAccount.address);
-                        assertBeforeBroadcast();
-                        const finalTx = await provider.sendTransaction(signedTx);
+                        const finalTx = await (0, evm_submission_1.submitSignedEvmTransaction)(signedTx, (raw) => provider.sendTransaction(raw), submission, assertBeforeBroadcast, rawTx);
                         return finalTx;
                     }
                     catch (error) {
@@ -1255,7 +1256,8 @@ class EthereumTransactions {
             };
             const sendEVMTrezorTransaction = async () => {
                 assertCurrent();
-                const transactionNonce = await provider.getTransactionCount(activeAccount.address, 'pending');
+                const transactionNonce = explicitHardwareNonce ??
+                    (await provider.getTransactionCount(activeAccount.address, 'pending'));
                 assertCurrent();
                 let txFormattedForTrezor = {};
                 const formatParams = isLegacy
@@ -1265,6 +1267,7 @@ class EthereumTransactions {
                     case true:
                         txFormattedForTrezor = {
                             ...formatParams,
+                            gasPrice: this.toHex0x(params.gasPrice, 'gasPrice'),
                             gasLimit: this.toHex0x(formatParams.gasLimit ?? params.gasLimit, 'gasLimit'),
                             value: this.toHex0x(formatParams.value ?? params.value, 'value'),
                             nonce: this.toBigNumber(transactionNonce)._hex,
@@ -1301,6 +1304,11 @@ class EthereumTransactions {
                         };
                         break;
                 }
+                assertTransactionGasLimit(txFormattedForTrezor);
+                const expectedUnsignedTransaction = serializeTransaction({
+                    ...txFormattedForTrezor,
+                    type: isLegacy ? 0 : 2,
+                });
                 const signature = await this.requireTrezorSigner().signEthTransaction({
                     index: `${activeAccountId}`,
                     tx: txFormattedForTrezor,
@@ -1323,10 +1331,9 @@ class EthereumTransactions {
                                 chainId: activeNetwork.chainId,
                                 type: 2, // Need explicit type for hardware wallet serialization
                             };
-                        const signedTx = (0, ethers_v6_1.serializeTransaction)(txFormattedForEthers, trezorSignature(signature.payload));
+                        const signedTx = serializeTransaction(txFormattedForEthers, trezorSignature(signature.payload));
                         assertHardwareTransactionSender(signedTx, activeAccount.address);
-                        assertBeforeBroadcast();
-                        const finalTx = await provider.sendTransaction(signedTx);
+                        const finalTx = await (0, evm_submission_1.submitSignedEvmTransaction)(signedTx, (raw) => provider.sendTransaction(raw), submission, assertBeforeBroadcast, expectedUnsignedTransaction);
                         return finalTx;
                     }
                     catch (error) {
@@ -1351,7 +1358,7 @@ class EthereumTransactions {
                     ? { ...params, type: 0 } // Force Type 0 for legacy transactions
                     : (0, omit_1.default)(params, ['gasPrice']); // Strip gasPrice for EIP-1559
                 try {
-                    const transaction = await (0, evm_local_signer_1.sendLocalEvmTransaction)(provider, decryptedPrivateKey, tx, assertBeforeBroadcast, assertCurrent);
+                    const transaction = await (0, evm_local_signer_1.sendLocalEvmTransaction)(provider, decryptedPrivateKey, tx, assertBeforeBroadcast, assertCurrent, undefined, submission);
                     // The broadcast response already has the hash. Pending transactions
                     // have no block number, so a block lookup can fail after a successful
                     // broadcast and incorrectly report the send as failed.
@@ -1380,7 +1387,14 @@ class EthereumTransactions {
                     !/^\d{1,78}$/.test(approvedMaximumFee))) {
                 throw new Error('Replacement fee approval required');
             }
-            const assertCurrent = () => assertCurrentContext?.();
+            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();
+            };
             const assertBeforeBroadcast = () => {
                 assertCurrent();
                 beforeBroadcast?.();
@@ -1406,10 +1420,15 @@ class EthereumTransactions {
                 (targetAccount && activeAccountType === types_1.KeyringAccountType.SmartAccount)) {
                 throw new Error('Replacement signing account is unavailable');
             }
+            if (!previewOnly)
+                signing = this.captureEvmSigningContext(targetAccount);
             const expectedSender = activeAccount.address.toLowerCase();
             const requestedHash = txHash.toLowerCase();
             const provider = this.web3Provider;
             assertCurrent();
+            const submission = previewOnly
+                ? undefined
+                : this.captureSubmission('speed-up', activeAccount, activeAccountType, activeAccountId, activeNetwork, assertCurrent, txHash);
             const validateLookup = (transaction) => {
                 assertCurrent();
                 if (!transaction)
@@ -1547,7 +1566,7 @@ class EthereumTransactions {
                             chainId: activeNetwork.chainId,
                             type: 2, // Need explicit type for hardware wallet serialization
                         };
-                    const rawTx = (0, ethers_v6_1.serializeTransaction)(txFormattedForEthers);
+                    const rawTx = serializeTransaction(txFormattedForEthers);
                     assertCurrent();
                     const signature = await this.requireLedgerSigner().evm.signEVMTransaction({
                         rawTx: rawTx.replace('0x', ''),
@@ -1560,11 +1579,10 @@ class EthereumTransactions {
                         v: parseInt(signature.v, 16),
                     };
                     if (signature) {
-                        const signedTx = (0, ethers_v6_1.serializeTransaction)(txFormattedForEthers, formattedSignature);
+                        const signedTx = serializeTransaction(txFormattedForEthers, formattedSignature);
                         assertSignedSender(signedTx);
                         assertHardwareTransactionSender(signedTx, activeAccount.address);
-                        assertBeforeBroadcast();
-                        const transactionResponse = await provider.sendTransaction(signedTx);
+                        const transactionResponse = await (0, evm_submission_1.submitSignedEvmTransaction)(signedTx, (raw) => provider.sendTransaction(raw), submission, assertBeforeBroadcast, rawTx);
                         return {
                             isSpeedUp: true,
                             transaction: transactionResponse,
@@ -1588,6 +1606,7 @@ class EthereumTransactions {
                             ? 'REPLACEMENT_ALREADY_KNOWN'
                             : 'REPLACEMENT_SEND_FAILED';
                     return {
+                        ...(0, evm_submission_1.evmSubmissionFailure)(error),
                         isSpeedUp: false,
                         error: true,
                         code,
@@ -1632,6 +1651,8 @@ class EthereumTransactions {
                                 : this.toHex0x(formattedTx.maxPriorityFeePerGas, 'maxPriorityFeePerGas');
                     }
                     assertCurrent();
+                    assertTransactionGasLimit(txFormattedForTrezor);
+                    const expectedUnsignedTransaction = serializeTransaction(txFormattedForTrezor);
                     const signature = await this.requireTrezorSigner().signEthTransaction({
                         coin: trezorCoin,
                         tx: txFormattedForTrezor,
@@ -1639,11 +1660,10 @@ class EthereumTransactions {
                         slip44: activeNetwork.slip44,
                     });
                     if (signature.success) {
-                        const signedTx = (0, ethers_v6_1.serializeTransaction)(txFormattedForTrezor, trezorSignature(signature.payload));
+                        const signedTx = serializeTransaction(txFormattedForTrezor, trezorSignature(signature.payload));
                         assertSignedSender(signedTx);
                         assertHardwareTransactionSender(signedTx, activeAccount.address);
-                        assertBeforeBroadcast();
-                        const transactionResponse = await provider.sendTransaction(signedTx);
+                        const transactionResponse = await (0, evm_submission_1.submitSignedEvmTransaction)(signedTx, (raw) => provider.sendTransaction(raw), submission, assertBeforeBroadcast, expectedUnsignedTransaction);
                         return {
                             isSpeedUp: true,
                             transaction: transactionResponse,
@@ -1667,6 +1687,7 @@ class EthereumTransactions {
                             ? 'REPLACEMENT_ALREADY_KNOWN'
                             : 'REPLACEMENT_SEND_FAILED';
                     return {
+                        ...(0, evm_submission_1.evmSubmissionFailure)(error),
                         isSpeedUp: false,
                         error: true,
                         code,
@@ -1683,7 +1704,7 @@ class EthereumTransactions {
                     if (address.toLowerCase() !== expectedSender) {
                         throw new Error('Replacement signing account changed');
                     }
-                    const transactionResponse = await (0, evm_local_signer_1.sendLocalEvmTransaction)(provider, decryptedPrivateKey, txWithEditedFee, assertBeforeBroadcast, assertCurrent);
+                    const transactionResponse = await (0, evm_local_signer_1.sendLocalEvmTransaction)(provider, decryptedPrivateKey, txWithEditedFee, assertBeforeBroadcast, assertCurrent, undefined, submission);
                     if (transactionResponse) {
                         return {
                             isSpeedUp: true,
@@ -1709,6 +1730,7 @@ class EthereumTransactions {
                                 ? 'INSUFFICIENT_FUNDS_REPLACEMENT'
                                 : 'REPLACEMENT_SEND_FAILED';
                     return {
+                        ...(0, evm_submission_1.evmSubmissionFailure)(error),
                         isSpeedUp: false,
                         error: true,
                         code,
@@ -1729,6 +1751,7 @@ class EthereumTransactions {
         this.sendSignedErc20Transaction = async ({ receiver, tokenAddress, tokenAmount, isLegacy = false, maxPriorityFeePerGas, maxFeePerGas, gasPrice, decimals, gasLimit, saveTrezorTx, }) => {
             const { activeAccount, activeAccountType, activeAccountId, activeNetwork, provider, assertCurrent, } = this.captureEvmSigningContext();
             const activeAccountAddress = activeAccount.address;
+            const submission = this.captureSubmission('erc20', activeAccount, activeAccountType, activeAccountId, activeNetwork, assertCurrent);
             ({ gasPrice, isLegacy, maxFeePerGas, maxPriorityFeePerGas } =
                 await this.resolveEvmFeeParams({
                     gasPrice,
@@ -1769,7 +1792,7 @@ class EthereumTransactions {
                         chainId: activeNetwork.chainId,
                         from: activeAccountAddress,
                         value: '0x0',
-                    }, assertCurrent, assertCurrent);
+                    }, assertCurrent, assertCurrent, undefined, submission);
                 }
                 catch (error) {
                     throw error;
@@ -1815,7 +1838,7 @@ class EthereumTransactions {
                             type: 2, // Need explicit type for hardware wallet serialization
                         };
                     }
-                    const rawTx = (0, ethers_v6_1.serializeTransaction)(txFormattedForEthers);
+                    const rawTx = serializeTransaction(txFormattedForEthers);
                     const signature = await this.requireLedgerSigner().evm.signEVMTransaction({
                         rawTx: rawTx.replace('0x', ''),
                         accountIndex: activeAccountId,
@@ -1829,11 +1852,14 @@ class EthereumTransactions {
                     };
                     if (signature) {
                         try {
-                            const signedTx = (0, ethers_v6_1.serializeTransaction)(txFormattedForEthers, formattedSignature);
+                            const signedTx = serializeTransaction(txFormattedForEthers, formattedSignature);
                             assertCurrent();
                             assertHardwareTransactionSender(signedTx, activeAccount.address);
-                            const finalTx = await provider.sendTransaction(signedTx);
-                            saveTrezorTx && saveTrezorTx(finalTx);
+                            const finalTx = await (0, evm_submission_1.submitSignedEvmTransaction)(signedTx, async (raw) => {
+                                const response = await provider.sendTransaction(raw);
+                                saveTrezorTx && saveTrezorTx(response);
+                                return response;
+                            }, submission, undefined, rawTx);
                             return finalTx;
                         }
                         catch (error) {
@@ -1886,6 +1912,11 @@ class EthereumTransactions {
                             data: txData,
                         };
                     }
+                    assertTransactionGasLimit(txToBeSignedByTrezor);
+                    const expectedUnsignedTransaction = serializeTransaction({
+                        ...txToBeSignedByTrezor,
+                        type: isLegacy ? 0 : 2,
+                    });
                     const signature = await this.requireTrezorSigner().signEthTransaction({
                         index: `${activeAccountId}`,
                         tx: txToBeSignedByTrezor,
@@ -1921,11 +1952,14 @@ class EthereumTransactions {
                                     type: 2, // Need explicit type for hardware wallet serialization
                                 };
                             }
-                            const signedTx = (0, ethers_v6_1.serializeTransaction)(txFormattedForEthers, trezorSignature(signature.payload));
+                            const signedTx = serializeTransaction(txFormattedForEthers, trezorSignature(signature.payload));
                             assertCurrent();
                             assertHardwareTransactionSender(signedTx, activeAccount.address);
-                            const finalTx = await provider.sendTransaction(signedTx);
-                            saveTrezorTx && saveTrezorTx(finalTx);
+                            const finalTx = await (0, evm_submission_1.submitSignedEvmTransaction)(signedTx, async (raw) => {
+                                const response = await provider.sendTransaction(raw);
+                                saveTrezorTx && saveTrezorTx(response);
+                                return response;
+                            }, submission, undefined, expectedUnsignedTransaction);
                             return finalTx;
                         }
                         catch (error) {
@@ -1952,6 +1986,7 @@ class EthereumTransactions {
         this.sendSignedErc721Transaction = async ({ receiver, tokenAddress, tokenId, isLegacy, maxPriorityFeePerGas, maxFeePerGas, gasPrice, gasLimit, }) => {
             const { activeAccount, activeAccountType, activeAccountId, activeNetwork, provider, assertCurrent, } = this.captureEvmSigningContext();
             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');
             }
@@ -1993,7 +2028,7 @@ class EthereumTransactions {
                         chainId: activeNetwork.chainId,
                         from: activeAccountAddress,
                         value: '0x0',
-                    }, assertCurrent, assertCurrent);
+                    }, assertCurrent, assertCurrent, undefined, submission);
                 }
                 catch (error) {
                     throw error;
@@ -2038,7 +2073,7 @@ class EthereumTransactions {
                             type: 2, // Need explicit type for hardware wallet serialization
                         };
                     }
-                    const rawTx = (0, ethers_v6_1.serializeTransaction)(txFormattedForEthers);
+                    const rawTx = serializeTransaction(txFormattedForEthers);
                     const signature = await this.requireLedgerSigner().evm.signEVMTransaction({
                         rawTx: rawTx.replace('0x', ''),
                         accountIndex: activeAccountId,
@@ -2052,10 +2087,10 @@ class EthereumTransactions {
                     };
                     if (signature) {
                         try {
-                            const signedTx = (0, ethers_v6_1.serializeTransaction)(txFormattedForEthers, formattedSignature);
+                            const signedTx = serializeTransaction(txFormattedForEthers, formattedSignature);
                             assertCurrent();
                             assertHardwareTransactionSender(signedTx, activeAccount.address);
-                            const finalTx = await provider.sendTransaction(signedTx);
+                            const finalTx = await (0, evm_submission_1.submitSignedEvmTransaction)(signedTx, (raw) => provider.sendTransaction(raw), submission, undefined, rawTx);
                             return finalTx;
                         }
                         catch (error) {
@@ -2110,6 +2145,11 @@ class EthereumTransactions {
                     }
                     // For EVM networks, Trezor expects 'eth' regardless of the network's currency
                     const trezorCoin = activeNetwork.slip44 === 60 ? 'eth' : activeNetwork.currency;
+                    assertTransactionGasLimit(txToBeSignedByTrezor);
+                    const expectedUnsignedTransaction = serializeTransaction({
+                        ...txToBeSignedByTrezor,
+                        type: isLegacy ? 0 : 2,
+                    });
                     const signature = await this.requireTrezorSigner().signEthTransaction({
                         index: `${activeAccountId}`,
                         tx: txToBeSignedByTrezor,
@@ -2145,10 +2185,10 @@ class EthereumTransactions {
                                     type: 2, // Need explicit type for hardware wallet serialization
                                 };
                             }
-                            const signedTx = (0, ethers_v6_1.serializeTransaction)(txFormattedForEthers, trezorSignature(signature.payload));
+                            const signedTx = serializeTransaction(txFormattedForEthers, trezorSignature(signature.payload));
                             assertCurrent();
                             assertHardwareTransactionSender(signedTx, activeAccount.address);
-                            const finalTx = await provider.sendTransaction(signedTx);
+                            const finalTx = await (0, evm_submission_1.submitSignedEvmTransaction)(signedTx, (raw) => provider.sendTransaction(raw), submission, undefined, expectedUnsignedTransaction);
                             return finalTx;
                         }
                         catch (error) {
@@ -2177,6 +2217,7 @@ class EthereumTransactions {
         this.sendSignedErc1155Transaction = async ({ receiver, tokenAddress, tokenId, tokenAmount, isLegacy, maxPriorityFeePerGas, maxFeePerGas, gasPrice, gasLimit, }) => {
             const { activeAccount, activeAccountType, activeAccountId, activeNetwork, provider, assertCurrent, } = this.captureEvmSigningContext();
             const activeAccountAddress = activeAccount.address;
+            const submission = this.captureSubmission('erc1155', activeAccount, activeAccountType, activeAccountId, activeNetwork, assertCurrent);
             ({ gasPrice, isLegacy, maxFeePerGas, maxPriorityFeePerGas } =
                 await this.resolveEvmFeeParams({
                     gasPrice,
@@ -2216,7 +2257,7 @@ class EthereumTransactions {
                         chainId: activeNetwork.chainId,
                         from: activeAccountAddress,
                         value: '0x0',
-                    }, assertCurrent, assertCurrent);
+                    }, assertCurrent, assertCurrent, undefined, submission);
                 }
                 catch (error) {
                     throw error;
@@ -2258,7 +2299,7 @@ class EthereumTransactions {
                             type: 2, // Need explicit type for hardware wallet serialization
                         };
                     }
-                    const rawTx = (0, ethers_v6_1.serializeTransaction)(txFormattedForEthers);
+                    const rawTx = serializeTransaction(txFormattedForEthers);
                     const signature = await this.requireLedgerSigner().evm.signEVMTransaction({
                         rawTx: rawTx.replace('0x', ''),
                         accountIndex: activeAccountId,
@@ -2272,10 +2313,10 @@ class EthereumTransactions {
                     };
                     if (signature) {
                         try {
-                            const signedTx = (0, ethers_v6_1.serializeTransaction)(txFormattedForEthers, formattedSignature);
+                            const signedTx = serializeTransaction(txFormattedForEthers, formattedSignature);
                             assertCurrent();
                             assertHardwareTransactionSender(signedTx, activeAccount.address);
-                            const finalTx = await provider.sendTransaction(signedTx);
+                            const finalTx = await (0, evm_submission_1.submitSignedEvmTransaction)(signedTx, (raw) => provider.sendTransaction(raw), submission, undefined, rawTx);
                             return finalTx;
                         }
                         catch (error) {
@@ -2324,6 +2365,11 @@ class EthereumTransactions {
                             data: txData,
                         };
                     }
+                    assertTransactionGasLimit(txToBeSignedByTrezor);
+                    const expectedUnsignedTransaction = serializeTransaction({
+                        ...txToBeSignedByTrezor,
+                        type: isLegacy ? 0 : 2,
+                    });
                     const signature = await this.requireTrezorSigner().signEthTransaction({
                         index: `${activeAccountId}`,
                         tx: txToBeSignedByTrezor,
@@ -2359,10 +2405,10 @@ class EthereumTransactions {
                                     type: 2, // Need explicit type for hardware wallet serialization
                                 };
                             }
-                            const signedTx = (0, ethers_v6_1.serializeTransaction)(txFormattedForEthers, trezorSignature(signature.payload));
+                            const signedTx = serializeTransaction(txFormattedForEthers, trezorSignature(signature.payload));
                             assertCurrent();
                             assertHardwareTransactionSender(signedTx, activeAccount.address);
-                            const finalTx = await provider.sendTransaction(signedTx);
+                            const finalTx = await (0, evm_submission_1.submitSignedEvmTransaction)(signedTx, (raw) => provider.sendTransaction(raw), submission, undefined, expectedUnsignedTransaction);
                             return finalTx;
                         }
                         catch (error) {
@@ -2424,56 +2470,82 @@ class EthereumTransactions {
             }
         };
         this.getTxGasLimit = async (tx) => {
-            const hasCalldata = Boolean(tx.data && tx.data !== '0x' && tx.data !== '0x0');
+            const request = { ...tx };
+            const network = this.getNetwork();
+            const identity = {
+                kind: network.kind,
+                chainId: network.chainId,
+                slip44: network.slip44,
+                url: network.url,
+            };
+            const chainId = (0, evm_fees_1.parseEvmFeeQuantity)(identity.chainId, 'chain ID');
+            const provider = this.web3Provider;
+            const controller = this.abortController;
+            const minimum = this.gasOverrides.minGasLimit;
+            const assertCurrent = () => {
+                const current = this.getNetwork();
+                if (controller.signal.aborted ||
+                    controller !== this.abortController ||
+                    current.kind !== identity.kind ||
+                    current.chainId !== identity.chainId ||
+                    current.slip44 !== identity.slip44 ||
+                    current.url !== identity.url ||
+                    this.web3Provider !== provider) {
+                    const error = new Error('EVM gas estimate context changed');
+                    error.name = 'AbortError';
+                    throw error;
+                }
+            };
+            const checked = (limit) => {
+                assertCurrent();
+                return ethers_v6_1.BigNumber.from((0, evm_fees_1.assertEvmGasLimit)(typeof limit === 'bigint' ? limit : limit.toBigInt(), chainId));
+            };
+            const hasCalldata = Boolean(request.data && request.data !== '0x' && request.data !== '0x0');
             try {
                 // First attempt: standard estimation
-                const estimated = await this.web3Provider.estimateGas(tx);
-                // Add 20% buffer to the estimated gas
-                const withBuffer = estimated.mul(120).div(100);
-                // Apply an explicit per-network floor only when configured.
-                if (this.gasOverrides.minGasLimit &&
-                    withBuffer.lt(this.gasOverrides.minGasLimit)) {
-                    return this.gasOverrides.minGasLimit;
-                }
-                return withBuffer;
+                assertCurrent();
+                const estimated = await provider.estimateGas(request);
+                return checked((0, evm_fees_1.bufferedEvmGasLimit)(estimated.toBigInt(), minimum?.toBigInt()));
             }
             catch (error) {
-                if (error?.code === 'SYSWEB3_RPC_RESPONSE_INVALID' ||
+                assertCurrent();
+                if (error instanceof evm_fees_1.EvmGasLimitError ||
+                    error?.code === 'SYSWEB3_RPC_RESPONSE_INVALID' ||
                     error?.name === 'AbortError' ||
                     this.abortController.signal.aborted)
                     throw error;
                 console.warn('Gas estimation failed:', error);
                 if (hasCalldata) {
                     const calldataFallback = ethers_v6_1.BigNumber.from('100000');
-                    if (this.gasOverrides.minGasLimit &&
-                        calldataFallback.lt(this.gasOverrides.minGasLimit)) {
-                        return this.gasOverrides.minGasLimit;
+                    if (minimum && calldataFallback.lt(minimum)) {
+                        return checked(minimum);
                     }
-                    return calldataFallback;
+                    return checked(calldataFallback);
                 }
                 // Try a simpler estimation for basic transfers
                 try {
-                    const simpleEstimate = await this.web3Provider.estimateGas({
-                        to: tx.to,
-                        from: tx.from,
-                        value: tx.value || '0x0',
+                    const simpleEstimate = await provider.estimateGas({
+                        to: request.to,
+                        from: request.from,
+                        value: request.value || '0x0',
                     });
                     const withBuffer = simpleEstimate.mul(150).div(100); // 50% buffer for failed estimations
-                    if (this.gasOverrides.minGasLimit &&
-                        withBuffer.lt(this.gasOverrides.minGasLimit)) {
-                        return this.gasOverrides.minGasLimit;
+                    if (minimum && withBuffer.lt(minimum)) {
+                        return checked(minimum);
                     }
-                    return withBuffer;
+                    return checked(withBuffer);
                 }
                 catch (secondError) {
-                    if (secondError?.code === 'SYSWEB3_RPC_RESPONSE_INVALID' ||
+                    assertCurrent();
+                    if (secondError instanceof evm_fees_1.EvmGasLimitError ||
+                        secondError?.code === 'SYSWEB3_RPC_RESPONSE_INVALID' ||
                         secondError?.name === 'AbortError' ||
                         this.abortController.signal.aborted) {
                         throw secondError;
                     }
                     // Ultimate fallback
                     console.warn('Simple estimation also failed, using default', secondError);
-                    return this.gasOverrides.minGasLimit || ethers_v6_1.BigNumber.from('100000');
+                    return checked(minimum || ethers_v6_1.BigNumber.from('100000'));
                 }
             }
         };
@@ -2548,6 +2620,7 @@ class EthereumTransactions {
         this.trezorSigner = trezorSigner;
         this.ledgerSigner = ledgerSigner;
         this.captureSigningContext = captureSigningContext;
+        this.captureSubmissionLifecycle = captureSubmissionLifecycle;
     }
     // Getter that automatically ensures providers are initialized when accessed
     get web3Provider() {