@fluxpointstudios/orynq-sdk-midnight-prover 0.1.0

package/src/__tests__/midnight-prover.test.ts

@@ -0,0 +1,716 @@
+/**
+ * @fileoverview Integration tests for the DefaultMidnightProver.
+ *
+ * Location: packages/midnight-prover/src/__tests__/midnight-prover.test.ts
+ *
+ * Summary:
+ * Integration tests for the DefaultMidnightProver class which coordinates all
+ * proof types and handles the full lifecycle of proof generation and publication.
+ * Tests cover connection management, proof generation, publication, and verification.
+ *
+ * Usage:
+ * Run with: pnpm test -- packages/midnight-prover
+ *
+ * Related files:
+ * - prover.ts: DefaultMidnightProver implementation
+ * - prover-interface.ts: MidnightProver interface definition
+ * - proofs/: Individual prover implementations
+ * - linking/: Publication and cross-chain linking
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+
+import {
+  DefaultMidnightProver,
+  createMidnightProver,
+} from "../prover.js";
+
+import {
+  proverRegistry,
+} from "../prover-interface.js";
+
+import {
+  HashChainProver,
+} from "../proofs/hash-chain-proof.js";
+
+import {
+  PolicyComplianceProver,
+} from "../proofs/policy-compliance-proof.js";
+
+import {
+  SelectiveDisclosureProver,
+} from "../proofs/selective-disclosure.js";
+
+import {
+  CardanoAnchorLinker,
+} from "../linking/cardano-anchor-link.js";
+
+import {
+  buildHashChainWitness,
+} from "../midnight/witness-builder.js";
+
+import {
+  MidnightProverError,
+  MidnightProverException,
+  isHashChainProof,
+  isPolicyProof,
+  isDisclosureProof,
+  type HashChainInput,
+  type PolicyInput,
+  type DisclosureInput,
+  type ProofServerConfig,
+} from "../types.js";
+
+import type {
+  TraceEvent,
+  TraceBundle,
+  TraceSpan,
+  CommandEvent,
+  OutputEvent,
+} from "@fluxpointstudios/orynq-sdk-process-trace";
+
+// =============================================================================
+// TEST HELPERS
+// =============================================================================
+
+/**
+ * Create a valid 64-character hex hash.
+ */
+function createMockHash(seed: string): string {
+  const hex = "0123456789abcdef";
+  let result = "";
+  for (let i = 0; i < 64; i++) {
+    result += hex[(seed.charCodeAt(i % seed.length) + i) % 16];
+  }
+  return result;
+}
+
+/**
+ * Create a mock trace event.
+ */
+function createMockEvent(seq: number, kind: string = "command"): TraceEvent {
+  const baseEvent = {
+    id: `event-${seq}-${Date.now()}`,
+    seq,
+    timestamp: new Date().toISOString(),
+    visibility: "public" as const,
+  };
+
+  if (kind === "command") {
+    return {
+      ...baseEvent,
+      kind: "command",
+      command: `test-command-${seq}`,
+      args: [`arg-${seq}`],
+    } as CommandEvent;
+  } else {
+    return {
+      ...baseEvent,
+      kind: "output",
+      stream: "stdout",
+      content: `output content ${seq}`,
+    } as OutputEvent;
+  }
+}
+
+/**
+ * Create an array of mock events.
+ */
+function createMockEvents(count: number): TraceEvent[] {
+  const events: TraceEvent[] = [];
+  for (let i = 1; i <= count; i++) {
+    events.push(createMockEvent(i, i % 2 === 0 ? "output" : "command"));
+  }
+  return events;
+}
+
+/**
+ * Create a mock trace span.
+ */
+function createMockSpan(id: string, seq: number, eventIds: string[]): TraceSpan {
+  return {
+    id,
+    spanSeq: seq,
+    name: `span-${seq}`,
+    status: "completed",
+    visibility: "public",
+    startedAt: new Date().toISOString(),
+    endedAt: new Date().toISOString(),
+    durationMs: 100,
+    eventIds,
+    childSpanIds: [],
+  };
+}
+
+/**
+ * Create a mock trace bundle.
+ */
+function createMockTraceBundle(): TraceBundle {
+  const events = createMockEvents(5);
+  const span1 = createMockSpan("span-1", 1, [events[0]!.id, events[1]!.id]);
+  const span2 = createMockSpan("span-2", 2, [events[2]!.id, events[3]!.id, events[4]!.id]);
+
+  return {
+    publicRun: {
+      sessionId: "session-123",
+      events: events.filter((_, i) => i < 2),
+      spans: [span1],
+    },
+    privateRun: {
+      sessionId: "session-123",
+      events,
+      spans: [span1, span2],
+    },
+    rootHash: createMockHash("root"),
+    merkleRoot: createMockHash("merkle"),
+  };
+}
+
+/**
+ * Create a mock proof server config.
+ */
+function createMockConfig(): ProofServerConfig {
+  return {
+    proofServerUrl: "https://mock.proof.server",
+    apiKey: "test-api-key",
+    timeout: 30000,
+    retries: 3,
+    circuitCacheDir: undefined,
+  };
+}
+
+// =============================================================================
+// DEFAULT MIDNIGHT PROVER TESTS
+// =============================================================================
+
+describe("DefaultMidnightProver", () => {
+  let prover: DefaultMidnightProver;
+  const config = createMockConfig();
+
+  beforeEach(async () => {
+    prover = new DefaultMidnightProver({ debug: false });
+    await prover.connect(config);
+  });
+
+  afterEach(async () => {
+    await prover.disconnect();
+  });
+
+  describe("constructor", () => {
+    it("should create a prover with default options", () => {
+      const defaultProver = new DefaultMidnightProver();
+      expect(defaultProver).toBeInstanceOf(DefaultMidnightProver);
+      expect(defaultProver.isConnected()).toBe(false);
+    });
+
+    it("should create a prover with custom options", () => {
+      const customProver = new DefaultMidnightProver({
+        debug: true,
+        circuitsDir: "./custom-circuits",
+        enableInference: false,
+      });
+      expect(customProver).toBeInstanceOf(DefaultMidnightProver);
+    });
+  });
+
+  describe("connection management", () => {
+    it("should connect and disconnect successfully", async () => {
+      const newProver = new DefaultMidnightProver();
+
+      expect(newProver.isConnected()).toBe(false);
+      await newProver.connect(config);
+      expect(newProver.isConnected()).toBe(true);
+      expect(newProver.getConfig()).toBeDefined();
+
+      await newProver.disconnect();
+      expect(newProver.isConnected()).toBe(false);
+    });
+
+    it("should throw for operations when not connected", async () => {
+      const disconnectedProver = new DefaultMidnightProver();
+
+      await expect(
+        disconnectedProver.proveHashChain({
+          events: createMockEvents(3),
+          genesisHash: createMockHash("genesis"),
+          expectedRootHash: createMockHash("root"),
+          cardanoAnchorTxHash: createMockHash("anchor"),
+        })
+      ).rejects.toThrow();
+    });
+  });
+
+  describe("proveHashChain", () => {
+    it("should generate a hash-chain proof", async () => {
+      const events = createMockEvents(5);
+      const genesisHash = await prover.getGenesisHash();
+      const witness = await buildHashChainWitness(events, genesisHash);
+
+      const input: HashChainInput = {
+        events,
+        genesisHash,
+        expectedRootHash: witness.computedRollingHash,
+        cardanoAnchorTxHash: createMockHash("anchor"),
+      };
+
+      const proof = await prover.proveHashChain(input);
+
+      expect(proof).toBeDefined();
+      expect(isHashChainProof(proof)).toBe(true);
+      expect(proof.proofId).toBeDefined();
+      expect(proof.publicInputs.rootHash).toBe(witness.computedRollingHash.toLowerCase());
+      expect(proof.publicInputs.eventCount).toBe(5);
+    });
+
+    it("should throw for invalid input", async () => {
+      const input: HashChainInput = {
+        events: [], // Empty events
+        genesisHash: createMockHash("genesis"),
+        expectedRootHash: createMockHash("root"),
+        cardanoAnchorTxHash: createMockHash("anchor"),
+      };
+
+      await expect(prover.proveHashChain(input)).rejects.toThrow(MidnightProverException);
+    });
+  });
+
+  describe("provePolicyCompliance", () => {
+    it("should generate a policy compliance proof", async () => {
+      const input: PolicyInput = {
+        promptHash: createMockHash("prompt"),
+        outputHash: createMockHash("output"),
+        policy: {
+          id: "test-policy",
+          version: "1.0.0",
+          rules: [
+            {
+              type: "blocklist",
+              target: "both",
+              params: { blockedHashes: [] },
+            },
+          ],
+        },
+        cardanoAnchorTxHash: createMockHash("anchor"),
+      };
+
+      const proof = await prover.provePolicyCompliance(input);
+
+      expect(proof).toBeDefined();
+      expect(isPolicyProof(proof)).toBe(true);
+      expect(proof.publicInputs.policyId).toBe("test-policy");
+      expect(proof.publicInputs.compliant).toBe(true);
+    });
+
+    it("should detect non-compliance", async () => {
+      const blockedHash = createMockHash("blocked");
+
+      const input: PolicyInput = {
+        promptHash: blockedHash,
+        outputHash: createMockHash("output"),
+        policy: {
+          id: "strict-policy",
+          version: "1.0.0",
+          rules: [
+            {
+              type: "blocklist",
+              target: "prompt",
+              params: { blockedHashes: [blockedHash] },
+            },
+          ],
+        },
+        cardanoAnchorTxHash: createMockHash("anchor"),
+      };
+
+      const proof = await prover.provePolicyCompliance(input);
+
+      expect(proof.publicInputs.compliant).toBe(false);
+    });
+  });
+
+  describe("proveSelectiveDisclosure", () => {
+    it("should generate a selective disclosure proof", async () => {
+      const bundle = createMockTraceBundle();
+
+      const input: DisclosureInput = {
+        bundle,
+        spanId: "span-1",
+        merkleRoot: bundle.merkleRoot ?? createMockHash("merkle"),
+        cardanoAnchorTxHash: createMockHash("anchor"),
+      };
+
+      // Note: The merkle root in the input must match what's computed from the spans
+      // For this test, we'll generate the proof but it may fail verification
+      // since we're using a mock merkle root
+
+      try {
+        const proof = await prover.proveSelectiveDisclosure(input);
+        expect(proof).toBeDefined();
+        expect(isDisclosureProof(proof)).toBe(true);
+        expect(proof.disclosedSpan).toBeDefined();
+      } catch (error) {
+        // Expected: hash mismatch since we're using mock merkle root
+        expect(error).toBeInstanceOf(MidnightProverException);
+      }
+    });
+
+    it("should throw for non-existent span", async () => {
+      const bundle = createMockTraceBundle();
+
+      const input: DisclosureInput = {
+        bundle,
+        spanId: "non-existent-span",
+        merkleRoot: createMockHash("merkle"),
+        cardanoAnchorTxHash: createMockHash("anchor"),
+      };
+
+      await expect(prover.proveSelectiveDisclosure(input)).rejects.toThrow(
+        MidnightProverException
+      );
+    });
+  });
+
+  describe("proveAttestation", () => {
+    it("should throw not implemented error", async () => {
+      const input = {
+        attestation: {} as never,
+        policy: {} as never,
+        cardanoAnchorTxHash: createMockHash("anchor"),
+      };
+
+      await expect(prover.proveAttestation(input)).rejects.toThrow(
+        /not yet implemented/i
+      );
+    });
+  });
+
+  describe("proveInference", () => {
+    it("should throw error when inference is disabled", async () => {
+      const input = {
+        modelId: "test-model",
+        modelWeightDigest: createMockHash("weights"),
+        inputTokens: [1, 2, 3],
+        outputTokens: [4, 5, 6],
+        params: {
+          temperature: 0.7,
+          topP: undefined,
+          topK: undefined,
+          maxTokens: 100,
+          stopStrings: undefined,
+          frequencyPenalty: undefined,
+          presencePenalty: undefined,
+        },
+        cardanoAnchorTxHash: createMockHash("anchor"),
+      };
+
+      expect(() => prover.proveInference(input)).toThrow(/disabled/i);
+    });
+
+    it("should throw not implemented even when enabled", async () => {
+      const enabledProver = new DefaultMidnightProver({ enableInference: true });
+      await enabledProver.connect(config);
+
+      const input = {
+        modelId: "test-model",
+        modelWeightDigest: createMockHash("weights"),
+        inputTokens: [1, 2, 3],
+        outputTokens: [4, 5, 6],
+        params: {
+          temperature: 0.7,
+          topP: undefined,
+          topK: undefined,
+          maxTokens: 100,
+          stopStrings: undefined,
+          frequencyPenalty: undefined,
+          presencePenalty: undefined,
+        },
+        cardanoAnchorTxHash: createMockHash("anchor"),
+      };
+
+      expect(() => enabledProver.proveInference(input)).toThrow(/not yet implemented/i);
+
+      await enabledProver.disconnect();
+    });
+  });
+
+  describe("publish", () => {
+    it("should publish a proof to the network", async () => {
+      const events = createMockEvents(3);
+      const genesisHash = await prover.getGenesisHash();
+      const witness = await buildHashChainWitness(events, genesisHash);
+
+      const hashChainProof = await prover.proveHashChain({
+        events,
+        genesisHash,
+        expectedRootHash: witness.computedRollingHash,
+        cardanoAnchorTxHash: createMockHash("anchor"),
+      });
+
+      const result = await prover.publish(hashChainProof);
+
+      expect(result).toBeDefined();
+      expect(result.midnightTxHash).toMatch(/^[0-9a-f]{64}$/);
+      expect(result.proofId).toBe(hashChainProof.proofId);
+    });
+  });
+
+  describe("verify", () => {
+    it("should verify a valid proof", async () => {
+      const events = createMockEvents(3);
+      const genesisHash = await prover.getGenesisHash();
+      const witness = await buildHashChainWitness(events, genesisHash);
+
+      const proof = await prover.proveHashChain({
+        events,
+        genesisHash,
+        expectedRootHash: witness.computedRollingHash,
+        cardanoAnchorTxHash: createMockHash("anchor"),
+      });
+
+      const result = await prover.verify(proof);
+
+      expect(result.valid).toBe(true);
+      expect(result.proofType).toBe("hash-chain");
+      expect(result.errors).toHaveLength(0);
+    });
+  });
+
+  describe("fetchProof", () => {
+    it("should return published proof from cache", async () => {
+      const events = createMockEvents(3);
+      const genesisHash = await prover.getGenesisHash();
+      const witness = await buildHashChainWitness(events, genesisHash);
+
+      const proof = await prover.proveHashChain({
+        events,
+        genesisHash,
+        expectedRootHash: witness.computedRollingHash,
+        cardanoAnchorTxHash: createMockHash("anchor"),
+      });
+
+      await prover.publish(proof);
+
+      const fetched = await prover.fetchProof(proof.proofId);
+
+      expect(fetched).toBeDefined();
+      expect(fetched?.proofId).toBe(proof.proofId);
+    });
+
+    it("should return undefined for unknown proof", async () => {
+      const fetched = await prover.fetchProof("unknown-proof-id");
+
+      expect(fetched).toBeUndefined();
+    });
+  });
+
+  describe("isPublished", () => {
+    it("should return true for published proof", async () => {
+      const events = createMockEvents(3);
+      const genesisHash = await prover.getGenesisHash();
+      const witness = await buildHashChainWitness(events, genesisHash);
+
+      const proof = await prover.proveHashChain({
+        events,
+        genesisHash,
+        expectedRootHash: witness.computedRollingHash,
+        cardanoAnchorTxHash: createMockHash("anchor"),
+      });
+
+      await prover.publish(proof);
+
+      const published = await prover.isPublished(proof.proofId);
+
+      expect(published).toBe(true);
+    });
+
+    it("should return false for unknown proof", async () => {
+      const published = await prover.isPublished("unknown-proof-id");
+
+      expect(published).toBe(false);
+    });
+  });
+
+  describe("waitForConfirmation", () => {
+    it("should wait for proof confirmation", async () => {
+      const events = createMockEvents(3);
+      const genesisHash = await prover.getGenesisHash();
+      const witness = await buildHashChainWitness(events, genesisHash);
+
+      const proof = await prover.proveHashChain({
+        events,
+        genesisHash,
+        expectedRootHash: witness.computedRollingHash,
+        cardanoAnchorTxHash: createMockHash("anchor"),
+      });
+
+      await prover.publish(proof);
+
+      const confirmed = await prover.waitForConfirmation(proof.proofId, 15000);
+
+      expect(confirmed).toBe(true);
+    });
+  });
+});
+
+// =============================================================================
+// FACTORY FUNCTION TESTS
+// =============================================================================
+
+describe("createMidnightProver", () => {
+  it("should create a prover instance", () => {
+    const prover = createMidnightProver();
+    expect(prover).toBeInstanceOf(DefaultMidnightProver);
+  });
+
+  it("should create a prover with options", () => {
+    const prover = createMidnightProver({
+      debug: true,
+      enableInference: false,
+    });
+    expect(prover).toBeInstanceOf(DefaultMidnightProver);
+  });
+});
+
+// =============================================================================
+// PROVER REGISTRY TESTS
+// =============================================================================
+
+describe("proverRegistry", () => {
+  it("should have default prover registered", () => {
+    const proverNames = proverRegistry.listProvers();
+    expect(proverNames).toContain("default");
+  });
+
+  it("should return default prover", () => {
+    const prover = proverRegistry.getDefault();
+    expect(prover).toBeDefined();
+  });
+
+  it("should get prover by name", () => {
+    const prover = proverRegistry.get("default");
+    expect(prover).toBeDefined();
+  });
+});
+
+// =============================================================================
+// INTEGRATION: FULL FLOW TESTS
+// =============================================================================
+
+describe("Full Integration Flow", () => {
+  let prover: DefaultMidnightProver;
+  let linker: CardanoAnchorLinker;
+  const config = createMockConfig();
+
+  beforeEach(async () => {
+    prover = new DefaultMidnightProver({ debug: false });
+    linker = new CardanoAnchorLinker({ debug: false });
+    await prover.connect(config);
+  });
+
+  afterEach(async () => {
+    await prover.disconnect();
+  });
+
+  it("should complete full proof lifecycle: generate -> publish -> link -> verify", async () => {
+    // 1. Generate proof
+    const events = createMockEvents(5);
+    const genesisHash = await prover.getGenesisHash();
+    const witness = await buildHashChainWitness(events, genesisHash);
+    const cardanoAnchorTxHash = createMockHash("cardano-anchor");
+
+    const proof = await prover.proveHashChain({
+      events,
+      genesisHash,
+      expectedRootHash: witness.computedRollingHash,
+      cardanoAnchorTxHash,
+    });
+
+    expect(proof).toBeDefined();
+    expect(proof.proofType).toBe("hash-chain");
+
+    // 2. Publish proof
+    const publicationResult = await prover.publish(proof);
+
+    expect(publicationResult.midnightTxHash).toBeDefined();
+    expect(publicationResult.proofId).toBe(proof.proofId);
+
+    // 3. Create cross-chain link
+    const link = linker.linkToAnchor(
+      proof,
+      cardanoAnchorTxHash,
+      publicationResult.midnightTxHash
+    );
+
+    expect(link).toBeDefined();
+    expect(link.midnightProofId).toBe(proof.proofId);
+    expect(link.midnightTxHash).toBe(publicationResult.midnightTxHash);
+    expect(link.cardanoAnchorTxHash).toBe(cardanoAnchorTxHash.toLowerCase());
+
+    // 4. Verify link
+    const linkVerification = await linker.verifyLink(link);
+
+    expect(linkVerification.valid).toBe(true);
+    expect(linkVerification.commitmentVerified).toBe(true);
+
+    // 5. Verify proof
+    const proofVerification = await prover.verify(proof);
+
+    expect(proofVerification.valid).toBe(true);
+
+    // 6. Check publication status
+    const published = await prover.isPublished(proof.proofId);
+
+    expect(published).toBe(true);
+  });
+
+  it("should handle multiple proof types for the same anchor", async () => {
+    const cardanoAnchorTxHash = createMockHash("shared-anchor");
+
+    // Generate hash-chain proof
+    const events = createMockEvents(3);
+    const genesisHash = await prover.getGenesisHash();
+    const witness = await buildHashChainWitness(events, genesisHash);
+
+    const hashChainProof = await prover.proveHashChain({
+      events,
+      genesisHash,
+      expectedRootHash: witness.computedRollingHash,
+      cardanoAnchorTxHash,
+    });
+
+    // Generate policy proof
+    const policyProof = await prover.provePolicyCompliance({
+      promptHash: createMockHash("prompt"),
+      outputHash: createMockHash("output"),
+      policy: {
+        id: "test-policy",
+        version: "1.0.0",
+        rules: [],
+      },
+      cardanoAnchorTxHash,
+    });
+
+    // Publish both
+    const hashChainResult = await prover.publish(hashChainProof);
+    const policyResult = await prover.publish(policyProof);
+
+    // Create links
+    const hashChainLink = linker.linkToAnchor(
+      hashChainProof,
+      cardanoAnchorTxHash,
+      hashChainResult.midnightTxHash
+    );
+
+    const policyLink = linker.linkToAnchor(
+      policyProof,
+      cardanoAnchorTxHash,
+      policyResult.midnightTxHash
+    );
+
+    // Both links should reference the same Cardano anchor
+    expect(hashChainLink.cardanoAnchorTxHash).toBe(policyLink.cardanoAnchorTxHash);
+
+    // Should be able to find both links by anchor
+    const anchorLinks = linker.getLinksByCardanoAnchor(cardanoAnchorTxHash);
+    expect(anchorLinks).toHaveLength(2);
+  });
+});