@sidhujag/sysweb3-keyring 1.0.619 → 1.0.621

package/cjs/transactions/ethereum.js

@@ -80,9 +80,43 @@ const normalizeEthersOverrides = (overrides) => {
     return normalized;
 };
 class EthereumTransactions {
-    constructor(getNetwork, getDecryptedPrivateKey, getState, ledgerSigner, trezorSigner) {
+    constructor(getNetwork, getDecryptedPrivateKey, getState, ledgerSigner, trezorSigner, captureSigningContext) {
         // Allow manual override of gas parameters when automatic estimation fails
         this.gasOverrides = {};
+        this.captureEvmSigningContext = () => {
+            const { activeAccountType, activeAccountId, accounts, activeNetwork } = this.getState();
+            const selectedAccount = accounts[activeAccountType]?.[activeAccountId];
+            if (!selectedAccount)
+                throw new Error('Active account not found');
+            const account = { address: selectedAccount.address };
+            const network = { ...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 ||
+                    currentAccount?.address?.toLowerCase() !==
+                        account.address.toLowerCase() ||
+                    [current.activeNetwork, this.getNetwork()].some((selected) => selected.kind !== network.kind ||
+                        selected.chainId !== network.chainId ||
+                        selected.slip44 !== network.slip44 ||
+                        selected.url !== network.url) ||
+                    this.web3Provider !== provider)
+                    throw new Error('Wallet signing context changed');
+            };
+            assertCurrent();
+            return {
+                activeAccount: account,
+                activeAccountType,
+                activeAccountId,
+                activeNetwork: network,
+                provider,
+                assertCurrent,
+            };
+        };
         this.signTypedData = async (addr, typedData, version) => {
             const { address, decryptedPrivateKey } = this.getDecryptedPrivateKey();
             const { activeAccountType, accounts, activeAccountId } = this.getState();
@@ -433,23 +467,23 @@ class EthereumTransactions {
                 throw new Error(`Invalid numeric field "${fieldName}" for EVM tx: ${String(value)}`);
             }
         };
-        this.resolveEvmFeeParams = async ({ gasPrice, isLegacy = false, maxFeePerGas, maxPriorityFeePerGas, }) => {
+        this.resolveEvmFeeParams = async ({ gasPrice, isLegacy = false, maxFeePerGas, maxPriorityFeePerGas, }, provider = this.web3Provider) => {
             if (isLegacy) {
                 return {
-                    gasPrice: gasPrice || (await this.web3Provider.getGasPrice()),
+                    gasPrice: gasPrice || (await provider.getGasPrice()),
                     isLegacy: true,
                     maxFeePerGas: undefined,
                     maxPriorityFeePerGas: undefined,
                 };
             }
             if (!maxFeePerGas || maxPriorityFeePerGas == null) {
-                const feeData = await this.web3Provider.getFeeData();
+                const feeData = await provider.getFeeData();
                 maxFeePerGas = maxFeePerGas || feeData.maxFeePerGas || feeData.gasPrice;
                 maxPriorityFeePerGas =
                     maxPriorityFeePerGas ?? feeData.maxPriorityFeePerGas;
                 if (!maxFeePerGas || maxPriorityFeePerGas == null) {
                     return {
-                        gasPrice: feeData.gasPrice || (await this.web3Provider.getGasPrice()),
+                        gasPrice: feeData.gasPrice || (await provider.getGasPrice()),
                         isLegacy: true,
                         maxFeePerGas: undefined,
                         maxPriorityFeePerGas: undefined,
@@ -872,8 +906,14 @@ class EthereumTransactions {
             }
         };
         this.sendFormattedTransactionInternal = async (params, isLegacy, beforeBroadcast) => {
-            const { activeAccountType, activeAccountId, accounts, activeNetwork } = this.getState();
-            const activeAccount = accounts[activeAccountType][activeAccountId];
+            // 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, } = this.captureEvmSigningContext();
+            const assertBeforeBroadcast = () => {
+                assertCurrent();
+                beforeBroadcast();
+            };
+            assertCurrent();
             const explicitEip1559 = params.type != null && ethers_v6_1.BigNumber.from(params.type).eq(2);
             const requestedEip1559 = explicitEip1559 ||
                 params.maxFeePerGas != null ||
@@ -911,16 +951,19 @@ class EthereumTransactions {
                     from: params.from || activeAccount.address,
                 }, ['gasPrice']);
             if (!params.gasLimit) {
-                params.gasLimit = await this.web3Provider.estimateGas(txForEstimation);
+                params.gasLimit = await provider.estimateGas(txForEstimation);
+                assertCurrent();
             }
             if (isLegacy) {
                 if (!params.gasPrice) {
-                    params.gasPrice = await this.web3Provider.getGasPrice();
+                    params.gasPrice = await provider.getGasPrice();
+                    assertCurrent();
                 }
             }
             else if (params.maxFeePerGas == null ||
                 params.maxPriorityFeePerGas == null) {
-                const feeData = await this.web3Provider.getFeeData();
+                const feeData = await provider.getFeeData();
+                assertCurrent();
                 params.maxFeePerGas = params.maxFeePerGas ?? feeData.maxFeePerGas;
                 params.maxPriorityFeePerGas =
                     params.maxPriorityFeePerGas ?? feeData.maxPriorityFeePerGas;
@@ -928,8 +971,8 @@ class EthereumTransactions {
                     if (requestedEip1559)
                         throw new Error('EIP-1559 fee data unavailable');
                     isLegacy = true;
-                    params.gasPrice =
-                        feeData.gasPrice ?? (await this.web3Provider.getGasPrice());
+                    params.gasPrice = feeData.gasPrice ?? (await provider.getGasPrice());
+                    assertCurrent();
                     delete params.maxFeePerGas;
                     delete params.maxPriorityFeePerGas;
                 }
@@ -937,7 +980,9 @@ class EthereumTransactions {
             if (!isLegacy)
                 validateEip1559Fees();
             const sendEVMLedgerTransaction = async () => {
-                const transactionNonce = await this.getRecommendedNonce(activeAccount.address);
+                assertCurrent();
+                const transactionNonce = await provider.getTransactionCount(activeAccount.address, 'pending');
+                assertCurrent();
                 const formatParams = isLegacy
                     ? (0, omit_1.default)(params, 'from')
                     : (0, omit_1.default)(params, ['from', 'gasPrice']); // Strip gasPrice for EIP-1559
@@ -959,6 +1004,7 @@ class EthereumTransactions {
                     rawTx: rawTx.replace('0x', ''),
                     accountIndex: activeAccountId,
                 });
+                assertCurrent();
                 const formattedSignature = {
                     r: `0x${signature.r}`,
                     s: `0x${signature.s}`,
@@ -967,8 +1013,8 @@ class EthereumTransactions {
                 if (signature) {
                     try {
                         const signedTx = (0, ethers_v6_1.serializeTransaction)(txFormattedForEthers, formattedSignature);
-                        beforeBroadcast();
-                        const finalTx = await this.web3Provider.sendTransaction(signedTx);
+                        assertBeforeBroadcast();
+                        const finalTx = await provider.sendTransaction(signedTx);
                         return finalTx;
                     }
                     catch (error) {
@@ -980,7 +1026,9 @@ class EthereumTransactions {
                 }
             };
             const sendEVMTrezorTransaction = async () => {
-                const transactionNonce = await this.getRecommendedNonce(activeAccount.address);
+                assertCurrent();
+                const transactionNonce = await provider.getTransactionCount(activeAccount.address, 'pending');
+                assertCurrent();
                 let txFormattedForTrezor = {};
                 const formatParams = isLegacy
                     ? (0, omit_1.default)(params, 'from')
@@ -1031,6 +1079,7 @@ class EthereumTransactions {
                     coin: activeNetwork.currency,
                     slip44: activeNetwork.slip44,
                 });
+                assertCurrent();
                 if (signature.success) {
                     try {
                         const txFormattedForEthers = isLegacy
@@ -1048,8 +1097,8 @@ class EthereumTransactions {
                             };
                         signature.payload.v = parseInt(signature.payload.v, 16); //v parameter must be a number by ethers standards
                         const signedTx = (0, ethers_v6_1.serializeTransaction)(txFormattedForEthers, signature.payload);
-                        beforeBroadcast();
-                        const finalTx = await this.web3Provider.sendTransaction(signedTx);
+                        assertBeforeBroadcast();
+                        const finalTx = await provider.sendTransaction(signedTx);
                         return finalTx;
                     }
                     catch (error) {
@@ -1061,6 +1110,7 @@ class EthereumTransactions {
                 }
             };
             const sendEVMTransaction = async () => {
+                assertCurrent();
                 const { address, decryptedPrivateKey } = this.getDecryptedPrivateKey();
                 // Validate that we have the correct private key for the active account to prevent race conditions
                 // This is critical for transaction security during account switches
@@ -1073,7 +1123,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)(this.web3Provider, decryptedPrivateKey, tx, beforeBroadcast);
+                    const transaction = await (0, evm_local_signer_1.sendLocalEvmTransaction)(provider, decryptedPrivateKey, tx, assertBeforeBroadcast, assertCurrent);
                     // 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.
@@ -1475,26 +1525,28 @@ class EthereumTransactions {
             }
         };
         this.sendSignedErc20Transaction = async ({ receiver, tokenAddress, tokenAmount, isLegacy = false, maxPriorityFeePerGas, maxFeePerGas, gasPrice, decimals, gasLimit, saveTrezorTx, }) => {
-            const { decryptedPrivateKey } = this.getDecryptedPrivateKey();
-            const { accounts, activeAccountType, activeAccountId, activeNetwork } = this.getState();
-            const { address: activeAccountAddress } = accounts[activeAccountType][activeAccountId];
+            const { activeAccount, activeAccountType, activeAccountId, activeNetwork, provider, assertCurrent, } = this.captureEvmSigningContext();
+            const activeAccountAddress = activeAccount.address;
             ({ gasPrice, isLegacy, maxFeePerGas, maxPriorityFeePerGas } =
                 await this.resolveEvmFeeParams({
                     gasPrice,
                     isLegacy,
                     maxFeePerGas,
                     maxPriorityFeePerGas,
-                }));
+                }, provider));
+            assertCurrent();
             const sendERC20Token = async () => {
+                assertCurrent();
+                const { decryptedPrivateKey } = this.getDecryptedPrivateKey();
                 try {
-                    const _contract = new ethers_v6_1.Contract(tokenAddress, (0, sysweb3_utils_1.getErc20Abi)(), this.web3Provider);
+                    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 this.web3Provider.getTransactionCount(activeAccountAddress, 'pending'),
+                            nonce: await provider.getTransactionCount(activeAccountAddress, 'pending'),
                             gasPrice,
                             ...(gasLimit && { gasLimit }),
                             type: 0, // Explicitly set Type 0 for legacy token transfers
@@ -1503,28 +1555,30 @@ class EthereumTransactions {
                     }
                     else {
                         const overrides = {
-                            nonce: await this.web3Provider.getTransactionCount(activeAccountAddress, 'pending'),
+                            nonce: await provider.getTransactionCount(activeAccountAddress, 'pending'),
                             maxPriorityFeePerGas,
                             maxFeePerGas,
                             ...(gasLimit && { gasLimit }),
                         };
                         transferMethod = await _contract.transfer.populateTransaction(receiver, calculatedTokenAmount, normalizeEthersOverrides(overrides));
                     }
-                    return await (0, evm_local_signer_1.sendLocalEvmTransaction)(this.web3Provider, decryptedPrivateKey, {
+                    return await (0, evm_local_signer_1.sendLocalEvmTransaction)(provider, decryptedPrivateKey, {
                         ...transferMethod,
                         chainId: activeNetwork.chainId,
                         from: activeAccountAddress,
                         value: '0x0',
-                    });
+                    }, assertCurrent, assertCurrent);
                 }
                 catch (error) {
                     throw error;
                 }
             };
             const sendERC20TokenOnLedger = async () => {
-                const transactionNonce = await this.getRecommendedNonce(activeAccountAddress);
+                assertCurrent();
+                const transactionNonce = await provider.getTransactionCount(activeAccountAddress, 'pending');
+                assertCurrent();
                 try {
-                    const _contract = new ethers_v6_1.Contract(tokenAddress, (0, sysweb3_utils_1.getErc20Abi)(), this.web3Provider);
+                    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', [
@@ -1564,6 +1618,7 @@ class EthereumTransactions {
                         rawTx: rawTx.replace('0x', ''),
                         accountIndex: activeAccountId,
                     });
+                    assertCurrent();
                     const formattedSignature = {
                         r: `0x${signature.r}`,
                         s: `0x${signature.s}`,
@@ -1572,7 +1627,8 @@ class EthereumTransactions {
                     if (signature) {
                         try {
                             const signedTx = (0, ethers_v6_1.serializeTransaction)(txFormattedForEthers, formattedSignature);
-                            const finalTx = await this.web3Provider.sendTransaction(signedTx);
+                            assertCurrent();
+                            const finalTx = await provider.sendTransaction(signedTx);
                             saveTrezorTx && saveTrezorTx(finalTx);
                             return finalTx;
                         }
@@ -1589,9 +1645,11 @@ class EthereumTransactions {
                 }
             };
             const sendERC20TokenOnTrezor = async () => {
-                const transactionNonce = await this.getRecommendedNonce(activeAccountAddress);
+                assertCurrent();
+                const transactionNonce = await provider.getTransactionCount(activeAccountAddress, 'pending');
+                assertCurrent();
                 try {
-                    const _contract = new ethers_v6_1.Contract(tokenAddress, (0, sysweb3_utils_1.getErc20Abi)(), this.web3Provider);
+                    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', [
@@ -1630,6 +1688,7 @@ class EthereumTransactions {
                         coin: activeNetwork.currency,
                         slip44: activeNetwork.slip44,
                     });
+                    assertCurrent();
                     if (signature.success) {
                         try {
                             let txFormattedForEthers;
@@ -1660,7 +1719,8 @@ class EthereumTransactions {
                             }
                             signature.payload.v = parseInt(signature.payload.v, 16); //v parameter must be a number by ethers standards
                             const signedTx = (0, ethers_v6_1.serializeTransaction)(txFormattedForEthers, signature.payload);
-                            const finalTx = await this.web3Provider.sendTransaction(signedTx);
+                            assertCurrent();
+                            const finalTx = await provider.sendTransaction(signedTx);
                             saveTrezorTx && saveTrezorTx(finalTx);
                             return finalTx;
                         }
@@ -1686,9 +1746,8 @@ class EthereumTransactions {
             }
         };
         this.sendSignedErc721Transaction = async ({ receiver, tokenAddress, tokenId, isLegacy, maxPriorityFeePerGas, maxFeePerGas, gasPrice, gasLimit, }) => {
-            const { decryptedPrivateKey } = this.getDecryptedPrivateKey();
-            const { accounts, activeAccountType, activeAccountId, activeNetwork } = this.getState();
-            const { address: activeAccountAddress } = accounts[activeAccountType][activeAccountId];
+            const { activeAccount, activeAccountType, activeAccountId, activeNetwork, provider, assertCurrent, } = this.captureEvmSigningContext();
+            const activeAccountAddress = activeAccount.address;
             if (tokenId === undefined || tokenId === null) {
                 throw new Error('ERC721 tokenId is required');
             }
@@ -1698,15 +1757,18 @@ class EthereumTransactions {
                     isLegacy,
                     maxFeePerGas,
                     maxPriorityFeePerGas,
-                }));
+                }, provider));
+            assertCurrent();
             const normalizedTokenId = ethers_v6_1.BigNumber.from(tokenId).toBigInt();
             const sendERC721Token = async () => {
+                assertCurrent();
+                const { decryptedPrivateKey } = this.getDecryptedPrivateKey();
                 let transferMethod;
                 try {
-                    const _contract = new ethers_v6_1.Contract(tokenAddress, (0, sysweb3_utils_1.getErc21Abi)(), this.web3Provider);
+                    const _contract = new ethers_v6_1.Contract(tokenAddress, (0, sysweb3_utils_1.getErc21Abi)(), provider);
                     if (isLegacy) {
                         const overrides = {
-                            nonce: await this.web3Provider.getTransactionCount(activeAccountAddress, 'pending'),
+                            nonce: await provider.getTransactionCount(activeAccountAddress, 'pending'),
                             gasPrice,
                             ...(gasLimit && { gasLimit }),
                             type: 0, // Explicitly set Type 0 for legacy NFT transfers
@@ -1715,28 +1777,30 @@ class EthereumTransactions {
                     }
                     else {
                         const overrides = {
-                            nonce: await this.web3Provider.getTransactionCount(activeAccountAddress, 'pending'),
+                            nonce: await provider.getTransactionCount(activeAccountAddress, 'pending'),
                             maxPriorityFeePerGas,
                             maxFeePerGas,
                             ...(gasLimit && { gasLimit }),
                         };
                         transferMethod = await _contract.transferFrom.populateTransaction(activeAccountAddress, receiver, normalizedTokenId, normalizeEthersOverrides(overrides));
                     }
-                    return await (0, evm_local_signer_1.sendLocalEvmTransaction)(this.web3Provider, decryptedPrivateKey, {
+                    return await (0, evm_local_signer_1.sendLocalEvmTransaction)(provider, decryptedPrivateKey, {
                         ...transferMethod,
                         chainId: activeNetwork.chainId,
                         from: activeAccountAddress,
                         value: '0x0',
-                    });
+                    }, assertCurrent, assertCurrent);
                 }
                 catch (error) {
                     throw error;
                 }
             };
             const sendERC721TokenOnLedger = async () => {
-                const transactionNonce = await this.getRecommendedNonce(activeAccountAddress);
+                assertCurrent();
+                const transactionNonce = await provider.getTransactionCount(activeAccountAddress, 'pending');
+                assertCurrent();
                 try {
-                    const _contract = new ethers_v6_1.Contract(tokenAddress, (0, sysweb3_utils_1.getErc21Abi)(), this.web3Provider);
+                    const _contract = new ethers_v6_1.Contract(tokenAddress, (0, sysweb3_utils_1.getErc21Abi)(), provider);
                     const txData = _contract.interface.encodeFunctionData('transferFrom', [
                         activeAccountAddress,
                         receiver,
@@ -1775,6 +1839,7 @@ class EthereumTransactions {
                         rawTx: rawTx.replace('0x', ''),
                         accountIndex: activeAccountId,
                     });
+                    assertCurrent();
                     const formattedSignature = {
                         r: `0x${signature.r}`,
                         s: `0x${signature.s}`,
@@ -1783,7 +1848,8 @@ class EthereumTransactions {
                     if (signature) {
                         try {
                             const signedTx = (0, ethers_v6_1.serializeTransaction)(txFormattedForEthers, formattedSignature);
-                            const finalTx = await this.web3Provider.sendTransaction(signedTx);
+                            assertCurrent();
+                            const finalTx = await provider.sendTransaction(signedTx);
                             return finalTx;
                         }
                         catch (error) {
@@ -1799,9 +1865,11 @@ class EthereumTransactions {
                 }
             };
             const sendERC721TokenOnTrezor = async () => {
-                const transactionNonce = await this.getRecommendedNonce(activeAccountAddress);
+                assertCurrent();
+                const transactionNonce = await provider.getTransactionCount(activeAccountAddress, 'pending');
+                assertCurrent();
                 try {
-                    const _contract = new ethers_v6_1.Contract(tokenAddress, (0, sysweb3_utils_1.getErc21Abi)(), this.web3Provider);
+                    const _contract = new ethers_v6_1.Contract(tokenAddress, (0, sysweb3_utils_1.getErc21Abi)(), provider);
                     const txData = _contract.interface.encodeFunctionData('transferFrom', [
                         activeAccountAddress,
                         receiver,
@@ -1842,6 +1910,7 @@ class EthereumTransactions {
                         coin: trezorCoin,
                         slip44: activeNetwork.slip44,
                     });
+                    assertCurrent();
                     if (signature.success) {
                         try {
                             let txFormattedForEthers;
@@ -1872,7 +1941,8 @@ class EthereumTransactions {
                             }
                             signature.payload.v = parseInt(signature.payload.v, 16); //v parameter must be a number by ethers standards
                             const signedTx = (0, ethers_v6_1.serializeTransaction)(txFormattedForEthers, signature.payload);
-                            const finalTx = await this.web3Provider.sendTransaction(signedTx);
+                            assertCurrent();
+                            const finalTx = await provider.sendTransaction(signedTx);
                             return finalTx;
                         }
                         catch (error) {
@@ -1899,26 +1969,28 @@ class EthereumTransactions {
             }
         };
         this.sendSignedErc1155Transaction = async ({ receiver, tokenAddress, tokenId, tokenAmount, isLegacy, maxPriorityFeePerGas, maxFeePerGas, gasPrice, gasLimit, }) => {
-            const { decryptedPrivateKey } = this.getDecryptedPrivateKey();
-            const { accounts, activeAccountType, activeAccountId, activeNetwork } = this.getState();
-            const { address: activeAccountAddress } = accounts[activeAccountType][activeAccountId];
+            const { activeAccount, activeAccountType, activeAccountId, activeNetwork, provider, assertCurrent, } = this.captureEvmSigningContext();
+            const activeAccountAddress = activeAccount.address;
             ({ gasPrice, isLegacy, maxFeePerGas, maxPriorityFeePerGas } =
                 await this.resolveEvmFeeParams({
                     gasPrice,
                     isLegacy,
                     maxFeePerGas,
                     maxPriorityFeePerGas,
-                }));
+                }, provider));
+            assertCurrent();
             const sendERC1155Token = async () => {
+                assertCurrent();
+                const { decryptedPrivateKey } = this.getDecryptedPrivateKey();
                 let transferMethod;
                 try {
-                    const _contract = new ethers_v6_1.Contract(tokenAddress, (0, sysweb3_utils_1.getErc55Abi)(), this.web3Provider);
+                    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 this.web3Provider.getTransactionCount(activeAccountAddress, 'pending'),
+                            nonce: await provider.getTransactionCount(activeAccountAddress, 'pending'),
                             gasPrice,
                             ...(gasLimit && { gasLimit }),
                             type: 0, // Explicitly set Type 0 for legacy ERC1155 transfers
@@ -1926,28 +1998,30 @@ class EthereumTransactions {
                     }
                     else {
                         overrides = {
-                            nonce: await this.web3Provider.getTransactionCount(activeAccountAddress, 'pending'),
+                            nonce: await provider.getTransactionCount(activeAccountAddress, 'pending'),
                             maxPriorityFeePerGas,
                             maxFeePerGas,
                             ...(gasLimit && { gasLimit }),
                         };
                     }
                     transferMethod = await _contract.safeTransferFrom.populateTransaction(activeAccountAddress, receiver, tokenId, amount.toBigInt(), '0x', normalizeEthersOverrides(overrides));
-                    return await (0, evm_local_signer_1.sendLocalEvmTransaction)(this.web3Provider, decryptedPrivateKey, {
+                    return await (0, evm_local_signer_1.sendLocalEvmTransaction)(provider, decryptedPrivateKey, {
                         ...transferMethod,
                         chainId: activeNetwork.chainId,
                         from: activeAccountAddress,
                         value: '0x0',
-                    });
+                    }, assertCurrent, assertCurrent);
                 }
                 catch (error) {
                     throw error;
                 }
             };
             const sendERC1155TokenOnLedger = async () => {
-                const transactionNonce = await this.getRecommendedNonce(activeAccountAddress);
+                assertCurrent();
+                const transactionNonce = await provider.getTransactionCount(activeAccountAddress, 'pending');
+                assertCurrent();
                 try {
-                    const _contract = new ethers_v6_1.Contract(tokenAddress, (0, sysweb3_utils_1.getErc55Abi)(), this.web3Provider);
+                    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)
@@ -1983,6 +2057,7 @@ class EthereumTransactions {
                         rawTx: rawTx.replace('0x', ''),
                         accountIndex: activeAccountId,
                     });
+                    assertCurrent();
                     const formattedSignature = {
                         r: `0x${signature.r}`,
                         s: `0x${signature.s}`,
@@ -1991,7 +2066,8 @@ class EthereumTransactions {
                     if (signature) {
                         try {
                             const signedTx = (0, ethers_v6_1.serializeTransaction)(txFormattedForEthers, formattedSignature);
-                            const finalTx = await this.web3Provider.sendTransaction(signedTx);
+                            assertCurrent();
+                            const finalTx = await provider.sendTransaction(signedTx);
                             return finalTx;
                         }
                         catch (error) {
@@ -2007,9 +2083,11 @@ class EthereumTransactions {
                 }
             };
             const sendERC1155TokenOnTrezor = async () => {
-                const transactionNonce = await this.getRecommendedNonce(activeAccountAddress);
+                assertCurrent();
+                const transactionNonce = await provider.getTransactionCount(activeAccountAddress, 'pending');
+                assertCurrent();
                 try {
-                    const _contract = new ethers_v6_1.Contract(tokenAddress, (0, sysweb3_utils_1.getErc55Abi)(), this.web3Provider);
+                    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)
@@ -2044,6 +2122,7 @@ class EthereumTransactions {
                         coin: activeNetwork.currency,
                         slip44: activeNetwork.slip44,
                     });
+                    assertCurrent();
                     if (signature.success) {
                         try {
                             let txFormattedForEthers;
@@ -2074,7 +2153,8 @@ class EthereumTransactions {
                             }
                             signature.payload.v = parseInt(signature.payload.v, 16); //v parameter must be a number by ethers standards
                             const signedTx = (0, ethers_v6_1.serializeTransaction)(txFormattedForEthers, signature.payload);
-                            const finalTx = await this.web3Provider.sendTransaction(signedTx);
+                            assertCurrent();
+                            const finalTx = await provider.sendTransaction(signedTx);
                             return finalTx;
                         }
                         catch (error) {
@@ -2256,6 +2336,7 @@ class EthereumTransactions {
         this.getState = getState;
         this.trezorSigner = trezorSigner;
         this.ledgerSigner = ledgerSigner;
+        this.captureSigningContext = captureSigningContext;
     }
     // Getter that automatically ensures providers are initialized when accessed
     get web3Provider() {