feat: Adds new tx contract data model [REFACTOR]

config/default.ts

@@ -9,7 +9,6 @@ type AppConfig = {
         base: Chain,
     },
     bridgeApiBaseUrl: string,
-    bridgeIndexerBaseUrl: string,
     bridgeIndexerPollingInterval: number,
     bridgePricePollingInterval: number,
     bridgeHeadsPollingInterval: number,
@@ -41,8 +40,7 @@ export const appConfig: AppConfig = {
         ethereum: process.env.NEXT_PUBLIC_ETH_NETWORK === 'mainnet' ? mainnet : sepolia,
         base: process.env.NEXT_PUBLIC_ETH_NETWORK === 'mainnet' ? base : baseSepolia,
     },
-    bridgeApiBaseUrl: process.env.NEXT_PUBLIC_BRIDGE_API_URL || 'http://0.0.0.0:8080',
-    bridgeIndexerBaseUrl: process.env.NEXT_PUBLIC_BRIDGE_INDEXER_URL ||'http://167.71.41.169:3000',
+    bridgeApiBaseUrl: process.env.NEXT_PUBLIC_BRIDGE_API_URL || 'https://hex-bridge-api.sandbox.avail.tools',
     bridgeIndexerPollingInterval: 30,
     bridgeHeadsPollingInterval: 600,
     bridgePricePollingInterval: 60,

services/transactions.ts

@@ -1,21 +1,19 @@
 import axios from "axios";
 import { appConfig } from "@/config/default";
 import { Transaction } from "@/types/transaction";
-import { Chain } from "@/types/common";
+import { TransactionResponseType } from "@/types/common";
 import { Logger } from "@/utils/logger";
 import { fetchWormholeTransactions } from "@/hooks/wormhole/helper";
 
