@sidhujag/sysweb3-keyring 2.1.9 → 2.1.11

package/cjs/transactions/ethereum.js

@@ -19,6 +19,8 @@ const evm_cancellation_1 = require("./evm-cancellation");
 const evm_envelope_1 = require("./evm-envelope");
 const evm_local_signer_1 = require("./evm-local-signer");
 const evm_submission_1 = require("./evm-submission");
+const hardware_signing_data_1 = require("../hardware-signing-data");
+const hardware_transaction_authority_1 = require("../hardware-transaction-authority");
 const ledger_signing_1 = require("./ledger-signing");
 const prepared_evm_1 = require("./prepared-evm");
 const trezor_signing_1 = require("./trezor-signing");
@@ -218,10 +220,30 @@ class EthereumTransactions {
         this.submitSignedHardwareTransaction = (provider, raw, broadcast, submission, beforeBroadcast, expectedUnsigned) => (0, evm_submission_1.submitSignedHardwareEvmTransaction)(raw, broadcast, submission, beforeBroadcast, expectedUnsigned, 
         // A device confirmation or journal write can outlast the earlier check.
         () => provider.verifyConfiguredChainId(true));
-        this.signTypedData = async (addr, typedData, version) => {
+        this.captureMessageSigning = (authority) => {
+            const owner = (0, hardware_transaction_authority_1.captureHardwareTransactionAuthority)(authority);
+            const context = this.captureEvmAccountContext();
+            const ledger = this.ledgerSigner, trezor = this.trezorSigner;
+            const assertCurrent = () => {
+                owner.assertCurrent();
+                context.assertCurrent();
+                if (this.ledgerSigner !== ledger || this.trezorSigner !== trezor)
+                    throw new Error('Wallet signing SDK changed');
+                owner.assertCurrent();
+            };
+            assertCurrent();
+            return {
+                context,
+                authority: Object.freeze({ assertCurrent, signal: owner.signal }),
+            };
+        };
+        this.signTypedData = async (addr, typedData, version, authority) => {
+            const captured = this.captureMessageSigning(authority);
+            const owner = captured.authority;
+            const { activeAccountType, activeAccountId, activeAccount } = captured.context;
             const { address, decryptedPrivateKey } = this.getDecryptedPrivateKey();
-            const { activeAccountType, accounts, activeAccountId } = this.getState();
-            const activeAccount = accounts[activeAccountType][activeAccountId];
+            owner.assertCurrent();
+            const approvedData = (0, hardware_signing_data_1.captureHardwareSigningData)(typedData, () => new Error('Invalid typed signing request'));
             // Validate that the derived address matches the active account to prevent race conditions
             if (address.toLowerCase() !== activeAccount.address.toLowerCase()) {
                 throw {
@@ -236,7 +258,7 @@ class EthereumTransactions {
                 const privKey = Buffer.from(stripHexPrefix(decryptedPrivateKey), 'hex');
                 return (0, eth_sig_util_1.signTypedData)({
                     privateKey: privKey,
-                    data: typedData,
+                    data: approvedData,
                     version,
                 });
             };
@@ -249,8 +271,8 @@ class EthereumTransactions {
                     version,
                     accountIndex: activeAccountId,
                     expectedAddress: activeAccount.address,
-                    data: typedData,
-                });
+                    data: approvedData,
+                }, owner);
             };
             const signTypedDataWithTrezor = async () => {
                 if (addr.toLowerCase() !== activeAccount.address.toLowerCase())
@@ -260,17 +282,29 @@ class EthereumTransactions {
                 return await this.requireTrezorSigner().signTypedData({
                     version,
                     address: addr,
-                    data: typedData,
+                    data: approvedData,
                     index: activeAccountId,
-                });
+                }, owner);
             };
-            switch (activeAccountType) {
-                case types_1.KeyringAccountType.Trezor:
-                    return await signTypedDataWithTrezor();
-                case types_1.KeyringAccountType.Ledger:
-                    return await signTypedDataWithLedger();
-                default:
-                    return signTypedDataLocal();
+            try {
+                owner.assertCurrent();
+                let result;
+                switch (activeAccountType) {
+                    case types_1.KeyringAccountType.Trezor:
+                        result = await signTypedDataWithTrezor();
+                        break;
+                    case types_1.KeyringAccountType.Ledger:
+                        result = await signTypedDataWithLedger();
+                        break;
+                    default:
+                        result = signTypedDataLocal();
+                }
+                owner.assertCurrent();
+                return result;
+            }
+            catch (error) {
+                owner.assertCurrent();
+                throw error;
             }
         };
         // Verify a UTXO address on the connected hardware wallet (Ledger or Trezor)
@@ -312,12 +346,15 @@ class EthereumTransactions {
                 'selectedAccount',
                 'targetAccount',
                 'assertCurrent',
+                'signal',
             ]);
             const selectedAccount = (0, prepared_evm_1.snapshotEvmSigningIdentity)(options.selectedAccount);
             const targetAccount = (0, prepared_evm_1.snapshotEvmSigningIdentity)(options.targetAccount);
