fix: address cursor feedbacks

Author: mathieuartu

packages/keyring-eth-trezor/jest.config.js

@@ -23,10 +23,10 @@ module.exports = merge(baseConfig, {
   // An object that configures minimum threshold enforcement for coverage results
   coverageThreshold: {
     global: {
-      branches: 59.58,
-      functions: 92.95,
-      lines: 93.15,
-      statements: 93.25,
+      branches: 60.92,
+      functions: 93.15,
+      lines: 93.5,
+      statements: 93.59,
     },
   },
 });

packages/keyring-eth-trezor/src/trezor-keyring-v2.test.ts

@@ -626,5 +626,73 @@ describe('TrezorKeyringV2', () => {
 
       expect(account.options.entropy.derivationPath).toBe(`m/44'/60'/0'/0`);
     });
+
+    it('clears registry when switching HD paths', async () => {
+      // Create wrapper with account on BIP44 path
+      const inner = createInnerKeyring();
+      inner.setAccountToUnlock(0);
+      await inner.addAccounts(1);
+
+      const wrapper = new TrezorKeyringV2({
+        legacyKeyring: inner,
+        entropySource,
+      });
+
+      // Get initial accounts - this populates the registry
+      const initialAccounts = await wrapper.getAccounts();
+      expect(initialAccounts).toHaveLength(1);
+      const initialAccountId = getFirstAccount(initialAccounts).id;
+
+      // Switch to legacy MEW path and add account
+      // This simulates what createAccounts does when path changes
+      inner.setHdPath(`m/44'/60'/0'`);
+      inner.hdk = fakeHdKey; // Reset HDKey after setHdPath clears it
+      inner.setAccountToUnlock(0);
+      await inner.addAccounts(1);
+
+      // Call createAccounts with the new path - this should clear registry
+      await wrapper.createAccounts(derivePathOptions(`m/44'/60'/0'/1`));
+
+      // The old account should no longer be accessible
+      await expect(wrapper.getAccount(initialAccountId)).rejects.toThrow(
+        /Account not found/u,
+      );
+    });
+  });
+
+  describe('locked device handling', () => {
+    it('returns cached accounts when device is locked', async () => {
+      const { wrapper, inner } = await createWrapperWithAccounts(2);
+
+      // First call with device unlocked populates the cache
+      const unlockedAccounts = await wrapper.getAccounts();
+      expect(unlockedAccounts).toHaveLength(2);
+
+      // Simulate locked device by clearing the HDKey
+      inner.hdk = {} as typeof fakeHdKey;
+
+      // Should return cached accounts
+      const lockedAccounts = await wrapper.getAccounts();
+      expect(lockedAccounts).toHaveLength(2);
+      expect(lockedAccounts).toStrictEqual(unlockedAccounts);
+    });
+
+    it('throws error when device is locked and accounts not cached', async () => {
+      const inner = createInnerKeyring();
+      inner.setAccountToUnlock(0);
+      await inner.addAccounts(1);
+
+      const wrapper = new TrezorKeyringV2({
+        legacyKeyring: inner,
+        entropySource,
+      });
+
+      // Simulate locked device before accounts are cached
+      inner.hdk = {} as typeof fakeHdKey;
+
+      await expect(wrapper.getAccounts()).rejects.toThrow(
+        /Trezor device is locked/u,
+      );
+    });
   });
 });

packages/keyring-eth-trezor/src/trezor-keyring-v2.ts

@@ -88,13 +88,20 @@ export class TrezorKeyringV2
 {
   readonly entropySource: EntropySourceId;
 
+  /**
+   * Tracks the current HD path to detect path changes.
+   * When the path changes, the registry must be cleared.
+   */
+  #currentHdPath: AllowedHdPath;
+
   constructor(options: TrezorKeyringV2Options) {
     super({
       type: options.type ?? KeyringType.Trezor,
       inner: options.legacyKeyring as TrezorKeyringAsEthKeyring,
       capabilities: trezorKeyringV2Capabilities,
     });
     this.entropySource = options.entropySource;
+    this.#currentHdPath = this.inner.hdPath as AllowedHdPath;
   }
 
   /**
@@ -123,6 +130,9 @@ export class TrezorKeyringV2
       // initialized HDKey. The registry will be populated lazily when
       // getAccounts() is called after the device is unlocked.
       await this.inner.deserialize(state);
+
+      // Sync the tracked HD path with the deserialized state
+      this.#currentHdPath = this.inner.hdPath as AllowedHdPath;
     });
   }
 
@@ -193,6 +203,30 @@ export class TrezorKeyringV2
       return [];
     }
 
+    // If the device is locked, we cannot derive addresses to find indices.
+    // Return cached accounts if available, otherwise throw a clear error.
+    if (!this.inner.isUnlocked()) {
+      const cachedAccounts = addresses
+        .map((address) => {
+          const existingId = this.registry.getAccountId(address);
+          return existingId ? this.registry.get(existingId) : undefined;
+        })
+        .filter(
+          (account): account is Bip44Account<KeyringAccount> =>
+            account !== undefined,
+        );
+
+      // If we have all accounts cached, return them
+      if (cachedAccounts.length === addresses.length) {
+        return cachedAccounts;
+      }
+
+      // Some accounts are not cached and device is locked
+      throw new Error(
+        'Trezor device is locked. Please unlock the device to access accounts.',
+      );
+    }
+
     return addresses.map((address) => {
       // Check if we already have this account in the registry
       const existingId = this.registry.getAccountId(address);
@@ -267,12 +301,14 @@ export class TrezorKeyringV2
       }
 
       // Derive the account at the specified index.
-      // Note: setHdPath resets the inner keyring's accounts array when the path changes.
-      // This mirrors the production behavior where switching HD paths (via the dropdown)
-      // resets the entire account list. The TrezorKeyring operates on a single path at
-      // a time - accounts from different paths cannot coexist. The V2 registry tracks
-      // accounts independently, but getAccounts() relies on the inner keyring's account
-      // list, so accounts from a previous path would become inaccessible after switching.
+      // If the HD path is changing, clear the registry to avoid stale accounts.
+      // The TrezorKeyring operates on a single path at a time - accounts from
+      // different paths cannot coexist in the inner keyring.
+      if (basePath !== this.#currentHdPath) {
+        this.registry.clear();
+        this.#currentHdPath = basePath;
+      }
+
       this.inner.setHdPath(basePath);
       this.inner.setAccountToUnlock(targetIndex);
       const [newAddress] = await this.inner.addAccounts(1);