@sidhujag/sysweb3-keyring 2.1.8 → 2.1.9

package/esm/transactions/ethereum.js

@@ -15,6 +15,7 @@ import { deriveEvmAccountFromMnemonic, parsePersonalMessage as parseLocalPersona
 import { captureEvmSubmission, submitSignedEvmTransaction, submitSignedHardwareEvmTransaction, evmSubmissionFailure, copyEvmSubmissionFailure, } from './evm-submission';
 import { signLedgerEvmTransaction } from './ledger-signing';
 import { signPreparedEvmEnvelope, snapshotPreparedEvmRequest, snapshotEvmSigningIdentity, preparedEvmGuard, } from './prepared-evm';
+import { signTrezorEvmTransaction } from './trezor-signing';
 import { getAddressDerivationPath } from '../utils/derivation-paths';
 const hardwareSignerUnavailable = (hardware) => Object.assign(new Error(`${hardware} signer is unavailable in this host`), {
     code: 'HARDWARE_SIGNER_UNAVAILABLE',
@@ -32,26 +33,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) => 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.
@@ -1061,29 +1042,20 @@ export class EthereumTransactions {
                     const expectedUnsignedTransaction = serializeTransaction(txFormattedForTrezor);
                     if (retained)
                         assertCancellationEnvelope(expectedUnsignedTransaction);
-                    const signature = await this.requireTrezorSigner().signEthTransaction({
+                    const { rawTransaction: signedTx } = await 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 {
@@ -1498,40 +1470,17 @@ export class EthereumTransactions {
                     ...txFormattedForTrezor,
                     type: isLegacy ? 0 : 2,
                 });
-                const signature = await this.requireTrezorSigner().signEthTransaction({
-                    index: `${activeAccountId}`,
-                    tx: txFormattedForTrezor,
+                const { rawTransaction: signedTx } = await 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();
@@ -1863,28 +1812,20 @@ export class EthereumTransactions {
                     assertCurrent();
                     assertTransactionGasLimit(txFormattedForTrezor);
                     const expectedUnsignedTransaction = serializeTransaction(txFormattedForTrezor);
-                    const signature = await this.requireTrezorSigner().signEthTransaction({
+                    const { rawTransaction: signedTx } = await 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);
@@ -2099,58 +2040,21 @@ export class EthereumTransactions {
                         ...txToBeSignedByTrezor,
                         type: isLegacy ? 0 : 2,
                     });
-                    const signature = await this.requireTrezorSigner().signEthTransaction({
-                        index: `${activeAccountId}`,
-                        tx: txToBeSignedByTrezor,
+                    const { rawTransaction: signedTx } = await 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;
@@ -2305,55 +2209,17 @@ export class EthereumTransactions {
                         ...txToBeSignedByTrezor,
                         type: isLegacy ? 0 : 2,
                     });
-                    const signature = await this.requireTrezorSigner().signEthTransaction({
-                        index: `${activeAccountId}`,
-                        tx: txToBeSignedByTrezor,
+                    const { rawTransaction: signedTx } = await 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 });
@@ -2502,55 +2368,17 @@ export class EthereumTransactions {
                         ...txToBeSignedByTrezor,
                         type: isLegacy ? 0 : 2,
                     });
-                    const signature = await this.requireTrezorSigner().signEthTransaction({
-                        index: `${activeAccountId}`,
-                        tx: txToBeSignedByTrezor,
+                    const { rawTransaction: signedTx } = await 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 });