tx details debug endpoint

Author: arcoraven

src/server/routes/admin/transaction.ts

@@ -0,0 +1,136 @@
+import { Static, Type } from "@sinclair/typebox";
+import { Queue } from "bullmq";
+import { FastifyInstance } from "fastify";
+import { StatusCodes } from "http-status-codes";
+import { stringify } from "thirdweb/utils";
+import { TransactionDB } from "../../../db/transactions/db";
+import { getConfig } from "../../../utils/cache/getConfig";
+import { maybeDate } from "../../../utils/primitiveTypes";
+import { redis } from "../../../utils/redis/redis";
+import { MineTransactionQueue } from "../../../worker/queues/mineTransactionQueue";
+import { SendTransactionQueue } from "../../../worker/queues/sendTransactionQueue";
+import { createCustomError } from "../../middleware/error";
+import { standardResponseSchema } from "../../schemas/sharedApiSchemas";
+
+const requestSchema = Type.Object({
+  queueId: Type.String({
+    description: "Transaction queue ID",
+    examples: ["9eb88b00-f04f-409b-9df7-7dcc9003bc35"],
+  }),
+});
+
+const jobSchema = Type.Object({
+  queue: Type.String(),
+  jobId: Type.String(),
+  timestamp: Type.String(),
+  processedOn: Type.Optional(Type.String()),
+  finishedOn: Type.Optional(Type.String()),
+  lines: Type.Array(Type.String()),
+});
+
+export const responseBodySchema = Type.Object({
+  result: Type.Object({
+    raw: Type.Any(),
+    jobs: Type.Array(jobSchema),
+  }),
+});
+
+responseBodySchema.example = {
+  result: {
+    raw: {
+      queueId: "9eb88b00-f04f-409b-9df7-7dcc9003bc35",
+    },
+    logs: ["Log line 1", "Log line 2"],
+  },
+};
+
+export async function getTransactionDetails(fastify: FastifyInstance) {
+  fastify.route<{
+    Params: Static<typeof requestSchema>;
+    Reply: Static<typeof responseBodySchema>;
+  }>({
+    method: "GET",
+    url: "/admin/transaction-details/:queueId",
+    schema: {
+      summary: "Get transaction details",
+      description: "Get raw logs and details for a transaction by queueId.",
+      tags: ["Admin"],
+      operationId: "transactionDetails",
+      params: requestSchema,
+      response: {
+        ...standardResponseSchema,
+        [StatusCodes.OK]: responseBodySchema,
+      },
+      hide: true,
+    },
+    handler: async (request, reply) => {
+      const { queueId } = request.params;
+
+      const transaction = await TransactionDB.get(queueId);
+      if (!transaction) {
+        throw createCustomError(
+          "Transaction not found.",
+          StatusCodes.BAD_REQUEST,
+          "TRANSACTION_NOT_FOUND",
+        );
+      }
+
+      const config = await getConfig();
+      const jobs: Static<typeof jobSchema>[] = [];
+
+      // SentTransaction jobs.
+      for (
+        let resendCount = 0;
+        resendCount < config.maxRetriesPerTx;
+        resendCount++
+      ) {
+        const jobDetails = await getJobDetails({
+          queue: SendTransactionQueue.q,
+          jobId: SendTransactionQueue.jobId({ queueId, resendCount }),
+        });
+        if (jobDetails) {
+          jobs.push(jobDetails);
+        }
+      }
+
+      // MineTransaction job.
+      const jobDetails = await getJobDetails({
+        queue: MineTransactionQueue.q,
+        jobId: MineTransactionQueue.jobId({ queueId }),
+      });
+      if (jobDetails) {
+        jobs.push(jobDetails);
+      }
+
+      reply.status(StatusCodes.OK).send({
+        result: {
+          raw: JSON.parse(stringify(transaction)),
+          jobs,
+        },
+      });
+    },
+  });
+}
+
+const getJobDetails = async (args: {
+  queue: Queue;
+  jobId: string;
+}): Promise<Static<typeof jobSchema> | null> => {
+  console.log("[DEBUG] args", args);
+  const { queue, jobId } = args;
+  const job = await queue.getJob(jobId);
+  if (!job) {
+    return null;
+  }
+
+  const key = `bull:${queue.name}:${jobId}:logs`;
+  const lines = await redis.lrange(key, 0, -1);
+  return {
+    queue: queue.name,
+    jobId,
+    timestamp: maybeDate(job.timestamp).toISOString(),
+    processedOn: maybeDate(job.processedOn)?.toISOString(),
+    finishedOn: maybeDate(job.finishedOn)?.toISOString(),
+    lines,
+  };
+};

