@sidhujag/sysweb3-keyring 2.1.8 → 2.1.9

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 2.1.9
+
+- Share canonical Trezor EVM signing across all six existing transaction paths and explicitly hosted native consumers. Preserve reviewed nonces, fees, access lists and account identity, with current-session checks before and after device signing.
+- Preserve trusted, locally observed pre-broadcast failure information for Ledger and Trezor without accepting device or provider claims. Reject mismatched signed envelopes without attaching their transaction hash.
+
 ## 2.1.8
 
 - Allow native and browser hosts to supply their Ledger transport through the same keyring engine and explicit session authority.

package/cjs/transactions/ethereum.js

@@ -21,6 +21,7 @@ const evm_local_signer_1 = require("./evm-local-signer");
 const evm_submission_1 = require("./evm-submission");
 const ledger_signing_1 = require("./ledger-signing");
 const prepared_evm_1 = require("./prepared-evm");
+const trezor_signing_1 = require("./trezor-signing");
 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',
@@ -38,26 +39,6 @@ const stripHexPrefix = (value) => {
         ? 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);
 // 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.
@@ -1067,29 +1048,20 @@ class EthereumTransactions {
                     const expectedUnsignedTransaction = serializeTransaction(txFormattedForTrezor);
                     if (retained)
                         assertCancellationEnvelope(expectedUnsignedTransaction);
-                    const signature = await this.requireTrezorSigner().signEthTransaction({
+                    const { rawTransaction: signedTx } = await (0, trezor_signing_1.signTrezorEvmTransaction)(this.requireTrezorSigner(), {
+                        accountIndex: activeAccountId,
                         coin: trezorCoin,
-                        tx: txFormattedForTrezor,
-                        index: activeAccountId.toString(),
+                        expectedAddress: activeAccount.address,
                         slip44: activeNetwork.slip44,
+                        unsignedTransaction: expectedUnsignedTransaction,
                     }, await this.authorizeHardwareTransaction(provider, assertCurrent));
                     assertCurrent();
-                    if (signature.success) {
-                        const signedTx = serializeTransaction(txFormattedForTrezor, trezorSignature(signature.payload));
-                        assertCurrent();
-                        assertHardwareTransactionSender(signedTx, activeAccount.address);
-                        const transactionResponse = await this.submitSignedHardwareTransaction(provider, signedTx, ({ rawTransaction, admit }) => admit(() => provider.sendTransaction(rawTransaction)), submission, undefined, expectedUnsignedTransaction);
-                        return {
-                            isCanceled: true,
-                            transaction: transactionResponse,
-                        };
-                    }
-                    else {
-                        return {
-                            isCanceled: false,
-                            error: true,
-                        };
-                    }
+                    assertHardwareTransactionSender(signedTx, activeAccount.address);
+                    const transactionResponse = await this.submitSignedHardwareTransaction(provider, signedTx, ({ rawTransaction, admit }) => admit(() => provider.sendTransaction(rawTransaction)), submission, undefined, expectedUnsignedTransaction);
+                    return {
+                        isCanceled: true,
+                        transaction: transactionResponse,
+                    };
                 }
                 catch (error) {
                     return {
@@ -1504,40 +1476,17 @@ class EthereumTransactions {
                     ...txFormattedForTrezor,
                     type: isLegacy ? 0 : 2,
                 });
-                const signature = await this.requireTrezorSigner().signEthTransaction({
-                    index: `${activeAccountId}`,
-                    tx: txFormattedForTrezor,
+                const { rawTransaction: signedTx } = await (0, trezor_signing_1.signTrezorEvmTransaction)(this.requireTrezorSigner(), {
+                    accountIndex: activeAccountId,
                     coin: activeNetwork.currency,
+                    expectedAddress: activeAccount.address,
                     slip44: activeNetwork.slip44,
+                    unsignedTransaction: expectedUnsignedTransaction,
                 }, await this.authorizeHardwareTransaction(provider, assertCurrent));
                 assertCurrent();
-                if (signature.success) {
-                    try {
-                        const txFormattedForEthers = isLegacy
-                            ? {
-                                ...formatParams,
-                                nonce: transactionNonce,
-                                chainId: activeNetwork.chainId,
-                                type: 0, // Force Type 0 for legacy
-                            }
-                            : {
-                                ...formatParams,
-                                nonce: transactionNonce,
-                                chainId: activeNetwork.chainId,
-                                type: 2, // Need explicit type for hardware wallet serialization
-                            };
-                        const signedTx = serializeTransaction(txFormattedForEthers, trezorSignature(signature.payload));
-                        assertHardwareTransactionSender(signedTx, activeAccount.address);
-                        const finalTx = await this.submitSignedHardwareTransaction(provider, signedTx, ({ rawTransaction, admit }) => admit(() => provider.sendTransaction(rawTransaction)), submission, assertBeforeBroadcast, expectedUnsignedTransaction);
-                        return finalTx;
-                    }
-                    catch (error) {
-                        throw error;
-                    }
-                }
-                else {
-                    throw new Error(`Transaction Signature Failed. Error: ${signature}`);
-                }
+                assertHardwareTransactionSender(signedTx, activeAccount.address);
+                const finalTx = await this.submitSignedHardwareTransaction(provider, signedTx, ({ rawTransaction, admit }) => admit(() => provider.sendTransaction(rawTransaction)), submission, assertBeforeBroadcast, expectedUnsignedTransaction);
+                return finalTx;
             };
             const sendEVMTransaction = async () => {
                 assertCurrent();
@@ -1869,28 +1818,20 @@ class EthereumTransactions {
                     assertCurrent();
                     assertTransactionGasLimit(txFormattedForTrezor);
                     const expectedUnsignedTransaction = serializeTransaction(txFormattedForTrezor);
-                    const signature = await this.requireTrezorSigner().signEthTransaction({
+                    const { rawTransaction: signedTx } = await (0, trezor_signing_1.signTrezorEvmTransaction)(this.requireTrezorSigner(), {
+                        accountIndex: activeAccountId,
                         coin: trezorCoin,
-                        tx: txFormattedForTrezor,
-                        index: activeAccountId.toString(),
+                        expectedAddress: activeAccount.address,
                         slip44: activeNetwork.slip44,
+                        unsignedTransaction: expectedUnsignedTransaction,
                     }, await this.authorizeHardwareTransaction(provider, assertCurrent));
-                    if (signature.success) {
-                        const signedTx = serializeTransaction(txFormattedForTrezor, trezorSignature(signature.payload));
-                        assertSignedSender(signedTx);
-                        assertHardwareTransactionSender(signedTx, activeAccount.address);
-                        const transactionResponse = await this.submitSignedHardwareTransaction(provider, signedTx, ({ rawTransaction, admit }) => admit(() => provider.sendTransaction(rawTransaction)), submission, assertBeforeBroadcast, expectedUnsignedTransaction);
-                        return {
-                            isSpeedUp: true,
-                            transaction: transactionResponse,
-                        };
-                    }
-                    else {
-                        return {
-                            isSpeedUp: false,
-                            error: true,
-                        };
-                    }
+                    assertSignedSender(signedTx);
+                    assertHardwareTransactionSender(signedTx, activeAccount.address);
+                    const transactionResponse = await this.submitSignedHardwareTransaction(provider, signedTx, ({ rawTransaction, admit }) => admit(() => provider.sendTransaction(rawTransaction)), submission, assertBeforeBroadcast, expectedUnsignedTransaction);
+                    return {
+                        isSpeedUp: true,
+                        transaction: transactionResponse,
+                    };
                 }
                 catch (error) {
                     console.error('[SpeedUp] Failed to send replacement transaction with Trezor:', error);
@@ -2105,58 +2046,21 @@ class EthereumTransactions {
                         ...txToBeSignedByTrezor,
                         type: isLegacy ? 0 : 2,
                     });
-                    const signature = await this.requireTrezorSigner().signEthTransaction({
-                        index: `${activeAccountId}`,
-                        tx: txToBeSignedByTrezor,
+                    const { rawTransaction: signedTx } = await (0, trezor_signing_1.signTrezorEvmTransaction)(this.requireTrezorSigner(), {
+                        accountIndex: activeAccountId,
                         coin: activeNetwork.currency,
+                        expectedAddress: activeAccount.address,
                         slip44: activeNetwork.slip44,
+                        unsignedTransaction: expectedUnsignedTransaction,
                     }, await this.authorizeHardwareTransaction(provider, assertCurrent, signal));
                     assertCurrent();
-                    if (signature.success) {
-                        try {
-                            let txFormattedForEthers;
-                            if (isLegacy) {
-                                txFormattedForEthers = {
-                                    to: tokenAddress,
-                                    value: '0x0',
-                                    gasLimit: gasLimit,
-                                    gasPrice,
-                                    data: txData,
-                                    nonce,
-                                    chainId: activeNetwork.chainId,
-                                    type: 0,
-                                };
-                            }
-                            else {
-                                txFormattedForEthers = {
-                                    to: tokenAddress,
-                                    value: '0x0',
-                                    gasLimit: gasLimit,
-                                    maxFeePerGas,
-                                    maxPriorityFeePerGas,
-                                    data: txData,
-                                    nonce,
-                                    chainId: activeNetwork.chainId,
-                                    type: 2, // Need explicit type for hardware wallet serialization
-                                };
-                            }
-                            const signedTx = serializeTransaction(txFormattedForEthers, trezorSignature(signature.payload));
-                            assertCurrent();
-                            assertHardwareTransactionSender(signedTx, activeAccount.address);
-                            const finalTx = await this.submitSignedHardwareTransaction(provider, signedTx, async ({ rawTransaction, admit }) => {
-                                const response = await admit(() => provider.sendTransaction(rawTransaction));
-                                saveTrezorTx && saveTrezorTx(response);
-                                return response;
-                            }, submission, undefined, expectedUnsignedTransaction);
-                            return finalTx;
-                        }
-                        catch (error) {
-                            throw error;
-                        }
-                    }
-                    else {
-                        throw new Error(`Transaction Signature Failed. Error: ${signature}`);
-                    }
+                    assertHardwareTransactionSender(signedTx, activeAccount.address);
+                    const finalTx = await this.submitSignedHardwareTransaction(provider, signedTx, async ({ rawTransaction, admit }) => {
+                        const response = await admit(() => provider.sendTransaction(rawTransaction));
+                        saveTrezorTx && saveTrezorTx(response);
+                        return response;
+                    }, submission, undefined, expectedUnsignedTransaction);
+                    return finalTx;
                 }
                 catch (error) {
                     throw error;
@@ -2311,55 +2215,17 @@ class EthereumTransactions {
                         ...txToBeSignedByTrezor,
                         type: isLegacy ? 0 : 2,
                     });
-                    const signature = await this.requireTrezorSigner().signEthTransaction({
-                        index: `${activeAccountId}`,
-                        tx: txToBeSignedByTrezor,
+                    const { rawTransaction: signedTx } = await (0, trezor_signing_1.signTrezorEvmTransaction)(this.requireTrezorSigner(), {
+                        accountIndex: activeAccountId,
                         coin: trezorCoin,
+                        expectedAddress: activeAccount.address,
                         slip44: activeNetwork.slip44,
+                        unsignedTransaction: expectedUnsignedTransaction,
                     }, await this.authorizeHardwareTransaction(provider, assertCurrent, signal));
                     assertCurrent();
-                    if (signature.success) {
-                        try {
-                            let txFormattedForEthers;
-                            if (isLegacy) {
-                                txFormattedForEthers = {
-                                    to: tokenAddress,
-                                    value: '0x0',
-                                    gasLimit,
-                                    gasPrice,
-                                    data: txData,
-                                    nonce,
-                                    chainId: activeNetwork.chainId,
-                                    type: 0,
-                                };
-                            }
-                            else {
-                                txFormattedForEthers = {
-                                    to: tokenAddress,
-                                    value: '0x0',
-                                    gasLimit,
-                                    maxFeePerGas,
-                                    maxPriorityFeePerGas,
-                                    data: txData,
-                                    nonce,
-                                    chainId: activeNetwork.chainId,
-                                    type: 2, // Need explicit type for hardware wallet serialization
-                                };
-                            }
-                            const signedTx = serializeTransaction(txFormattedForEthers, trezorSignature(signature.payload));
-                            assertCurrent();
-                            assertHardwareTransactionSender(signedTx, activeAccount.address);
-                            const finalTx = await this.submitSignedHardwareTransaction(provider, signedTx, ({ rawTransaction, admit }) => admit(() => provider.sendTransaction(rawTransaction)), submission, undefined, expectedUnsignedTransaction);
-                            return finalTx;
-                        }
-                        catch (error) {
-                            console.log({ error });
-                            throw error;
-                        }
-                    }
-                    else {
-                        throw new Error(`Transaction Signature Failed. Error: ${signature}`);
-                    }
+                    assertHardwareTransactionSender(signedTx, activeAccount.address);
+                    const finalTx = await this.submitSignedHardwareTransaction(provider, signedTx, ({ rawTransaction, admit }) => admit(() => provider.sendTransaction(rawTransaction)), submission, undefined, expectedUnsignedTransaction);
+                    return finalTx;
                 }
                 catch (error) {
                     console.log({ errorDois: error });
@@ -2508,55 +2374,17 @@ class EthereumTransactions {
                         ...txToBeSignedByTrezor,
                         type: isLegacy ? 0 : 2,
                     });
-                    const signature = await this.requireTrezorSigner().signEthTransaction({
-                        index: `${activeAccountId}`,
-                        tx: txToBeSignedByTrezor,
+                    const { rawTransaction: signedTx } = await (0, trezor_signing_1.signTrezorEvmTransaction)(this.requireTrezorSigner(), {
+                        accountIndex: activeAccountId,
                         coin: activeNetwork.currency,
+                        expectedAddress: activeAccount.address,
                         slip44: activeNetwork.slip44,
+                        unsignedTransaction: expectedUnsignedTransaction,
                     }, await this.authorizeHardwareTransaction(provider, assertCurrent, signal));
                     assertCurrent();
-                    if (signature.success) {
-                        try {
-                            let txFormattedForEthers;
-                            if (isLegacy) {
-                                txFormattedForEthers = {
-                                    to: tokenAddress,
-                                    value: '0x0',
-                                    gasLimit,
-                                    gasPrice,
-                                    data: txData,
-                                    nonce,
-                                    chainId: activeNetwork.chainId,
-                                    type: 0,
-                                };
-                            }
-                            else {
-                                txFormattedForEthers = {
-                                    to: tokenAddress,
-                                    value: '0x0',
-                                    gasLimit,
-                                    maxFeePerGas,
-                                    maxPriorityFeePerGas,
-                                    data: txData,
-                                    nonce,
-                                    chainId: activeNetwork.chainId,
-                                    type: 2, // Need explicit type for hardware wallet serialization
-                                };
-                            }
-                            const signedTx = serializeTransaction(txFormattedForEthers, trezorSignature(signature.payload));
-                            assertCurrent();
-                            assertHardwareTransactionSender(signedTx, activeAccount.address);
-                            const finalTx = await this.submitSignedHardwareTransaction(provider, signedTx, ({ rawTransaction, admit }) => admit(() => provider.sendTransaction(rawTransaction)), submission, undefined, expectedUnsignedTransaction);
-                            return finalTx;
-                        }
-                        catch (error) {
-                            console.log({ error });
-                            throw error;
-                        }
-                    }
-                    else {
-                        throw new Error(`Transaction Signature Failed. Error: ${signature}`);
-                    }
+                    assertHardwareTransactionSender(signedTx, activeAccount.address);
+                    const finalTx = await this.submitSignedHardwareTransaction(provider, signedTx, ({ rawTransaction, admit }) => admit(() => provider.sendTransaction(rawTransaction)), submission, undefined, expectedUnsignedTransaction);
+                    return finalTx;
                 }
                 catch (error) {
                     console.log({ error });