Address review: fix receipt typecheck and export redacted serialize API.

Build validated RoundReceipt objects without unsafe casts, and add serializeCanonicalJson for redacted artifacts that fail schema validation.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: CemAyyildiz

packages/sdk/src/index.ts

@@ -86,6 +86,7 @@ export {
 
 export {
   serializeReceipt,
+  serializeCanonicalJson,
   parseReceipt,
   validateReceipt,
   networkFingerprint,

packages/sdk/src/public-api-snapshot.test.ts

@@ -45,6 +45,7 @@ const EXPECTED_EXPORTS = [
   "parseReceipt",
   "redactReceipt",
   "runMainnetReadiness",
+  "serializeCanonicalJson",
   "serializeReceipt",
   "tryDecodeBase64",
   "tryDecodeHex",

packages/sdk/src/receipt.ts

@@ -170,7 +170,19 @@ function validateBidEntry(value: unknown, field: string): BidReceiptEntry {
   assertNullableHexString(evidence.ciphertext, `${field}.evidence.ciphertext`);
   assertNullableHexString(evidence.auditorBlob, `${field}.evidence.auditorBlob`);
 
-  return entry as BidReceiptEntry;
+  return {
+    commitment: entry.commitment as string,
+    escrow: entry.escrow as string,
+    revealedValue: entry.revealedValue as string | null,
+    nonce: entry.nonce as string | null,
+    hashValid: entry.hashValid as boolean | null,
+    valid: entry.valid as boolean,
+    settled: entry.settled as boolean,
+    evidence: {
+      ciphertext: evidence.ciphertext as string | null,
+      auditorBlob: evidence.auditorBlob as string | null,
+    },
+  };
 }
 
 /** Validate a parsed or in-memory receipt before export/serialize. */
@@ -224,11 +236,12 @@ export function validateReceipt(value: unknown): RoundReceipt {
   }
 
   const bids = receipt.bids as Record<string, unknown>;
+  const validatedBids: Record<string, BidReceiptEntry> = {};
   for (const bidder of receipt.bidders as string[]) {
     if (!(bidder in bids)) {
       validationError(`missing bid entry for bidder ${bidder}`, `bids.${bidder}`);
     }
-    validateBidEntry(bids[bidder], `bids.${bidder}`);
+    validatedBids[bidder] = validateBidEntry(bids[bidder], `bids.${bidder}`);
   }
 
   if (receipt.winner !== null) {
@@ -240,14 +253,44 @@ export function validateReceipt(value: unknown): RoundReceipt {
     assertNonEmptyString(receipt.artifactChecksum, "artifactChecksum");
   }
 
-  return receipt as RoundReceipt;
+  const validated: RoundReceipt = {
+    version: RECEIPT_VERSION,
+    network: receipt.network as string,
+    networkFingerprint: receipt.networkFingerprint as string,
+    contractId: receipt.contractId as string,
+    exportedAt: receipt.exportedAt as string,
+    roundId: receipt.roundId as string,
+    itemRef: receipt.itemRef as string,
+    revealRound: receipt.revealRound as number,
+    clearingRule: receipt.clearingRule as string,
+    commitDeadline: receipt.commitDeadline as string,
+    revealDeadline: receipt.revealDeadline as string,
+    operator: receipt.operator as string,
+    auditorPubkey: receipt.auditorPubkey as string,
+    bidders: [...(receipt.bidders as string[])],
+    bids: validatedBids,
+    winner: receipt.winner as string | null,
+    winningValue: receipt.winningValue as string | null,
+    status: receipt.status as string,
+  };
+  if (receipt.artifactChecksum !== undefined) {
+    validated.artifactChecksum = receipt.artifactChecksum as string;
+  }
+  return validated;
+}
+
+/** Canonical JSON (deep-sorted keys, trailing newline) without schema checks.
+ *  Use for redacted / partial artifacts that are not valid RoundReceipt values.
+ *  Verifiable receipts must go through {@link serializeReceipt}. */
+export function serializeCanonicalJson(value: unknown): string {
+  return JSON.stringify(value, sortKeys) + "\n";
 }
 
 /** Serialise a receipt to canonical JSON (deep-sorted keys, no whitespace).
  *  This is the format the CLI writes and the verifier reads. */
 export function serializeReceipt(receipt: RoundReceipt): string {
   validateReceipt(receipt);
-  return JSON.stringify(receipt, sortKeys) + "\n";
+  return serializeCanonicalJson(receipt);
 }
 
 /** Parse a receipt from its canonical JSON form. */

packages/sdk/src/redact.test.ts

@@ -1,22 +1,15 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
 
-import { serializeReceipt, parseReceipt, type RoundReceipt } from "./receipt.js";
+import {
+  serializeReceipt,
+  serializeCanonicalJson,
+  type RoundReceipt,
+} from "./receipt.js";
+import { SubRosaReceiptValidationError } from "./errors.js";
 import { redactReceipt, type BidReceiptEntry } from "./redact.js";
 import { verifyReceipt } from "./verify.js";
 
-function canonicalJson(value: unknown): string {
-  const sortKeys = (_: string, v: unknown): unknown => {
-    if (v !== null && typeof v === "object" && !Array.isArray(v)) {
-      return Object.fromEntries(
-        Object.entries(v).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)),
-      );
-    }
-    return v;
-  };
-  return JSON.stringify(value, sortKeys) + "\n";
-}
-
 function makeReceipt(): RoundReceipt {
   return {
     version: 1,
@@ -148,11 +141,22 @@ test("preserves network and verification metadata", () => {
 
 test("redaction output is deterministic", () => {
   const receipt = makeReceipt();
-  const first = canonicalJson(redactReceipt(receipt));
-  const second = canonicalJson(redactReceipt(receipt));
+  const first = serializeCanonicalJson(redactReceipt(receipt));
+  const second = serializeCanonicalJson(redactReceipt(receipt));
   assert.equal(first, second);
 });
 
+test("serializeReceipt rejects redacted receipts; serializeCanonicalJson accepts them", () => {
+  const redacted = redactReceipt(makeReceipt());
+  assert.throws(
+    () => serializeReceipt(redacted),
+    (err: unknown) => err instanceof SubRosaReceiptValidationError,
+  );
+  const canonical = serializeCanonicalJson(redacted);
+  assert.match(canonical, /"<redacted>"/);
+  assert.equal(canonical, serializeCanonicalJson(JSON.parse(canonical)));
+});
+
 test("keep-list preserves specified top-level field", () => {
   const receipt = makeReceipt();
   const redacted = redactReceipt(receipt, { keep: ["contractId"] });
@@ -289,5 +293,5 @@ test("idempotent on nested structures", () => {
   };
   const once = redactReceipt(receipt);
   const twice = redactReceipt(once);
-  assert.equal(canonicalJson(once), canonicalJson(twice));
+  assert.equal(serializeCanonicalJson(once), serializeCanonicalJson(twice));
 });