-const indexerInstance = axios.create({
-    baseURL: appConfig.bridgeIndexerBaseUrl,
-    headers: { "Access-Control-Allow-Origin": "*" },
-    withCredentials: false
+const bridgeApiInstance = axios.create({
+  baseURL: appConfig.bridgeApiBaseUrl,
+  headers: { "Access-Control-Allow-Origin": "*" },
+  withCredentials: false,
 });
 
 type TransactionQueryParams = {
-    availAddress?: string;
-    ethAddress?: string;
-    sourceChain?: string;
-    destinationChain?: string;
+  availAddress?: string;
+  ethAddress?: string;
 };
 
 function validateParams({ availAddress, ethAddress }: TransactionQueryParams) {
@@ -26,47 +24,47 @@ function validateParams({ availAddress, ethAddress }: TransactionQueryParams) {
     }
 }
 
-/** 
+function validateTransactionResponseType(queryParam: string) : string {
+    const chainAddressResponseMapping: Record<string, TransactionResponseType> = Object.freeze({
+        "ethAddress": TransactionResponseType.ETH_SEND,
+        "availAddress": TransactionResponseType.AVAIL_SEND
+    })
+    return chainAddressResponseMapping[queryParam];
+}
+
+/**
  * @description Fetches transactions from the indexer
- *      
- * @param userAddress
- * @param sourceChain
- * @param destinationChain
+ *
+ * @param address
+ * @param queryParam
  * @returns  List of transactions
-*/
-async function fetchTransactions(userAddress: string, sourceChain?: string, destinationChain?: string): Promise<Transaction[]> {
-    try {
-        const response = await indexerInstance.get(`/transactions`, {
-            params: {
-                userAddress,
-                sourceChain,
-                destinationChain,
-                limit: 100,
-                page: 0,
-            },
-        });
-        const transactions = response.data.data.result;
-        if (destinationChain) {
-            return transactions.map((transaction: Transaction) => ({
-                ...transaction,
-                destinationChain,
-            }));
-        }
-
-        return transactions;
-    } catch (e: any) {
-        Logger.error(`ERROR_FETCHING_TRANSACTIONS: ${e}`);
-        return [];
-    }
+ */
+async function fetchTransactions(
+  address: string,
+  queryParam: string
+): Promise<Transaction[]> {
+  try {
+    const response = await bridgeApiInstance.get(`/transactions`, {
+      params: {
+        [queryParam]: address,
+      },
+    });
+    return response.data[validateTransactionResponseType(queryParam)];
+  } catch (e: any) {
+    Logger.error(`ERROR_FETCHING_TRANSACTIONS: ${e}`);
+    return [];
+  }
 }
 
-const fetchWithErrorHandling = async (address: string, source: Chain, dest?: Chain) => {
-    try {
-        return await fetchTransactions(address, source, dest);
-    } catch (error) {
-        Logger.error(`Failed to fetch transactions for ${address} from ${source} to ${dest}: ${error}`);
-        return [];
-    }
+const fetchWithErrorHandling = async (address: string, queryParam: string) => {
+  try {
+    return await fetchTransactions(address, queryParam);
+  } catch (error) {
+    Logger.error(
+      `Failed to fetch transactions for ${address} from ${queryParam}: ${error}`
+    );
+    return [];
+  }
 };
 
 /**
@@ -75,10 +73,11 @@ const fetchWithErrorHandling = async (address: string, source: Chain, dest?: Cha
  * @param {TransactionQueryParams} 
  * @returns Transaction[]
  */
-export const getAllTransactions = async (
-    { availAddress, ethAddress, sourceChain, destinationChain }: TransactionQueryParams
-): Promise<Transaction[]> => {
-    validateParams({ availAddress, ethAddress });
+export const getAllTransactions = async ({
+  availAddress,
+  ethAddress,
+}: TransactionQueryParams): Promise<Transaction[]> => {
+  validateParams({ availAddress, ethAddress });
 
     const allTransactions: Transaction[] = [];
     const seenHashes = new Set<string>();
@@ -95,18 +94,11 @@ export const getAllTransactions = async (
     const fetchPromises: Promise<Transaction[]>[] = [];
 
     if (ethAddress) {
-        fetchPromises.push(
-            fetchWithErrorHandling(ethAddress, Chain.ETH, Chain.AVAIL),
-            fetchWithErrorHandling(ethAddress, Chain.AVAIL, Chain.ETH),
-            // fetchWormholeTransactions(false, ethAddress as `0x${string}`)
-        );
+        fetchPromises.push(fetchWithErrorHandling(ethAddress, "ethAddress"));
     }
 
     if (availAddress) {
-        fetchPromises.push(
-            fetchWithErrorHandling(availAddress, Chain.AVAIL, Chain.ETH),
-            fetchWithErrorHandling(availAddress, Chain.ETH, Chain.AVAIL)
-        );
+        fetchPromises.push(fetchWithErrorHandling(availAddress, "availAddress"));
     }
 
     const results = await Promise.all(fetchPromises);

types/common.ts

@@ -13,6 +13,11 @@ export enum TransactionStatus {
   CLAIM_PENDING = "PENDING",
 }
 
+export enum TransactionResponseType {
+  AVAIL_SEND = "availSend",
+  ETH_SEND = "ethSend"
+}
+
 export interface ethBalance {
   decimals: number;
   formatted: string;

types/transaction.ts

@@ -77,25 +77,18 @@ export interface sendMessageParams {
 }
 
 export interface Transaction {
-  status: TransactionStatus,
-  destinationChain: Chain,
-  messageId?: number,
-  sourceChain: Chain,
-  amount: string,
-  dataType?: "ERC20",
-  depositorAddress: `0x${string}` | string,
-  receiverAddress: string,
-  sourceBlockHash?: `${string}`,
-  sourceBlockNumber?: number,
-  sourceTransactionHash: `0x${string}`,
-  sourceTransactionIndex?: number,
-  sourceTimestamp: string
-  sourceTokenAddress?: `0x${string}`;
-  destinationTransactionHash?: `0x${string}` | string;
-  destinationTransactionBlockNumber?: number;
-  destinationTransactionTimestamp?: number;
-  destinationTransactionIndex?: number;
-  destinationTokenAddress?: `0x${string}`;
-  message?: string;
-  blockHash?: `0x${string}`;
+    amount: string,
+    depositorAddress: string,
+    destinationBlockHash?: string,
+    destinationBlockNumber?: number,
+    destinationTimestamp?: string,
+    messageId: number,
+    receiverAddress: string,
+    sourceBlockHash: string,
+    sourceBlockNumber: number,
+    sourceTimestamp: string,
+    sourceTransactionHash: string,
+    sourceTransactionIndex?: number,
+    status: TransactionStatus,
+    tokenId: string
 }