Merge pull request #431 from hack-a-chain-software/transaction-code

feat: added code filter to transactions query

Author: mschead

indexer/src/kadena-server/config/graphql-types.ts

@@ -959,6 +959,7 @@ export type QueryTransactionsArgs = {
   before?: InputMaybe<Scalars['String']['input']>;
   blockHash?: InputMaybe<Scalars['String']['input']>;
   chainId?: InputMaybe<Scalars['String']['input']>;
+  code?: InputMaybe<Scalars['String']['input']>;
   first?: InputMaybe<Scalars['Int']['input']>;
   fungibleName?: InputMaybe<Scalars['String']['input']>;
   isCoinbase?: InputMaybe<Scalars['Boolean']['input']>;

indexer/src/kadena-server/config/schema.graphql

@@ -311,6 +311,7 @@ type Query {
     minimumDepth: Int
     requestKey: String
     isCoinbase: Boolean
+    code: String
   ): QueryTransactionsConnection! @complexity(value: 1, multipliers: ["first", "last"])
 
   """

indexer/src/kadena-server/repository/application/transaction-repository.ts

@@ -73,6 +73,8 @@ export interface GetTransactionsCountParams {
   hasTokenId?: boolean | null;
   /** Filter by coinbase */
   isCoinbase?: boolean | null;
+  /** Filter by transaction code */
+  transactionCode?: string | null;
 }
 
 /**

indexer/src/kadena-server/repository/infra/query-builders/transaction-query-builder.ts

@@ -413,4 +413,69 @@ export default class TransactionQueryBuilder {
 
     return { query, queryParams };
   }
+
+  buildTransactionByCodeQuery(params: {
+    after?: string | null;
+    before?: string | null;
+    order: string;
+    limit: number;
+    transactionCode: string;
+  }) {
+    let whereCondition = `\nWHERE td.code::text LIKE '%' || $2::text || '%' AND b.canonical = $3`;
+    let queryParams: (string | number | boolean)[] = [params.limit, params.transactionCode, true];
+
+    if (!params.after && !params.before && params.order === 'DESC') {
+      const currentTime = Date.now() - 10000000;
+      queryParams.push(currentTime, 0);
+      whereCondition += `\nAND t.creationtime > $${queryParams.length - 1} AND t.id > $${queryParams.length}`;
+    }
+
+    if (params.after) {
+      const [creationTime, id] = params.after.split(':');
+      queryParams.push(creationTime, id);
+      whereCondition += `\nAND (t.creationtime, t.id) < ($${queryParams.length - 1}, $${queryParams.length})`;
+    }
+    if (params.before) {
+      const [creationTime, id] = params.before.split(':');
+      queryParams.push(creationTime, id);
+      whereCondition += `\nAND (t.creationtime, t.id) > ($${queryParams.length - 1}, $${queryParams.length})`;
+    }
+
+    const query = `
+      WITH filtered_transactions AS (
+        SELECT t.*, td.code, td.nonce, td.sigs, td.continuation, td.pactid, td.proof, td.rollback, td.gas, td.step, td.data, b.height, b.hash as "blockHash"
+        FROM "Transactions" t
+        JOIN "TransactionDetails" td ON t.id = td."transactionId"
+        JOIN "Blocks" b ON b.id = t."blockId"
+        ${whereCondition}
+        ORDER BY t.creationtime ${params.order}, t.id ${params.order}
+      )
+      SELECT
+        t.id AS id,
+        t.creationtime AS "creationTime",
+        t.hash AS "hashTransaction",
+        t.nonce AS "nonceTransaction",
+        t.sigs AS sigs,
+        t.continuation AS continuation,
+        t.num_events AS "eventCount",
+        t.pactid AS "pactId",
+        t.proof AS proof,
+        t.rollback AS rollback,
+        t.txid AS txid,
+        t.height AS "height",
+        t."blockHash" AS "blockHash",
+        t."chainId" AS "chainId",
+        t.gas AS "gas",
+        t.step AS step,
+        t.data AS data,
+        t.code AS code,
+        t.logs AS "logs",
+        t.result AS "result",
+        t.requestkey AS "requestKey"
+      FROM filtered_transactions t
+      LIMIT $1
+    `;
+
+    return { query, queryParams };
+  }
 }

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

@@ -126,9 +126,30 @@ export default class TransactionDbRepository implements TransactionRepository {
       return pageInfo;
     }
 
-    const maxHeightFromDb = (await rootPgPool.query(`SELECT max(height) FROM "Blocks"`)).rows[0]
-      .max;
+    if (rest.transactionCode) {
+      const { query, queryParams } = this.queryBuilder.buildTransactionByCodeQuery({
+        after,
+        before,
+        order,
+        limit,
+        transactionCode: rest.transactionCode,
+      });
+
+      // Execute the query with the constructed parameters
+      const { rows } = await rootPgPool.query(query, queryParams);
+
+      // Transform database rows into GraphQL-compatible edges with cursors
+      const edges = rows.map(row => ({
+        cursor: `${row.creationTime.toString()}:${row.id.toString()}`,
+        node: transactionValidator.validate(row),
+      }));
+
+      const pageInfo = getPageInfo({ edges, order, limit, after, before });
+      return pageInfo;
+    }
 
+    const maxHeightQuery = `SELECT max(height) FROM "Blocks"`;
+    const maxHeightFromDb = (await rootPgPool.query(maxHeightQuery)).rows[0].max;
     // If no minimumDepth is specified, we can use the normal query approach
     if (!rest.minimumDepth) {
       // Build and execute the query using the query builder

indexer/src/kadena-server/resolvers/fields/query-transactions-connection/total-count-query-transactions-connection-resolver.ts

@@ -20,6 +20,7 @@ const schema = zod.object({
   minimumDepth: zod.number().nullable().optional(),
   requestKey: zod.string().nullable().optional(),
   isCoinbase: zod.boolean().nullable().optional(),
+  transactionCode: zod.string().nullable().optional(),
 });
 
 /**
@@ -43,7 +44,13 @@ export const totalCountQueryTransactionsConnectionResolver: QueryTransactionsCon
       fungibleName,
       requestKey,
       isCoinbase,
+      transactionCode,
     } = schema.parse(parent);
+
+    if (transactionCode) {
+      throw new Error('Total count is not supported for transactions with code.');
+    }
+
     const output = await context.transactionRepository.getTransactionsCount({
       accountName,
       blockHash,

indexer/src/kadena-server/resolvers/query/transactions-query-resolver.ts

@@ -16,6 +16,7 @@
  * a clean interface for transaction data access.
  */
 
+import { isNullOrUndefined } from '@/utils/helpers';
 import { ResolverContext } from '../../config/apollo-server-config';
 import { QueryResolvers } from '../../config/graphql-types';
 import { buildTransactionOutput } from '../output/build-transaction-output';
@@ -59,6 +60,21 @@ export const transactionsQueryResolver: QueryResolvers<ResolverContext>['transac
     isCoinbase,
   } = args;
 
+  const hasNoParamsSet = Object.values({
+    accountName,
+    blockHash,
+    chainId,
+    fungibleName,
+    requestKey,
+    maxHeight,
+    minHeight,
+    minimumDepth,
+    isCoinbase,
+  }).every(v => isNullOrUndefined(v));
+  if (args.code && !hasNoParamsSet) {
+    throw new Error('Code parameter cannot be composed with other filters');
+  }
+
   // Call the repository layer to retrieve the filtered and paginated transactions
   // Pass all parameters through to maintain complete filtering flexibility
   const output = await context.transactionRepository.getTransactions({
@@ -71,6 +87,7 @@ export const transactionsQueryResolver: QueryResolvers<ResolverContext>['transac
     minHeight,
     minimumDepth,
     isCoinbase,
+    transactionCode: args.code,
     first,
     last,
     before,
@@ -105,5 +122,6 @@ export const transactionsQueryResolver: QueryResolvers<ResolverContext>['transac
     isCoinbase,
     fungibleName,
     requestKey,
+    transactionCode: args.code,
   };
 };