refactor: improved transactions count when using minHeight and maxHeight

Author: mschead

indexer/src/kadena-server/repository/infra/repository/transaction-db-repository.ts

@@ -540,6 +540,41 @@ export default class TransactionDbRepository implements TransactionRepository {
     return totalCount;
   }
 
+  private getHeightChange(
+    counters: { chainId: number; counter: number }[],
+    minHeight: number | null,
+    maxHeight: number | null,
+  ) {
+    // If no height constraints, return the sum of all counters
+    if (!minHeight && !maxHeight) {
+      return counters.reduce((acc, curr) => acc + curr.counter, 0);
+    }
+
+    let totalCount = 0;
+    for (const { chainId, counter } of counters) {
+      // Determine starting height for each chain
+      const chainStartHeight = chainId >= 10 ? 852054 : 0;
+
+      // If no maxHeight provided, use counter - 1 (since height 0 is valid)
+      const chainMaxHeight = maxHeight !== null ? maxHeight : counter - 1;
+
+      // Calculate the effective height range for this chain
+      const effectiveMinHeight = Math.max(minHeight || 0, chainStartHeight);
+      const effectiveMaxHeight = chainMaxHeight;
+
+      // If the range is invalid (min > max), skip this chain
+      if (effectiveMinHeight > effectiveMaxHeight) {
+        continue;
+      }
+
+      // Calculate how many blocks are included in the range [effectiveMinHeight, effectiveMaxHeight]
+      const includedBlocks = Math.max(0, effectiveMaxHeight - effectiveMinHeight + 1);
+
+      totalCount += includedBlocks;
+    }
+
+    return totalCount;
+  }
   /**
    * Counts transactions matching the specified filter parameters.
    * This method efficiently counts matching transactions without retrieving full data.
@@ -552,72 +587,53 @@ export default class TransactionDbRepository implements TransactionRepository {
       isCoinbase: isCoinbaseParam,
       chainId: chainIdParam,
       minimumDepth: minimumDepthParam,
+      minHeight: minHeightParam,
+      maxHeight: maxHeightParam,
       ...rest
     } = params;
+
     const hasNoOtherParams = Object.values(rest).every(v => v === undefined || v === null);
     if (hasNoOtherParams) {
       const query = `
-        SELECT sum("canonicalTransactions") as "totalTransactionsCount", sum("canonicalBlocks") as "totalBlocksCount"
+        SELECT "chainId", "canonicalTransactions" as "transactionsCount", "canonicalBlocks" as "blocksCount"
         FROM "Counters"
-        ${chainIdParam ? `WHERE "chainId" = $1` : ''}
       `;
 
-      const { rows } = await rootPgPool.query(query, chainIdParam ? [chainIdParam] : []);
-
-      const totalTransactionsCount = parseInt(rows?.[0]?.totalTransactionsCount ?? '0', 10);
-      const totalBlocksCount = parseInt(rows?.[0]?.totalBlocksCount ?? '0', 10);
-      const totalCount = totalTransactionsCount + (params.isCoinbase ? totalBlocksCount : 0);
+      const { rows } = await rootPgPool.query(query);
+
+      const counters = rows
+        .map(r => {
+          const { chainId, transactionsCount, blocksCount } = r;
+          const counter =
+            parseInt(transactionsCount, 10) + (params.isCoinbase ? parseInt(blocksCount, 10) : 0);
+          return {
+            chainId,
+            counter,
+          };
+        })
+        .filter(c => (chainIdParam ? c.chainId.toString() === chainIdParam : true));
+
+      const counterConsideringHeight = this.getHeightChange(
+        counters,
+        minHeightParam ?? null,
+        maxHeightParam ?? null,
+      );
 
       const depthDecrement = (minimumDepthParam ?? 0) * (isNullOrUndefined(chainIdParam) ? 20 : 1);
-      return Math.max(totalCount - depthDecrement, 0);
-    }
-
-    const {
-      accountName: accountNameParam,
-      fungibleName: fungibleNameParam,
-      chainId: chainIdParamTwo,
-      ...rest2
-    } = params;
-    const hasNoOtherParams2 = Object.values(rest2).every(v => v === undefined || v === null);
-    if (accountNameParam && fungibleNameParam && hasNoOtherParams2) {
-      let query = `
-        SELECT COUNT(*) as count
-        FROM "Transactions" t
-        JOIN "Events" e ON e."transactionId" = t.id
-        WHERE t.sender = $1 AND e.module = $2
-      `;
-
-      if (chainIdParamTwo) {
-        query += `\nAND EXISTS (
-          SELECT 1
-          FROM "Blocks" b
-          WHERE b.id = t."blockId"
-          AND b."chainId" = $3
-          AND b.canonical = true
-        )`;
-      }
-
-      const { rows: countResult } = await rootPgPool.query(query, [
-        accountNameParam,
-        fungibleNameParam,
-        chainIdParamTwo,
-      ]);
-
-      const totalCount = parseInt(countResult[0].count, 10);
-      const depthDecrement =
-        (minimumDepthParam ?? 0) * (isNullOrUndefined(chainIdParamTwo) ? 20 : 1);
-      return Math.max(totalCount - depthDecrement, 0);
+      return counterConsideringHeight - depthDecrement;
     }
 
     const {
       blockHash,
       accountName,
-      chainId,
       requestKey,
       fungibleName,
-      minHeight,
-      maxHeight,
       hasTokenId,
+      chainId,
+      isCoinbase,
+      maxHeight,
+      minHeight,
+      minimumDepth,
     } = params;
     const transactionsParams: (string | number)[] = [];
     const blockParams: (string | number | boolean)[] = [];
@@ -630,18 +646,12 @@ export default class TransactionDbRepository implements TransactionRepository {
       transactionsParams.push(accountName);
       const op = localOperator(transactionsParams.length);
       transactionsConditions += `${op} t.sender = $${transactionsParams.length}`;
-    } else if (!isCoinbaseParam) {
+    } else if (!isCoinbase) {
       transactionsParams.push('coinbase');
       const op = localOperator(transactionsParams.length);
       transactionsConditions += `${op} t.sender != $${transactionsParams.length}`;
     }
 
-    if (requestKey) {
-      transactionsParams.push(requestKey);
-      const op = localOperator(transactionsParams.length);
-      transactionsConditions += `${op} t."requestkey" = $${transactionsParams.length}`;
-    }
-
     if (fungibleName) {
       transactionsParams.push(fungibleName);
       const op = localOperator(transactionsParams.length);
@@ -655,19 +665,23 @@ export default class TransactionDbRepository implements TransactionRepository {
         )`;
     }
 
-    if (accountName && hasTokenId) {
-      transactionsParams.push(accountName);
+    if (hasTokenId) {
       const op = localOperator(transactionsParams.length);
       transactionsConditions += `
         ${op} EXISTS
         (
           SELECT 1
           FROM "Transfers" t
-          WHERE t."from_acct" = $${transactionsParams.length}
-          AND t."hasTokenId" = true
+          WHERE t."hasTokenId" = true
         )`;
     }
 
+    if (requestKey) {
+      transactionsParams.push(requestKey);
+      const op = localOperator(transactionsParams.length);
+      transactionsConditions += `${op} t."requestkey" = $${transactionsParams.length}`;
+    }
+
     const paramsOffset = transactionsParams.length;
 
     blockParams.push(true);
@@ -698,16 +712,16 @@ export default class TransactionDbRepository implements TransactionRepository {
     }
 
     const totalCountQuery = `
-    WITH filtered_transactions AS (
-      SELECT id, "blockId"
-      FROM "Transactions" t
-      ${transactionsConditions}
+      WITH filtered_transactions AS (
+        SELECT id, "blockId"
+        FROM "Transactions" t
+        ${transactionsConditions}
       )
       SELECT COUNT(*) as count
       FROM filtered_transactions t
       ${blocksConditions ? `JOIN "Blocks" b ON b.id = t."blockId"` : ''}
       ${blocksConditions}
-      `;
+    `;
 
     const { rows: countResult } = await rootPgPool.query(totalCountQuery, [
       ...transactionsParams,