fix(wallet): stop querying the StakePoolProvider for all pools when…

… no delegation certs found

This fix stops the observable returned from `createQueryStakePoolsProvider` querying the
`StakePoolProvider` if an empty array of pool IDs is passed, as this indicates no data is
required, rather than all.

DelegateeTracker now takes in a TrackedStakePoolProvider in order to be
able to set 'queryStakePools' as 'initialized' when it doesn't need to
make any requests (wallet not delegated)

packages/wallet/src/services/DelegationTracker/DelegationTracker.ts

@@ -1,11 +1,4 @@
-import {
-  Cardano,
-  ChainHistoryProvider,
-  SlotEpochCalc,
-  StakePoolProvider,
-  TimeSettings,
-  createSlotEpochCalc
-} from '@cardano-sdk/core';
+import { Cardano, ChainHistoryProvider, SlotEpochCalc, TimeSettings, createSlotEpochCalc } from '@cardano-sdk/core';
 import { DelegationTracker, TransactionsTracker } from '../types';
 import { Observable, combineLatest, map } from 'rxjs';
 import {
@@ -18,7 +11,7 @@ import {
 import { RetryBackoffConfig } from 'backoff-rxjs';
 import { RewardsHistoryProvider, createRewardsHistoryProvider, createRewardsHistoryTracker } from './RewardsHistory';
 import { Shutdown } from '@cardano-sdk/util';
-import { TrackedRewardsProvider } from '../ProviderTracker';
+import { TrackedRewardsProvider, TrackedStakePoolProvider } from '../ProviderTracker';
 import { TrackerSubject } from '@cardano-sdk/util-rxjs';
 import { TxWithEpoch } from './types';
 import { WalletStores } from '../../persistence';
@@ -38,7 +31,7 @@ export type BlockEpochProvider = ReturnType<typeof createBlockEpochProvider>;
 export interface DelegationTrackerProps {
   rewardsTracker: TrackedRewardsProvider;
   rewardAccountAddresses$: Observable<Cardano.RewardAccount[]>;
-  stakePoolProvider: StakePoolProvider;
+  stakePoolProvider: TrackedStakePoolProvider;
   timeSettings$: Observable<TimeSettings[]>;
   epoch$: Observable<Cardano.Epoch>;
   transactionsTracker: TransactionsTracker;

packages/wallet/src/services/DelegationTracker/RewardAccounts.ts

@@ -1,15 +1,16 @@
 /* eslint-disable unicorn/no-nested-ternary */
 import { BigIntMath, isNotNil } from '@cardano-sdk/util';
-import { Cardano, RewardsProvider, StakePoolProvider } from '@cardano-sdk/core';
+import { Cardano, RewardsProvider } from '@cardano-sdk/core';
 import { Delegatee, RewardAccount, StakeKeyStatus } from '../types';
 import { KeyValueStore } from '../../persistence';
-import { Observable, combineLatest, concat, distinctUntilChanged, filter, map, merge, switchMap, tap } from 'rxjs';
+import { Observable, combineLatest, concat, distinctUntilChanged, filter, map, merge, of, switchMap, tap } from 'rxjs';
 import {
   RegAndDeregCertificateTypes,
   includesAnyCertificate,
   isLastStakeKeyCertOfType
 } from './transactionCertificates';
 import { RetryBackoffConfig } from 'backoff-rxjs';
+import { TrackedStakePoolProvider } from '../ProviderTracker';
 import { TxWithEpoch } from './types';
 import { coldObservableProvider, deepEquals, shallowArrayEquals } from '../util';
 import findLast from 'lodash/findLast';
@@ -18,12 +19,16 @@ import uniq from 'lodash/uniq';
 
 export const createQueryStakePoolsProvider =
   (
-    stakePoolProvider: StakePoolProvider,
+    stakePoolProvider: TrackedStakePoolProvider,
     store: KeyValueStore<Cardano.PoolId, Cardano.StakePool>,
     retryBackoffConfig: RetryBackoffConfig
   ) =>
-  (poolIds: Cardano.PoolId[]) =>
-    merge(
+  (poolIds: Cardano.PoolId[]) => {
+    if (poolIds.length === 0) {
+      stakePoolProvider.setStatInitialized(stakePoolProvider.stats.queryStakePools$);
+      return of([]);
+    }
+    return merge(
       store.getValues(poolIds),
       coldObservableProvider({
         provider: () =>
@@ -41,6 +46,7 @@ export const createQueryStakePoolsProvider =
         })
       )
     );
+  };
 export type ObservableStakePoolProvider = ReturnType<typeof createQueryStakePoolsProvider>;
 
 const getWithdrawalQuantity = (
@@ -169,7 +175,8 @@ export const createDelegateeTracker = (
   combineLatest([certificates$, epoch$]).pipe(
     switchMap(([transactions, lastEpoch]) => {
       const stakePoolIds = [lastEpoch + 1, lastEpoch + 2, lastEpoch + 3].map(getStakePoolIdAtEpoch(transactions));
-      return stakePoolProvider(uniq(stakePoolIds.filter(isNotNil))).pipe(
+      const uniqStakePoolIds = uniq(stakePoolIds.filter(isNotNil));
+      return stakePoolProvider(uniqStakePoolIds).pipe(
         map((stakePools) => stakePoolIds.map((poolId) => stakePools.find((pool) => pool.id === poolId) || undefined)),
         map(([currentEpoch, nextEpoch, nextNextEpoch]) => ({ currentEpoch, nextEpoch, nextNextEpoch }))
       );

packages/wallet/test/services/DelegationTracker/RewardAccounts.test.ts

@@ -3,13 +3,15 @@
 /* eslint-disable prettier/prettier */
 import { Cardano, RewardsProvider } from '@cardano-sdk/core';
 import { EMPTY, Observable, of } from 'rxjs';
-import { KeyValueStore } from '../../../src/persistence';
+import { InMemoryStakePoolsStore, KeyValueStore } from '../../../src/persistence';
 import { RetryBackoffConfig } from 'backoff-rxjs';
 import {
   StakeKeyStatus,
+  TrackedStakePoolProvider,
   addressKeyStatuses,
   addressRewards,
   createDelegateeTracker,
+  createQueryStakePoolsProvider,
   createRewardsProvider,
   fetchRewardsTrigger$,
   getStakePoolIdAtEpoch
@@ -258,5 +260,41 @@ describe('RewardAccounts', () => {
         expect(stakePoolProvider).toBeCalledWith([poolId1, poolId2]);
       });
     });
+
+    test('does not query the StakePoolProvider when there are no delegations certs provided', () => {
+      createTestScheduler().run(({ cold, expectObservable, flush }) => {
+        const epoch$ = cold('-a', { a: currentEpoch.number });
+        const trackedStakePoolProvider = {
+          queryStakePools: jest.fn(),
+          setStatInitialized: jest.fn(),
+          stats: { queryStakePools$: {} }
+        };
+        const observableStakePoolProvider = createQueryStakePoolsProvider(
+          trackedStakePoolProvider as unknown as TrackedStakePoolProvider,
+          new InMemoryStakePoolsStore(),
+          { initialInterval: 10 }
+        );
+        const target$ = createDelegateeTracker(
+          observableStakePoolProvider,
+          epoch$,
+          cold('a', {
+            a: []
+          })
+        );
+        expectObservable(target$).toBe('-a', {
+          a: {
+            currentEpoch: undefined,
+            nextEpoch: undefined,
+            nextNextEpoch: undefined
+          }
+        });
+        flush();
+        expect(trackedStakePoolProvider.queryStakePools).toBeCalledTimes(0);
+        expect(trackedStakePoolProvider.setStatInitialized).toBeCalledTimes(1);
+        expect(trackedStakePoolProvider.setStatInitialized).toBeCalledWith(
+          trackedStakePoolProvider.stats.queryStakePools$
+        );
+      });
+    });
   });
 });