feat: activity service

alexp3y · alexp3y · commit 578ae43d93a7 · 2025-02-07T15:26:39.000+01:00
diff --git a/apps/mobile/src/hooks/use-account-unified-identifier.ts b/apps/mobile/src/hooks/use-account-unified-identifier.ts
@@ -0,0 +1,46 @@
+import { useMemo } from 'react';
+
+import {
+  useStacksSignerAddressFromAccountIndex,
+  useStacksSigners,
+} from '@/store/keychains/stacks/stacks-keychains.read';
+
+import { UnifiedAccountIdentifier } from '@leather.io/services';
+
+import {
+  useBitcoinAccountServiceRequest,
+  useTotalBitcoinAccountServiceRequests,
+} from './use-bitcoin-account-service-requests';
+
+export function useTotalUnifiedAccountIdentifiers() {
+  const btcRequests = useTotalBitcoinAccountServiceRequests();
+  const signers = useStacksSigners();
+  return useMemo(
+    () =>
+      !btcRequests || !signers
+        ? []
+        : btcRequests.map(
+            req =>
+              ({
+                ...req.account,
+                stxAddress: signers
+                  .fromAccountIndex(req.account.fingerprint, req.account.accountIndex)
+                  // TODO: throw error when no matching Stacks address
+                  .map(signer => signer.address)[0]!,
+              }) satisfies UnifiedAccountIdentifier
+          ),
+    [btcRequests, signers]
+  );
+}
+
+export function useUnifiedAccountIdentifier(fingerprint: string, accountIndex: number) {
+  const btcRequest = useBitcoinAccountServiceRequest(fingerprint, accountIndex);
+  const stxAddress = useStacksSignerAddressFromAccountIndex(fingerprint, accountIndex) ?? '';
+  if (!stxAddress) {
+    throw new Error('Stacks address not found');
+  }
+  return {
+    ...btcRequest.account,
+    stxAddress,
+  } satisfies UnifiedAccountIdentifier;
+}
diff --git a/apps/mobile/src/queries/activity/account-activity.query.ts b/apps/mobile/src/queries/activity/account-activity.query.ts
@@ -0,0 +1,49 @@
+import {
+  useTotalUnifiedAccountIdentifiers,
+  useUnifiedAccountIdentifier,
+} from '@/hooks/use-account-unified-identifier';
+import { toFetchState } from '@/shared/fetch-state';
+import { useSettings } from '@/store/settings/settings';
+import { QueryFunctionContext, useQuery } from '@tanstack/react-query';
+
+import { UnifiedAccountIdentifier, getActivityService } from '@leather.io/services';
+
+export function useTotalActivity() {
+  const accountIdentifiers = useTotalUnifiedAccountIdentifiers();
+  return toFetchState(useAggregateActivityQuery(accountIdentifiers));
+}
+
+export function useAccountActivity(fingerprint: string, accountIndex: number) {
+  const accountIdentifier = useUnifiedAccountIdentifier(fingerprint, accountIndex);
+  return toFetchState(useAccountActivityQuery(accountIdentifier));
+}
+
+export function useAccountActivityQuery(account: UnifiedAccountIdentifier) {
+  const { fiatCurrencyPreference } = useSettings();
+  return useQuery({
+    queryKey: ['activity-service-get-account-activity', account, fiatCurrencyPreference],
+    queryFn: ({ signal }: QueryFunctionContext) =>
+      getActivityService().getAccountActivity(account, signal),
+    refetchOnReconnect: false,
+    refetchOnWindowFocus: false,
+    refetchOnMount: true,
+    retryOnMount: false,
+    staleTime: 1 * 1000,
+    gcTime: 1 * 1000,
+  });
+}
+
+export function useAggregateActivityQuery(accounts: UnifiedAccountIdentifier[]) {
+  const { fiatCurrencyPreference } = useSettings();
+  return useQuery({
+    queryKey: ['activity-service-get-aggregate-activity', accounts, fiatCurrencyPreference],
+    queryFn: ({ signal }: QueryFunctionContext) =>
+      getActivityService().getAggregateActivity(accounts, signal),
+    refetchOnReconnect: false,
+    refetchOnWindowFocus: false,
+    refetchOnMount: true,
+    retryOnMount: false,
+    staleTime: 1 * 1000,
+    gcTime: 1 * 1000,
+  });
+}
diff --git a/packages/constants/src/index.ts b/packages/constants/src/index.ts
@@ -3,6 +3,8 @@ import type {
   AccountDisplayPreferenceInfo,
   BitcoinUnit,
   BitcoinUnitInfo,
+  BtcCryptoAssetInfo,
+  StxCryptoAssetInfo,
 } from '@leather.io/models';
 
 export const gaiaUrl = 'https://hub.blockstack.org';
