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

AngelCastilloB · AngelCastilloB · commit 383085ec87b5 · 2024-12-04T18:01:25.000+08:00
diff --git a/packages/core/src/Asset/types/AssetInfo.ts b/packages/core/src/Asset/types/AssetInfo.ts
@@ -25,4 +25,5 @@ export interface AssetInfo {
   tokenMetadata?: TokenMetadata | null;
   /** CIP-0025. `undefined` if not loaded, `null` if no metadata found */
   nftMetadata?: NftMetadata | null;
+  staleAt?: Date | null;
 }
diff --git a/packages/wallet/src/Wallets/BaseWallet.ts b/packages/wallet/src/Wallets/BaseWallet.ts
@@ -22,6 +22,7 @@ import {
   DelegationTracker,
   DynamicChangeAddressResolver,
   FailedTx,
+  Milliseconds,
   OutgoingTx,
   PersistentDocumentTrackerSubject,
   PollingConfig,
@@ -78,6 +79,8 @@ import {
   Subject,
   Subscription,
   catchError,
+  defaultIfEmpty,
+  defer,
   distinctUntilChanged,
   filter,
   firstValueFrom,
@@ -116,6 +119,7 @@ export interface BaseWalletProps {
   readonly name: string;
   readonly polling?: PollingConfig;
   readonly retryBackoffConfig?: RetryBackoffConfig;
+  readonly maxAssetInfoCacheAge?: Milliseconds;
 }
 
 export enum PublicCredentialsManagerType {
@@ -295,6 +299,7 @@ export class BaseWallet implements ObservableWallet {
   constructor(
     {
       name,
+      maxAssetInfoCacheAge,
       polling: {
         interval: pollInterval = DEFAULT_POLLING_CONFIG.pollInterval,
         maxInterval = pollInterval * DEFAULT_POLLING_CONFIG.maxIntervalMultiplier,
@@ -564,10 +569,17 @@ export class BaseWallet implements ObservableWallet {
       : new TrackerSubject(of(new Array<PubStakeKeyAndStatus>()));
 
     this.balance = createBalanceTracker(this.protocolParameters$, this.utxo, this.delegation);
+
+    // TODO[LW-11929]: Implement `observe` method in DocumentStore interface.
+    const assetsCache$ = defer(() => stores.assets.get().pipe(defaultIfEmpty(new Map())));
+
     this.assetInfo$ = new PersistentDocumentTrackerSubject(
       createAssetsTracker({
         assetProvider: this.assetProvider,
+        assetsCache$,
+        balanceTracker: this.balance,
         logger: contextLogger(this.#logger, 'assets$'),
+        maxAssetInfoCacheAge,
         onFatalError,
         retryBackoffConfig,
         transactionsTracker: this.transactions
diff --git a/packages/wallet/src/services/AssetsTracker.ts b/packages/wallet/src/services/AssetsTracker.ts
@@ -1,4 +1,6 @@
 import { Asset, Cardano } from '@cardano-sdk/core';
+import { Assets } from '../types';
+import { BalanceTracker, Milliseconds, TransactionsTracker } from './types';
 import { Logger } from 'ts-log';
 import {
   Observable,
@@ -8,6 +10,7 @@ import {
   debounceTime,
   distinctUntilChanged,
   filter,
+  firstValueFrom,
   map,
   of,
   share,
@@ -17,7 +20,6 @@ import {
 } from 'rxjs';
 import { RetryBackoffConfig } from 'backoff-rxjs';
 import { TrackedAssetProvider } from './ProviderTracker';
-import { TransactionsTracker } from './types';
 import { coldObservableProvider, concatAndCombineLatest } from '@cardano-sdk/util-rxjs';
 import { deepEquals, isNotNil } from '@cardano-sdk/util';
 import { newTransactions$ } from './TransactionsTracker';
@@ -35,11 +37,102 @@ const bufferTick =
     source$.pipe(connect((shared$) => shared$.pipe(buffer(shared$.pipe(debounceTime(1))))));
 
 const ASSET_INFO_FETCH_CHUNK_SIZE = 100;
+const ONE_WEEK = 7 * 24 * 60 * 60 * 1000;
+
+const isInBalance = (assetId: Cardano.AssetId, balance: Cardano.Value): boolean =>
+  balance.assets?.has(assetId) ?? false;
+
+/**
+ * Splits a list of asset IDs into cached and uncached groups based on their presence in the cache,
+ * their freshness, and their balance status:
+ *
+ * 1. Assets not in Balance:
+ *    - Always use the cached version if present in the cache, ignoring freshness.
+ * 2. Assets in Balance:
+ *    - Use the cached version only if it exists and its `staleAt` timestamp already expired.
+ * 3. Uncached Assets:
+ *    - If an asset is not in the cache or does not meet the above criteria, mark it as uncached.
+ */
+const splitCachedAndUncachedAssets = (
+  cache: Assets,
+  balance: Cardano.Value,
+  assetIds: Cardano.AssetId[]
+): { cachedAssets: Assets; uncachedAssetIds: Cardano.AssetId[] } => {
+  const cachedAssets: Assets = new Map();
+  const uncachedAssetIds: Cardano.AssetId[] = [];
+  const now = new Date();
+
+  for (const id of assetIds) {
+    const cachedAssetInfo = cache.get(id);
+
+    if (!cachedAssetInfo) {
+      uncachedAssetIds.push(id);
+      continue;
+    }
+
+    const { staleAt } = cachedAssetInfo;
+
+    const expired = !staleAt || new Date(staleAt) < now;
+
+    const mustFetch = !isAssetInfoComplete(cachedAssetInfo) || (isInBalance(id, balance) && expired);
+
+    if (mustFetch) {
+      uncachedAssetIds.push(id);
+    } else {
+      cachedAssets.set(id, cachedAssetInfo);
+    }
+  }
+
+  return { cachedAssets, uncachedAssetIds };
+};
+
+const getAssetsWithCache = async (
+  assetIdsChunk: Cardano.AssetId[],
+  assetCache$: Observable<Assets>,
+  totalBalance$: Observable<Cardano.Value>,
+  assetProvider: TrackedAssetProvider,
+  maxAssetInfoCacheAge: Milliseconds
+): Promise<Asset.AssetInfo[]> => {
+  const [cache, totalValue] = await Promise.all([firstValueFrom(assetCache$), firstValueFrom(totalBalance$)]);
+
+  const { cachedAssets, uncachedAssetIds } = splitCachedAndUncachedAssets(cache, totalValue, assetIdsChunk);
+
+  if (uncachedAssetIds.length === 0) {
+    // If all assets are cached we wont perform any fetches from assetProvider, but still need to
+    // mark it as initialized.
+    if (!assetProvider.stats.getAsset$.value.initialized) {
+      assetProvider.setStatInitialized(assetProvider.stats.getAsset$);
+    }
+
+    return [...cachedAssets.values()];
+  }
+
+  const fetchedAssets = await assetProvider.getAssets({
+    assetIds: uncachedAssetIds,
+    extraData: { nftMetadata: true, tokenMetadata: true }
+  });
+
+  const now = Date.now();
+  const updatedFetchedAssets = fetchedAssets.map((asset) => {
+    const randomDelta = Math.floor(Math.random() * 2 * 24 * 60 * 60 * 1000); // Random time between 0 and 2 days
+    return {
+      ...asset,
+      staleAt: new Date(now + maxAssetInfoCacheAge + randomDelta)
+    };
+  });
+
+  return [...cachedAssets.values(), ...updatedFetchedAssets];
+};
+
 export const createAssetService =
   (
     assetProvider: TrackedAssetProvider,
+    assetCache$: Observable<Assets>,
+    totalBalance$: Observable<Cardano.Value>,
     retryBackoffConfig: RetryBackoffConfig,
-    onFatalError?: (value: unknown) => void
+    onFatalError?: (value: unknown) => void,
+    maxAssetInfoCacheAge: Milliseconds = ONE_WEEK
+    // eslint-disable-next-line max-params
   ) =>
   (assetIds: Cardano.AssetId[]) =>
     concatAndCombineLatest(
@@ -48,23 +141,24 @@ export const createAssetService =
           onFatalError,
           pollUntil: isEveryAssetInfoComplete,
           provider: () =>
-            assetProvider.getAssets({
-              assetIds: assetIdsChunk,
-              extraData: { nftMetadata: true, tokenMetadata: true }
-            }),
+            getAssetsWithCache(assetIdsChunk, assetCache$, totalBalance$, assetProvider, maxAssetInfoCacheAge),
           retryBackoffConfig,
           trigger$: of(true) // fetch only once
         })
       )
-    ).pipe(map((arr) => arr.flat())); // concat the chunk results
+    ).pipe(map((arr) => arr.flat())); // Concatenate the chunk results
+
 export type AssetService = ReturnType<typeof createAssetService>;
 
 export interface AssetsTrackerProps {
   transactionsTracker: TransactionsTracker;
   assetProvider: TrackedAssetProvider;
   retryBackoffConfig: RetryBackoffConfig;
   logger: Logger;
+  assetsCache$: Observable<Assets>;
+  balanceTracker: BalanceTracker;
   onFatalError?: (value: unknown) => void;
+  maxAssetInfoCacheAge?: Milliseconds;
 }
 
 interface AssetsTrackerInternals {
@@ -76,8 +170,28 @@ const uniqueAssetIds = ({ body: { outputs } }: Cardano.OnChainTx) =>
 const flatUniqueAssetIds = (txes: Cardano.OnChainTx[]) => uniq(txes.flatMap(uniqueAssetIds));
 
 export const createAssetsTracker = (
-  { assetProvider, transactionsTracker: { history$ }, retryBackoffConfig, logger, onFatalError }: AssetsTrackerProps,
-  { assetService = createAssetService(assetProvider, retryBackoffConfig, onFatalError) }: AssetsTrackerInternals = {}
+  {
+    assetProvider,
+    assetsCache$,
+    transactionsTracker: { history$ },
+    balanceTracker: {
+      utxo: { total$ }
+    },
+    retryBackoffConfig,
+    logger,
+    onFatalError,
+    maxAssetInfoCacheAge
+  }: AssetsTrackerProps,
+  {
+    assetService = createAssetService(
+      assetProvider,
+      assetsCache$,
+      total$,
+      retryBackoffConfig,
+      onFatalError,
+      maxAssetInfoCacheAge
+    )
+  }: AssetsTrackerInternals = {}
 ) =>
   new Observable<Map<Cardano.AssetId, Asset.AssetInfo>>((subscriber) => {
     let fetchedAssetInfoMap = new Map<Cardano.AssetId, Asset.AssetInfo>();
diff --git a/packages/wallet/test/PersonalWallet/load.test.ts b/packages/wallet/test/PersonalWallet/load.test.ts
@@ -12,14 +12,7 @@ import {
 } from '../../src';
 import { AddressType, AsyncKeyAgent, Bip32Account, GroupedAddress, util } from '@cardano-sdk/key-management';
 import {
-  AssetId,
-  createStubStakePoolProvider,
-  generateRandomBigInt,
-  generateRandomHexString,
-  mockProviders as mocks,
-  somePartialStakePools
-} from '@cardano-sdk/util-dev';
-import {
+  Asset,
   Cardano,
   ChainHistoryProvider,
   HandleProvider,
@@ -28,6 +21,14 @@ import {
   UtxoProvider,
   coalesceValueQuantities
 } from '@cardano-sdk/core';
+import {
+  AssetId,
+  createStubStakePoolProvider,
+  generateRandomBigInt,
+  generateRandomHexString,
+  mockProviders as mocks,
+  somePartialStakePools
+} from '@cardano-sdk/util-dev';
 import { InvalidConfigurationError } from '@cardano-sdk/tx-construction';
 import { InvalidStringError } from '@cardano-sdk/util';
 import { ReplaySubject, firstValueFrom } from 'rxjs';
@@ -142,6 +143,9 @@ const createWallet = async (props: CreateWalletProps) => {
   );
 };
 
+const removeStaleAt = (assetInfos: Map<Cardano.AssetId, Asset.AssetInfo>) =>
+  new Map([...assetInfos.entries()].map(([key, value]) => [key, { ...value, staleAt: undefined }]));
+
 const assertWalletProperties = async (
   wallet: BaseWallet,
   expectedDelegateeId: Cardano.PoolId | undefined,
@@ -188,7 +192,7 @@ const assertWalletProperties = async (
   expect(rewardAccounts[0].delegatee?.nextNextEpoch?.id).toEqual(expectedDelegateeId);
   expect(rewardAccounts[0].rewardBalance).toBe(mocks.rewardAccountBalance);
   // assets$
-  expect(await firstValueFrom(wallet.assetInfo$)).toEqual(
+  expect(removeStaleAt(await firstValueFrom(wallet.assetInfo$))).toEqual(
     new Map([
       [AssetId.TSLA, mocks.asset],
       [handleAssetId, handleAssetInfo]
diff --git a/packages/wallet/test/PersonalWallet/shutdown.test.ts b/packages/wallet/test/PersonalWallet/shutdown.test.ts
@@ -1,6 +1,15 @@
 /* eslint-disable max-statements */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { AddressType, Bip32Account, GroupedAddress, util } from '@cardano-sdk/key-management';
+import {
+  Asset,
+  Cardano,
+  ChainHistoryProvider,
+  NetworkInfoProvider,
+  RewardsProvider,
+  UtxoProvider,
+  coalesceValueQuantities
+} from '@cardano-sdk/core';
 import {
   AssetId,
   createStubStakePoolProvider,
@@ -15,14 +24,6 @@ import {
   WalletNetworkInfoProviderStats,
   createPersonalWallet
 } from '../../src';
-import {
-  Cardano,
-  ChainHistoryProvider,
-  NetworkInfoProvider,
-  RewardsProvider,
-  UtxoProvider,
-  coalesceValueQuantities
-} from '@cardano-sdk/core';
 import { WalletStores, createInMemoryWalletStores } from '../../src/persistence';
 import { firstValueFrom } from 'rxjs';
 import { dummyLogger as logger } from 'ts-log';
@@ -81,6 +82,9 @@ const createWallet = async (stores: WalletStores, providers: Providers, pollingC
   );
 };
 
+const removeStaleAt = (assetInfos: Map<Cardano.AssetId, Asset.AssetInfo>) =>
+  new Map([...assetInfos.entries()].map(([key, value]) => [key, { ...value, staleAt: undefined }]));
+
 const assertWalletProperties = async (
   wallet: BaseWallet,
   expectedDelegateeId: Cardano.PoolId | undefined,
@@ -126,7 +130,7 @@ const assertWalletProperties = async (
   expect(addresses[0].address).toEqual(address);
   expect(addresses[0].rewardAccount).toEqual(rewardAccount);
   // assets$
-  expect(await firstValueFrom(wallet.assetInfo$)).toEqual(
+  expect(removeStaleAt(await firstValueFrom(wallet.assetInfo$))).toEqual(
     new Map([
       [AssetId.TSLA, mocks.asset],
       [mocks.handleAssetId, mocks.handleAssetInfo]
diff --git a/packages/wallet/test/services/AssetsTracker.test.ts b/packages/wallet/test/services/AssetsTracker.test.ts

Original file line number	Diff line number	Diff line change
`@@ -25,4 +25,5 @@ export interface AssetInfo {`
`25`	`25`	`tokenMetadata?: TokenMetadata \| null;`
`26`	`26`	/** CIP-0025. `undefined` if not loaded, `null` if no metadata found */
`27`	`27`	`nftMetadata?: NftMetadata \| null;`
	`28`	`+ staleAt?: Date \| null;`
`28`	`29`	`}`