feat!: partial BaseWallet tx history

BaseWallet will load only last n transactions on initial load

BREAKING CHANGE: remove BaseWallet stake pool and drep provider dependency
- add RewardAccountInfoProvider as a new BaseWallet dependency

Author: mkazlauskas

.github/workflows/continuous-integration-blockfrost-e2e.yaml

@@ -26,6 +26,8 @@ env:
   TEST_CLIENT_TX_SUBMIT_PROVIDER_PARAMS: '{"baseUrl":"http://localhost:4000/"}'
   TEST_CLIENT_UTXO_PROVIDER: 'blockfrost'
   TEST_CLIENT_UTXO_PROVIDER_PARAMS: '{"baseUrl":"http://localhost:3015"}'
+  TEST_CLIENT_REWARD_ACCOUNT_INFO_PROVIDER: 'blockfrost'
+  TEST_CLIENT_REWARD_ACCOUNT_INFO_PROVIDER_PARAMS: '{"baseUrl":"http://localhost:3015"}'
   TEST_CLIENT_STAKE_POOL_PROVIDER: 'http'
   TEST_CLIENT_STAKE_POOL_PROVIDER_PARAMS: '{"baseUrl":"http://localhost:4000/"}'
   WS_PROVIDER_URL: 'http://localhost:4100/ws'

.github/workflows/continuous-integration-e2e.yaml

@@ -28,6 +28,8 @@ env:
   TEST_CLIENT_UTXO_PROVIDER_PARAMS: '{"baseUrl":"http://localhost:4000/"}'
   TEST_CLIENT_STAKE_POOL_PROVIDER: 'http'
   TEST_CLIENT_STAKE_POOL_PROVIDER_PARAMS: '{"baseUrl":"http://localhost:4000/"}'
+  TEST_CLIENT_REWARD_ACCOUNT_INFO_PROVIDER: 'blockfrost'
+  TEST_CLIENT_REWARD_ACCOUNT_INFO_PROVIDER_PARAMS: '{"baseUrl":"http://localhost:3015"}'
   WS_PROVIDER_URL: 'http://localhost:4100/ws'
 
 on:

packages/cardano-services-client/src/RewardAccountInfoProvider/RewardAccountInfoProvider.ts