-            const hostGuard = (0, prepared_evm_1.preparedEvmGuard)({
+            const owner = (0, hardware_transaction_authority_1.captureHardwareTransactionAuthority)({
                 assertCurrent: options.assertCurrent,
+                signal: options.signal,
             });
+            const hostGuard = owner.assertCurrent;
             const target = {
                 id: targetAccount.id,
                 type: targetAccount.type,
@@ -337,8 +374,11 @@ class EthereumTransactions {
                     throw new Error('EVM digest signing context changed');
             };
             assertCurrent();
+            if (context.activeAccountType === types_1.KeyringAccountType.Ledger ||
+                context.activeAccountType === types_1.KeyringAccountType.Trezor)
+                throw Object.assign(new Error('Hardware raw-digest signing is unsupported; use owned typed-data signing'), { code: 'HARDWARE_RAW_DIGEST_UNSUPPORTED' });
             const { address, decryptedPrivateKey } = this.getDecryptedPrivateKey(target);
-            const { activeAccountId, activeAccountType, activeNetwork, activeAccount } = context;
+            const { activeAccount } = context;
             // Validate that the derived address matches the active account to prevent race conditions
             if (address.toLowerCase() !== activeAccount.address.toLowerCase()) {
                 throw {
@@ -377,54 +417,24 @@ class EthereumTransactions {
                     throw error;
                 }
             };
-            const signWithLedger = async () => {
-                try {
-                    const response = await this.requireLedgerSigner().evm.signPersonalMessage({
-                        accountIndex: activeAccountId,
-                        expectedAddress: activeAccount.address,
-                        message: msg,
-                    });
-                    return response;
-                }
-                catch (error) {
-                    throw error;
-                }
-            };
-            const signWithTrezor = async () => {
-                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.requireTrezorSigner().signMessage({
-                        coin: trezorCoin,
-                        address: activeAccount.address,
-                        index: activeAccountId,
-                        message: msg,
-                        slip44: activeNetwork.slip44,
-                    });
-                    return response.signature;
-                }
-                catch (error) {
-                    throw error;
-                }
-            };
-            let signature;
-            switch (activeAccountType) {
-                case types_1.KeyringAccountType.Trezor:
-                    signature = await signWithTrezor();
-                    break;
-                case types_1.KeyringAccountType.Ledger:
-                    signature = await signWithLedger();
-                    break;
-                default:
-                    signature = sign();
-            }
+            const signature = sign();
             assertCurrent();
             return signature;
         };
-        this.signPersonalMessage = async (params) => {
+        this.signPersonalMessage = async (params, authority) => {
+            const captured = this.captureMessageSigning(authority);
+            const owner = captured.authority;
+            if (!Array.isArray(params) || params.length !== 2)
+                throw new Error('Invalid personal message request');
+            params = [0, 1].map((index) => {
+                const field = Object.getOwnPropertyDescriptor(params, String(index));
+                if (!field || !('value' in field) || typeof field.value !== 'string')
+                    throw new Error('Invalid personal message request');
+                return field.value;
+            });
             const { address, decryptedPrivateKey } = this.getDecryptedPrivateKey();
-            const { accounts, activeAccountId, activeAccountType, activeNetwork } = this.getState();
-            const activeAccount = accounts[activeAccountType][activeAccountId];
+            owner.assertCurrent();
+            const { activeAccountId, activeAccountType, activeNetwork, activeAccount } = captured.context;
             // Validate that the derived address matches the active account to prevent race conditions
             if (address.toLowerCase() !== activeAccount.address.toLowerCase()) {
                 throw {
@@ -482,7 +492,7 @@ class EthereumTransactions {
                         accountIndex: activeAccountId,
                         expectedAddress: activeAccount.address,
                         message: messageForLedger,
-                    });
+                    }, owner);
                     return response;
                 }
                 catch (error) {
@@ -509,20 +519,32 @@ class EthereumTransactions {
                         index: activeAccountId,
                         message: messageForTrezor,
                         slip44: activeNetwork.slip44,
-                    });
+                    }, owner);
                     return response.signature;
                 }
                 catch (error) {
                     throw error;
                 }
             };
-            switch (activeAccountType) {
-                case types_1.KeyringAccountType.Trezor:
-                    return await signPersonalMessageWithTrezor();
-                case types_1.KeyringAccountType.Ledger:
-                    return await signPersonalMessageWithLedger();
-                default:
-                    return signPersonalMessageWithDefaultWallet();
+            try {
+                owner.assertCurrent();
+                let result;
+                switch (activeAccountType) {
+                    case types_1.KeyringAccountType.Trezor:
+                        result = await signPersonalMessageWithTrezor();
+                        break;
+                    case types_1.KeyringAccountType.Ledger:
+                        result = await signPersonalMessageWithLedger();
+                        break;
+                    default:
+                        result = signPersonalMessageWithDefaultWallet();
+                }
+                owner.assertCurrent();
+                return result;
+            }
+            catch (error) {
+                owner.assertCurrent();
+                throw error;
             }
         };
         this.parsePersonalMessage = (hexMsg) => {