@@ -112,3 +114,21 @@ export const accountDisplayPreferencesKeyedByType: Record<
     name: 'Stacks address',
   },
 };
+
+export const btcCryptoAsset: BtcCryptoAssetInfo = {
+  chain: 'bitcoin',
+  protocol: 'nativeBtc',
+  symbol: 'BTC',
+  category: 'fungible',
+  decimals: 8,
+  hasMemo: false,
+};
+
+export const stxCryptoAsset: StxCryptoAssetInfo = {
+  chain: 'stacks',
+  protocol: 'nativeStx',
+  symbol: 'STX',
+  category: 'fungible',
+  decimals: 6,
+  hasMemo: false,
+};
diff --git a/packages/models/src/activity.model.ts b/packages/models/src/activity.model.ts
@@ -0,0 +1,42 @@
+import { CryptoAssetInfo } from './crypto-assets/crypto-asset-info.model';
+import { Money } from './money.model';
+
+export const ActivityTypes = {
+  tokenTransfer: 'tokenTransfer',
+  contractCall: 'contractCall',
+};
+export type ActivityType = keyof typeof ActivityTypes;
+
+export interface BaseActivity {
+  readonly type: ActivityType;
+  readonly txid: string;
+  readonly timestamp: number;
+  readonly status: 'pending' | 'success' | 'failed';
+}
+
+export const TokenTransferDirections = {
+  outbound: 'outbound',
+  inbound: 'inbound',
+};
+export type TokenTransferDirection = keyof typeof TokenTransferDirections;
+
+export interface TokenTransferActivity extends BaseActivity {
+  readonly type: 'tokenTransfer';
+  readonly asset: CryptoAssetInfo;
+  readonly direction: TokenTransferDirection;
+  readonly amount: {
+    crypto: Money;
+    fiat: Money;
+  };
+}
+
+export interface ContractCallActivity extends BaseActivity {
+  readonly type: 'contractCall';
+}
+
+export type Activity = TokenTransferActivity | ContractCallActivity;
+
+// Token
+// Collectible
+// Swap
+// Smart Contract Activity
diff --git a/packages/models/src/index.ts b/packages/models/src/index.ts
@@ -16,3 +16,4 @@ export * from './settings.model';
 export * from './transactions/bitcoin-transaction.model';
 export * from './transactions/stacks-transaction.model';
 export * from './utxo.model';
