feat(mobile): use local transactions for graph

suite-common/graph/package.json

@@ -13,12 +13,13 @@
     },
     "dependencies": {
         "@mobily/ts-belt": "^3.13.1",
+        "@reduxjs/toolkit": "1.9.5",
         "@suite-common/fiat-services": "workspace:*",
         "@suite-common/suite-config": "workspace:*",
         "@suite-common/suite-utils": "workspace:*",
-        "@suite-common/transaction-cache-engine": "workspace:*",
         "@suite-common/wallet-config": "workspace:*",
         "@suite-common/wallet-core": "workspace:*",
+        "@suite-common/wallet-types": "workspace:*",
         "@suite-common/wallet-utils": "workspace:*",
         "@trezor/blockchain-link": "workspace:*",
         "@trezor/connect": "workspace:*",

suite-common/graph/redux.d.ts

@@ -0,0 +1,7 @@
+import { AsyncThunkAction } from '@reduxjs/toolkit';
+
+declare module 'redux' {
+    export interface Dispatch {
+        <TThunk extends AsyncThunkAction<any, any, any>>(thunk: TThunk): ReturnType<TThunk>;
+    }
+}

suite-common/transaction-cache-engine/src/utils/balanceHistory.ts → suite-common/graph/src/balanceHistoryUtils.ts

@@ -2,7 +2,13 @@ import { BigNumber } from '@trezor/utils/src/bigNumber';
 import { AccountTransaction } from '@trezor/connect';
 import { NetworkSymbol, getNetworkType } from '@suite-common/wallet-config';
 
-import { AccountBalanceHistory } from '../types';
+export type AccountBalanceHistory = {
+    time: number;
+    txs: number;
+    received: BigNumber;
+    sent: BigNumber;
+    sentToSelf: BigNumber;
+};
 
 const getAccountBalanceHistoryBTC = ({
     transactions,
@@ -97,8 +103,8 @@ const getAccountBalanceHistoryRipple = ({
         if (summaryMap.has(blockTime)) {
             const summary = summaryMap.get(blockTime)!;
             summary.txs += 1;
-            summary.received = amount.plus(receivedDrops);
-            summary.sent = amount.plus(sentDrops);
+            summary.received = summary.received.plus(receivedDrops);
+            summary.sent = summary.sent.plus(sentDrops);
         } else {
             summaryMap.set(blockTime, {
                 time: blockTime,
@@ -113,7 +119,7 @@ const getAccountBalanceHistoryRipple = ({
     return Array.from(summaryMap.values()).sort((a, b) => a.time - b.time);
 };
 
-export const getAccountBalanceHistory = ({
+export const getAccountBalanceHistoryFromTransactions = ({
     transactions,
     coin,
 }: {

suite-common/graph/src/graphBalanceEvents.ts

@@ -1,15 +1,18 @@
+import { useDispatch } from 'react-redux';
+
 import { A, pipe } from '@mobily/ts-belt';
 import { fromUnixTime, getUnixTime } from 'date-fns';
 
 import { NetworkSymbol, getNetworkType } from '@suite-common/wallet-config';
 import TrezorConnect from '@trezor/connect';
 import { AccountBalanceHistory as AccountMovementHistory } from '@trezor/blockchain-link';
-import {
-    AccountBalanceHistory,
-    TransactionCacheEngine,
-} from '@suite-common/transaction-cache-engine';
+import { fetchAllTransactionsForAccountThunk } from '@suite-common/wallet-core';
 
 import { BalanceMovementEvent, GroupedBalanceMovementEvent, AccountItem } from './types';
+import {
+    AccountBalanceHistory,
+    getAccountBalanceHistoryFromTransactions,
+} from './balanceHistoryUtils';
 
 /**
  * Calculates received and sent values of each balance movement point.
@@ -107,18 +110,26 @@ export const getAccountMovementEvents = async ({
     account,
     startOfTimeFrameDate,
     endOfTimeFrameDate,
+    dispatch,
 }: {
     account: AccountItem;
     startOfTimeFrameDate: Date | null;
     endOfTimeFrameDate: Date;
+    dispatch: ReturnType<typeof useDispatch>;
 }) => {
     const { coin, identity, descriptor } = account;
 
     const getBalanceHistory = async () => {
         if (getNetworkType(coin) === 'ripple') {
-            return TransactionCacheEngine.getAccountBalanceHistory({
+            const allTransactions = await dispatch(
+                fetchAllTransactionsForAccountThunk({
+                    accountKey: account.accountKey,
+                }),
+            ).unwrap();
+
+            return getAccountBalanceHistoryFromTransactions({
+                transactions: allTransactions,
                 coin,
-                descriptor,
             });
         }
         const connectBalanceHistory = await TrezorConnect.blockchainGetAccountBalanceHistory({

suite-common/graph/src/graphDataFetching.ts

@@ -1,17 +1,17 @@
+import { useDispatch } from 'react-redux';
+
 import { A, D, G, pipe } from '@mobily/ts-belt';
 import { fromUnixTime, getUnixTime } from 'date-fns';
 
-import { BigNumber } from '@trezor/utils/src/bigNumber';
+import { getFiatRatesForTimestamps } from '@suite-common/fiat-services';
 import { FiatCurrencyCode } from '@suite-common/suite-config';
 import { NetworkSymbol, getNetworkType } from '@suite-common/wallet-config';
 import { formatNetworkAmount } from '@suite-common/wallet-utils';
 import { AccountBalanceHistory as AccountMovementHistory } from '@trezor/blockchain-link';
 import TrezorConnect from '@trezor/connect';
-import { getFiatRatesForTimestamps } from '@suite-common/fiat-services';
-import {
-    AccountBalanceHistory,
-    TransactionCacheEngine,
-} from '@suite-common/transaction-cache-engine';
+import { BigNumber } from '@trezor/utils/src/bigNumber';
+import { fetchAllTransactionsForAccountThunk } from '@suite-common/wallet-core';
+import { AccountKey } from '@suite-common/wallet-types';
 
 import { NUMBER_OF_POINTS } from './constants';
 import {
@@ -22,6 +22,10 @@ import {
     mergeMultipleFiatBalanceHistories,
 } from './graphUtils';
 import { AccountItem, FiatGraphPoint, FiatGraphPointWithCryptoBalance } from './types';
+import {
+    AccountBalanceHistory,
+    getAccountBalanceHistoryFromTransactions,
+} from './balanceHistoryUtils';
 
 export const addBalanceForAccountMovementHistory = (
     data: AccountMovementHistory[] | AccountBalanceHistory[],
@@ -87,12 +91,16 @@ const getAccountBalanceHistory = async ({
     descriptor,
     endOfTimeFrameDate,
     forceRefetch,
+    dispatch,
+    accountKey,
 }: {
     coin: NetworkSymbol;
     identity?: string;
     descriptor: string;
     endOfTimeFrameDate: Date;
     forceRefetch?: boolean;
+    dispatch: ReturnType<typeof useDispatch>;
+    accountKey: AccountKey;
 }): Promise<AccountHistoryBalancePoint[]> => {
     const endTimeFrameTimestamp = getUnixTime(endOfTimeFrameDate);
     const cacheKey = `${coin}-${descriptor}-${endTimeFrameTimestamp}`;
@@ -103,9 +111,15 @@ const getAccountBalanceHistory = async ({
 
     const getBalanceHistory = async () => {
         if (getNetworkType(coin) === 'ripple') {
-            return TransactionCacheEngine.getAccountBalanceHistory({
+            const allTransactions = await dispatch(
+                fetchAllTransactionsForAccountThunk({
+                    accountKey,
+                }),
+            ).unwrap();
+
+            return getAccountBalanceHistoryFromTransactions({
+                transactions: allTransactions,
                 coin,
-                descriptor,
             });
         }
         const connectBalanceHistory = await TrezorConnect.blockchainGetAccountBalanceHistory({
@@ -205,6 +219,7 @@ export const getMultipleAccountBalanceHistoryWithFiat = async ({
     fiatCurrency,
     forceRefetch,
     isElectrumBackend,
+    dispatch,
 }: {
     accounts: AccountItem[];
     startOfTimeFrameDate: Date | null;
@@ -213,15 +228,18 @@ export const getMultipleAccountBalanceHistoryWithFiat = async ({
     fiatCurrency: FiatCurrencyCode;
     forceRefetch?: boolean;
     isElectrumBackend: boolean;
+    dispatch: ReturnType<typeof useDispatch>;
 }): Promise<FiatGraphPoint[] | FiatGraphPointWithCryptoBalance[]> => {
     const accountsWithBalanceHistory = await Promise.all(
-        accounts.map(({ coin, descriptor, identity }) =>
+        accounts.map(({ coin, descriptor, identity, accountKey }) =>
             getAccountBalanceHistory({
                 coin,
                 descriptor,
                 identity,
                 endOfTimeFrameDate,
                 forceRefetch,
+                dispatch,
+                accountKey,
             })
                 .then(balanceHistory => ({
                     coin,

suite-common/graph/src/hooks.ts

@@ -1,5 +1,5 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-import { useSelector } from 'react-redux';
+import { useDispatch, useSelector } from 'react-redux';
 
 import { roundToNearestMinutes, subHours } from 'date-fns';
 import { A } from '@mobily/ts-belt';
@@ -93,6 +93,7 @@ export function useGraphForAccounts(params: useGraphForAccountsParams): {
     const [error, setError] = useState<string | null>(null);
     const isDiscoveryActive = useSelector(selectIsDeviceDiscoveryActive);
     const isDeviceAuthorized = useSelector(selectIsDeviceAuthorized);
+    const dispatch = useDispatch();
 
     const lastFetchTimestamp = useRef<number | null>(null);
 
@@ -118,6 +119,7 @@ export function useGraphForAccounts(params: useGraphForAccountsParams): {
                         endOfTimeFrameDate,
                         forceRefetch,
                         isElectrumBackend,
+                        dispatch,
                     });
 
                     let events;
@@ -128,6 +130,7 @@ export function useGraphForAccounts(params: useGraphForAccountsParams): {
                             account: accounts[0],
                             startOfTimeFrameDate,
                             endOfTimeFrameDate,
+                            dispatch,
                         });
 
                         normalizeExtremeGraphEvents(
@@ -159,6 +162,7 @@ export function useGraphForAccounts(params: useGraphForAccountsParams): {
             isPortfolioGraph,
             isDiscoveryActive,
             isElectrumBackend,
+            dispatch,
         ],
     );