@sidhujag/sysweb3-keyring 1.0.545 → 1.0.547

package/test/unit/keyring-manager/initialization.spec.ts

@@ -0,0 +1,782 @@
+import { INetworkType } from '@sidhujag/sysweb3-network';
+
+import { KeyringManager, KeyringAccountType } from '../../../src';
+import {
+  FAKE_PASSWORD,
+  PEACE_SEED_PHRASE,
+  SECOND_FAKE_SEED_PHRASE,
+} from '../../helpers/constants';
+import { setupMocks } from '../../helpers/setup';
+
+describe('KeyringManager Initialization', () => {
+  let keyringManager: KeyringManager;
+  let mockVaultStateGetter: jest.Mock;
+  let currentVaultState: any;
+
+  beforeEach(async () => {
+    setupMocks();
+    // Set up vault-keys
+    await setupTestVault(FAKE_PASSWORD);
+  });
+
+  afterEach(async () => {
+    // Clean up resources
+    if (keyringManager) {
+      await keyringManager.destroy();
+    }
+  });
+
+  describe('Seed Management', () => {
+    it('should create a new valid seed phrase', () => {
+      keyringManager = new KeyringManager();
+      const seed = keyringManager.createNewSeed();
+
+      expect(seed).toBeDefined();
+      expect(seed.split(' ')).toHaveLength(12);
+      expect(keyringManager.isSeedValid(seed)).toBe(true);
+    });
+
+    it('should validate seed phrases correctly', () => {
+      keyringManager = new KeyringManager();
+
+      expect(keyringManager.isSeedValid(PEACE_SEED_PHRASE)).toBe(true);
+      expect(keyringManager.isSeedValid('invalid seed phrase')).toBe(false);
+      expect(keyringManager.isSeedValid('')).toBe(false);
+    });
+
+    it('should retrieve the seed after initialization', async () => {
+      keyringManager = new KeyringManager();
+
+      // Set up mock vault state getter for initializeWalletSecurely
+      currentVaultState = createMockVaultState({
+        activeAccountId: 0,
+        activeAccountType: KeyringAccountType.HDAccount,
+        networkType: INetworkType.Ethereum,
+        chainId: 1,
+      });
+      mockVaultStateGetter = jest.fn(() => currentVaultState);
+      keyringManager.setVaultStateGetter(mockVaultStateGetter);
+
+      await keyringManager.initializeWalletSecurely(
+        PEACE_SEED_PHRASE,
+        FAKE_PASSWORD
+      );
+
+      const retrievedSeed = await keyringManager.getSeed(FAKE_PASSWORD);
+      expect(retrievedSeed).toBe(PEACE_SEED_PHRASE);
+    });
+
+    it('should reject seed retrieval with wrong password', async () => {
+      keyringManager = new KeyringManager();
+
+      // Set up mock vault state getter for initializeWalletSecurely
+      currentVaultState = createMockVaultState({
+        activeAccountId: 0,
+        activeAccountType: KeyringAccountType.HDAccount,
+        networkType: INetworkType.Ethereum,
+        chainId: 1,
+      });
+      mockVaultStateGetter = jest.fn(() => currentVaultState);
+      keyringManager.setVaultStateGetter(mockVaultStateGetter);
+
+      await keyringManager.initializeWalletSecurely(
+        PEACE_SEED_PHRASE,
+        FAKE_PASSWORD
+      );
+
+      await expect(keyringManager.getSeed('wrong_password')).rejects.toThrow(
+        'Invalid password'
+      );
+    });
+  });
+
+  describe('Wallet Initialization', () => {
+    it('should initialize wallet for EVM chain', async () => {
+      // Set up EVM vault state
+      currentVaultState = createMockVaultState({
+        activeAccountId: 0,
+        activeAccountType: KeyringAccountType.HDAccount,
+        networkType: INetworkType.Ethereum,
+        chainId: 1,
+      });
+      mockVaultStateGetter = jest.fn(() => currentVaultState);
+
+      keyringManager = await KeyringManager.createInitialized(
+        PEACE_SEED_PHRASE,
+        FAKE_PASSWORD,
+        mockVaultStateGetter
+      );
+
+      expect(keyringManager.isUnlocked()).toBe(true);
+
+      const { activeAccount } = keyringManager.getActiveAccount();
+      expect(activeAccount.address).toBeDefined();
+      expect(activeAccount.address.startsWith('0x')).toBe(true);
+    });
+
+    it('should initialize wallet for UTXO chain', async () => {
+      // 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
+      );
+
+      expect(keyringManager.isUnlocked()).toBe(true);
+
+      const { activeAccount } = keyringManager.getActiveAccount();
+      expect(activeAccount.address).toBeDefined();
+      expect(activeAccount.address.match(/^(sys1|tsys1)/)).toBeTruthy();
+    });
+
+    it('should create deterministic addresses from the same seed', async () => {
+      // Set up EVM vault state for both keyrings
+      currentVaultState = createMockVaultState({
+        activeAccountId: 0,
+        activeAccountType: KeyringAccountType.HDAccount,
+        networkType: INetworkType.Ethereum,
+        chainId: 1,
+      });
+
+      // First EVM keyring
+      const mockVaultStateGetter1 = jest.fn(() => currentVaultState);
+      const keyring1 = await KeyringManager.createInitialized(
+        PEACE_SEED_PHRASE,
+        FAKE_PASSWORD,
+        mockVaultStateGetter1
+      );
+
+      // Second EVM keyring with same seed
+      const mockVaultStateGetter2 = jest.fn(() => currentVaultState);
+      const keyring2 = await KeyringManager.createInitialized(
+        PEACE_SEED_PHRASE,
+        FAKE_PASSWORD,
+        mockVaultStateGetter2
+      );
+
+      const account1 = keyring1.getActiveAccount().activeAccount;
+      const account2 = keyring2.getActiveAccount().activeAccount;
+
+      expect(account1.address).toBe(account2.address);
+      expect(account1.xpub).toBe(account2.xpub);
+    });
+
+    it('should handle initialization with invalid seed', async () => {
+      currentVaultState = createMockVaultState({
+        activeAccountId: 0,
+        activeAccountType: KeyringAccountType.HDAccount,
+        networkType: INetworkType.Ethereum,
+        chainId: 1,
+      });
+      mockVaultStateGetter = jest.fn(() => currentVaultState);
+
+      await expect(
+        KeyringManager.createInitialized(
+          'invalid seed phrase',
+          FAKE_PASSWORD,
+          mockVaultStateGetter
+        )
+      ).rejects.toThrow('Invalid Seed');
+    });
+
+    it('should be idempotent for multiple initializations with same parameters', async () => {
+      keyringManager = new KeyringManager();
+
+      // Set up mock vault state getter for initializeWalletSecurely
+      currentVaultState = createMockVaultState({
+        activeAccountId: 0,
+        activeAccountType: KeyringAccountType.HDAccount,
+        networkType: INetworkType.Ethereum,
+        chainId: 1,
+      });
+      mockVaultStateGetter = jest.fn(() => currentVaultState);
+      keyringManager.setVaultStateGetter(mockVaultStateGetter);
+
+      // First initialization
+      const account1 = await keyringManager.initializeWalletSecurely(
+        PEACE_SEED_PHRASE,
+        FAKE_PASSWORD
+      );
+
+      // Second initialization with same parameters should return same account
+      const account2 = await keyringManager.initializeWalletSecurely(
+        PEACE_SEED_PHRASE,
+        FAKE_PASSWORD
+      );
+
+      expect(account1.address).toBe(account2.address);
+      expect(account1.id).toBe(account2.id);
+    });
+
+    it('should reject re-initialization with different parameters', async () => {
+      keyringManager = new KeyringManager();
+
+      // Set up mock vault state getter for initializeWalletSecurely
+      currentVaultState = createMockVaultState({
+        activeAccountId: 0,
+        activeAccountType: KeyringAccountType.HDAccount,
+        networkType: INetworkType.Ethereum,
+        chainId: 1,
+      });
+      mockVaultStateGetter = jest.fn(() => currentVaultState);
+      keyringManager.setVaultStateGetter(mockVaultStateGetter);
+
+      // First initialization
+      await keyringManager.initializeWalletSecurely(
+        PEACE_SEED_PHRASE,
+        FAKE_PASSWORD
+      );
+
+      // Try to initialize with different seed
+      await expect(
+        keyringManager.initializeWalletSecurely(
+          SECOND_FAKE_SEED_PHRASE,
+          FAKE_PASSWORD
+        )
+      ).rejects.toThrow('Wallet already initialized with different parameters');
+    });
+  });
+
+  describe('Lock/Unlock', () => {
+    beforeEach(async () => {
+      // 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
+      );
+    });
+
+    it('should lock and unlock wallet with correct password', async () => {
+      expect(keyringManager.isUnlocked()).toBe(true);
+
+      keyringManager.lockWallet();
+      expect(keyringManager.isUnlocked()).toBe(false);
+
+      const unlockResult = await keyringManager.unlock(FAKE_PASSWORD);
+      expect(unlockResult.canLogin).toBe(true);
+      expect(keyringManager.isUnlocked()).toBe(true);
+    });
+
+    it('should reject unlock with wrong password', async () => {
+      keyringManager.lockWallet();
+
+      const unlockResult = await keyringManager.unlock('wrong_password');
+      expect(unlockResult.canLogin).toBe(false);
+      expect(keyringManager.isUnlocked()).toBe(false);
+    });
+
+    it('should clear session data on lock', () => {
+      expect(keyringManager.isUnlocked()).toBe(true);
+
+      keyringManager.lockWallet();
+
+      // After locking, keyring should not be unlocked
+      expect(keyringManager.isUnlocked()).toBe(false);
+    });
+
+    it('should restore functionality after unlock', async () => {
+      const initialAccount = keyringManager.getActiveAccount().activeAccount;
+
+      keyringManager.lockWallet();
+      await keyringManager.unlock(FAKE_PASSWORD);
+
+      const accountAfterUnlock =
+        keyringManager.getActiveAccount().activeAccount;
+      expect(accountAfterUnlock.address).toBe(initialAccount.address);
+    });
+
+    it('should handle multiple lock/unlock cycles', async () => {
+      for (let i = 0; i < 3; i++) {
+        keyringManager.lockWallet();
+        expect(keyringManager.isUnlocked()).toBe(false);
+
+        const result = await keyringManager.unlock(FAKE_PASSWORD);
+        expect(result.canLogin).toBe(true);
+        expect(keyringManager.isUnlocked()).toBe(true);
+      }
+    });
+  });
+
+  describe('Session Management', () => {
+    it('should transfer session data between keyrings', async () => {
+      // Set up EVM vault state
+      currentVaultState = createMockVaultState({
+        activeAccountId: 0,
+        activeAccountType: KeyringAccountType.HDAccount,
+        networkType: INetworkType.Ethereum,
+        chainId: 1,
+      });
+
+      // Create first keyring
+      const mockVaultStateGetter1 = jest.fn(() => currentVaultState);
+      const keyring1 = await KeyringManager.createInitialized(
+        PEACE_SEED_PHRASE,
+        FAKE_PASSWORD,
+        mockVaultStateGetter1
+      );
+
+      // Create second keyring
+      const keyring2 = new KeyringManager();
+
+      // Transfer session from first to second keyring
+      keyring1.transferSessionTo(keyring2);
+
+      // Both should be unlocked (first should be locked after transfer, second should be unlocked)
+      expect(keyring1.isUnlocked()).toBe(false); // Source keyring is locked after transfer
+      expect(keyring2.isUnlocked()).toBe(true); // Target keyring is unlocked
+
+      // Second keyring should be able to perform operations with transferred session
+      const seed2 = await keyring2.getSeed(FAKE_PASSWORD);
+      expect(seed2).toBe(PEACE_SEED_PHRASE);
+    });
+
+    it('should throw when transferring from locked keyring', () => {
+      const keyring1 = new KeyringManager();
+      const keyring2 = new KeyringManager();
+
+      expect(() => keyring1.transferSessionTo(keyring2)).toThrow(
+        'Source keyring must be unlocked to transfer session'
+      );
+    });
+  });
+
+  describe('Wallet Reset', () => {
+    beforeEach(async () => {
+      // Set up EVM vault state
+      currentVaultState = createMockVaultState({
+        activeAccountId: 0,
+        activeAccountType: KeyringAccountType.HDAccount,
+        networkType: INetworkType.Ethereum,
+        chainId: 1,
+      });
+      mockVaultStateGetter = jest.fn(() => currentVaultState);
+
+      keyringManager = await KeyringManager.createInitialized(
+        PEACE_SEED_PHRASE,
+        FAKE_PASSWORD,
+        mockVaultStateGetter
+      );
+    });
+
+    it('should forget wallet with correct password', async () => {
+      await keyringManager.forgetMainWallet(FAKE_PASSWORD);
+
+      // After forgetting, wallet should be locked and empty
+      expect(keyringManager.isUnlocked()).toBe(false);
+      const unlockResult = await keyringManager.unlock(FAKE_PASSWORD);
+      expect(unlockResult.canLogin).toBe(false); // No vault to unlock
+    });
+
+    it('should reject forget wallet with wrong password', async () => {
+      await expect(
+        keyringManager.forgetMainWallet('wrong_password')
+      ).rejects.toThrow('Invalid password');
+    });
+
+    it('should require unlock before forget wallet', async () => {
+      keyringManager.lockWallet();
+
+      await expect(
+        keyringManager.forgetMainWallet(FAKE_PASSWORD)
+      ).rejects.toThrow('Unlock wallet first');
+    });
+  });
+
+  describe('Edge Cases', () => {
+    it('should handle vault recreation from corrupted session', async () => {
+      // Set up EVM vault state
+      currentVaultState = createMockVaultState({
+        activeAccountId: 0,
+        activeAccountType: KeyringAccountType.HDAccount,
+        networkType: INetworkType.Ethereum,
+        chainId: 1,
+      });
+      mockVaultStateGetter = jest.fn(() => currentVaultState);
+
+      keyringManager = await KeyringManager.createInitialized(
+        PEACE_SEED_PHRASE,
+        FAKE_PASSWORD,
+        mockVaultStateGetter
+      );
+
+      // Simulate corrupted session by clearing internal state
+      keyringManager.lockWallet();
+
+      // Should recreate session from vault on unlock
+      const result = await keyringManager.unlock(FAKE_PASSWORD);
+      expect(result.canLogin).toBe(true);
+
+      // Verify functionality is restored
+      const seed = await keyringManager.getSeed(FAKE_PASSWORD);
+      expect(seed).toBe(PEACE_SEED_PHRASE);
+    });
+
+    it("should create vault keys when they don't exist", async () => {
+      // Use a keyring with proper UTXO setup
+      keyringManager = new KeyringManager();
+
+      // Set up mock vault state getter for initializeWalletSecurely
+      currentVaultState = createMockVaultState({
+        activeAccountId: 0,
+        activeAccountType: KeyringAccountType.HDAccount,
+        networkType: INetworkType.Syscoin,
+        chainId: 57,
+      });
+      mockVaultStateGetter = jest.fn(() => currentVaultState);
+      keyringManager.setVaultStateGetter(mockVaultStateGetter);
+
+      // Get the actual storage instance
+      const keyringStorage = (keyringManager as any).storage;
+
+      // Ensure no vault-keys exist initially (clean state)
+      await keyringStorage.set('vault-keys', null);
+
+      // Should create vault-keys and initialize successfully
+      const result = await keyringManager.initializeWalletSecurely(
+        PEACE_SEED_PHRASE,
+        FAKE_PASSWORD
+      );
+
+      expect(result).toBeDefined();
+      expect(result.address).toBeDefined();
+
+      // Verify vault-keys were actually created by checking storage
+      const vaultKeys = await keyringStorage.get('vault-keys');
+      expect(vaultKeys).toBeDefined();
+      expect(vaultKeys.hash).toBeDefined();
+      expect(vaultKeys.salt).toBeDefined();
+      expect(typeof vaultKeys.hash).toBe('string');
+      expect(typeof vaultKeys.salt).toBe('string');
+      expect(vaultKeys.hash.length).toBeGreaterThan(0);
+      expect(vaultKeys.salt.length).toBeGreaterThan(0);
+
+      // Verify keyring is now unlocked and functional
+      expect(keyringManager.isUnlocked()).toBe(true);
+      const seed = await keyringManager.getSeed(FAKE_PASSWORD);
+      expect(seed).toBe(PEACE_SEED_PHRASE);
+    });
+
+    it('should re-initialize from vault when Trezor account was active', async () => {
+      // 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 import
+      keyringManager.trezorSigner.getAccountInfo = jest.fn().mockResolvedValue({
+        descriptor: 'xpub_trezor_test',
+        balance: 100000000,
+      });
+      keyringManager.trezorSigner.getPublicKey = jest.fn().mockResolvedValue({
+        publicKey: '0x04...',
+      });
+      keyringManager.getAddress = jest
+        .fn()
+        .mockResolvedValue('sys1q_trezor_test');
+
+      // Import and activate Trezor account
+      const trezorAccount = await keyringManager.importTrezorAccount(
+        'Test Trezor'
+      );
+
+      // Update vault state with Trezor account
+      currentVaultState.accounts[KeyringAccountType.Trezor][trezorAccount.id] =
+        {
+          id: trezorAccount.id,
+          label: 'Test Trezor',
+          address: trezorAccount.address,
+          xpub: trezorAccount.xpub,
+          xprv: '',
+          isImported: false,
+          isTrezorWallet: true,
+          isLedgerWallet: false,
+          balances: { syscoin: 0, ethereum: 0 },
+          assets: { syscoin: [], ethereum: [] },
+        };
+      currentVaultState.activeAccount = {
+        id: trezorAccount.id,
+        type: KeyringAccountType.Trezor,
+      };
+
+      // Account switch is handled by vault state update
+
+      // Verify Trezor is active
+      const activeBefore = keyringManager.getActiveAccount();
+      expect(activeBefore.activeAccountType).toBe(KeyringAccountType.Trezor);
+      expect(activeBefore.activeAccount.isTrezorWallet).toBe(true);
+
+      // Lock keyring and create new instance (simulates app restart)
+      keyringManager.lockWallet();
+      const newKeyringManager = new KeyringManager();
+      const newMockVaultStateGetter = jest.fn(() => currentVaultState);
+      newKeyringManager.setVaultStateGetter(newMockVaultStateGetter);
+
+      // Mock Trezor for new keyring
+      newKeyringManager.trezorSigner.getAccountInfo = jest
+        .fn()
+        .mockResolvedValue({
+          descriptor: 'xpub_trezor_test',
+          balance: 100000000,
+        });
+
+      // Unlock and verify Trezor account is restored as active
+      const unlockResult = await newKeyringManager.unlock(FAKE_PASSWORD);
+      expect(unlockResult.canLogin).toBe(true);
+
+      const activeAfter = newKeyringManager.getActiveAccount();
+      expect(activeAfter.activeAccountType).toBe(KeyringAccountType.Trezor);
+      expect(activeAfter.activeAccount.isTrezorWallet).toBe(true);
+      expect(activeAfter.activeAccount.id).toBe(trezorAccount.id);
+    });
+
+    it('should re-initialize from vault when Ledger account was active', async () => {
+      // 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 Ledger ensureConnection
+      keyringManager.ledgerSigner.ensureConnection = jest
+        .fn()
+        .mockResolvedValue(undefined);
+
+      // Mock Ledger import
+      keyringManager.ledgerSigner.utxo = {
+        getXpub: jest
+          .fn()
+          .mockResolvedValue(
+            'zpub6rFR7y4Q2AijBEqTUquhVz398htDFrtymD9xYYfG1m4wAcvPhXNfE3EfH1r1ADqtfSdVCToUG868RvUUkgDKf31mGDtKsAYz2oz2AGutZYs'
+          ),
+        getUtxoAddress: jest.fn().mockResolvedValue('sys1q_ledger_test'),
+        verifyUtxoAddress: jest.fn().mockResolvedValue('sys1q_ledger_test'),
+      };
+
+      const ledgerAccount = await keyringManager.importLedgerAccount(
+        'Test Ledger'
+      );
+      expect(ledgerAccount).toBeDefined();
+      if (!ledgerAccount) {
+        throw new Error('Ledger account creation failed');
+      }
+
+      // Update vault state with Ledger account
+      currentVaultState.accounts[KeyringAccountType.Ledger][ledgerAccount.id] =
+        {
+          id: ledgerAccount.id,
+          label: 'Test Ledger',
+          address: ledgerAccount.address,
+          xpub: ledgerAccount.xpub,
+          xprv: '',
+          isImported: false,
+          isTrezorWallet: false,
+          isLedgerWallet: true,
+          balances: { syscoin: 0, ethereum: 0 },
+          assets: { syscoin: [], ethereum: [] },
+        };
+      currentVaultState.activeAccount = {
+        id: ledgerAccount.id,
+        type: KeyringAccountType.Ledger,
+      };
+
+      // Account switch is handled by vault state update
+
+      // Lock and recreate keyring
+      keyringManager.lockWallet();
+      const newKeyringManager = new KeyringManager();
+      const newMockVaultStateGetter = jest.fn(() => currentVaultState);
+      newKeyringManager.setVaultStateGetter(newMockVaultStateGetter);
+
+      // Mock Ledger ensureConnection for new keyring
+      newKeyringManager.ledgerSigner.ensureConnection = jest
+        .fn()
+        .mockResolvedValue(undefined);
+
+      // Mock Ledger for new keyring
+      newKeyringManager.ledgerSigner.utxo = {
+        getXpub: jest
+          .fn()
+          .mockResolvedValue(
+            'zpub6rFR7y4Q2AijBEqTUquhVz398htDFrtymD9xYYfG1m4wAcvPhXNfE3EfH1r1ADqtfSdVCToUG868RvUUkgDKf31mGDtKsAYz2oz2AGutZYs'
+          ),
+        getUtxoAddress: jest.fn().mockResolvedValue('sys1q_ledger_test'),
+        verifyUtxoAddress: jest.fn().mockResolvedValue('sys1q_ledger_test'),
+      };
+
+      const unlockResult = await newKeyringManager.unlock(FAKE_PASSWORD);
+      expect(unlockResult.canLogin).toBe(true);
+
+      const activeAfter = newKeyringManager.getActiveAccount();
+      expect(activeAfter.activeAccountType).toBe(KeyringAccountType.Ledger);
+      expect(activeAfter.activeAccount.isLedgerWallet).toBe(true);
+    });
+
+    it('should re-initialize from vault when imported account was active', async () => {
+      // 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
+      );
+
+      // Import zprv account
+      const mainnetZprv =
+        'zprvAdGDwa3WySqQoVwVSbYRMKxDhSXpK2wW6wDjekCMdm7TaQ3igf52xRRjYghTvnFurtMm6CMgQivEDJs5ixGSnTtv8usFmkAoTe6XCF5hnpR';
+      const importedAccount = await keyringManager.importAccount(
+        mainnetZprv,
+        'Test Imported'
+      );
+
+      // Update vault state with imported account
+      currentVaultState.accounts[KeyringAccountType.Imported][
+        importedAccount.id
+      ] = {
+        id: importedAccount.id,
+        label: 'Test Imported',
+        address: importedAccount.address,
+        xpub: importedAccount.xpub,
+        xprv: importedAccount.xprv,
+        isImported: true,
+        isTrezorWallet: false,
+        isLedgerWallet: false,
+        balances: { syscoin: 0, ethereum: 0 },
+        assets: { syscoin: [], ethereum: [] },
+      };
+      currentVaultState.activeAccount = {
+        id: importedAccount.id,
+        type: KeyringAccountType.Imported,
+      };
+
+      // Account switch is handled by vault state update
+
+      // Lock and recreate keyring
+      keyringManager.lockWallet();
+      const newKeyringManager = new KeyringManager();
+      const newMockVaultStateGetter = jest.fn(() => currentVaultState);
+      newKeyringManager.setVaultStateGetter(newMockVaultStateGetter);
+
+      const unlockResult = await newKeyringManager.unlock(FAKE_PASSWORD);
+      expect(unlockResult.canLogin).toBe(true);
+
+      const activeAfter = newKeyringManager.getActiveAccount();
+      expect(activeAfter.activeAccountType).toBe(KeyringAccountType.Imported);
+      expect(activeAfter.activeAccount.isImported).toBe(true);
+      expect(activeAfter.activeAccount.id).toBe(importedAccount.id);
+    });
+
+    it('should handle missing hardware wallet during re-init gracefully', async () => {
+      // 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
+      );
+
+      // Import Trezor
+      keyringManager.trezorSigner.getAccountInfo = jest.fn().mockResolvedValue({
+        descriptor: 'xpub_trezor_missing',
+        balance: 100000000,
+      });
+      keyringManager.trezorSigner.getPublicKey = jest.fn().mockResolvedValue({
+        publicKey: '0x04...',
+      });
+      keyringManager.getAddress = jest
+        .fn()
+        .mockResolvedValue('sys1q_trezor_missing');
+
+      const trezorAccount = await keyringManager.importTrezorAccount(
+        'Missing Trezor'
+      );
+
+      // Update vault state with Trezor account
+      currentVaultState.accounts[KeyringAccountType.Trezor][trezorAccount.id] =
+        {
+          id: trezorAccount.id,
+          label: 'Missing Trezor',
+          address: trezorAccount.address,
+          xpub: trezorAccount.xpub,
+          xprv: '',
+          isImported: false,
+          isTrezorWallet: true,
+          isLedgerWallet: false,
+          balances: { syscoin: 0, ethereum: 0 },
+          assets: { syscoin: [], ethereum: [] },
+        };
+      currentVaultState.activeAccount = {
+        id: trezorAccount.id,
+        type: KeyringAccountType.Trezor,
+      };
+
+      // Recreate keyring with Trezor as active but hardware not available
+      keyringManager.lockWallet();
+      const newKeyringManager = new KeyringManager();
+      const newMockVaultStateGetter = jest.fn(() => currentVaultState);
+      newKeyringManager.setVaultStateGetter(newMockVaultStateGetter);
+
+      // Mock hardware wallet communication error
+      newKeyringManager.trezorSigner.getAccountInfo = jest
+        .fn()
+        .mockRejectedValue(new Error('Trezor device not found'));
+
+      // Should still unlock successfully
+      const unlockResult = await newKeyringManager.unlock(FAKE_PASSWORD);
+      expect(unlockResult.canLogin).toBe(true);
+
+      // Account info should still be accessible from vault
+      const activeAfter = newKeyringManager.getActiveAccount();
+      expect(activeAfter.activeAccount.label).toBe('Missing Trezor');
+    });
+  });
+});