txs: new queries

src/react-query/index.ts

@@ -7,6 +7,7 @@ export { persistOptions, queryClient } from './queryClient';
 export type {
   MutationConfig,
   MutationFunctionResult,
+  InfiniteQueryConfig,
   QueryConfig,
   QueryConfigDeprecated,
   QueryConfigWithSelect,

src/react-query/types.ts

@@ -1,4 +1,4 @@
-import { QueryFunctionContext, QueryKey, UseMutationOptions, UseQueryOptions } from '@tanstack/react-query';
+import { QueryFunctionContext, QueryKey, UseInfiniteQueryOptions, UseMutationOptions, UseQueryOptions } from '@tanstack/react-query';
 
 // Used to obtain argument types for query functions.
 export type QueryFunctionArgs<T extends (...args: any) => any> = QueryFunctionContext<ReturnType<T>>;
@@ -45,3 +45,8 @@ export type QueryConfigDeprecated<QueryFnType extends (...args: any) => any> = O
   UseQueryOptions<ExtractFnReturnType<QueryFnType>>,
   'queryKey' | 'queryFn'
 >;
+
+export type InfiniteQueryConfig<TQueryFnData, TError, TData> = Pick<
+  UseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryFnData, Array<string | { [key: string]: any }>>,
+  'cacheTime' | 'enabled' | 'refetchInterval' | 'retry' | 'staleTime' | 'select' | 'onError' | 'onSettled' | 'onSuccess'
+>;

src/resources/transactions/consolidatedTransactions.ts

@@ -0,0 +1,147 @@
+import { useInfiniteQuery } from '@tanstack/react-query';
+import { InfiniteQueryConfig, QueryConfig, QueryFunctionArgs, createQueryKey, queryClient } from '@/react-query';
+import { NativeCurrencyKey, RainbowTransaction } from '@/entities';
+import { TransactionApiResponse, TransactionsReceivedMessage } from './types';
+import { RainbowError, logger } from '@/logger';
+import { rainbowFetch } from '@/rainbow-fetch';
+import { ADDYS_API_KEY } from 'react-native-dotenv';
+import { RainbowNetworks } from '@/networks';
+//import { parseTransaction } from '@/parsers/transactions';
+
+const CONSOLIDATED_TRANSACTIONS_INTERVAL = 30000;
+const CONSOLIDATED_TRANSACTIONS_TIMEOUT = 20000;
+
+// ///////////////////////////////////////////////
+// Query Types
+
+export type ConsolidatedTransactionsArgs = {
+  address: string;
+  currency: NativeCurrencyKey;
+  chainIds: number[];
+};
+
+// ///////////////////////////////////////////////
+// Query Key
+
+export const consolidatedTransactionsQueryKey = ({ address, currency, chainIds }: ConsolidatedTransactionsArgs) =>
+  createQueryKey('consolidatedTransactions', { address, currency, chainIds }, { persisterVersion: 1 });
+
+type ConsolidatedTransactionsQueryKey = ReturnType<typeof consolidatedTransactionsQueryKey>;
+
+// ///////////////////////////////////////////////
+// Query Fetcher
+
+export async function fetchConsolidatedTransactions<ConsolidatedTransactionsResult>(
+  { address, currency, chainIds }: ConsolidatedTransactionsArgs,
+  config: QueryConfig<ConsolidatedTransactionsResult, Error, ConsolidatedTransactionsQueryKey>
+) {
+  return await queryClient.fetchQuery(
+    consolidatedTransactionsQueryKey({
+      address,
+      currency,
+      chainIds,
+    }),
+    consolidatedTransactionsQueryFunction,
+    config
+  );
+}
+
+// ///////////////////////////////////////////////
+// Query Function
+
+type _QueryResult = {
+  cutoff?: number;
+  nextPage?: string;
+  transactions: RainbowTransaction[] | [];
+};
+
+export async function consolidatedTransactionsQueryFunction({
+  queryKey: [{ address, currency, chainIds }],
+  pageParam,
+}: QueryFunctionArgs<typeof consolidatedTransactionsQueryKey>): Promise<_QueryResult> {
+  try {
+    const chainIdsString = chainIds.join(',');
+    const url = `https://addys.p.rainbow.me/v3/${chainIdsString}/${address}/transactions`;
+    const response = await rainbowFetch(url, {
+      method: 'get',
+      params: {
+        currency: currency.toLowerCase(),
+        ...(pageParam ? { pageCursor: pageParam } : {}),
+      },
+      timeout: CONSOLIDATED_TRANSACTIONS_TIMEOUT,
+      headers: {
+        Authorization: `Bearer ${ADDYS_API_KEY}`,
+      },
+    });
+
+    const consolidatedTransactions = await parseConsolidatedTransactions(response?.data, currency);
+
+    return {
+      cutoff: response?.data?.meta?.cut_off,
+      nextPage: response?.data?.meta?.next_page_cursor,
+      transactions: consolidatedTransactions,
+    };
+  } catch (e) {
+    logger.error(new RainbowError('consolidatedTransactionsQueryFunction: '), {
+      message: e,
+    });
+    return { transactions: [] };
+  }
+}
+
+type ConsolidatedTransactionsResult = {
+  cutoff?: number;
+  nextPage?: string;
+  transactions: RainbowTransaction[];
+};
+/**
+ * 
+ * should we? 
+ *   queryClient.invalidateQueries({
+        queryKey: nftsQueryKey({ address: accountAddress }),
+      });
+ */
+async function parseConsolidatedTransactions(
+  message: TransactionsReceivedMessage,
+  currency: NativeCurrencyKey
+): Promise<RainbowTransaction[]> {
+  const data = message?.payload?.transactions || [];
+
+  return [];
+  //   const parsedTransactionPromises = data.map((tx: TransactionApiResponse) =>
+  //     parseTransaction(tx, currency)
+  //   );
+  //   // Filter out undefined values immediately
+
+  //   const parsedConsolidatedTransactions = (
+  //     await Promise.all(parsedTransactionPromises)
+  //   ).flat(); // Filter out any remaining undefined values
+
+  //   return parsedConsolidatedTransactions;
+}
+
+// ///////////////////////////////////////////////
+// Query Hook
+
+export function useConsolidatedTransactions(
+  { address, currency }: Pick<ConsolidatedTransactionsArgs, 'address' | 'currency'>,
+  config: InfiniteQueryConfig<ConsolidatedTransactionsResult, Error, ConsolidatedTransactionsResult> = {}
+) {
+  const chainIds = RainbowNetworks.filter(network => network.enabled && network.networkType !== 'testnet').map(network => network.id);
+
+  return useInfiniteQuery(
+    consolidatedTransactionsQueryKey({
+      address,
+      currency,
+      chainIds,
+    }),
+    consolidatedTransactionsQueryFunction,
+    {
+      ...config,
+      keepPreviousData: true,
+      getNextPageParam: lastPage => lastPage?.nextPage,
+      refetchInterval: CONSOLIDATED_TRANSACTIONS_INTERVAL,
+      retry: 3,
+    }
+  );
+}

src/resources/transactions/transaction.ts

@@ -0,0 +1,127 @@
+import { NativeCurrencyKey } from '@/entities';
+import { createQueryKey, queryClient, QueryFunctionArgs, QueryFunctionResult } from '@/react-query';
+import { useQuery } from '@tanstack/react-query';
+import { consolidatedTransactionsQueryFunction, consolidatedTransactionsQueryKey } from './consolidatedTransactions';
+import { useAccountSettings } from '@/hooks';
+import { RainbowNetworks, getNetworkObj } from '@/networks';
+import { rainbowFetch } from '@/rainbow-fetch';
+import { ADDYS_API_KEY } from 'react-native-dotenv';
+//import { parseTransaction } from '@/parsers/transactions';
+import { Network } from '@/networks/types';
+import { RainbowError, logger } from '@/logger';
+
+type ConsolidatedTransactionsResult = QueryFunctionResult<typeof consolidatedTransactionsQueryFunction>;
+
+export type TransactionArgs = {
+  hash: string;
+  address: string;
+  currency: NativeCurrencyKey;
+  network: Network;
+};
+
+export type BackendTransactionArgs = {
+  hash: string;
+  network: Network;
+  enabled: boolean;
+};
+
+export const transactionQueryKey = ({ hash, address, currency, network }: TransactionArgs) =>
+  createQueryKey('transactions', { address, currency, network, hash }, { persisterVersion: 1 });
+
+export const fetchTransaction = async ({
+  queryKey: [{ address, currency, network, hash }],
+}: QueryFunctionArgs<typeof transactionQueryKey>) => {
+  try {
+    const chainId = getNetworkObj(network).id;
+    const url = `https://addys.p.rainbow.me/v3/${chainId}/${address}/transactions/${hash}`;
+    const response = await rainbowFetch(url, {
+      method: 'get',
+      params: {
+        currency: currency.toLowerCase(),
+      },
+      timeout: 20000,
+      headers: {
+        Authorization: `Bearer ${ADDYS_API_KEY}`,
+      },
+    });
+    const tx = response?.data?.payload?.transaction || [];
+
+    return undefined;
+    // const parsedTx = await parseTransaction(tx, currency);
+    // if (!parsedTx) throw new Error('Failed to parse transaction');
+    // return parsedTx;
+  } catch (e) {
+    logger.error(new RainbowError('fetchTransaction: '), {
+      message: (e as Error)?.message,
+    });
+  }
+};
+
+// ///////////////////////////////////////////////
+// Query Function
+
+export const transactionFetchQuery = async ({
+  address,
+  currency,
+  network,
+  hash,
+}: {
+  address: string;
+  currency: NativeCurrencyKey;
+  network: Network;
+  hash: string;
+}) => queryClient.fetchQuery(transactionQueryKey({ address, currency, network, hash }), fetchTransaction);
+
+type PaginatedTransactions = { pages: ConsolidatedTransactionsResult[] };
+
+export function useBackendTransaction({ hash, network }: BackendTransactionArgs) {
+  const { accountAddress, nativeCurrency } = useAccountSettings();
+
+  const chainIds = RainbowNetworks.filter(network => network.enabled && network.networkType !== 'testnet').map(network => network.id);
+
+  const paginatedTransactionsKey = consolidatedTransactionsQueryKey({
+    address: accountAddress,
+    currency: nativeCurrency,
+    chainIds,
+  });
+
+  const params: TransactionArgs = {
+    hash: hash,
+    address: accountAddress,
+    currency: nativeCurrency,
+    network: network,
+  };
+
+  return useQuery(transactionQueryKey(params), fetchTransaction, {
+    enabled: !!hash && !!accountAddress && !!network,
+    initialData: () => {
+      const queryData = queryClient.getQueryData<PaginatedTransactions>(paginatedTransactionsKey);
+      const pages = queryData?.pages || [];
+      for (const page of pages) {
+        const tx = page.transactions.find(tx => tx.hash === hash);
+        if (tx) {
+          return tx;
+        }
+      }
+    },
+    initialDataUpdatedAt: () => queryClient.getQueryState(paginatedTransactionsKey)?.dataUpdatedAt,
+  });
+}
+
+export const useTransaction = ({ network, hash }: { network: Network; hash: string }) => {
+  const {
+    data: backendTransaction,
+    isLoading: backendTransactionIsLoading,
+    isFetched: backendTransactionIsFetched,
+  } = useBackendTransaction({
+    hash,
+    network,
+    enabled: !!hash && !!network,
+  });
+
+  return {
+    data: backendTransaction,
+    isLoading: backendTransactionIsLoading,
+    isFetched: backendTransactionIsFetched,
+  };
+};