src/server/routes/index.ts

@@ -120,9 +120,9 @@ import { getTxHashReceipt } from "./transaction/blockchain/getTxReceipt";
 import { getUserOpReceipt } from "./transaction/blockchain/getUserOpReceipt";
 import { sendSignedTransaction } from "./transaction/blockchain/sendSignedTx";
 import { sendSignedUserOp } from "./transaction/blockchain/sendSignedUserOp";
-import { checkGroupStatus } from "./transaction/group";
 
 // Indexer
+import { getTransactionDetails } from "./admin/transaction";
 import { setUrlsToCorsConfiguration } from "./configuration/cors/set";
 import { getIpAllowlist } from "./configuration/ip/get";
 import { setIpAllowlist } from "./configuration/ip/set";
@@ -246,7 +246,6 @@ export const withRoutes = async (fastify: FastifyInstance) => {
   await fastify.register(checkTxStatus);
   await fastify.register(getAllTx);
   await fastify.register(getAllDeployedContracts);
-  await fastify.register(checkGroupStatus);
   await fastify.register(retryTransaction);
   await fastify.register(syncRetryTransaction);
   await fastify.register(cancelTransaction);
@@ -287,4 +286,7 @@ export const withRoutes = async (fastify: FastifyInstance) => {
   await fastify.register(getContractEventLogs);
   await fastify.register(getEventLogs);
   await fastify.register(pageEventLogs);
+
+  // Admin
+  await fastify.register(getTransactionDetails);
 };

src/server/routes/transaction/group.ts

@@ -4,12 +4,18 @@ export const maybeBigInt = (val?: string) => (val ? BigInt(val) : undefined);
 
 // These overloads hint TS at the response type (ex: Address if `val` is Address).
 export function normalizeAddress(val: Address): Address;
-export function normalizeAddress(val: Address | undefined): Address | undefined;
+export function normalizeAddress(val?: Address): Address | undefined;
 export function normalizeAddress(val: string): Address;
-export function normalizeAddress(val: string | undefined): Address | undefined;
+export function normalizeAddress(val?: string): Address | undefined;
 export function normalizeAddress(val: string | null): undefined;
 export function normalizeAddress(
   val?: string | Address | null,
 ): Address | undefined {
   return val ? (val.toLowerCase() as Address) : undefined;
 }
+
+export function maybeDate(val: number): Date;
+export function maybeDate(val?: number): Date | undefined;
+export function maybeDate(val?: number): Date | undefined {
+  return val ? new Date(val) : undefined;
+}

src/utils/primitiveTypes.ts

@@ -24,11 +24,11 @@ export class MineTransactionQueue {
 
   // There must be a worker to poll the result for every transaction hash,
   // even for the same queueId. This handles if any retried transactions succeed.
-  private static _jobId = (data: MineTransactionData) => data.queueId;
+  static jobId = (data: MineTransactionData) => data.queueId;
 
   static add = async (data: MineTransactionData) => {
     const serialized = superjson.stringify(data);
-    const jobId = this._jobId(data);
+    const jobId = this.jobId(data);
     await this.q.add(jobId, serialized, { jobId });
   };
 

src/worker/queues/mineTransactionQueue.ts

@@ -18,18 +18,18 @@ export class SendTransactionQueue {
   });
 
   // Allow enqueing the same queueId for multiple retries.
-  private static _jobId = (data: SendTransactionData) =>
+  static jobId = (data: SendTransactionData) =>
     `${data.queueId}:${data.resendCount}`;
 
   static add = async (data: SendTransactionData) => {
     const serialized = superjson.stringify(data);
-    const jobId = this._jobId(data);
+    const jobId = this.jobId(data);
     await this.q.add(jobId, serialized, { jobId });
   };
 
   static remove = async (data: SendTransactionData) => {
     try {
-      await this.q.remove(this._jobId(data));
+      await this.q.remove(this.jobId(data));
     } catch (e) {
       // Job is currently running.
     }