@sidhujag/sysweb3-keyring 1.0.547 → 1.0.548

package/test/unit/hardware/trezor.spec.ts

@@ -1,828 +0,0 @@
-import { INetworkType } from '@sidhujag/sysweb3-network';
-
-import { KeyringManager, KeyringAccountType } from '../../../src';
-import { FAKE_PASSWORD, PEACE_SEED_PHRASE } from '../../helpers/constants';
-import { setupMocks } from '../../helpers/setup';
-
-describe('Trezor Hardware Wallet', () => {
-  let keyringManager: KeyringManager;
-  let mockVaultStateGetter: jest.Mock;
-  let currentVaultState: any;
-  let accountCounter = 0;
-
-  beforeEach(async () => {
-    setupMocks();
-    // Set up vault-keys that would normally be created by Pali's MainController
-    await setupTestVault(FAKE_PASSWORD);
-
-    // Reset counter for each test
-    accountCounter = 0;
-
-    // Set up UTXO vault state
-    currentVaultState = createMockVaultState({
-      activeAccountId: 0,
-      activeAccountType: KeyringAccountType.HDAccount,
-      networkType: INetworkType.Syscoin,
-      chainId: 57,
-    });
-    mockVaultStateGetter = jest.fn(() => currentVaultState);
-
-    keyringManager = await KeyringManager.createInitialized(
-      PEACE_SEED_PHRASE,
-      FAKE_PASSWORD,
-      mockVaultStateGetter
-    );
-
-    // Mock Trezor signer methods with dynamic responses
-    keyringManager.trezorSigner.getAccountInfo = jest
-      .fn()
-      .mockImplementation(() => {
-        accountCounter++;
-        return Promise.resolve({
-          descriptor: `xpub6CUGRUonZSQ4TWtTMmzXdrXDtypWKiKpXqNPQ8R5ziHackBvPaKjYNDvyVp7ytpqqxV5BDK1Co76d4oVGkYvJXFFpbhctBCTKRQ8Y7HNrxE${accountCounter}`,
-          balance: '100000000', // 1 SYS in satoshis
-        });
-      });
-
-    keyringManager.trezorSigner.getPublicKey = jest.fn().mockResolvedValue({
-      publicKey: '0x04mock_public_key',
-    });
-
-    // Mock getAddress for Trezor accounts with dynamic addresses
-    keyringManager.getAddress = jest.fn().mockImplementation(() => {
-      return Promise.resolve(`sys1qmock_trezor_address_${accountCounter}`);
-    });
-  });
-
-  afterEach(async () => {
-    // Clean up hardware wallet connections
-    if (keyringManager) {
-      await keyringManager.destroy();
-    }
-  });
-
-  describe('Account Import', () => {
-    it('should import Trezor account', async () => {
-      const account = await keyringManager.importTrezorAccount('My Trezor');
-
-      expect(account).toBeDefined();
-      expect(account.id).toBe(0); // First Trezor account gets ID 0
-      expect(account.label).toBe('My Trezor');
-      expect(account.isTrezorWallet).toBe(true);
-      expect(account.isLedgerWallet).toBe(false);
-      expect(account.isImported).toBe(false);
-      expect(account.xprv).toBe(''); // Hardware wallets store empty xprv
-
-      // Update vault state with imported account
-      currentVaultState.accounts[KeyringAccountType.Trezor][account.id] = {
-        id: account.id,
-        label: account.label,
-        address: account.address,
-        xpub: account.xpub,
-        xprv: '',
-        isImported: false,
-        isTrezorWallet: true,
-        isLedgerWallet: false,
-        balances: { syscoin: 0, ethereum: 0 },
-        assets: { syscoin: [], ethereum: [] },
-      };
-    });
-
-    it('should import multiple Trezor accounts', async () => {
-      const account1 = await keyringManager.importTrezorAccount();
-
-      // Update vault state
-      currentVaultState.accounts[KeyringAccountType.Trezor][account1.id] = {
-        id: account1.id,
-        label: account1.label,
-        address: account1.address,
-        xpub: account1.xpub,
-        xprv: '',
-        isImported: false,
-        isTrezorWallet: true,
-        isLedgerWallet: false,
-        balances: { syscoin: 0, ethereum: 0 },
-        assets: { syscoin: [], ethereum: [] },
-      };
-
-      const account2 = await keyringManager.importTrezorAccount();
-
-      // Update vault state
-      currentVaultState.accounts[KeyringAccountType.Trezor][account2.id] = {
-        id: account2.id,
-        label: account2.label,
-        address: account2.address,
-        xpub: account2.xpub,
-        xprv: '',
-        isImported: false,
-        isTrezorWallet: true,
-        isLedgerWallet: false,
-        balances: { syscoin: 0, ethereum: 0 },
-        assets: { syscoin: [], ethereum: [] },
-      };
-
-      const account3 = await keyringManager.importTrezorAccount(
-        'Custom Trezor'
-      );
-
-      // Update vault state
-      currentVaultState.accounts[KeyringAccountType.Trezor][account3.id] = {
-        id: account3.id,
-        label: account3.label,
-        address: account3.address,
-        xpub: account3.xpub,
-        xprv: '',
-        isImported: false,
-        isTrezorWallet: true,
-        isLedgerWallet: false,
-        balances: { syscoin: 0, ethereum: 0 },
-        assets: { syscoin: [], ethereum: [] },
-      };
-
-      expect(account1.id).toBe(0);
-      expect(account1.label).toBe('Trezor 1');
-
-      expect(account2.id).toBe(1);
-      expect(account2.label).toBe('Trezor 2');
-
-      expect(account3.id).toBe(2);
-      expect(account3.label).toBe('Custom Trezor');
-    });
-
-    it('should handle Trezor import for EVM networks', async () => {
-      // Set up EVM vault state
-      const evmVaultState = createMockVaultState({
-        activeAccountId: 0,
-        activeAccountType: KeyringAccountType.HDAccount,
-        networkType: INetworkType.Ethereum,
-        chainId: 1,
-      });
-      const evmVaultStateGetter = jest.fn(() => evmVaultState);
-
-      // Create EVM keyring
-      const evmKeyring = await KeyringManager.createInitialized(
-        PEACE_SEED_PHRASE,
-        FAKE_PASSWORD,
-        evmVaultStateGetter
-      );
-
-      // Mock Trezor EVM methods with proper EVM address
-      evmKeyring.trezorSigner.getPublicKey = jest.fn().mockResolvedValue({
-        publicKey: '0x04mock_evm_public_key',
-      });
-      evmKeyring.trezorSigner.getAccountInfo = jest.fn().mockResolvedValue({
-        descriptor: '0x742D35Cc6634C0532925a3b844bc9e7595f2bd9f', // Return EVM address directly as descriptor
-        balance: '1000000000000000000', // 1 ETH in wei
-      });
-
-      const account = await evmKeyring.importTrezorAccount('Trezor ETH');
-
-      expect(account).toBeDefined();
-      expect(account.address.startsWith('0x')).toBe(true);
-      expect(account.isTrezorWallet).toBe(true);
-    });
-
-    it('should reject duplicate Trezor addresses', async () => {
-      // First import
-      const firstAccount = await keyringManager.importTrezorAccount();
-
-      // Update vault state with first account
-      currentVaultState.accounts[KeyringAccountType.Trezor][firstAccount.id] = {
-        id: firstAccount.id,
-        label: firstAccount.label,
-        address: firstAccount.address,
-        xpub: firstAccount.xpub,
-        xprv: '',
-        isImported: false,
-        isTrezorWallet: true,
-        isLedgerWallet: false,
-        balances: { syscoin: 0, ethereum: 0 },
-        assets: { syscoin: [], ethereum: [] },
-      };
-
-      // Mock Trezor returning same address
-      keyringManager.trezorSigner.getAccountInfo = jest.fn().mockResolvedValue({
-        descriptor: 'xpub_duplicate',
-        balance: '100000000',
-      });
-
-      // Should reject duplicate
-      await expect(keyringManager.importTrezorAccount()).rejects.toThrow(
-        'Account already exists'
-      );
-    });
-  });
-
-  describe('Account Management', () => {
-    beforeEach(async () => {
-      // Import a Trezor account
-      const account = await keyringManager.importTrezorAccount('Test Trezor');
-
-      // Update vault state with imported account
-      currentVaultState.accounts[KeyringAccountType.Trezor][account.id] = {
-        id: account.id,
-        label: account.label,
-        address: account.address,
-        xpub: account.xpub,
-        xprv: '',
-        isImported: false,
-        isTrezorWallet: true,
-        isLedgerWallet: false,
-        balances: { syscoin: 0, ethereum: 0 },
-        assets: { syscoin: [], ethereum: [] },
-      };
-    });
-
-    it('should switch to Trezor account', async () => {
-      // Update vault state to set Trezor as active
-      currentVaultState.activeAccount = {
-        id: 0,
-        type: KeyringAccountType.Trezor,
-      };
-
-      // Account switch is handled by vault state update
-
-      const { activeAccount, activeAccountType } =
-        keyringManager.getActiveAccount();
-      expect(activeAccountType).toBe(KeyringAccountType.Trezor);
-      expect(activeAccount.isTrezorWallet).toBe(true);
-      expect(activeAccount.label).toBe('Test Trezor');
-    });
-
-    it('should get Trezor account xpub', async () => {
-      // Update vault state to set Trezor as active
-      currentVaultState.activeAccount = {
-        id: 0,
-        type: KeyringAccountType.Trezor,
-      };
-
-      // Account switch is handled by vault state update
-
-      const xpub = keyringManager.getAccountXpub();
-      expect(xpub).toBeDefined();
-      expect(typeof xpub).toBe('string');
-      // For UTXO it should be an xpub, for EVM it's the public key
-    });
-
-    it('should handle mixed account types', async () => {
-      // Add HD account
-      const hdAccount = await keyringManager.addNewAccount('HD Account 2');
-
-      // Update vault state with HD account
-      currentVaultState.accounts[KeyringAccountType.HDAccount][hdAccount.id] = {
-        id: hdAccount.id,
-        label: hdAccount.label,
-        address: hdAccount.address,
-        xpub: hdAccount.xpub,
-        xprv: '',
-        isImported: false,
-        isTrezorWallet: false,
-        isLedgerWallet: false,
-        balances: { syscoin: 0, ethereum: 0 },
-        assets: { syscoin: [], ethereum: [] },
-      };
-
-      // Import another Trezor
-      const trezor2Account = await keyringManager.importTrezorAccount(
-        'Trezor 2'
-      );
-
-      // Update vault state with second Trezor
-      currentVaultState.accounts[KeyringAccountType.Trezor][trezor2Account.id] =
-        {
-          id: trezor2Account.id,
-          label: trezor2Account.label,
-          address: trezor2Account.address,
-          xpub: trezor2Account.xpub,
-          xprv: '',
-          isImported: false,
-          isTrezorWallet: true,
-          isLedgerWallet: false,
-          balances: { syscoin: 0, ethereum: 0 },
-          assets: { syscoin: [], ethereum: [] },
-        };
-
-      // Switch between them
-      currentVaultState.activeAccount = {
-        id: 0,
-        type: KeyringAccountType.HDAccount,
-      };
-      // Account switch is handled by vault state update
-      expect(keyringManager.getActiveAccount().activeAccountType).toBe(
-        KeyringAccountType.HDAccount
-      );
-
-      currentVaultState.activeAccount = {
-        id: 0,
-        type: KeyringAccountType.Trezor,
-      };
-      // Account switch is handled by vault state update
-      expect(keyringManager.getActiveAccount().activeAccountType).toBe(
-        KeyringAccountType.Trezor
-      );
-
-      currentVaultState.activeAccount = {
-        id: trezor2Account.id,
-        type: KeyringAccountType.Trezor,
-      };
-      // Account switch is handled by vault state update
-      expect(keyringManager.getActiveAccount().activeAccount.label).toBe(
-        'Trezor 2'
-      );
-    });
-  });
-
-  describe('Transaction Signing', () => {
-    beforeEach(async () => {
-      // Mock syscoinjs-lib main signer
-      const mockSigner = {
-        hd: jest.fn(),
-        main: {
-          send: jest.fn().mockResolvedValue({
-            extractTransaction: () => ({
-              getId: () => 'mock_transaction_id',
-            }),
-          }),
-          blockbookURL: 'https://blockbook.test',
-          createTransaction: jest.fn().mockResolvedValue({
-            psbt: 'mock_psbt',
-            fee: 1000,
-          }),
-        },
-      };
-
-      // Mock the syscoinTransaction getSigner method directly
-      (keyringManager.syscoinTransaction as any).getSigner = jest
-        .fn()
-        .mockReturnValue(mockSigner);
-
-      const account = await keyringManager.importTrezorAccount('Signing Test');
-      if (account) {
-        // Update vault state to set Trezor as active
-        currentVaultState.accounts[KeyringAccountType.Trezor][account.id] = {
-          id: account.id,
-          label: account.label,
-          address: account.address,
-          xpub: account.xpub,
-          xprv: '',
-          isImported: false,
-          isTrezorWallet: true,
-          isLedgerWallet: false,
-          balances: { syscoin: 0, ethereum: 0 },
-          assets: { syscoin: [], ethereum: [] },
-        };
-        currentVaultState.activeAccount = {
-          id: account.id,
-          type: KeyringAccountType.Trezor,
-        };
-      }
-    });
-
-    it('should prepare PSBT for Trezor signing', async () => {
-      const psbtData = {
-        psbt: 'valid_psbt_data',
-        assets: [],
-      };
-
-      // Mock the entire signPSBT method to avoid PSBT parsing
-      const originalSignPSBT = keyringManager.syscoinTransaction.signPSBT;
-      keyringManager.syscoinTransaction.signPSBT = jest.fn().mockResolvedValue({
-        psbt: 'mock_signed_psbt_data',
-      });
-
-      const result = await keyringManager.syscoinTransaction.signPSBT({
-        psbt: psbtData,
-        isTrezor: true,
-        isLedger: false,
-      });
-
-      expect(result).toBeDefined();
-      expect(result.psbt).toBe('mock_signed_psbt_data');
-      expect(keyringManager.syscoinTransaction.signPSBT).toHaveBeenCalledWith(
-        expect.objectContaining({
-          isTrezor: true,
-          isLedger: false,
-        })
-      );
-
-      // Restore original method
-      keyringManager.syscoinTransaction.signPSBT = originalSignPSBT;
-    });
-
-    it('should handle Trezor transaction flow', async () => {
-      const xpub = keyringManager.getAccountXpub();
-      expect(xpub).toBeDefined();
-
-      // Mock the PSBT parsing for sendTransaction too
-      const mockSyscoinjs = require('syscoinjs-lib');
-      const originalImportPsbtFromJson = mockSyscoinjs.utils.importPsbtFromJson;
-      mockSyscoinjs.utils.importPsbtFromJson = jest.fn().mockReturnValue({
-        extractTransaction: jest.fn().mockReturnValue({
-          getId: jest.fn().mockReturnValue('mock_transaction_id'),
-        }),
-      });
-
-      // Mock transaction creation - use current sendTransaction API signature
-      const signedPsbt = {
-        psbt: 'valid_psbt_data',
-        assets: [],
-      };
-
-      const result = await keyringManager.syscoinTransaction.sendTransaction(
-        signedPsbt
-      );
-
-      expect(result.txid).toBeDefined();
-
-      // Restore original function
-      mockSyscoinjs.utils.importPsbtFromJson = originalImportPsbtFromJson;
-    });
-
-    it('should handle EVM transaction signing for Trezor', async () => {
-      // Set up EVM vault state
-      const evmVaultState = createMockVaultState({
-        activeAccountId: 0,
-        activeAccountType: KeyringAccountType.HDAccount,
-        networkType: INetworkType.Ethereum,
-        chainId: 1,
-      });
-      const evmVaultStateGetter = jest.fn(() => evmVaultState);
-
-      // Create EVM keyring with Trezor
-      const evmKeyring = await KeyringManager.createInitialized(
-        PEACE_SEED_PHRASE,
-        FAKE_PASSWORD,
-        evmVaultStateGetter
-      );
-
-      // Mock Trezor EVM methods
-      evmKeyring.trezorSigner.getAccountInfo = jest.fn().mockResolvedValue({
-        descriptor: '0x742D35Cc6634C0532925a3b844bc9e7595f2bd9f',
-        balance: '1000000000000000000',
-      });
-
-      evmKeyring.trezorSigner.getPublicKey = jest.fn().mockResolvedValue({
-        publicKey: '0x04mock_evm_public_key',
-      });
-
-      evmKeyring.trezorSigner.signEthTransaction = jest.fn().mockResolvedValue({
-        v: '0x1c',
-        r: '0x123456789abcdef123456789abcdef123456789abcdef123456789abcdef12345678',
-        s: '0x987654321fedcba987654321fedcba987654321fedcba987654321fedcba987654',
-      });
-
-      // Import Trezor account
-      const evmAccount = await evmKeyring.importTrezorAccount('Trezor ETH');
-      if (evmAccount) {
-        // Update vault state to set Trezor as active
-        evmVaultState.accounts[KeyringAccountType.Trezor][evmAccount.id] = {
-          id: evmAccount.id,
-          label: evmAccount.label,
-          address: evmAccount.address,
-          xpub: evmAccount.xpub,
-          xprv: '',
-          isImported: false,
-          isTrezorWallet: true,
-          isLedgerWallet: false,
-          balances: { syscoin: 0, ethereum: 0 },
-          assets: { syscoin: [], ethereum: [] },
-        };
-        evmVaultState.activeAccount = {
-          id: evmAccount.id,
-          type: KeyringAccountType.Trezor,
-        };
-
-        // Account switch is handled by vault state update
-      }
-
-      // Test EVM transaction signing
-      expect(evmKeyring.trezorSigner.signEthTransaction).toBeDefined();
-      expect(evmAccount.address.startsWith('0x')).toBe(true);
-    });
-  });
-
-  describe('Network Support', () => {
-    it('should support Trezor on different UTXO networks', async () => {
-      // Set up testnet vault state
-      const testnetVaultState = createMockVaultState({
-        activeAccountId: 0,
-        activeAccountType: KeyringAccountType.HDAccount,
-        networkType: INetworkType.Syscoin,
-        chainId: 5700,
-      });
-      const testnetVaultStateGetter = jest.fn(() => testnetVaultState);
-
-      // Test on testnet
-      const testnetKeyring = await KeyringManager.createInitialized(
-        PEACE_SEED_PHRASE,
-        FAKE_PASSWORD,
-        testnetVaultStateGetter
-      );
-
-      const account = await testnetKeyring.importTrezorAccount(
-        'Testnet Trezor'
-      );
-      expect(account.address.match(/^(sys1|tsys1)/)).toBeTruthy();
-    });
-
-    it('should maintain separate Trezor accounts per network', async () => {
-      // Import on mainnet
-      const mainnetAccount = await keyringManager.importTrezorAccount(
-        'Mainnet Trezor'
-      );
-
-      // Set up testnet vault state
-      const testnetVaultState = createMockVaultState({
-        activeAccountId: 0,
-        activeAccountType: KeyringAccountType.HDAccount,
-        networkType: INetworkType.Syscoin,
-        chainId: 5700,
-      });
-      const testnetVaultStateGetter = jest.fn(() => testnetVaultState);
-
-      // Create testnet keyring
-      const testnetKeyring = await KeyringManager.createInitialized(
-        PEACE_SEED_PHRASE,
-        FAKE_PASSWORD,
-        testnetVaultStateGetter
-      );
-
-      // Import on testnet
-      const testnetAccount = await testnetKeyring.importTrezorAccount(
-        'Testnet Trezor'
-      );
-
-      // Accounts should be independent
-      expect(mainnetAccount.address).not.toBe(testnetAccount.address);
-      expect(mainnetAccount.address.match(/^(sys1|tsys1)/)).toBeTruthy();
-      expect(testnetAccount.address.match(/^(sys1|tsys1)/)).toBeTruthy();
-    });
-  });
-
-  describe('Error Handling', () => {
-    it('should handle Trezor connection errors', async () => {
-      // Mock connection failure
-      keyringManager.trezorSigner.getAccountInfo = jest
-        .fn()
-        .mockRejectedValue(new Error('Trezor not connected'));
-
-      await expect(keyringManager.importTrezorAccount()).rejects.toThrow(
-        'Trezor not connected'
-      );
-    });
-
-    it('should handle invalid Trezor responses', async () => {
-      // Mock invalid response
-      keyringManager.trezorSigner.getAccountInfo = jest.fn().mockResolvedValue({
-        descriptor: null,
-        balance: null,
-      });
-
-      await expect(keyringManager.importTrezorAccount()).rejects.toThrow(
-        'Something wrong happened'
-      );
-    });
-
-    it('should handle Trezor device disconnection during signing', async () => {
-      const account = await keyringManager.importTrezorAccount(
-        'Disconnect Test'
-      );
-      if (account) {
-        // Update vault state to set Trezor as active
-        currentVaultState.accounts[KeyringAccountType.Trezor][account.id] = {
-          id: account.id,
-          label: account.label,
-          address: account.address,
-          xpub: account.xpub,
-          xprv: '',
-          isImported: false,
-          isTrezorWallet: true,
-          isLedgerWallet: false,
-          balances: { syscoin: 0, ethereum: 0 },
-          assets: { syscoin: [], ethereum: [] },
-        };
-        currentVaultState.activeAccount = {
-          id: account.id,
-          type: KeyringAccountType.Trezor,
-        };
-
-        // Account switch is handled by vault state update
-      }
-
-      // Mock Trezor disconnection during signing
-      keyringManager.trezorSigner.signUtxoTransaction = jest
-        .fn()
-        .mockRejectedValue(new Error('Device disconnected'));
-
-      const psbtData = {
-        psbt: 'valid_psbt_data',
-        assets: [],
-      };
-
-      await expect(
-        keyringManager.syscoinTransaction.signPSBT({
-          psbt: psbtData,
-          isTrezor: true,
-          isLedger: false,
-        })
-      ).rejects.toThrow();
-    });
-
-    it('should handle Trezor firmware update required', async () => {
-      // Mock firmware update required error
-      keyringManager.trezorSigner.getAccountInfo = jest
-        .fn()
-        .mockRejectedValue(new Error('Device firmware update required'));
-
-      await expect(keyringManager.importTrezorAccount()).rejects.toThrow(
-        'Device firmware update required'
-      );
-    });
-  });
-
-  describe('Security', () => {
-    it('should not expose private keys for hardware wallets', async () => {
-      const account = await keyringManager.importTrezorAccount('Security Test');
-
-      expect(account).toBeDefined();
-      expect(account.xprv).toBe(''); // Should be empty for hardware wallets
-      expect(account.isTrezorWallet).toBe(true);
-
-      // Should not be able to get private key for hardware wallet
-      await expect(
-        keyringManager.getPrivateKeyByAccountId(
-          account.id,
-          KeyringAccountType.Trezor,
-          FAKE_PASSWORD
-        )
-      ).rejects.toThrow();
-    });
-
-    it('should maintain hardware wallet isolation', async () => {
-      const account = await keyringManager.importTrezorAccount(
-        'Isolation Test'
-      );
-
-      if (account) {
-        // Update vault state
-        currentVaultState.accounts[KeyringAccountType.Trezor][account.id] = {
-          id: account.id,
-          label: account.label,
-          address: account.address,
-          xpub: account.xpub,
-          xprv: '',
-          isImported: false,
-          isTrezorWallet: true,
-          isLedgerWallet: false,
-          balances: { syscoin: 0, ethereum: 0 },
-          assets: { syscoin: [], ethereum: [] },
-        };
-
-        // Verify Trezor accounts are completely separate from HD accounts
-        const hdAccounts =
-          currentVaultState.accounts[KeyringAccountType.HDAccount];
-        const trezorAccounts =
-          currentVaultState.accounts[KeyringAccountType.Trezor];
-
-        expect(Object.keys(hdAccounts)).toHaveLength(1); // Initial HD account
-        expect(Object.keys(trezorAccounts)).toHaveLength(1); // One imported Trezor account
-
-        // Verify no cross-contamination of account types
-        Object.values(hdAccounts).forEach((account: any) => {
-          expect(account.isTrezorWallet).toBe(false);
-        });
-
-        Object.values(trezorAccounts).forEach((account: any) => {
-          expect(account.isTrezorWallet).toBe(true);
-        });
-      }
-    });
-
-    it('should handle hardware wallet re-initialization securely', async () => {
-      const account = await keyringManager.importTrezorAccount('Reinit Test');
-
-      if (account) {
-        // Update vault state
-        currentVaultState.accounts[KeyringAccountType.Trezor][account.id] = {
-          id: account.id,
-          label: account.label,
-          address: account.address,
-          xpub: account.xpub,
-          xprv: '',
-          isImported: false,
-          isTrezorWallet: true,
-          isLedgerWallet: false,
-          balances: { syscoin: 0, ethereum: 0 },
-          assets: { syscoin: [], ethereum: [] },
-        };
-        currentVaultState.activeAccount = {
-          id: account.id,
-          type: KeyringAccountType.Trezor,
-        };
-
-        // Account switch is handled by vault state update
-
-        // Lock and unlock to test re-initialization
-        keyringManager.lockWallet();
-
-        // Mock hardware wallet communication error during unlock
-        keyringManager.trezorSigner.getAccountInfo = jest
-          .fn()
-          .mockRejectedValue(new Error('Trezor device not found'));
-
-        // Should still unlock successfully - account info comes from vault
-        const unlockResult = await keyringManager.unlock(FAKE_PASSWORD);
-        expect(unlockResult.canLogin).toBe(true);
-
-        // Account info should still be accessible from vault
-        const activeAfter = keyringManager.getActiveAccount();
-        expect(activeAfter.activeAccount.label).toBe('Reinit Test');
-        expect(activeAfter.activeAccount.isTrezorWallet).toBe(true);
-      }
-    });
-
-    it('should verify UTXO address on Trezor device', async () => {
-      // Mock trezorSigner.verifyAddress to simulate device verification
-      keyringManager.trezorSigner.verifyUtxoAddress = jest
-        .fn()
-        .mockResolvedValue('sys1qmock_trezor_verified_address');
-
-      const account = await keyringManager.importTrezorAccount('Verify Test');
-
-      if (account) {
-        // Update vault state
-        currentVaultState.accounts[KeyringAccountType.Trezor][account.id] = {
-          id: account.id,
-          label: account.label,
-          address: account.address,
-          xpub: account.xpub,
-          xprv: '',
-          isImported: false,
-          isTrezorWallet: true,
-          isLedgerWallet: false,
-          balances: { syscoin: 0, ethereum: 0 },
-          assets: { syscoin: [], ethereum: [] },
-        };
-
-        // Test verifyUtxoAddress
-        const verifiedAddress =
-          await keyringManager.trezorSigner.verifyUtxoAddress(
-            account.id,
-            'sys',
-            57
-          );
-
-        expect(verifiedAddress).toBe('sys1qmock_trezor_verified_address');
-
-        // Verify that the mock was called
-        expect(
-          keyringManager.trezorSigner.verifyUtxoAddress
-        ).toHaveBeenCalledWith(account.id, 'sys', 57);
-      }
-    });
-
-    it('should handle user cancellation during address verification', async () => {
-      // Mock getAccountInfo to return quickly
-      const originalGetAccountInfo = keyringManager.trezorSigner.getAccountInfo;
-      keyringManager.trezorSigner.getAccountInfo = jest.fn().mockResolvedValue({
-        descriptor: 'test-xpub',
-        balance: '0',
-      });
-
-      // Create an account successfully first
-      let account;
-      try {
-        account = await keyringManager.importTrezorAccount('Cancel Test');
-        expect(account).toBeDefined();
-      } finally {
-        // Restore getAccountInfo
-        keyringManager.trezorSigner.getAccountInfo = originalGetAccountInfo;
-      }
-
-      // Mock verifyUtxoAddress directly to avoid retry delays
-      keyringManager.trezorSigner.verifyUtxoAddress = jest
-        .fn()
-        .mockRejectedValue(new Error('Address verification cancelled by user'));
-
-      try {
-        // Attempt to verify address - this should throw immediately
-        await keyringManager.trezorSigner.verifyUtxoAddress(
-          account.id,
-          'sys',
-          57
-        );
-        // Should not reach here
-        fail('Expected error was not thrown');
-      } catch (error: any) {
-        expect(error.message).toContain(
-          'Address verification cancelled by user'
-        );
-      }
-
-      // Verify the mock was called
-      expect(
-        keyringManager.trezorSigner.verifyUtxoAddress
-      ).toHaveBeenCalledWith(account.id, 'sys', 57);
-    });
-  });
-});