@@ -0,0 +1,142 @@
+import { Cardano, DRepProvider, RewardAccountInfoProvider, StakePoolProvider } from '@cardano-sdk/core';
+
+import { BlockfrostClient, BlockfrostProvider, fetchSequentially, isBlockfrostNotFoundError } from '../blockfrost';
+import { Logger } from 'ts-log';
+import { isNotNil } from '@cardano-sdk/util';
+import uniq from 'lodash/uniq.js';
+import type { Responses } from '@blockfrost/blockfrost-js';
+
+export type BlockfrostRewardAccountInfoProviderDependencies = {
+  client: BlockfrostClient;
+  logger: Logger;
+  stakePoolProvider: StakePoolProvider;
+  dRepProvider: DRepProvider;
+};
+
+export class BlockfrostRewardAccountInfoProvider extends BlockfrostProvider implements RewardAccountInfoProvider {
+  #dRepProvider: DRepProvider;
+  #stakePoolProvider: StakePoolProvider;
+
+  constructor({ client, logger, stakePoolProvider, dRepProvider }: BlockfrostRewardAccountInfoProviderDependencies) {
+    super(client, logger);
+    this.#dRepProvider = dRepProvider;
+    this.#stakePoolProvider = stakePoolProvider;
+  }
+
+  async rewardAccountInfo(address: Cardano.RewardAccount): Promise<Cardano.RewardAccountInfo> {
+    const [account, [lastRegistrationActivity]] = await Promise.all([
+      await this.request<Responses['account_content']>(`accounts/${address}`).catch(
+        (error): Responses['account_content'] => {
+          if (isBlockfrostNotFoundError(error)) {
+            return {
+              active: false,
+              active_epoch: null,
+              controlled_amount: '0',
+              drep_id: null,
+              pool_id: null,
+              reserves_sum: '0',
+              rewards_sum: '0',
+              stake_address: address,
+              treasury_sum: '0',
+              withdrawable_amount: '0',
+              withdrawals_sum: '0'
+            };
+          }
+          throw error;
+        }
+      ),
+      this.request<Responses['account_registration_content']>(
+        `accounts/${address}/registrations?order=desc&count=1`
+      ).catch((error: unknown) => {
+        if (isBlockfrostNotFoundError(error)) {
+          return [];
+        }
+        throw error;
+      })
+    ]);
+
+    // This provider maps 'Unregistering' into 'Unregistered',
+    // because it is expensive to discriminate between those statuses (would have to fetch tx, tip, era summaries)
+    // There is currently no logic within cardano-js-sdk that would work differently because of that.
+    const credentialStatus = account.active
+      ? Cardano.StakeCredentialStatus.Registered
+      : lastRegistrationActivity?.action === 'registered'
+      ? Cardano.StakeCredentialStatus.Registering
+      : Cardano.StakeCredentialStatus.Unregistered;
+    const rewardBalance = BigInt(account.withdrawable_amount || '0');
+
+    const [delegatee, dRepDelegatee, deposit] = await Promise.all([
+      this.#getDelegatee(address),
+      this.#getDrepDelegatee(account),
+      // This provider currently does not find other deposits (pool/drep/govaction)
+      await this.#getKeyDeposit(lastRegistrationActivity)
+    ]);
+
+    return {
+      address,
+      credentialStatus,
+      dRepDelegatee,
+      delegatee,
+      deposit,
+      rewardBalance
+    };
+  }
+
+  async delegationPortfolio(rewardAccounts: Cardano.RewardAccount[]): Promise<Cardano.Cip17DelegationPortfolio | null> {
+    // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+    rewardAccounts;
+    // TODO;
+    return null;
+  }
+
+  async #getDrepDelegatee(account: Responses['account_content']): Promise<Cardano.DRepDelegatee | undefined> {
+    if (!account.drep_id) return;
+    const dRepInfo = await this.#dRepProvider.getDRepInfo({ id: Cardano.DRepID(account.drep_id) });
+    return {
+      // TODO: always abstain or always no confidence
+      delegateRepresentative: dRepInfo
+    };
+  }
+
+  async #getKeyDeposit(lastRegistrationActivity: Responses['account_registration_content'][0] | undefined) {
+    if (!lastRegistrationActivity || lastRegistrationActivity.action === 'deregistered') {
+      return 0n;
+    }
+    const tx = await this.request<Responses['tx_content']>(`txs/${lastRegistrationActivity.tx_hash}`);
+    const block = await this.request<Responses['block_content']>(`blocks/${tx.block}`);
+    const epochParameters = await this.request<Responses['epoch_param_content']>(`epochs/${block.epoch}/parameters`);
+    return BigInt(epochParameters.key_deposit);
+  }
+
+  async #getDelegatee(address: Cardano.RewardAccount): Promise<Cardano.Delegatee | undefined> {
+    const latestEpoch = await this.request<Responses['epoch_content']>('epochs/latest');
+    const delegationHistory = await fetchSequentially<Responses['account_delegation_content'][0]>({
+      haveEnoughItems: (items) => items[items.length - 1]?.active_epoch <= latestEpoch.epoch,
+      paginationOptions: { order: 'desc' },
+      request: (paginationQueryString) => this.request(`accounts/${address}/delegations?${paginationQueryString}`)
+    });
+
+    const poolIds = [
+      delegationHistory.find(({ active_epoch }) => active_epoch <= latestEpoch.epoch)?.pool_id,
+      delegationHistory.find(({ active_epoch }) => active_epoch <= latestEpoch.epoch + 1)?.pool_id,
+      delegationHistory.find(({ active_epoch }) => active_epoch <= latestEpoch.epoch + 2)?.pool_id
+    ] as Array<Cardano.PoolId | undefined>;
+
+    const poolIdsToFetch = uniq(poolIds.filter(isNotNil));
+    if (poolIdsToFetch.length === 0) {
+      return undefined;
+    }
+
+    const stakePools = await this.#stakePoolProvider.queryStakePools({
+      filters: { identifier: { values: poolIdsToFetch.map((id) => ({ id })) } },
+      pagination: { limit: 3, startAt: 0 }
+    });
+
+    const stakePoolMathingPoolId = (index: number) => stakePools.pageResults.find((pool) => pool.id === poolIds[index]);
+    return {
+      currentEpoch: stakePoolMathingPoolId(0),
+      nextEpoch: stakePoolMathingPoolId(1),
+      nextNextEpoch: stakePoolMathingPoolId(2)
+    };
+  }
+}

