fix: sub account caching policy only cache known address (#167)

Author: stephancill

packages/account-sdk/src/sign/base-account/Signer.test.ts

@@ -1026,7 +1026,9 @@ describe('Signer', () => {
       expect(accounts).toEqual([subAccountAddress, globalAccountAddress]);
 
       // Test with eth_requestAccounts as well
-      const requestedAccounts = await signer.request({ method: 'eth_requestAccounts' });
+      const requestedAccounts = await signer.request({
+        method: 'eth_requestAccounts',
+      });
       expect(requestedAccounts).toEqual([subAccountAddress, globalAccountAddress]);
     });
   });
@@ -1262,9 +1264,157 @@ describe('Signer', () => {
       expect(accounts).toEqual([subAccountAddress, globalAccountAddress]);
 
       // eth_requestAccounts will also order based on defaultAccount
-      const requestedAccounts = await signer.request({ method: 'eth_requestAccounts' });
+      const requestedAccounts = await signer.request({
+        method: 'eth_requestAccounts',
+      });
       expect(requestedAccounts).toEqual([subAccountAddress, globalAccountAddress]);
     });
+
+    it('should return cached sub account when requested address matches', async () => {
+      await signer.cleanup();
+
+      // Setup initial connection
+      (decryptContent as Mock).mockResolvedValueOnce({
+        result: { value: null },
+      });
+      await signer.handshake({ method: 'handshake' });
+
+      (decryptContent as Mock).mockResolvedValueOnce({
+        result: {
+          value: {
+            accounts: [{ address: globalAccountAddress, capabilities: {} }],
+          },
+        },
+      });
+      await signer.request({ method: 'wallet_connect', params: [] });
+
+      // Cache a sub account
+      store.subAccounts.set({
+        address: subAccountAddress,
+        factory: globalAccountAddress,
+        factoryData: '0x',
+      });
+
+      // Request same address (isAddressEqual handles case-insensitive comparison)
+      const result = await signer.request({
+        method: 'wallet_addSubAccount',
+        params: [
+          {
+            version: '1',
+            account: {
+              type: 'deployed',
+              address: subAccountAddress,
+              chainId: '0x14a34',
+            },
+          },
+        ],
+      });
+
+      // Should return cached without calling backend
+      expect(result.address).toBe(subAccountAddress);
+      expect(decryptContent).toHaveBeenCalledTimes(2); // Only handshake + connect, not addSubAccount
+    });
+
+    it('should fetch from backend when requested address differs from cached', async () => {
+      await signer.cleanup();
+
+      const secondSubAccountAddress = '0x9999999999999999999999999999999999999999';
+
+      // Setup initial connection
+      (decryptContent as Mock).mockResolvedValueOnce({
+        result: { value: null },
+      });
+      await signer.handshake({ method: 'handshake' });
+
+      (decryptContent as Mock).mockResolvedValueOnce({
+        result: {
+          value: {
+            accounts: [{ address: globalAccountAddress, capabilities: {} }],
+          },
+        },
+      });
+      await signer.request({ method: 'wallet_connect', params: [] });
+
+      // Cache a sub account
+      store.subAccounts.set({
+        address: subAccountAddress,
+        factory: globalAccountAddress,
+        factoryData: '0x',
+      });
+
+      // Request different address
+      (decryptContent as Mock).mockResolvedValueOnce({
+        result: {
+          value: {
+            address: secondSubAccountAddress,
+            factory: globalAccountAddress,
+            factoryData: '0x123',
+          },
+        },
+      });
+
+      const result = await signer.request({
+        method: 'wallet_addSubAccount',
+        params: [
+          {
+            version: '1',
+            account: {
+              type: 'deployed',
+              address: secondSubAccountAddress,
+              chainId: '0x14a34',
+            },
+          },
+        ],
+      });
+
+      // Should call backend and return new sub account
+      expect(result.address).toBe(secondSubAccountAddress);
+      expect(decryptContent).toHaveBeenCalledTimes(3); // handshake + connect + addSubAccount
+    });
+
+    it('should return cached sub account for create type (no address specified)', async () => {
+      await signer.cleanup();
+
+      // Setup initial connection
+      (decryptContent as Mock).mockResolvedValueOnce({
+        result: { value: null },
+      });
+      await signer.handshake({ method: 'handshake' });
+
+      (decryptContent as Mock).mockResolvedValueOnce({
+        result: {
+          value: {
+            accounts: [{ address: globalAccountAddress, capabilities: {} }],
+          },
+        },
+      });
+      await signer.request({ method: 'wallet_connect', params: [] });
+
+      // Cache a sub account
+      store.subAccounts.set({
+        address: subAccountAddress,
+        factory: globalAccountAddress,
+        factoryData: '0x',
+      });
+
+      // Request create type (no specific address)
+      const result = await signer.request({
+        method: 'wallet_addSubAccount',
+        params: [
+          {
+            version: '1',
+            account: {
+              type: 'create',
+              keys: [{ publicKey: '0x123', type: 'p256' }],
+            },
+          },
+        ],
+      });
+
+      // Should return cached without calling backend
+      expect(result.address).toBe(subAccountAddress);
+      expect(decryptContent).toHaveBeenCalledTimes(2); // Only handshake + connect, not addSubAccount
+    });
   });
 
   describe('auto sub account', () => {
@@ -1856,7 +2006,10 @@ describe('Signer', () => {
       });
 
       // Set the chain to match the mocked client
-      signer['chain'] = { id: 84532, rpcUrl: 'https://eth-rpc.example.com/84532' };
+      signer['chain'] = {
+        id: 84532,
+        rpcUrl: 'https://eth-rpc.example.com/84532',
+      };
       signer['accounts'] = [globalAccountAddress];
 
       // Setup basic handshake
@@ -2144,7 +2297,10 @@ describe('Signer', () => {
       });
 
       // Set the chain to match the mocked client
-      signer['chain'] = { id: 84532, rpcUrl: 'https://eth-rpc.example.com/84532' };
+      signer['chain'] = {
+        id: 84532,
+        rpcUrl: 'https://eth-rpc.example.com/84532',
+      };
       signer['accounts'] = [globalAccountAddress];
 
       // Mock decryptContent for wallet_connect to set up accounts

packages/account-sdk/src/sign/base-account/Signer.ts

@@ -603,15 +603,32 @@ export class Signer {
     factoryData?: Hex;
   }> {
     const state = store.getState();
-    const subAccount = state.subAccount;
+    const cachedSubAccount = state.subAccount;
     const subAccountsConfig = store.subAccountsConfig.get();
-    if (subAccount?.address) {
-      this.accounts =
-        subAccountsConfig?.defaultAccount === 'sub'
-          ? prependWithoutDuplicates(this.accounts, subAccount.address)
-          : appendWithoutDuplicates(this.accounts, subAccount.address);
-      this.callback?.('accountsChanged', this.accounts);
-      return subAccount;
+
+    // Extract requested address from params (for deployed/undeployed types)
+    const requestedAddress =
+      Array.isArray(request.params) &&
+      request.params.length > 0 &&
+      request.params[0]?.account?.address
+        ? request.params[0].account.address
+        : undefined;
+
+    // Only return cached if:
+    // 1. Cache exists AND
+    // 2. No specific address requested (create type) OR requested address matches cached
+    if (cachedSubAccount?.address) {
+      const shouldUseCache =
+        !requestedAddress || isAddressEqual(requestedAddress, cachedSubAccount.address);
+
+      if (shouldUseCache) {
+        this.accounts =
+          subAccountsConfig?.defaultAccount === 'sub'
+            ? prependWithoutDuplicates(this.accounts, cachedSubAccount.address)
+            : appendWithoutDuplicates(this.accounts, cachedSubAccount.address);
+        this.callback?.('accountsChanged', this.accounts);
+        return cachedSubAccount;
+      }
     }
 
     // Wait for the popup to be loaded before sending the request