@ledgerhq/cryptoassets 13.33.0-nightly.20251125074637 → 13.34.0-nightly.20251126023856

package/src/cal-client/persistence.test.ts

@@ -7,10 +7,14 @@ import {
   toTokenCurrencyRaw,
   fromTokenCurrencyRaw,
   extractTokensFromState,
+  extractHashesFromState,
+  extractPersistedCALFromState,
   filterExpiredTokens,
   restoreTokensToCache,
+  PERSISTENCE_VERSION,
   type TokenCurrencyRaw,
   type PersistedTokenEntry,
+  type PersistedCAL,
   type StateWithCryptoAssets,
 } from "./persistence";
 import { cryptoAssetsApi } from "./state-manager/api";
@@ -215,6 +219,24 @@ describe("Token Persistence", () => {
 
       expect(tokens).toEqual([]);
     });
+
+    it("should return empty array if no RTK Query state", () => {
+      const mockState = {} as unknown as StateWithCryptoAssets;
+
+      const tokens = extractTokensFromState(mockState);
+
+      expect(tokens).toEqual([]);
+    });
+
+    it("should return empty array if queries is undefined", () => {
+      const mockState = {
+        [cryptoAssetsApi.reducerPath]: {},
+      } as unknown as StateWithCryptoAssets;
+
+      const tokens = extractTokensFromState(mockState);
+
+      expect(tokens).toEqual([]);
+    });
   });
 
   describe("filterExpiredTokens", () => {
@@ -293,69 +315,505 @@ describe("Token Persistence", () => {
   });
 
   describe("restoreTokensToCache", () => {
-    it("should restore valid tokens to RTK Query cache", () => {
+    it("should restore valid tokens to RTK Query cache", async () => {
       const mockDispatch = jest.fn();
       const now = Date.now();
       const ttl = 24 * 60 * 60 * 1000;
 
-      const tokens: PersistedTokenEntry[] = [
-        {
-          data: toTokenCurrencyRaw(mockToken),
-          timestamp: now,
-        },
-      ];
+      const persistedData: PersistedCAL = {
+        version: PERSISTENCE_VERSION,
+        tokens: [
+          {
+            data: toTokenCurrencyRaw(mockToken),
+            timestamp: now,
+          },
+        ],
+      };
 
-      restoreTokensToCache(mockDispatch, tokens, ttl);
+      await restoreTokensToCache(mockDispatch, persistedData, ttl);
 
       // Should dispatch once with upsertQueryEntries (which contains both ID and address entries)
       expect(mockDispatch).toHaveBeenCalledTimes(1);
 
-      // upsertQueryEntries returns action objects, not functions
       expect(mockDispatch).toHaveBeenCalled();
     });
 
-    it("should skip expired tokens", () => {
+    it("should skip expired tokens", async () => {
       const mockDispatch = jest.fn();
       const now = Date.now();
       const ttl = 24 * 60 * 60 * 1000;
 
-      const tokens: PersistedTokenEntry[] = [
-        {
-          data: toTokenCurrencyRaw(mockToken),
-          timestamp: now - 25 * 60 * 60 * 1000, // Expired
-        },
-      ];
+      const persistedData: PersistedCAL = {
+        version: PERSISTENCE_VERSION,
+        tokens: [
+          {
+            data: toTokenCurrencyRaw(mockToken),
+            timestamp: now - 25 * 60 * 60 * 1000,
+          },
+        ],
+      };
 
-      restoreTokensToCache(mockDispatch, tokens, ttl);
+      await restoreTokensToCache(mockDispatch, persistedData, ttl);
 
-      // Should not dispatch anything for expired tokens
       expect(mockDispatch).not.toHaveBeenCalled();
     });
 
-    it("should skip tokens with missing parent currency", () => {
+    it("should skip tokens with missing parent currency", async () => {
       const mockDispatch = jest.fn();
       const now = Date.now();
       const ttl = 24 * 60 * 60 * 1000;
 
-      const tokens: PersistedTokenEntry[] = [
-        {
-          data: {
-            id: "unknown/token/test",
-            contractAddress: "0xabc",
-            parentCurrencyId: "unknown_currency",
-            tokenType: "erc20",
-            name: "Test",
-            ticker: "TEST",
-            units: [{ name: "TEST", code: "TEST", magnitude: 18 }],
+      const persistedData: PersistedCAL = {
+        version: PERSISTENCE_VERSION,
+        tokens: [
+          {
+            data: {
+              id: "unknown/token/test",
+              contractAddress: "0xabc",
+              parentCurrencyId: "unknown_currency",
+              tokenType: "erc20",
+              name: "Test",
+              ticker: "TEST",
+              units: [{ name: "TEST", code: "TEST", magnitude: 18 }],
+            },
+            timestamp: now,
           },
-          timestamp: now,
-        },
-      ];
+        ],
+      };
 
-      restoreTokensToCache(mockDispatch, tokens, ttl);
+      await restoreTokensToCache(mockDispatch, persistedData, ttl);
 
-      // Should not dispatch for tokens with missing parent
       expect(mockDispatch).not.toHaveBeenCalled();
     });
+
+    it("should restore tokens when hash matches", async () => {
+      const mockDispatch = jest.fn();
+      const now = Date.now();
+      const ttl = 24 * 60 * 60 * 1000;
+      const storedHash = "hash123";
+
+      mockDispatch.mockImplementation(async action => {
+        if (typeof action === "function") {
+          const thunkResult = await action(mockDispatch, () => ({}), undefined);
+          return thunkResult;
+        }
+        const actionStr = String(action);
+        if (
+          actionStr.includes("getTokensSyncHash") ||
+          (action as any)?.type?.includes("getTokensSyncHash")
+        ) {
+          return { data: storedHash, error: undefined };
+        }
+        return action;
+      });
+
+      const persistedData: PersistedCAL = {
+        version: PERSISTENCE_VERSION,
+        tokens: [
+          {
+            data: toTokenCurrencyRaw(mockToken),
+            timestamp: now,
+          },
+        ],
+        hashes: { ethereum: storedHash },
+      };
+
+      await restoreTokensToCache(mockDispatch, persistedData, ttl);
+
+      const invalidateCalls = mockDispatch.mock.calls.filter(call => {
+        const action = call[0];
+        if (!action) return false;
+        const callStr = String(action);
+        return (
+          callStr.includes("invalidateTags") || (action as any)?.type?.includes("invalidateTags")
+        );
+      });
+      expect(invalidateCalls).toHaveLength(0);
+      expect(mockDispatch).toHaveBeenCalled();
+    });
+
+    it("should skip restore when hash changed", async () => {
+      const mockDispatch = jest.fn();
+      const now = Date.now();
+      const ttl = 24 * 60 * 60 * 1000;
+      const storedHash = "hash123";
+      const currentHash = "hash456";
+      const upsertActions: any[] = [];
+
+      mockDispatch.mockImplementation(async action => {
+        if (typeof action === "function") {
+          const actionStr = String(action);
+          if (actionStr.includes("getTokensSyncHash")) {
+            return { data: currentHash, error: undefined };
+          }
+          const result = await action(mockDispatch, () => ({}), undefined);
+          return result;
+        }
+        const actionType = (action as any)?.type || "";
+        if (actionType.includes("upsertQueryEntries") || actionType.includes("upsert")) {
+          upsertActions.push(action);
+        }
+        return action;
+      });
+
+      const persistedData: PersistedCAL = {
+        version: PERSISTENCE_VERSION,
+        tokens: [
+          {
+            data: toTokenCurrencyRaw(mockToken),
+            timestamp: now,
+          },
+        ],
+        hashes: { ethereum: storedHash },
+      };
+
+      await restoreTokensToCache(mockDispatch, persistedData, ttl);
+
+      expect(upsertActions).toHaveLength(0);
+    });
+
+    it("should return early when all tokens are evicted after hash validation", async () => {
+      const mockDispatch = jest.fn();
+      const now = Date.now();
+      const ttl = 24 * 60 * 60 * 1000;
+      const storedHash = "hash123";
+      const currentHash = "hash456";
+      const upsertActions: any[] = [];
+
+      mockDispatch.mockImplementation(async action => {
+        if (typeof action === "function") {
+          const actionStr = String(action);
+          if (actionStr.includes("getTokensSyncHash")) {
+            return { data: currentHash, error: undefined };
+          }
+          const result = await action(mockDispatch, () => ({}), undefined);
+          return result;
+        }
+        const actionType = (action as any)?.type || "";
+        if (actionType.includes("upsertQueryEntries") || actionType.includes("upsert")) {
+          upsertActions.push(action);
+        }
+        return action;
+      });
+
+      const persistedData: PersistedCAL = {
+        version: PERSISTENCE_VERSION,
+        tokens: [
+          {
+            data: toTokenCurrencyRaw(mockToken),
+            timestamp: now,
+          },
+        ],
+        hashes: { ethereum: storedHash },
+      };
+
+      await restoreTokensToCache(mockDispatch, persistedData, ttl);
+
+      expect(upsertActions).toHaveLength(0);
+    });
+
+    it("should skip restore when hash fetch fails", async () => {
+      const mockDispatch = jest.fn();
+      const now = Date.now();
+      const ttl = 24 * 60 * 60 * 1000;
+      const storedHash = "hash123";
+      const upsertActions: any[] = [];
+
+      mockDispatch.mockImplementation(async action => {
+        if (typeof action === "function") {
+          const actionStr = String(action);
+          if (actionStr.includes("getTokensSyncHash")) {
+            throw new Error("Network error");
+          }
+          const result = await action(mockDispatch, () => ({}), undefined);
+          return result;
+        }
+        const actionType = (action as any)?.type || "";
+        if (actionType.includes("upsertQueryEntries") || actionType.includes("upsert")) {
+          upsertActions.push(action);
+        }
+        return action;
+      });
+
+      const persistedData: PersistedCAL = {
+        version: PERSISTENCE_VERSION,
+        tokens: [
+          {
+            data: toTokenCurrencyRaw(mockToken),
+            timestamp: now,
+          },
+        ],
+        hashes: { ethereum: storedHash },
+      };
+
+      await restoreTokensToCache(mockDispatch, persistedData, ttl);
+
+      expect(upsertActions).toHaveLength(0);
+    });
+
+    it("should restore tokens when currentHash is undefined (cannot validate)", async () => {
+      const mockDispatch = jest.fn();
+      const now = Date.now();
+      const ttl = 24 * 60 * 60 * 1000;
+      const storedHash = "hash123";
+      const upsertActions: any[] = [];
+
+      mockDispatch.mockImplementation(async action => {
+        if (typeof action === "function") {
+          const actionStr = String(action);
+          if (actionStr.includes("getTokensSyncHash")) {
+            return { data: undefined, error: undefined };
+          }
+          if (actionStr.includes("upsertQueryEntries") || actionStr.includes("upsert")) {
+            upsertActions.push(action);
+          }
+          const result = await action(mockDispatch, () => ({}), undefined);
+          return result;
+        }
+        const actionType = (action as any)?.type || "";
+        if (actionType.includes("upsertQueryEntries") || actionType.includes("upsert")) {
+          upsertActions.push(action);
+        }
+        return action;
+      });
+
+      const persistedData: PersistedCAL = {
+        version: PERSISTENCE_VERSION,
+        tokens: [
+          {
+            data: toTokenCurrencyRaw(mockToken),
+            timestamp: now,
+          },
+        ],
+        hashes: { ethereum: storedHash },
+      };
+
+      await restoreTokensToCache(mockDispatch, persistedData, ttl);
+
+      expect(upsertActions.length).toBeGreaterThan(0);
+    });
+
+    it("should restore tokens without hash (backward compatibility)", async () => {
+      const mockDispatch = jest.fn();
+      const now = Date.now();
+      const ttl = 24 * 60 * 60 * 1000;
+
+      const persistedData: PersistedCAL = {
+        version: PERSISTENCE_VERSION,
+        tokens: [
+          {
+            data: toTokenCurrencyRaw(mockToken),
+            timestamp: now,
+          },
+        ],
+        // No hashes field - old persisted data
+      };
+
+      await restoreTokensToCache(mockDispatch, persistedData, ttl);
+
+      const invalidateCalls = mockDispatch.mock.calls.filter(call => {
+        const action = call[0];
+        if (!action) return false;
+        const callStr = String(action);
+        return (
+          callStr.includes("invalidateTags") || (action as any)?.type?.includes("invalidateTags")
+        );
+      });
+      expect(invalidateCalls).toHaveLength(0);
+      expect(mockDispatch).toHaveBeenCalled();
+    });
+
+    it("should handle multiple currencies with different hash states", async () => {
+      const mockDispatch = jest.fn();
+      const now = Date.now();
+      const ttl = 24 * 60 * 60 * 1000;
+      let getHashCallCount = 0;
+      const upsertActions: any[] = [];
+
+      const polygonToken: TokenCurrency = {
+        ...mockToken,
+        id: "polygon/erc20/usdt",
+        parentCurrency: findCryptoCurrencyById("polygon")!,
+      };
+
+      mockDispatch.mockImplementation(async action => {
+        if (typeof action === "function") {
+          const actionStr = String(action);
+          if (actionStr.includes("getTokensSyncHash")) {
+            getHashCallCount++;
+            if (getHashCallCount === 2) {
+              return { data: "hash999", error: undefined };
+            }
+            return { data: "hash123", error: undefined };
+          }
+          if (actionStr.includes("upsertQueryEntries") || actionStr.includes("upsert")) {
+            upsertActions.push(action);
+          }
+          const result = await action(mockDispatch, () => ({}), undefined);
+          return result;
+        }
+        const actionType = (action as any)?.type || "";
+        if (actionType.includes("upsertQueryEntries") || actionType.includes("upsert")) {
+          upsertActions.push(action);
+        }
+        return action;
+      });
+
+      const persistedData: PersistedCAL = {
+        version: PERSISTENCE_VERSION,
+        tokens: [
+          {
+            data: toTokenCurrencyRaw(mockToken),
+            timestamp: now,
+          },
+          {
+            data: toTokenCurrencyRaw(polygonToken),
+            timestamp: now,
+          },
+        ],
+        hashes: {
+          ethereum: "hash123",
+          polygon: "hash456",
+        },
+      };
+
+      await restoreTokensToCache(mockDispatch, persistedData, ttl);
+
+      expect(upsertActions.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe("extractHashesFromState", () => {
+    it("should extract hashes from getTokensSyncHash queries", () => {
+      const mockState = {
+        [cryptoAssetsApi.reducerPath]: {
+          queries: {
+            'getTokensSyncHash("ethereum")': {
+              status: "fulfilled",
+              data: "hash123",
+              endpointName: "getTokensSyncHash",
+            },
+            'getTokensSyncHash("polygon")': {
+              status: "fulfilled",
+              data: "hash456",
+              endpointName: "getTokensSyncHash",
+            },
+          },
+        },
+      } as unknown as StateWithCryptoAssets;
+
+      const hashes = extractHashesFromState(mockState);
+
+      expect(hashes).toEqual({
+        ethereum: "hash123",
+        polygon: "hash456",
+      });
+    });
+
+    it("should return empty object when no hash queries exist", () => {
+      const mockState = {
+        [cryptoAssetsApi.reducerPath]: {
+          queries: {
+            'findTokenById({"id":"ethereum/erc20/usdt"})': {
+              status: "fulfilled",
+              data: mockToken,
+              endpointName: "findTokenById",
+            },
+          },
+        },
+      } as unknown as StateWithCryptoAssets;
+
+      const hashes = extractHashesFromState(mockState);
+
+      expect(hashes).toEqual({});
+    });
+
+    it("should return empty object if no RTK Query state", () => {
+      const mockState = {} as unknown as StateWithCryptoAssets;
+
+      const hashes = extractHashesFromState(mockState);
+
+      expect(hashes).toEqual({});
+    });
+
+    it("should return empty object if queries is undefined", () => {
+      const mockState = {
+        [cryptoAssetsApi.reducerPath]: {},
+      } as unknown as StateWithCryptoAssets;
+
+      const hashes = extractHashesFromState(mockState);
+
+      expect(hashes).toEqual({});
+    });
+  });
+
+  describe("extractPersistedCALFromState", () => {
+    it("should extract complete PersistedCAL with tokens and hashes", () => {
+      const mockState = {
+        [cryptoAssetsApi.reducerPath]: {
+          queries: {
+            'findTokenById({"id":"ethereum/erc20/usdt"})': {
+              status: "fulfilled",
+              data: mockToken,
+              endpointName: "findTokenById",
+              fulfilledTimeStamp: Date.now(),
+            },
+            'getTokensSyncHash("ethereum")': {
+              status: "fulfilled",
+              data: "hash123",
+              endpointName: "getTokensSyncHash",
+            },
+          },
+        },
+      } as unknown as StateWithCryptoAssets;
+
+      const persistedData = extractPersistedCALFromState(mockState);
+
+      expect(persistedData.version).toBe(PERSISTENCE_VERSION);
+      expect(persistedData.tokens).toHaveLength(1);
+      expect(persistedData.tokens[0].data.id).toBe("ethereum/erc20/usdt");
+      expect(persistedData.hashes).toEqual({ ethereum: "hash123" });
+    });
+
+    it("should extract PersistedCAL without hashes if none exist", () => {
+      const mockState = {
+        [cryptoAssetsApi.reducerPath]: {
+          queries: {
+            'findTokenById({"id":"ethereum/erc20/usdt"})': {
+              status: "fulfilled",
+              data: mockToken,
+              endpointName: "findTokenById",
+              fulfilledTimeStamp: Date.now(),
+            },
+          },
+        },
+      } as unknown as StateWithCryptoAssets;
+
+      const persistedData = extractPersistedCALFromState(mockState);
+
+      expect(persistedData.version).toBe(PERSISTENCE_VERSION);
+      expect(persistedData.tokens).toHaveLength(1);
+      expect(persistedData.hashes).toBeUndefined();
+    });
+
+    it("should return empty tokens array if no tokens found", () => {
+      const mockState = {
+        [cryptoAssetsApi.reducerPath]: {
+          queries: {
+            'getTokensSyncHash("ethereum")': {
+              status: "fulfilled",
+              data: "hash123",
+              endpointName: "getTokensSyncHash",
+            },
+          },
+        },
+      } as unknown as StateWithCryptoAssets;
+
+      const persistedData = extractPersistedCALFromState(mockState);
+
+      expect(persistedData.version).toBe(PERSISTENCE_VERSION);
+      expect(persistedData.tokens).toHaveLength(0);
+      expect(persistedData.hashes).toEqual({ ethereum: "hash123" });
+    });
   });
 });