feat: runes balances service

Author: alexp3y

apps/mobile/src/features/balances/bitcoin/runes-balance.tsx

@@ -1,5 +1,4 @@
 import { TokenIcon } from '@/components/widgets/tokens/token-icon';
-import { createBitcoinAccountIdentifier } from '@/hooks/use-bitcoin-account-service-requests';
 import { AccountId } from '@/models/domain.model';
 import {
   useRunesAccountBalance,
@@ -42,34 +41,31 @@ export function RunesBalance() {
   // TODO LEA-1726: handle balance loading & error states
   if (data.state !== 'success') return;
 
-  return data.value.accountBalances.map((balances: any) =>
-    balances.runes.map((balance: any, index: any) => (
-      <RunesTokenBalance
-        key={`${balance.asset.symbol}-${index}`}
-        symbol={balance.asset.symbol}
-        name={balance.asset.name}
-        availableBalance={balance.availableBalance}
-        fiatBalance={balance.totalBalance}
-        px="5"
-        py="3"
-      />
-    ))
-  );
+  return data.value.runes.map((balance, index) => (
+    <RunesTokenBalance
+      key={`${balance.asset.symbol}-${index}`}
+      symbol={balance.asset.symbol}
+      name={balance.asset.runeName}
+      availableBalance={balance.crypto.availableBalance}
+      fiatBalance={balance.usd.totalBalance}
+      px="5"
+      py="3"
+    />
+  ));
 }
 
 export function RunesBalanceByAccount({ fingerprint, accountIndex }: AccountId) {
-  const account = createBitcoinAccountIdentifier(fingerprint, accountIndex, []);
-  const data = useRunesAccountBalance(account);
+  const data = useRunesAccountBalance(fingerprint, accountIndex);
 
   // TODO LEA-1726: handle balance loading & error states
   if (data.state !== 'success') return;
-  return data.value.runes.map((balance: any, index: any) => (
+  return data.value.runes.map((balance, index) => (
     <RunesTokenBalance
       key={`${balance.asset.symbol}-${index}`}
       symbol={balance.asset.symbol}
-      name={balance.asset.name}
-      availableBalance={balance.availableBalance}
-      fiatBalance={balance.totalBalance}
+      name={balance.asset.spacedRuneName}
+      availableBalance={balance.crypto.availableBalance}
+      fiatBalance={balance.usd.availableBalance}
       px="5"
       py="3"
     />

apps/mobile/src/features/balances/stacks/sip10-balance.tsx

@@ -41,14 +41,14 @@ export function Sip10Balance() {
   // TODO LEA-1726: handle balance loading & error states
   if (data.state !== 'success') return;
 
-  return data.value.aggregateBalances.map((balance, index) => {
+  return data.value.sip10s.map((balance, index) => {
     if (index >= sip10MaxDisplay) return null;
     return (
       <Sip10TokenBalance
         key={`${balance.asset.symbol}-${index}`}
         symbol={balance.asset.symbol}
         name={balance.asset.name}
-        availableBalance={balance.sip10.availableBalance}
+        availableBalance={balance.crypto.availableBalance}
         fiatBalance={balance.usd.totalBalance}
         px="5"
         py="3"
@@ -72,7 +72,7 @@ export function Sip10BalanceByAccount({ accountIndex, fingerprint }: Sip10Balanc
         key={`${balance.asset.symbol}-${index}`}
         symbol={balance.asset.symbol}
         name={balance.asset.name}
-        availableBalance={balance.sip10.availableBalance}
+        availableBalance={balance.crypto.availableBalance}
         fiatBalance={balance.usd.totalBalance}
         px="5"
         py="3"

apps/mobile/src/queries/balance/account-balance.query.ts

@@ -3,16 +3,23 @@ import { useStxAccountBalance } from '@/queries/balance/stx-balance.query';
 import { FetchState, toFetchState } from '@/shared/fetch-state';
 
 import { Money } from '@leather.io/models';
-import { BtcAccountBalance, Sip10AddressBalance, StxAddressBalance } from '@leather.io/services';
+import {
+  BtcAccountBalance,
+  RunesAccountBalance,
+  Sip10AddressBalance,
+  StxAddressBalance,
+} from '@leather.io/services';
 import { createMoney, isDefined, sumMoney } from '@leather.io/utils';
 
 import { useBtcAccountBalance } from './btc-balance.query';
+import { useRunesAccountBalance } from './runes-balance.query';
 import { useSip10AccountBalance } from './sip10-balance.query';
 
 interface AccountBalance {
   btc: FetchState<BtcAccountBalance>;
   stx: FetchState<StxAddressBalance>;
   sip10: FetchState<Sip10AddressBalance>;
+  runes: FetchState<RunesAccountBalance>;
   totalBalance: FetchState<Money>;
 }
 
@@ -24,28 +31,33 @@ export function useAccountBalance(accountId: AccountId): AccountBalance {
   const btcAccountBalance = useBtcAccountBalance(fingerprint, accountIndex);
   const stxAccountBalance = useStxAccountBalance(fingerprint, accountIndex);
   const sip10AccountBalance = useSip10AccountBalance(fingerprint, accountIndex);
+  const runesAccountBalance = useRunesAccountBalance(fingerprint, accountIndex);
 
   const isLoading =
     btcAccountBalance.state === 'loading' &&
     stxAccountBalance.state === 'loading' &&
-    sip10AccountBalance.state === 'loading';
+    sip10AccountBalance.state === 'loading' &&
+    runesAccountBalance.state === 'loading';
   const isError =
     btcAccountBalance.state === 'error' &&
     stxAccountBalance.state === 'error' &&
-    sip10AccountBalance.state === 'error';
+    sip10AccountBalance.state === 'error' &&
+    runesAccountBalance.state === 'error';
   const accountBalance = sumMoney(
     [
       zeroMoneyUsd,
       btcAccountBalance.value?.usd.availableBalance,
       stxAccountBalance.value?.usd.availableBalance,
       sip10AccountBalance.value?.usd.availableBalance,
+      runesAccountBalance.value?.usd.availableBalance,
     ].filter(isDefined)
   );
 
   return {
     btc: btcAccountBalance,
     stx: stxAccountBalance,
     sip10: sip10AccountBalance,
+    runes: runesAccountBalance,
     totalBalance: toFetchState({
       isLoading,
       data: accountBalance,

apps/mobile/src/queries/balance/runes-balance.query.ts

@@ -1,21 +1,27 @@
-import { useTotalBitcoinAccountServiceRequests } from '@/hooks/use-bitcoin-account-service-requests';
+import {
+  useBitcoinAccountServiceRequest,
+  useTotalBitcoinAccountServiceRequests,
+  useWalletBitcoinAccountServiceRequests,
+} from '@/hooks/use-bitcoin-account-service-requests';
 import { toFetchState } from '@/shared/fetch-state';
 import { QueryFunctionContext, useQuery } from '@tanstack/react-query';
 
 import { BitcoinAccountIdentifier, getRunesBalancesService } from '@leather.io/services';
 
 export function useRunesTotalBalance() {
   // TODO LEA-1982: check with Alex once we have xpub-based runes endpoint from BIS
-  const accounts = useTotalBitcoinAccountServiceRequests();
-  return toFetchState(useRunesAggregateBalanceQuery(accounts.map(account => account.account)));
+  const totalRequests = useTotalBitcoinAccountServiceRequests();
+  return toFetchState(useRunesAggregateBalanceQuery(totalRequests.map(r => r.account)));
 }
 
-export function useRunesAggregateBalance(accounts: BitcoinAccountIdentifier[]) {
-  return toFetchState(useRunesAggregateBalanceQuery(accounts));
+export function useRunesWalletBalance(fingerprint: string) {
+  const walletRequests = useWalletBitcoinAccountServiceRequests(fingerprint);
+  return toFetchState(useRunesAggregateBalanceQuery(walletRequests.map(r => r.account)));
 }
 
-export function useRunesAccountBalance(account: BitcoinAccountIdentifier) {
-  return toFetchState(useRunesAccountBalanceQuery(account));
+export function useRunesAccountBalance(fingerprint: string, accountIndex: number) {
+  const accountRequest = useBitcoinAccountServiceRequest(fingerprint, accountIndex);
+  return toFetchState(useRunesAccountBalanceQuery(accountRequest.account));
 }
 
 export function useRunesAggregateBalanceQuery(accounts: BitcoinAccountIdentifier[]) {

apps/mobile/src/queries/balance/total-balance.query.ts

@@ -4,18 +4,21 @@ import { FetchState, toFetchState } from '@/shared/fetch-state';
 import { Money } from '@leather.io/models';
 import {
   BtcAggregateBalance,
+  RunesAggregateBalance,
   Sip10AggregateBalance,
   StxAggregateBalance,
 } from '@leather.io/services';
 import { createMoney, isDefined, sumMoney } from '@leather.io/utils';
 
 import { useBtcTotalBalance } from './btc-balance.query';
+import { useRunesTotalBalance } from './runes-balance.query';
 import { useSip10TotalBalance } from './sip10-balance.query';
 
 interface TotalBalance {
   btc: FetchState<BtcAggregateBalance>;
   stx: FetchState<StxAggregateBalance>;
   sip10: FetchState<Sip10AggregateBalance>;
+  runes: FetchState<RunesAggregateBalance>;
   totalBalance: FetchState<Money>;
 }
 
@@ -25,28 +28,33 @@ export function useTotalBalance(): TotalBalance {
   const btcTotalBalance = useBtcTotalBalance();
   const stxTotalBalance = useStxTotalBalance();
   const sip10TotalBalance = useSip10TotalBalance();
+  const runesTotalBalance = useRunesTotalBalance();
 
   const isLoading =
     btcTotalBalance.state === 'loading' &&
     stxTotalBalance.state === 'loading' &&
-    sip10TotalBalance.state === 'loading';
+    sip10TotalBalance.state === 'loading' &&
+    runesTotalBalance.state === 'loading';
   const isError =
     btcTotalBalance.state === 'error' &&
     stxTotalBalance.state === 'error' &&
-    sip10TotalBalance.state === 'error';
+    sip10TotalBalance.state === 'error' &&
+    runesTotalBalance.state === 'error';
   const accountBalance = sumMoney(
     [
       zeroMoneyUsd,
       btcTotalBalance.value?.usd.availableBalance,
       stxTotalBalance.value?.usd.availableBalance,
       sip10TotalBalance.value?.usd.availableBalance,
+      runesTotalBalance.value?.usd.availableBalance,
     ].filter(isDefined)
   );
 
   return {
     btc: btcTotalBalance,
     stx: stxTotalBalance,
     sip10: sip10TotalBalance,
+    runes: runesTotalBalance,
     totalBalance: toFetchState({
       isLoading,
       data: accountBalance,

packages/services/src/balances/runes-balances.service.ts

@@ -12,34 +12,32 @@ import { BestInSlotApiClient } from '../infrastructure/api/best-in-slot/best-in-
 import { MarketDataService } from '../market-data/market-data.service';
 import { BitcoinAccountIdentifier } from '../shared/bitcoin.types';
 import { baseCryptoAssetZeroBalanceUsd } from './constants';
-import { parseRunesOutputsBalances } from './runes-balances.utils';
+import { aggregateRunesAccountBalances, readRunesOutputsBalances } from './runes-balances.utils';
 
 export interface RuneAssetBalance {
   asset: RuneCryptoAssetInfo;
   usd: CryptoAssetBalance;
-  rune: CryptoAssetBalance;
+  crypto: CryptoAssetBalance;
 }
 
-export interface RuneAccountBalance {
-  account: BitcoinAccountIdentifier;
+export interface RunesAggregateBalance {
   usd: CryptoAssetBalance;
   runes: RuneAssetBalance[];
 }
 
-export interface RuneAggregateBalance {
-  usd: CryptoAssetBalance;
-  accountBalances: RuneAccountBalance[];
+export interface RunesAccountBalance extends RunesAggregateBalance {
+  account: BitcoinAccountIdentifier;
 }
 
 export interface RunesBalancesService {
   getRunesAccountBalance(
     bitcoinAccount: BitcoinAccountIdentifier,
     signal?: AbortSignal
-  ): Promise<RuneAccountBalance>;
+  ): Promise<RunesAccountBalance>;
   getRunesAggregateBalance(
     accounts: BitcoinAccountIdentifier[],
     signal?: AbortSignal
-  ): Promise<RuneAggregateBalance>;
+  ): Promise<RunesAggregateBalance>;
 }
 
 export function createRunesBalancesService(
@@ -54,7 +52,7 @@ export function createRunesBalancesService(
   async function getRunesAggregateBalance(
     accounts: BitcoinAccountIdentifier[],
     signal?: AbortSignal
-  ) {
+  ): Promise<RunesAggregateBalance> {
     const accountBalances = await Promise.all(
       accounts.map(account => getRunesAccountBalance(account, signal))
     );
@@ -63,29 +61,35 @@ export function createRunesBalancesService(
         baseCryptoAssetZeroBalanceUsd,
         ...accountBalances.map(b => b.usd),
       ]),
-      accountBalances,
+      runes: aggregateRunesAccountBalances(accountBalances),
     };
   }
 
   /**
    * Retrieve Rune balances for given account.
    * Includes cumulative USD-denominated balance.
    */
-  async function getRunesAccountBalance(account: BitcoinAccountIdentifier, signal?: AbortSignal) {
+  async function getRunesAccountBalance(
+    account: BitcoinAccountIdentifier,
+    signal?: AbortSignal
+  ): Promise<RunesAccountBalance> {
     const runesOutputs = await bisApiClient.fetchRunesValidOutputs(
       account.taprootDescriptor,
       signal
     );
-    const runesOutputsBalances = parseRunesOutputsBalances(runesOutputs);
-    const balances = await Promise.all(
+    const runesOutputsBalances = readRunesOutputsBalances(runesOutputs);
+    const runesBalances = await Promise.all(
       Object.keys(runesOutputsBalances).map(runeName => {
         return getRuneBalance(runeName, runesOutputsBalances[runeName], signal);
       })
     );
     return {
       account,
-      usd: aggregateBaseCryptoAssetBalances(balances.map(b => b.usd)),
-      runes: balances,
+      usd: aggregateBaseCryptoAssetBalances([
+        baseCryptoAssetZeroBalanceUsd,
+        ...runesBalances.map(b => b.usd),
+      ]),
+      runes: runesBalances,
     };
   }
 
@@ -95,12 +99,12 @@ export function createRunesBalancesService(
     signal?: AbortSignal
   ): Promise<RuneAssetBalance> {
     const runeInfo = await runeAssetService.getAssetInfo(runeName, signal);
-    const totalBalance = createMoney(initBigNumber(amount), runeInfo.symbol, runeInfo.decimals);
+    const totalBalance = createMoney(initBigNumber(amount), runeInfo.runeName, runeInfo.decimals);
     const runeMarketData = await marketDataService.getRuneMarketData(runeInfo, signal);
     return {
       asset: runeInfo,
-      rune: createBaseCryptoAssetBalance(totalBalance),
       usd: createBaseCryptoAssetBalance(baseCurrencyAmountInQuote(totalBalance, runeMarketData)),
+      crypto: createBaseCryptoAssetBalance(totalBalance),
     };
   }
   return {