fixup! feat: asset tracker now uses local cache before fetching asset metadata

Author: AngelCastilloB

packages/wallet/src/services/AssetsTracker.ts

@@ -71,7 +71,7 @@ const splitCachedAndUncachedAssets = (
 
       if (!isInBalance(id, balance)) {
         cachedAssets.set(id, cachedAssetInfo);
-      } else if (staleAt && new Date(staleAt) < now) {
+      } else if (staleAt && new Date(staleAt) >= now) {
         cachedAssets.set(id, cachedAssetInfo);
       } else {
         uncachedAssetIds.push(id);
@@ -96,7 +96,7 @@ export const createAssetService =
   ) =>
   (assetIds: Cardano.AssetId[]) =>
     combineLatest([assetCache$, totalBalance$]).pipe(
-      take(1), // Take only the first combination of emissions
+      take(1),
       switchMap(([cache, totalValue]) => {
         const { cachedAssets, uncachedAssetIds } = splitCachedAndUncachedAssets(cache, totalValue, assetIds);
 

packages/wallet/test/services/AssetsTracker.test.ts

@@ -10,7 +10,7 @@ import {
   createAssetsTracker
 } from '../../src/services';
 
-import { Observable, from, lastValueFrom, map, of, take, tap } from 'rxjs';
+import { Observable, from, lastValueFrom, of, tap } from 'rxjs';
 import { RetryBackoffConfig } from 'backoff-rxjs';
 
 const createTxWithValues = (values: Partial<Cardano.Value>[]): Cardano.HydratedTx =>
@@ -32,6 +32,8 @@ const cip68AssetId = {
   )
 };
 
+const ONE_WEEK = 7 * 24 * 60 * 60 * 1000;
+
 const assetInfo = {
   PXL: { assetId: AssetId.PXL, nftMetadata: { name: 'nft' }, tokenMetadata: null } as Asset.AssetInfo,
   TSLA: { assetId: AssetId.TSLA, nftMetadata: null, tokenMetadata: null } as Asset.AssetInfo,
@@ -406,8 +408,8 @@ describe('createAssetService', () => {
   it('returns cached assets if all assets are fresh', () => {
     createTestScheduler().run(({ cold, expectObservable, flush }) => {
       const cachedAssets = new Map([
-        [AssetId.TSLA, { assetId: AssetId.TSLA, staleAt: new Date() } as never],
-        [AssetId.PXL, { assetId: AssetId.PXL, staleAt: new Date() } as never]
+        [AssetId.TSLA, { assetId: AssetId.TSLA, staleAt: new Date(Date.now() + ONE_WEEK) } as never],
+        [AssetId.PXL, { assetId: AssetId.PXL, staleAt: new Date(Date.now() + ONE_WEEK) } as never]
       ]);
 
       (assetProvider.getAssets as jest.Mock).mockImplementation(() => of([]));
@@ -447,10 +449,12 @@ describe('createAssetService', () => {
 
   it('fetches uncached assets from the provider', () => {
     createTestScheduler().run(({ cold, expectObservable, flush }) => {
-      const cachedAssets = new Map([[AssetId.TSLA, { assetId: AssetId.TSLA, staleAt: new Date() } as never]]);
+      const cachedAssets = new Map([
+        [AssetId.TSLA, { assetId: AssetId.TSLA, staleAt: new Date(Date.now() + ONE_WEEK) } as never]
+      ]);
       const fetchedAssets = [
-        { assetId: AssetId.PXL, nftMetadata: null },
-        { assetId: AssetId.Unit, nftMetadata: null }
+        { assetId: AssetId.PXL, nftMetadata: null, tokenMetadata: null },
+        { assetId: AssetId.Unit, nftMetadata: null, tokenMetadata: null }
       ];
 
       (assetProvider.getAssets as jest.Mock).mockImplementation(() => of(fetchedAssets));
@@ -466,21 +470,13 @@ describe('createAssetService', () => {
         onFatalError
       );
 
-      const result$ = assetService([AssetId.TSLA, AssetId.PXL, AssetId.Unit]).pipe(
-        take(1),
-        map((assets) =>
-          assets.map((asset) => ({
-            ...asset,
-            staleAt: 'normalized'
-          }))
-        )
-      );
+      const result$ = assetService([AssetId.TSLA, AssetId.PXL, AssetId.Unit]);
 
       expectObservable(result$).toBe('(a|)', {
         a: [
-          { assetId: AssetId.TSLA, staleAt: 'normalized' },
-          { assetId: AssetId.PXL, nftMetadata: null, staleAt: 'normalized' },
-          { assetId: AssetId.Unit, nftMetadata: null, staleAt: 'normalized' }
+          { assetId: AssetId.TSLA, staleAt: expect.any(Date) },
+          { assetId: AssetId.PXL, nftMetadata: null, staleAt: expect.any(Date), tokenMetadata: null },
+          { assetId: AssetId.Unit, nftMetadata: null, staleAt: expect.any(Date), tokenMetadata: null }
         ]
       });
 
@@ -491,8 +487,8 @@ describe('createAssetService', () => {
   it('handles an empty cache and fetches all assets', () => {
     createTestScheduler().run(({ cold, expectObservable, flush }) => {
       const fetchedAssets = [
-        { assetId: AssetId.TSLA, nftMetadata: null },
-        { assetId: AssetId.PXL, nftMetadata: null }
+        { assetId: AssetId.TSLA, nftMetadata: null, tokenMetadata: null },
+        { assetId: AssetId.PXL, nftMetadata: null, tokenMetadata: null }
       ];
 
       (assetProvider.getAssets as jest.Mock).mockImplementation(() => of(fetchedAssets));
@@ -508,25 +504,87 @@ describe('createAssetService', () => {
         onFatalError
       );
 
-      const result$ = assetService([AssetId.TSLA, AssetId.PXL]).pipe(
-        take(1),
-        // eslint-disable-next-line sonarjs/no-identical-functions
-        map((assets) =>
-          assets.map((asset) => ({
-            ...asset,
-            staleAt: 'normalized'
-          }))
-        )
+      const result$ = assetService([AssetId.TSLA, AssetId.PXL]);
+
+      expectObservable(result$).toBe('(a|)', {
+        a: [
+          { assetId: AssetId.TSLA, nftMetadata: null, staleAt: expect.any(Date), tokenMetadata: null },
+          { assetId: AssetId.PXL, nftMetadata: null, staleAt: expect.any(Date), tokenMetadata: null }
+        ]
+      });
+
+      flush();
+    });
+  });
+
+  it('fetches stale assets from the provider', () => {
+    createTestScheduler().run(({ cold, expectObservable, flush }) => {
+      const cachedAssets = new Map([
+        // Stale
+        [
+          AssetId.TSLA,
+          {
+            assetId: AssetId.TSLA,
+            nftMetadata: { name: 'tsla_cached_name' },
+            staleAt: new Date(Date.now() - ONE_WEEK)
+          } as never
+        ],
+        // Fresh
+        [
+          AssetId.PXL,
+          {
+            assetId: AssetId.PXL,
+            nftMetadata: { name: 'pxl_cached_name' },
+            staleAt: new Date(Date.now() + ONE_WEEK)
+          } as never
+        ]
+      ]);
+
+      const fetchedAssets = [
+        { assetId: AssetId.TSLA, nftMetadata: { name: 'tsla_updated_name' }, tokenMetadata: null }
+      ];
+
+      (assetProvider.getAssets as jest.Mock).mockImplementation((args: { assetIds: Cardano.AssetId[] }) => {
+        expect(args.assetIds).toEqual([AssetId.TSLA]); // Only stale asset should be requested
+        return of(fetchedAssets);
+      });
+
+      const assetCache$ = cold('(a|)', { a: cachedAssets });
+      const totalBalance$ = cold('(a|)', {
+        a: {
+          assets: new Map([
+            [AssetId.TSLA, 1000n],
+            [AssetId.PXL, 1000n]
+          ]),
+          coins: 0n
+        }
+      });
+
+      const assetService = createAssetService(
+        assetProvider,
+        assetCache$,
+        totalBalance$,
+        retryBackoffConfig,
+        onFatalError
       );
 
+      const result$ = assetService([AssetId.TSLA, AssetId.PXL]);
+
       expectObservable(result$).toBe('(a|)', {
         a: [
-          { assetId: AssetId.TSLA, nftMetadata: null, staleAt: 'normalized' },
-          { assetId: AssetId.PXL, nftMetadata: null, staleAt: 'normalized' }
+          { assetId: AssetId.PXL, nftMetadata: { name: 'pxl_cached_name' }, staleAt: expect.any(Date) },
+          {
+            assetId: AssetId.TSLA,
+            nftMetadata: { name: 'tsla_updated_name' },
+            staleAt: expect.any(Date),
+            tokenMetadata: null
+          }
         ]
       });
 
       flush();
+
+      expect(assetProvider.getAssets).toHaveBeenCalledTimes(1);
     });
   });
 });