@sidhujag/sysweb3-keyring 1.0.627 → 2.0.0

package/cjs/transactions/ethereum.js

@@ -14,7 +14,38 @@ const providers_1 = require("../providers");
 const types_1 = require("../types");
 const evm_local_signer_1 = require("./evm-local-signer");
 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',
+});
+const assertHardwareTransactionSender = (signedTx, expectedAddress) => {
+    if (transaction_1.Transaction.from(signedTx).from?.toLowerCase() !==
+        expectedAddress.toLowerCase()) {
+        throw Object.assign(new Error('Hardware signature does not match the approved account'), {
+            code: 'HARDWARE_ACCOUNT_MISMATCH',
+        });
+    }
+};
 const stripHexPrefix = (value) => 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) => {
+    const { r, s, v } = signature;
+    if (![r, s].every((value) => /^(?:0x)?[0-9a-f]{64}$/i.test(value))) {
+        throw new Error('Invalid Trezor signature scalar encoding');
+    }
+    if (typeof v === 'string' && !/^(?:0x)?[0-9a-f]+$/i.test(v)) {
+        throw new Error('Invalid Trezor signature recovery value');
+    }
+    const recovery = typeof v === 'number' ? v : Number.parseInt(v, 16);
+    if (!Number.isSafeInteger(recovery) || recovery < 0) {
+        throw new Error('Invalid Trezor signature recovery value');
+    }
+    return {
+        r: `0x${stripHexPrefix(r)}`,
+        s: `0x${stripHexPrefix(s)}`,
+        v: recovery,
+    };
+};
 const normalizeEthersOverrideValue = (value) => (0, ethers_v6_1.normalizeTxValue)(value);
 const nonNegativeFeeQuantity = (value, label) => {
     // Match the exported BigNumberish object contract without trusting a
@@ -131,7 +162,28 @@ class EthereumTransactions {
     constructor(getNetwork, getDecryptedPrivateKey, getState, ledgerSigner, trezorSigner, captureSigningContext) {
         // Allow manual override of gas parameters when automatic estimation fails
         this.gasOverrides = {};
+        this.requireLedgerSigner = () => {
+            if (!this.ledgerSigner)
+                throw hardwareSignerUnavailable('Ledger');
+            return this.ledgerSigner;
+        };
+        this.requireTrezorSigner = () => {
+            if (!this.trezorSigner)
+                throw hardwareSignerUnavailable('Trezor');
+            return this.trezorSigner;
+        };
+        this.assertHardwareSignerAvailable = (targetAccount) => {
+            const state = this.getState();
+            const type = targetAccount?.type ?? state.activeAccountType;
+            const id = targetAccount?.id ?? state.activeAccountId;
+            const account = state.accounts[type]?.[id];
+            if (type === types_1.KeyringAccountType.Ledger || account?.isLedgerWallet)
+                this.requireLedgerSigner();
+            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)
@@ -192,9 +244,10 @@ class EthereumTransactions {
                     throw {
                         message: 'Decrypting for wrong address, change activeAccount maybe',
                     };
-                return await this.ledgerSigner.evm.signTypedData({
+                return await this.requireLedgerSigner().evm.signTypedData({
                     version,
                     accountIndex: activeAccountId,
+                    expectedAddress: activeAccount.address,
                     data: typedData,
                 });
             };
@@ -203,7 +256,7 @@ class EthereumTransactions {
                     throw {
                         message: 'Decrypting for wrong address, change activeAccount maybe',
                     };
-                return await this.trezorSigner.signTypedData({
+                return await this.requireTrezorSigner().signTypedData({
                     version,
                     address: addr,
                     data: typedData,
@@ -225,9 +278,9 @@ class EthereumTransactions {
             const { activeAccountType } = this.getState();
             switch (activeAccountType) {
                 case types_1.KeyringAccountType.Ledger:
-                    return await this.ledgerSigner.verifyUtxoAddress(accountIndex, currency, slip44);
+                    return await this.requireLedgerSigner().verifyUtxoAddress(accountIndex, currency, slip44);
                 case types_1.KeyringAccountType.Trezor:
-                    return await this.trezorSigner.verifyUtxoAddress(accountIndex, currency, slip44);
+                    return await this.requireTrezorSigner().verifyUtxoAddress(accountIndex, currency, slip44);
                 default:
                     throw new Error('verifyUtxoAddress is only available for hardware wallet accounts');
             }
@@ -284,8 +337,9 @@ class EthereumTransactions {
             };
             const signWithLedger = async () => {
                 try {
-                    const response = await this.ledgerSigner.evm.signPersonalMessage({
+                    const response = await this.requireLedgerSigner().evm.signPersonalMessage({
                         accountIndex: activeAccountId,
+                        expectedAddress: activeAccount.address,
                         message: msg,
                     });
                     return response;
@@ -298,7 +352,7 @@ class EthereumTransactions {
                 try {
                     // For EVM networks, Trezor expects 'eth' regardless of the network's currency
                     const trezorCoin = activeNetwork.slip44 === 60 ? 'eth' : activeNetwork.currency;
-                    const response = await this.trezorSigner.signMessage({
+                    const response = await this.requireTrezorSigner().signMessage({
                         coin: trezorCoin,
                         address: activeAccount.address,
                         index: activeAccountId,
@@ -377,8 +431,9 @@ class EthereumTransactions {
                         // Message is plain text, convert to hex
                         messageForLedger = Buffer.from(msg, 'utf8').toString('hex');
                     }
-                    const response = await this.ledgerSigner.evm.signPersonalMessage({
+                    const response = await this.requireLedgerSigner().evm.signPersonalMessage({
                         accountIndex: activeAccountId,
+                        expectedAddress: activeAccount.address,
                         message: messageForLedger,
                     });
                     return response;
@@ -401,7 +456,7 @@ class EthereumTransactions {
                     }
                     // For EVM networks, Trezor expects 'eth' regardless of the network's currency
                     const trezorCoin = activeNetwork.slip44 === 60 ? 'eth' : activeNetwork.currency;
-                    const response = await this.trezorSigner.signMessage({
+                    const response = await this.requireTrezorSigner().signMessage({
                         coin: trezorCoin,
                         address: activeAccount.address,
                         index: activeAccountId,
@@ -674,9 +729,52 @@ class EthereumTransactions {
                 (!Number.isSafeInteger(fallbackNonce) || fallbackNonce < 0)) {
                 throw new Error('Invalid cancellation fallback nonce');
             }
+            const previewOnly = options.previewOnly === true;
+            const approvedMaximumFee = options.approvedMaximumFee;
+            if (!previewOnly &&
+                (typeof approvedMaximumFee !== 'string' ||
+                    !/^(0|[1-9][0-9]{0,77})$/.test(approvedMaximumFee))) {
+                throw new Error('Cancellation fee approval required');
+            }
             const assertHostContext = options.assertCurrentContext;
             assertHostContext();
-            const { activeAccount, activeAccountType, activeAccountId, activeNetwork, provider, assertCurrent: assertKeyringContext, } = this.captureEvmSigningContext();
+            const state = this.getState();
+            const selectedType = state.activeAccountType;
+            const selectedId = state.activeAccountId;
+            const selectedAddress = state.accounts?.[selectedType]?.[selectedId]?.address;
+            const activeAccountType = options.targetAccount?.type ?? selectedType;
+            const activeAccountId = options.targetAccount?.id ?? selectedId;
+            const targetAccount = options.targetAccount
+                ? { type: activeAccountType, id: activeAccountId }
+                : undefined;
+            const activeAccount = {
+                ...state.accounts?.[activeAccountType]?.[activeAccountId],
+            };
+            const activeNetwork = { ...state.activeNetwork };
+            if (!selectedAddress ||
+                !activeAccount.address ||
+                (targetAccount && activeAccountType === types_1.KeyringAccountType.SmartAccount)) {
+                throw new Error('Cancellation signing account is unavailable');
+            }
+            if (!previewOnly)
+                this.assertHardwareSignerAvailable(targetAccount);
+            const provider = this.web3Provider;
+            const assertSession = this.captureSigningContext?.();
+            const assertKeyringContext = () => {
+                assertSession?.();
+                const current = this.getState();
+                if (current.activeAccountType !== selectedType ||
+                    current.activeAccountId !== selectedId ||
+                    current.accounts?.[selectedType]?.[selectedId]?.address?.toLowerCase() !== selectedAddress.toLowerCase() ||
+                    current.accounts?.[activeAccountType]?.[activeAccountId]?.address?.toLowerCase() !== activeAccount.address.toLowerCase() ||
+                    [current.activeNetwork, this.getNetwork()].some((selected) => selected.kind !== activeNetwork.kind ||
+                        selected.chainId !== activeNetwork.chainId ||
+                        selected.slip44 !== activeNetwork.slip44 ||
+                        selected.url !== activeNetwork.url) ||
+                    this.web3Provider !== provider) {
+                    throw new Error('Wallet signing context changed');
+                }
+            };
             const assertCurrent = () => {
                 assertHostContext();
                 assertKeyringContext();
@@ -798,6 +896,22 @@ class EthereumTransactions {
                         maxPriorityFeePerGas: bumpCancelFee(oldTxsGasValues.maxPriorityFeePerGas),
                     }),
             };
+            const maximumFee = newGasValues.gasLimit.mul(isLegacy ? newGasValues.gasPrice : newGasValues.maxFeePerGas);
+            assertCurrent();
+            if (previewOnly)
+                return {
+                    isCanceled: false,
+                    error: false,
+                    maximumFee: maximumFee.toString(),
+                };
+            if (maximumFee.gt(approvedMaximumFee))
+                throw new Error('Cancellation fee exceeds approval');
+            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))
+                    throw new Error('Cancellation fee exceeds approval');
+            };
             // Base cancel transaction parameters (same for all wallet types)
             const baseCancelTx = {
                 nonce: tx.nonce,
@@ -841,10 +955,12 @@ class EthereumTransactions {
                             chainId: activeNetwork.chainId,
                             type: 2, // Need explicit type for hardware wallet serialization
                         };
+                    assertApprovedEnvelope(txFormattedForEthers);
                     const rawTx = (0, ethers_v6_1.serializeTransaction)(txFormattedForEthers);
-                    const signature = await this.ledgerSigner.evm.signEVMTransaction({
+                    const signature = await this.requireLedgerSigner().evm.signEVMTransaction({
                         rawTx: rawTx.replace('0x', ''),
                         accountIndex: activeAccountId,
+                        expectedAddress: activeAccount.address,
                     });
                     assertCurrent();
                     const formattedSignature = {
@@ -855,6 +971,7 @@ class EthereumTransactions {
                     if (signature) {
                         const signedTx = (0, ethers_v6_1.serializeTransaction)(txFormattedForEthers, formattedSignature);
                         assertCurrent();
+                        assertHardwareTransactionSender(signedTx, activeAccount.address);
                         const transactionResponse = await provider.sendTransaction(signedTx);
                         return {
                             isCanceled: true,
@@ -908,7 +1025,8 @@ class EthereumTransactions {
                                 ? formattedTx.maxPriorityFeePerGas
                                 : this.toHex0x(formattedTx.maxPriorityFeePerGas, 'maxPriorityFeePerGas');
                     }
-                    const signature = await this.trezorSigner.signEthTransaction({
+                    assertApprovedEnvelope(txFormattedForTrezor);
+                    const signature = await this.requireTrezorSigner().signEthTransaction({
                         coin: trezorCoin,
                         tx: txFormattedForTrezor,
                         index: activeAccountId.toString(),
@@ -916,8 +1034,9 @@ class EthereumTransactions {
                     });
                     assertCurrent();
                     if (signature.success) {
-                        const signedTx = (0, ethers_v6_1.serializeTransaction)(txFormattedForTrezor, signature.payload);
+                        const signedTx = (0, ethers_v6_1.serializeTransaction)(txFormattedForTrezor, trezorSignature(signature.payload));
                         assertCurrent();
+                        assertHardwareTransactionSender(signedTx, activeAccount.address);
                         const transactionResponse = await provider.sendTransaction(signedTx);
                         return {
                             isCanceled: true,
@@ -942,11 +1061,11 @@ class EthereumTransactions {
             const cancelWithPrivateKey = async () => {
                 try {
                     assertCurrent();
-                    const { address, decryptedPrivateKey } = this.getDecryptedPrivateKey();
+                    const { address, decryptedPrivateKey } = this.getDecryptedPrivateKey(targetAccount);
                     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);
+                    const transactionResponse = await (0, evm_local_signer_1.sendLocalEvmTransaction)(provider, decryptedPrivateKey, changedTxToCancel, assertCurrent, assertCurrent, assertApprovedEnvelope);
                     if (transactionResponse) {
                         return {
                             isCanceled: true,
@@ -1107,9 +1226,10 @@ class EthereumTransactions {
                         type: 2, // Need explicit type for hardware wallet serialization
                     };
                 const rawTx = (0, ethers_v6_1.serializeTransaction)(txFormattedForEthers);
-                const signature = await this.ledgerSigner.evm.signEVMTransaction({
+                const signature = await this.requireLedgerSigner().evm.signEVMTransaction({
                     rawTx: rawTx.replace('0x', ''),
                     accountIndex: activeAccountId,
+                    expectedAddress: activeAccount.address,
                 });
                 assertCurrent();
                 const formattedSignature = {
@@ -1120,6 +1240,7 @@ class EthereumTransactions {
                 if (signature) {
                     try {
                         const signedTx = (0, ethers_v6_1.serializeTransaction)(txFormattedForEthers, formattedSignature);
+                        assertHardwareTransactionSender(signedTx, activeAccount.address);
                         assertBeforeBroadcast();
                         const finalTx = await provider.sendTransaction(signedTx);
                         return finalTx;
@@ -1180,7 +1301,7 @@ class EthereumTransactions {
                         };
                         break;
                 }
-                const signature = await this.trezorSigner.signEthTransaction({
+                const signature = await this.requireTrezorSigner().signEthTransaction({
                     index: `${activeAccountId}`,
                     tx: txFormattedForTrezor,
                     coin: activeNetwork.currency,
@@ -1202,8 +1323,8 @@ class EthereumTransactions {
                                 chainId: activeNetwork.chainId,
                                 type: 2, // Need explicit type for hardware wallet serialization
                             };
-                        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 signedTx = (0, ethers_v6_1.serializeTransaction)(txFormattedForEthers, trezorSignature(signature.payload));
+                        assertHardwareTransactionSender(signedTx, activeAccount.address);
                         assertBeforeBroadcast();
                         const finalTx = await provider.sendTransaction(signedTx);
                         return finalTx;
@@ -1252,6 +1373,8 @@ class EthereumTransactions {
         this.sendTransactionWithEditedFee = async (txHash, isLegacy = false, options = {}) => {
             const { assertCurrentContext, validateOriginal, beforeBroadcast, approvedMaximumFee, } = options;
             const previewOnly = options.previewOnly === true;
+            if (!previewOnly)
+                this.assertHardwareSignerAvailable(options.targetAccount);
             if (!previewOnly &&
                 (typeof approvedMaximumFee !== 'string' ||
                     !/^\d{1,78}$/.test(approvedMaximumFee))) {
@@ -1366,7 +1489,6 @@ class EthereumTransactions {
                 newGasValues.maxPriorityFeePerGas.gt(newGasValues.maxFeePerGas))
                 throw new Error('Invalid replacement fee');
             const maximumFee = newGasValues.gasLimit.mul(isLegacy ? newGasValues.gasPrice : newGasValues.maxFeePerGas);
-            let adjustedValue = txValue;
             if (isLikelyMaxSend && txValue.add(maximumFee).gt(currentBalance)) {
                 if (isContractCall) {
                     console.error('[SpeedUp] Cannot adjust value for contract call - rejecting speedup');
@@ -1377,16 +1499,19 @@ class EthereumTransactions {
                         message: 'Cannot speed up a likely max-send contract call; value cannot be adjusted to fit new gas',
                     };
                 }
-                adjustedValue = currentBalance.gt(maximumFee)
-                    ? currentBalance.sub(maximumFee)
-                    : ethers_v6_1.Zero;
+                return {
+                    isSpeedUp: false,
+                    error: true,
+                    code: 'REPLACEMENT_VALUE_WOULD_CHANGE',
+                    message: 'Add funds before speeding up this transaction; the original amount will not be changed',
+                };
             }
             const txWithEditedFee = {
                 chainId: activeNetwork.chainId,
                 from: tx.from,
                 to: tx.to,
                 nonce: tx.nonce,
-                value: adjustedValue,
+                value: txValue,
                 data: txData,
                 gasLimit: newGasValues.gasLimit,
                 ...(tx.accessList != null ? { accessList: tx.accessList } : {}),
@@ -1424,9 +1549,10 @@ class EthereumTransactions {
                         };
                     const rawTx = (0, ethers_v6_1.serializeTransaction)(txFormattedForEthers);
                     assertCurrent();
-                    const signature = await this.ledgerSigner.evm.signEVMTransaction({
+                    const signature = await this.requireLedgerSigner().evm.signEVMTransaction({
                         rawTx: rawTx.replace('0x', ''),
                         accountIndex: activeAccountId,
+                        expectedAddress: activeAccount.address,
                     });
                     const formattedSignature = {
                         r: `0x${signature.r}`,
@@ -1436,6 +1562,7 @@ class EthereumTransactions {
                     if (signature) {
                         const signedTx = (0, ethers_v6_1.serializeTransaction)(txFormattedForEthers, formattedSignature);
                         assertSignedSender(signedTx);
+                        assertHardwareTransactionSender(signedTx, activeAccount.address);
                         assertBeforeBroadcast();
                         const transactionResponse = await provider.sendTransaction(signedTx);
                         return {
@@ -1505,15 +1632,16 @@ class EthereumTransactions {
                                 : this.toHex0x(formattedTx.maxPriorityFeePerGas, 'maxPriorityFeePerGas');
                     }
                     assertCurrent();
-                    const signature = await this.trezorSigner.signEthTransaction({
+                    const signature = await this.requireTrezorSigner().signEthTransaction({
                         coin: trezorCoin,
                         tx: txFormattedForTrezor,
                         index: activeAccountId.toString(),
                         slip44: activeNetwork.slip44,
                     });
                     if (signature.success) {
-                        const signedTx = (0, ethers_v6_1.serializeTransaction)(txFormattedForTrezor, signature.payload);
+                        const signedTx = (0, ethers_v6_1.serializeTransaction)(txFormattedForTrezor, trezorSignature(signature.payload));
                         assertSignedSender(signedTx);
+                        assertHardwareTransactionSender(signedTx, activeAccount.address);
                         assertBeforeBroadcast();
                         const transactionResponse = await provider.sendTransaction(signedTx);
                         return {
@@ -1688,9 +1816,10 @@ class EthereumTransactions {
                         };
                     }
                     const rawTx = (0, ethers_v6_1.serializeTransaction)(txFormattedForEthers);
-                    const signature = await this.ledgerSigner.evm.signEVMTransaction({
+                    const signature = await this.requireLedgerSigner().evm.signEVMTransaction({
                         rawTx: rawTx.replace('0x', ''),
                         accountIndex: activeAccountId,
+                        expectedAddress: activeAccount.address,
                     });
                     assertCurrent();
                     const formattedSignature = {
@@ -1702,6 +1831,7 @@ class EthereumTransactions {
                         try {
                             const signedTx = (0, ethers_v6_1.serializeTransaction)(txFormattedForEthers, formattedSignature);
                             assertCurrent();
+                            assertHardwareTransactionSender(signedTx, activeAccount.address);
                             const finalTx = await provider.sendTransaction(signedTx);
                             saveTrezorTx && saveTrezorTx(finalTx);
                             return finalTx;
@@ -1756,7 +1886,7 @@ class EthereumTransactions {
                             data: txData,
                         };
                     }
-                    const signature = await this.trezorSigner.signEthTransaction({
+                    const signature = await this.requireTrezorSigner().signEthTransaction({
                         index: `${activeAccountId}`,
                         tx: txToBeSignedByTrezor,
                         coin: activeNetwork.currency,
@@ -1791,9 +1921,9 @@ class EthereumTransactions {
                                     type: 2, // Need explicit type for hardware wallet serialization
                                 };
                             }
-                            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 signedTx = (0, ethers_v6_1.serializeTransaction)(txFormattedForEthers, trezorSignature(signature.payload));
                             assertCurrent();
+                            assertHardwareTransactionSender(signedTx, activeAccount.address);
                             const finalTx = await provider.sendTransaction(signedTx);
                             saveTrezorTx && saveTrezorTx(finalTx);
                             return finalTx;
@@ -1909,9 +2039,10 @@ class EthereumTransactions {
                         };
                     }
                     const rawTx = (0, ethers_v6_1.serializeTransaction)(txFormattedForEthers);
-                    const signature = await this.ledgerSigner.evm.signEVMTransaction({
+                    const signature = await this.requireLedgerSigner().evm.signEVMTransaction({
                         rawTx: rawTx.replace('0x', ''),
                         accountIndex: activeAccountId,
+                        expectedAddress: activeAccount.address,
                     });
                     assertCurrent();
                     const formattedSignature = {
@@ -1923,6 +2054,7 @@ class EthereumTransactions {
                         try {
                             const signedTx = (0, ethers_v6_1.serializeTransaction)(txFormattedForEthers, formattedSignature);
                             assertCurrent();
+                            assertHardwareTransactionSender(signedTx, activeAccount.address);
                             const finalTx = await provider.sendTransaction(signedTx);
                             return finalTx;
                         }
@@ -1978,7 +2110,7 @@ class EthereumTransactions {
                     }
                     // For EVM networks, Trezor expects 'eth' regardless of the network's currency
                     const trezorCoin = activeNetwork.slip44 === 60 ? 'eth' : activeNetwork.currency;
-                    const signature = await this.trezorSigner.signEthTransaction({
+                    const signature = await this.requireTrezorSigner().signEthTransaction({
                         index: `${activeAccountId}`,
                         tx: txToBeSignedByTrezor,
                         coin: trezorCoin,
@@ -2013,9 +2145,9 @@ class EthereumTransactions {
                                     type: 2, // Need explicit type for hardware wallet serialization
                                 };
                             }
-                            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 signedTx = (0, ethers_v6_1.serializeTransaction)(txFormattedForEthers, trezorSignature(signature.payload));
                             assertCurrent();
+                            assertHardwareTransactionSender(signedTx, activeAccount.address);
                             const finalTx = await provider.sendTransaction(signedTx);
                             return finalTx;
                         }
@@ -2127,9 +2259,10 @@ class EthereumTransactions {
                         };
                     }
                     const rawTx = (0, ethers_v6_1.serializeTransaction)(txFormattedForEthers);
-                    const signature = await this.ledgerSigner.evm.signEVMTransaction({
+                    const signature = await this.requireLedgerSigner().evm.signEVMTransaction({
                         rawTx: rawTx.replace('0x', ''),
                         accountIndex: activeAccountId,
+                        expectedAddress: activeAccount.address,
                     });
                     assertCurrent();
                     const formattedSignature = {
@@ -2141,6 +2274,7 @@ class EthereumTransactions {
                         try {
                             const signedTx = (0, ethers_v6_1.serializeTransaction)(txFormattedForEthers, formattedSignature);
                             assertCurrent();
+                            assertHardwareTransactionSender(signedTx, activeAccount.address);
                             const finalTx = await provider.sendTransaction(signedTx);
                             return finalTx;
                         }
@@ -2190,7 +2324,7 @@ class EthereumTransactions {
                             data: txData,
                         };
                     }
-                    const signature = await this.trezorSigner.signEthTransaction({
+                    const signature = await this.requireTrezorSigner().signEthTransaction({
                         index: `${activeAccountId}`,
                         tx: txToBeSignedByTrezor,
                         coin: activeNetwork.currency,
@@ -2225,9 +2359,9 @@ class EthereumTransactions {
                                     type: 2, // Need explicit type for hardware wallet serialization
                                 };
                             }
-                            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 signedTx = (0, ethers_v6_1.serializeTransaction)(txFormattedForEthers, trezorSignature(signature.payload));
                             assertCurrent();
+                            assertHardwareTransactionSender(signedTx, activeAccount.address);
                             const finalTx = await provider.sendTransaction(signedTx);
                             return finalTx;
                         }
@@ -2403,7 +2537,10 @@ class EthereumTransactions {
             };
         };
         this.getNetwork = getNetwork;
-        this.getDecryptedPrivateKey = getDecryptedPrivateKey;
+        this.getDecryptedPrivateKey = (targetAccount) => {
+            this.assertHardwareSignerAvailable(targetAccount);
+            return getDecryptedPrivateKey(targetAccount);
+        };
         this.abortController = new AbortController();
         // NOTE: Defer network access until vault state getter is initialized
         // The web3Provider will be created lazily when first accessed via getters