+export * from './activity.model';
diff --git a/packages/services/src/activity/activity.service.ts b/packages/services/src/activity/activity.service.ts
@@ -0,0 +1,55 @@
+import { Activity } from '@leather.io/models';
+import { isDefined } from '@leather.io/utils';
+
+import { UnifiedAccountIdentifier } from '../shared/bitcoin.types';
+import { BitcoinTransactionsService } from '../transactions/bitcoin-transactions.service';
+import { StacksTransactionsService } from '../transactions/stacks-transactions.service';
+import {
+  mapBitcoinTxToActivity,
+  mapStacksTxToActivity,
+  sortActivityByTimestampDesc,
+} from './activity.utils';
+
+export interface ActivityService {
+  getAccountActivity(account: UnifiedAccountIdentifier, signal?: AbortSignal): Promise<Activity[]>;
+  getAggregateActivity(
+    account: UnifiedAccountIdentifier[],
+    signal?: AbortSignal
+  ): Promise<Activity[]>;
+}
+
+export function createActivityService(
+  stacksTransactionsService: StacksTransactionsService,
+  bitcoinTransactionsService: BitcoinTransactionsService
+): ActivityService {
+  /*
+   * Gets unified activity list for an account sorted by timestamp
+   */
+  async function getAccountActivity(account: UnifiedAccountIdentifier, signal?: AbortSignal) {
+    const [stacksTransactions, bitcoinTransactions] = await Promise.all([
+      stacksTransactionsService.getTotalTransactions(account.stxAddress, signal),
+      bitcoinTransactionsService.getTotalTransactions(account, signal),
+    ]);
+    return [
+      ...stacksTransactions.map(mapStacksTxToActivity),
+      ...bitcoinTransactions.map(mapBitcoinTxToActivity),
+    ]
+      .filter(isDefined)
+      .sort(sortActivityByTimestampDesc);
+  }
+
+  /*
+   * Gets unified activity list for an account sorted by timestamp
+   */
+  async function getAggregateActivity(accounts: UnifiedAccountIdentifier[], signal?: AbortSignal) {
+    const accountActivities = await Promise.all(
+      accounts.map(identifier => getAccountActivity(identifier, signal))
+    );
+    return accountActivities.flat().sort(sortActivityByTimestampDesc);
+  }
+
+  return {
+    getAccountActivity,
+    getAggregateActivity,
+  };
+}
diff --git a/packages/services/src/activity/activity.utils.ts b/packages/services/src/activity/activity.utils.ts
@@ -0,0 +1,68 @@
+import { btcCryptoAsset, stxCryptoAsset } from '@leather.io/constants';
+import {
+  Activity,
+  ContractCallActivity,
+  StacksTx,
+  TokenTransferActivity,
+} from '@leather.io/models';
+import { createMoney } from '@leather.io/utils';
+
+import { LeatherApiBitcoinTransaction } from '../infrastructure/api/leather/leather-api.client';
+
+export function mapStacksTxToActivity(stacksTx: StacksTx): Activity | undefined {
+  switch (stacksTx.tx_type) {
+    case 'token_transfer':
+      return mapStacksTxToTransferActivity(stacksTx);
+    case 'contract_call':
+      return mapStacksTxToContractCallActivity(stacksTx);
+    default:
+      return;
+  }
+}
+
+function mapStacksTxToTransferActivity(stacksTx: StacksTx): TokenTransferActivity {
+  const stxTransferActivity: TokenTransferActivity = {
+    type: 'tokenTransfer',
+    asset: stxCryptoAsset,
+    direction: 'outbound',
+    amount: {
+      crypto: createMoney(0, 'STX'),
+      fiat: createMoney(0, 'USD'),
+    },
+    txid: stacksTx.tx_id,
+    timestamp: 0,
+    status: 'success',
+  };
+  return stxTransferActivity;
+}
+
+function mapStacksTxToContractCallActivity(stacksTx: StacksTx): ContractCallActivity {
+  const stxTransferActivity: ContractCallActivity = {
+    type: 'contractCall',
+    txid: stacksTx.tx_id,
+    timestamp: 0,
+    status: 'success',
+  };
+  return stxTransferActivity;
+}
+
+export function mapBitcoinTxToActivity(bitcoinTx: LeatherApiBitcoinTransaction): Activity {
+  // All bitcoin transactions will currently be considered transfers
+  const btcTransferActivity: TokenTransferActivity = {
+    type: 'tokenTransfer',
+    asset: btcCryptoAsset,
+    txid: bitcoinTx.txid,
+    direction: 'outbound',
+    amount: {
+      crypto: createMoney(0, 'BTC'),
+      fiat: createMoney(0, 'USD'),
+    },
+    timestamp: 0,
+    status: 'success',
+  };
+  return btcTransferActivity;
+}
+
+export function sortActivityByTimestampDesc(a: Activity, b: Activity) {
+  return b.timestamp - a.timestamp;
+}
diff --git a/packages/services/src/index.ts b/packages/services/src/index.ts
@@ -12,4 +12,6 @@ export * from './inversify.config';
 export * from './market-data/market-data.service';
 export * from './shared/bitcoin.types';
 export * from './transactions/stacks-transactions.service';
+export * from './transactions/bitcoin-transactions.service';
 export * from './utxos/utxos.service';
+export * from './activity/activity.service';
diff --git a/packages/services/src/infrastructure/api/leather/leather-api.client.ts b/packages/services/src/infrastructure/api/leather/leather-api.client.ts
@@ -15,23 +15,23 @@ const leatherApiUtxoSchema = z.object({
   vout: z.number(),
 });
 