packages/cardano-services-client/src/RewardAccountInfoProvider/index.ts

@@ -0,0 +1 @@
+export * from './RewardAccountInfoProvider';

packages/cardano-services-client/src/RewardsProvider/BlockfrostRewardsProvider.ts

@@ -31,7 +31,7 @@ export class BlockfrostRewardsProvider extends BlockfrostProvider implements Rew
     }: Range<Cardano.EpochNo> = {}
   ): Promise<Reward[]> {
     const batchSize = 100;
-    return fetchSequentially<Reward, Responses['account_reward_content'][0]>({
+    return fetchSequentially<Responses['account_reward_content'][0], Reward>({
       haveEnoughItems: (_, rewardsPage) => {
         const lastReward = rewardsPage[rewardsPage.length - 1];
         return !lastReward || lastReward.epoch >= upperBound;

packages/cardano-services-client/src/blockfrost/util.ts

@@ -22,7 +22,7 @@ const buildQueryString = ({ page, count, order }: PaginationOptions) => {
 };
 
 // copied from @cardano-sdk/cardano-services and updated to use custom blockfrost client instead of blockfrost-js
-export const fetchSequentially = async <Item, Response>(
+export const fetchSequentially = async <Response, Item = Response>(
   props: {
     request: (paginationQueryString: string) => Promise<Response[]>;
     responseTranslator?: (response: Response[]) => Item[];
@@ -42,7 +42,7 @@ export const fetchSequentially = async <Item, Response>(
     const newAccumulatedItems = [...accumulated, ...maybeTranslatedResponse] as Item[];
     const haveEnoughItems = props.haveEnoughItems?.(newAccumulatedItems, response);
     if (response.length === count && !haveEnoughItems) {
-      return fetchSequentially<Item, Response>(props, page + 1, newAccumulatedItems);
+      return fetchSequentially<Response, Item>(props, page + 1, newAccumulatedItems);
     }
     return newAccumulatedItems;
   } catch (error) {

packages/cardano-services-client/src/index.ts

@@ -6,6 +6,7 @@ export * from './StakePoolProvider';
 export * from './UtxoProvider';
 export * from './ChainHistoryProvider';
 export * from './DRepProvider';
+export * from './RewardAccountInfoProvider';
 export * from './NetworkInfoProvider';
 export * from './RewardsProvider';
 export * from './HandleProvider';

packages/core/src/Provider/RewardAccountInfoProvider/index.ts

@@ -0,0 +1 @@
+export * from './types';

packages/core/src/Provider/RewardAccountInfoProvider/types.ts

@@ -0,0 +1,6 @@
+import { Cardano, Provider } from '../..';
+
+export interface RewardAccountInfoProvider extends Provider {
+  rewardAccountInfo(rewardAccount: Cardano.RewardAccount): Promise<Cardano.RewardAccountInfo>;
+  delegationPortfolio(rewardAccounts: Cardano.RewardAccount[]): Promise<Cardano.Cip17DelegationPortfolio | null>;
+}

packages/core/src/Provider/index.ts

@@ -2,6 +2,7 @@ export * from './Provider';
 export * from './StakePoolProvider';
 export * from './AssetProvider';
 export * from './NetworkInfoProvider';
+export * from './RewardAccountInfoProvider';
 export * from './RewardsProvider';
 export * from './TxSubmitProvider';
 export * as ProviderUtil from './providerUtil';