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

.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,191 @@
+import { Cardano, DRepProvider, RewardAccountInfoProvider, Serialization, StakePoolProvider } from '@cardano-sdk/core';
+
+import { BlockfrostClient, BlockfrostProvider, fetchSequentially, isBlockfrostNotFoundError } from '../blockfrost';
+import { HexBlob, isNotNil } from '@cardano-sdk/util';
+import { Logger } from 'ts-log';
+import uniq from 'lodash/uniq.js';
+import type { Responses } from '@blockfrost/blockfrost-js';
+
+export type BlockfrostRewardAccountInfoProviderDependencies = {
+  client: BlockfrostClient;
+  logger: Logger;
+  stakePoolProvider: StakePoolProvider;
+  dRepProvider: DRepProvider;
+};
+
+const emptyArrayIfNotFound = (error: unknown) => {
+  if (isBlockfrostNotFoundError(error)) {
+    return [];
+  }
+  throw error;
+};
+
+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], latestEpoch] = 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(emptyArrayIfNotFound),
+      this.request<Responses['epoch_content']>('epochs/latest')
+    ]);
+
+    const currentEpoch = Cardano.EpochNo(latestEpoch.epoch);
+    const isUnregisteringAtEpoch = await this.#getUnregisteringAtEpoch(lastRegistrationActivity);
+
+    const credentialStatus = account.active
+      ? Cardano.StakeCredentialStatus.Registered
+      : lastRegistrationActivity?.action === 'registered'
+      ? Cardano.StakeCredentialStatus.Registering
+      : isUnregisteringAtEpoch! >= currentEpoch
+      ? Cardano.StakeCredentialStatus.Unregistered
+      : Cardano.StakeCredentialStatus.Unregistering;
+    const rewardBalance = BigInt(account.withdrawable_amount || '0');
+
+    const [delegatee, dRepDelegatee, deposit] = await Promise.all([
+      this.#getDelegatee(address, currentEpoch),
+      this.#getDrepDelegatee(account),
+      // This provider currently does not find other deposits (pool/drep/govaction)
+      this.#getKeyDeposit(lastRegistrationActivity)
+    ]);
+
+    return {
+      address,
+      credentialStatus,
+      dRepDelegatee,
+      delegatee,
+      deposit,
+      rewardBalance
+    };
+  }
+
+  async delegationPortfolio(rewardAccount: Cardano.RewardAccount): Promise<Cardano.Cip17DelegationPortfolio | null> {
+    const portfolios = await fetchSequentially({
+      haveEnoughItems: (items: Array<null | Cardano.Cip17DelegationPortfolio>) => items.some(isNotNil),
+      paginationOptions: { order: 'desc' },
+      request: async (paginationQueryString) => {
+        const txs = await this.request<Responses['account_delegation_content']>(
+          `accounts/${rewardAccount}/delegations?${paginationQueryString}`
+        ).catch(emptyArrayIfNotFound);
+        const result: Array<null | Cardano.Cip17DelegationPortfolio> = [];
+        for (const { tx_hash } of txs) {
+          const metadata = await this.request<Responses['tx_content_metadata_cbor']>(
+            `txs/${tx_hash}/metadata/cbor`
+          ).catch(emptyArrayIfNotFound);
+          const cbor = metadata.find(({ label }) => label === '6862')?.metadata;
+          if (!cbor) {
+            result.push(null);
+            continue;
+          }
+          const metadatum = Serialization.TransactionMetadatum.fromCbor(HexBlob(cbor));
+          try {
+            result.push(Cardano.cip17FromMetadatum(metadatum.toCore()));
+            break;
+          } catch {
+            result.push(null);
+          }
+        }
+        return result;
+      }
+    });
+    return portfolios.find(isNotNil) || null;
+  }
+
+  async #getUnregisteringAtEpoch(
+    lastRegistrationActivity: Responses['account_registration_content'][0]
+  ): Promise<Cardano.EpochNo | undefined> {
+    if (lastRegistrationActivity.action === 'registered') {
+      return;
+    }
+    const tx = await this.request<Responses['tx_content']>(`txs/${lastRegistrationActivity.tx_hash}`);
+    const block = await this.request<Responses['block_content']>(`blocks/${tx.block}`);
+    return Cardano.EpochNo(block.epoch!);
+  }
+
+  async #getDrepDelegatee(account: Responses['account_content']): Promise<Cardano.DRepDelegatee | undefined> {
+    if (!account.drep_id) return;
+    if (account.drep_id === 'drep_always_abstain') {
+      return { delegateRepresentative: { __typename: 'AlwaysAbstain' } };
+    }
+    if (account.drep_id === 'drep_always_no_confidence') {
+      return { delegateRepresentative: { __typename: 'AlwaysNoConfidence' } };
+    }
+    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,
+    currentEpoch: Cardano.EpochNo
+  ): Promise<Cardano.Delegatee | undefined> {
+    const delegationHistory = await fetchSequentially<Responses['account_delegation_content'][0]>({
+      haveEnoughItems: (items) => items[items.length - 1]?.active_epoch <= currentEpoch,
+      paginationOptions: { order: 'desc' },
+      request: (paginationQueryString) => this.request(`accounts/${address}/delegations?${paginationQueryString}`)
+    });
+
+    const poolIds = [
+      delegationHistory.find(({ active_epoch }) => active_epoch <= currentEpoch)?.pool_id,
+      delegationHistory.find(({ active_epoch }) => active_epoch <= currentEpoch + 1)?.pool_id,
+      delegationHistory.find(({ active_epoch }) => active_epoch <= currentEpoch + 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';

packages/e2e/.env.example

@@ -20,6 +20,8 @@ TEST_CLIENT_HANDLE_PROVIDER=http
 TEST_CLIENT_HANDLE_PROVIDER_PARAMS='{"baseUrl":"http://localhost:4011/"}'
 TEST_CLIENT_NETWORK_INFO_PROVIDER=ws
 TEST_CLIENT_NETWORK_INFO_PROVIDER_PARAMS='{"baseUrl":"http://localhost:4000/"}'
+TEST_CLIENT_REWARD_ACCOUNT_INFO_PROVIDER=blockfrost
+TEST_CLIENT_REWARD_ACCOUNT_INFO_PROVIDER_PARAMS='{"baseUrl":"http://localhost:3015"}'
 TEST_CLIENT_REWARDS_PROVIDER=http
 TEST_CLIENT_REWARDS_PROVIDER_PARAMS='{"baseUrl":"http://localhost:4000/"}'
 TEST_CLIENT_TX_SUBMIT_PROVIDER=http

packages/e2e/src/environment.ts

@@ -98,6 +98,8 @@ const validators = {
   TEST_CLIENT_HANDLE_PROVIDER_PARAMS: providerParams(),
   TEST_CLIENT_NETWORK_INFO_PROVIDER: str(),
   TEST_CLIENT_NETWORK_INFO_PROVIDER_PARAMS: providerParams(),
+  TEST_CLIENT_REWARD_ACCOUNT_INFO_PROVIDER: str(),
+  TEST_CLIENT_REWARD_ACCOUNT_INFO_PROVIDER_PARAMS: providerParams(),
   TEST_CLIENT_REWARDS_PROVIDER: str(),
   TEST_CLIENT_REWARDS_PROVIDER_PARAMS: providerParams(),
   TEST_CLIENT_STAKE_POOL_PROVIDER: str(),
@@ -158,6 +160,8 @@ export const walletVariables = [
   'TEST_CLIENT_NETWORK_INFO_PROVIDER_PARAMS',
   'TEST_CLIENT_REWARDS_PROVIDER',
   'TEST_CLIENT_REWARDS_PROVIDER_PARAMS',
+  'TEST_CLIENT_REWARD_ACCOUNT_INFO_PROVIDER',
+  'TEST_CLIENT_REWARD_ACCOUNT_INFO_PROVIDER_PARAMS',
   'TEST_CLIENT_STAKE_POOL_PROVIDER',
   'TEST_CLIENT_STAKE_POOL_PROVIDER_PARAMS',
   'TEST_CLIENT_TX_SUBMIT_PROVIDER',

packages/e2e/src/factories.ts

@@ -22,6 +22,7 @@ import {
   HandleProvider,
   NetworkInfoProvider,
   ProviderFactory,
+  RewardAccountInfoProvider,
   RewardsProvider,
   StakePoolProvider,
   TxSubmitProvider,
@@ -42,6 +43,7 @@ import {
   BlockfrostClient,
   BlockfrostDRepProvider,
   BlockfrostNetworkInfoProvider,
+  BlockfrostRewardAccountInfoProvider,
   BlockfrostRewardsProvider,
   BlockfrostTxSubmitProvider,
   BlockfrostUtxoProvider,
@@ -84,6 +86,7 @@ export const keyManagementFactory = new ProviderFactory<CreateKeyAgent>();
 export const assetProviderFactory = new ProviderFactory<AssetProvider>();
 export const chainHistoryProviderFactory = new ProviderFactory<ChainHistoryProvider>();
 export const drepProviderFactory = new ProviderFactory<DRepProvider>();
+export const rewardAccountInfoProviderFactory = new ProviderFactory<RewardAccountInfoProvider>();
 export const networkInfoProviderFactory = new ProviderFactory<NetworkInfoProvider>();
 export const rewardsProviderFactory = new ProviderFactory<RewardsProvider>();
 export const txSubmitProviderFactory = new ProviderFactory<TxSubmitProvider>();
@@ -206,6 +209,36 @@ drepProviderFactory.register(BLOCKFROST_PROVIDER, async (params: any, logger): P
   });
 });
 
+rewardAccountInfoProviderFactory.register(
+  BLOCKFROST_PROVIDER,
+  async (params: any, logger): Promise<RewardAccountInfoProvider> => {
+    if (params.baseUrl === undefined) throw new Error(`${BlockfrostDRepProvider.name}: ${MISSING_URL_PARAM}`);
+    const env = getEnv(walletVariables);
+
+    return new Promise<RewardAccountInfoProvider>(async (resolve) => {
+      resolve(
+        new BlockfrostRewardAccountInfoProvider({
+          client: new BlockfrostClient(
+            { apiVersion: params.apiVersion, baseUrl: params.baseUrl, projectId: params.projectId },
+            { rateLimiter: { schedule: (task) => task() } }
+          ),
+          dRepProvider: await drepProviderFactory.create(
+            BLOCKFROST_PROVIDER,
+            env.TEST_CLIENT_DREP_PROVIDER_PARAMS,
+            logger
+          ),
+          logger,
+          stakePoolProvider: await stakePoolProviderFactory.create(
+            HTTP_PROVIDER,
+            env.TEST_CLIENT_STAKE_POOL_PROVIDER_PARAMS,
+            logger
+          )
+        })
+      );
+    });
+  }
+);
+
 networkInfoProviderFactory.register(
   HTTP_PROVIDER,
   async (params: any, logger: Logger): Promise<NetworkInfoProvider> => {
@@ -525,11 +558,6 @@ export const getWallet = async (props: GetWalletProps) => {
       env.TEST_CLIENT_CHAIN_HISTORY_PROVIDER_PARAMS,
       logger
     ),
-    drepProvider: await drepProviderFactory.create(
-      env.TEST_CLIENT_DREP_PROVIDER,
-      env.TEST_CLIENT_DREP_PROVIDER_PARAMS,
-      logger
-    ),
     handleProvider: await handleProviderFactory.create(
       env.TEST_CLIENT_HANDLE_PROVIDER,
       env.TEST_CLIENT_HANDLE_PROVIDER_PARAMS,
@@ -540,6 +568,11 @@ export const getWallet = async (props: GetWalletProps) => {
       env.TEST_CLIENT_NETWORK_INFO_PROVIDER_PARAMS,
       logger
     ),
+    rewardAccountInfoProvider: await rewardAccountInfoProviderFactory.create(
+      env.TEST_CLIENT_REWARD_ACCOUNT_INFO_PROVIDER,
+      env.TEST_CLIENT_REWARD_ACCOUNT_INFO_PROVIDER_PARAMS,
+      logger
+    ),
     rewardsProvider: await rewardsProviderFactory.create(
       env.TEST_CLIENT_REWARDS_PROVIDER,
       env.TEST_CLIENT_REWARDS_PROVIDER_PARAMS,
@@ -633,6 +666,11 @@ export const getSharedWallet = async (props: GetSharedWalletProps) => {
       env.TEST_CLIENT_NETWORK_INFO_PROVIDER_PARAMS,
       logger
     ),
+    rewardAccountInfoProvider: await rewardAccountInfoProviderFactory.create(
+      env.TEST_CLIENT_REWARD_ACCOUNT_INFO_PROVIDER,
+      env.TEST_CLIENT_REWARD_ACCOUNT_INFO_PROVIDER_PARAMS,
+      logger
+    ),
     rewardsProvider: await rewardsProviderFactory.create(
       env.TEST_CLIENT_REWARDS_PROVIDER,
       env.TEST_CLIENT_REWARDS_PROVIDER_PARAMS,