refactor(verifier): fic VerificationResultId issue

Author: tunntun

node/src/app.ts

@@ -14,12 +14,11 @@ import { nodeKeys } from "./crypto/keyPair.js";
 import { fetchPeerInfo } from "./gossip/utils/fetchPeerInfo.js";
 import { nodeState } from "./state/nodeState.js";
 import { runGDV } from "./verifier/gdvVerifier.js";
-import { getVerificationResultId } from "./merkle/verificationMerkleTree.js";
 import { minePendingVerificationResults } from "./mining/blockMiner.js";
 
 import type { MessageType, BaseMessage, PayloadByMessageType, NetworkMessageOf, NewPeerPayload, NetworkMessage} from "./types/messages.js";
 import type { ProofRecord } from "./types/proof.js";
-import type { VerificationResult } from "./types/verification.js";
+import { getVerificationResultId, type VerificationResult } from "./types/verification.js";
 
 const app = express();
 app.use(express.json());
@@ -453,7 +452,7 @@ app.get("/mempool", (_req, res) => {
   res.json({
     size: nodeState.verificationMempool.size(),
     results: results.map((result) => ({
-      resultId: getVerificationResultId(result),
+      resultId: result.verificationResultId,
       proofId: result.proofId,
       verifierNodeId: result.verifierNodeId,
       verified: result.verified,

node/src/merkle/verificationMerkleTree.ts

@@ -23,8 +23,4 @@ export async function computeVerificationMerkleRoot(
   const tree = await generateMerkleTree(leaves);
 
   return tree.root;
-}
-
-export function getVerificationResultId(result: VerificationResult): VerificationResultId {
-  return `${result.proofId}:${result.verifierNodeId}`;
 }

node/src/mining/blockMiner.ts

@@ -1,6 +1,6 @@
 import { createBlock } from "../block/block.js";
 import { mineBlock } from "../PoW/proofOfWork.js";
-import { getVerificationResultId } from "../merkle/verificationMerkleTree.js";
+import { getVerificationResultId } from "../types/verification.js";
 
 import type { Block, BlockInput } from "../types/block.js";
 import type { MinePendingResultsInput } from "../types/mining.js";
@@ -31,7 +31,7 @@ export async function minePendingVerificationResults(input: MinePendingResultsIn
     return null;
 
 
-  input.mempool.remove(selectedResults.map(getVerificationResultId));
+  input.mempool.remove(selectedResults.map((result) => result.verificationResultId));
 
   return minedBlock;
 }

node/src/state/verificationMempool.ts

@@ -1,12 +1,11 @@
-import type { VerificationResult, VerificationResultId } from "../types/verification.js";
-import { getVerificationResultId } from "../merkle/verificationMerkleTree.js";
+import { type VerificationResult, type VerificationResultId, getVerificationResultId } from "../types/verification.js";
+
 
 export class VerificationMempool {
   private results = new Map<VerificationResultId, VerificationResult>();
 
   add(result: VerificationResult): void {
-    const resultId = getVerificationResultId(result);
-    this.results.set(resultId, result);
+    this.results.set(result.verificationResultId, result);
   }
 
   getAll(): VerificationResult[] {

node/src/types/verification.ts

@@ -1,12 +1,13 @@
 import type { NodeId } from "./peer.js";
 
 export interface VerificationResult {
+  verificationResultId: VerificationResultId;
   proofId: string;
   verifierNodeId: NodeId;
   verified: boolean;
   szsStatus: string | null;
   gdvOutputHash: string;
-  gdvRawOutput: string; // TODO: think gdvRawOutput?: string;
+  gdvRawOutput?: string;
   verifiedAt: number;
 }
 
@@ -20,3 +21,7 @@ export interface RunGDVInput {
   tptpRoot: string;
   dockerImage: string;
 }
+
+export function getVerificationResultId(proofId: string, verifierNodeId: NodeId): VerificationResultId {
+  return `${proofId}:${verifierNodeId}`;
+}

node/src/verifier/gdvVerifier.ts

@@ -5,11 +5,10 @@ import { tmpdir } from "os";
 import { join } from "path";
 import { promisify } from "util";
 
-import type { VerificationResult, RunGDVInput } from "../types/verification.js";
+import {getVerificationResultId, type VerificationResult, type RunGDVInput } from "../types/verification.js";
 
 const execFileAsync = promisify(execFile);
 
-
 function extractSZSStatus(output: string): string | null {
   const match = output.match(/SZS status\s+([A-Za-z_]+)/i);
 
@@ -32,11 +31,25 @@ function normalizeTPTPIncludes(problemContent: string): string {
   );
 }
 
-export async function runGDV(input: RunGDVInput): Promise<VerificationResult> {
-  const { proofId, verifierNodeId, problemContent, proofContent, tptpRoot, dockerImage } =
-    input;
+export async function runGDV(
+  input: RunGDVInput
+): Promise<VerificationResult> {
+  const {
+    proofId,
+    verifierNodeId,
+    problemContent,
+    proofContent,
+    tptpRoot,
+    dockerImage,
+  } = input;
+
+  const verificationResultId = getVerificationResultId(proofId, verifierNodeId);
+
+  const workDir = join(
+    tmpdir(),
+    `gdv-${proofId}-${randomUUID()}`
+  );
 
-  const workDir = join(tmpdir(), `gdv-${proofId}-${randomUUID()}`);
   const problemFile = join(workDir, "problem.p");
   const proofFile = join(workDir, "proof.s");
 
@@ -56,10 +69,21 @@ export async function runGDV(input: RunGDVInput): Promise<VerificationResult> {
   await mkdir(workDir, { recursive: true });
 
   try {
-    const normalizedProblemContent = normalizeTPTPIncludes(problemContent);
+    const normalizedProblemContent =
+      normalizeTPTPIncludes(problemContent);
+
+    await writeFile(
+      problemFile,
+      normalizedProblemContent,
+      "utf8"
+    );
+
+    await writeFile(
+      proofFile,
+      cleanedProofContent,
+      "utf8"
+    );
 
-    await writeFile(problemFile, normalizedProblemContent, "utf8");
-    await writeFile(proofFile, cleanedProofContent, "utf8");
     const { stdout, stderr } = await execFileAsync("docker", [
       "run",
       "--rm",
@@ -83,22 +107,30 @@ export async function runGDV(input: RunGDVInput): Promise<VerificationResult> {
     const verified = gdvOutput.includes("SUCCESS") || szsStatus === "Verified";
 
     return {
+      verificationResultId,
       proofId,
       verifierNodeId,
       verified,
       szsStatus,
-      gdvOutputHash: createHash("sha256").update(gdvOutput).digest("hex"),
+      gdvOutputHash: createHash("sha256")
+        .update(gdvOutput)
+        .digest("hex"),
       gdvRawOutput: gdvOutput,
       verifiedAt: Date.now(),
     };
   } catch (error) {
-    const err = error as { stdout?: string; stderr?: string; message?: string };
+    const err = error as {
+      stdout?: string;
+      stderr?: string;
+      message?: string;
+    };
 
-    const gdvOutput = `${err.stdout ?? ""}\n${err.stderr ?? ""}\n${
-      err.message ?? ""
-    }`;
+    const gdvOutput = `${err.stdout ?? ""}\n${
+      err.stderr ?? ""
+    }\n${err.message ?? ""}`;
 
     return {
+      verificationResultId,
       proofId,
       verifierNodeId,
       verified: false,
@@ -108,6 +140,9 @@ export async function runGDV(input: RunGDVInput): Promise<VerificationResult> {
       verifiedAt: Date.now(),
     };
   } finally {
-    await rm(workDir, { recursive: true, force: true });
+    await rm(workDir, {
+      recursive: true,
+      force: true,
+    });
   }
 }