-const leatherApiTxVinLightSchema = z.object({
+const leatherApiBitcoinTransactionVinSchema = z.object({
   value: z.string(),
   n: z.number(),
   addresses: z.array(z.string()),
   isAddress: z.boolean(),
   isOwn: z.boolean(),
 });
 
-const leatherApiTxVoutLightSchema = z.object({
+const leatherApiBitcoinTransactionVoutSchema = z.object({
   value: z.string(),
   n: z.number(),
   spent: z.boolean(),
   addresses: z.array(z.string()),
   isAddress: z.boolean(),
   isOwn: z.boolean(),
 });
-const leatherApiTxLightSchema = z.object({
+const leatherApiBitcoinTransactionSchema = z.object({
   txid: z.string(),
   blockHash: z.string().optional(),
   blockHeight: z.number(),
@@ -40,8 +40,8 @@ const leatherApiTxLightSchema = z.object({
   value: z.string(),
   valueIn: z.string(),
   fees: z.string(),
-  vin: leatherApiTxVinLightSchema,
-  vout: leatherApiTxVoutLightSchema,
+  vin: leatherApiBitcoinTransactionVinSchema,
+  vout: leatherApiBitcoinTransactionVoutSchema,
 });
 
 const leatherApiFiatExchangeRatesSchema = z.object({
@@ -67,15 +67,18 @@ const mockFiatExchangeRatesResponse = {
 };
 
 export type LeatherApiUtxo = z.infer<typeof leatherApiUtxoSchema>;
-export type LeatherApiTxLight = z.infer<typeof leatherApiTxLightSchema>;
+export type LeatherApiBitcoinTransaction = z.infer<typeof leatherApiBitcoinTransactionSchema>;
 export interface LeatherApiExchangeRates {
   [symbol: string]: number;
 }
 
 export interface LeatherApiClient {
   fetchFiatExchangeRates(signal?: AbortSignal): Promise<LeatherApiExchangeRates>;
   fetchUtxos(descriptor: string, signal?: AbortSignal): Promise<LeatherApiUtxo[]>;
-  fetchTxs(descriptor: string, signal?: AbortSignal): Promise<LeatherApiTxLight[]>;
+  fetchBitcoinTransactions(
+    descriptor: string,
+    signal?: AbortSignal
+  ): Promise<LeatherApiBitcoinTransaction[]>;
 }
 
 export function createLeatherApiClient(
@@ -110,16 +113,16 @@ export function createLeatherApiClient(
     );
   }
 
-  async function fetchTxs(descriptor: string, signal?: AbortSignal) {
+  async function fetchBitcoinTransactions(descriptor: string, signal?: AbortSignal) {
     const network = settingsService.getSettings().network.chain.bitcoin.bitcoinNetwork;
     return await cacheService.fetchWithCache(
-      ['leather-txs', network, descriptor],
+      ['leather-bitcoin-transactions', network, descriptor],
       async () => {
-        const res = await axios.get<LeatherApiUtxo[]>(
+        const res = await axios.get<LeatherApiBitcoinTransaction[]>(
           `https://leather-bitcoin-balances.wallet-6d1.workers.dev/${network}/${descriptor}/txs`,
           { signal }
         );
-        return z.array(leatherApiTxLightSchema).parse(res.data);
+        return z.array(leatherApiBitcoinTransactionSchema).parse(res.data);
       },
       { ttl: HttpCacheTimeMs.fiveSeconds }
     );
@@ -128,6 +131,6 @@ export function createLeatherApiClient(
   return {
     fetchFiatExchangeRates,
     fetchUtxos,
-    fetchTxs,
+    fetchBitcoinTransactions,
   };
 }
diff --git a/packages/services/src/inversify.config.ts b/packages/services/src/inversify.config.ts
diff --git a/packages/services/src/shared/bitcoin.types.ts b/packages/services/src/shared/bitcoin.types.ts
diff --git a/packages/services/src/transactions/bitcoin-transactions.service.ts b/packages/services/src/transactions/bitcoin-transactions.service.ts
diff --git a/packages/services/src/transactions/stacks-transactions.service.ts b/packages/services/src/transactions/stacks-transactions.service.ts
