Independently verifying a Governed Settlement Receipt

Zero-storage output model (by design)

GSR-JCS-1 canonicalization profile

Pre-canonicalization field rules

Apply these mutations to a deep copy of the receipt object, then JCS-canonicalize the result. Signing input and anchor digest preimage use the same canonical string.

All other receipt fields (version, canonicalization_profile, receipt_id, payment, governance, synthesis, provenance, anchor.contract, anchor.chain, signature.algorithm) are included unchanged. Anchor digest after signing equals SHA-256(UTF-8(canonical string)) hex.

key_id derivation (ML-DSA-65)

Public API: GET /api/trust/signing-key

GET https://www.stratalize.com/api/trust/signing-key

{
  "public_key": "<ML-DSA-65 hex>",
  "current_algorithm": "ML-DSA-65",
  "current_key_id": "mldsa65-xxxxxxxxxxxxxxxx",
  "key_id_derivation": {
    "algorithm": "SHA-256",
    "input": "ML-DSA-65 public key bytes (hex-decoded)",
    "fingerprint": "first 16 lowercase hex characters of SHA-256 digest",
    "prefix": "mldsa65-"
  },
  "keys": [
    {
      "algorithm": "ML-DSA-65",
      "format": "hex",
      "key": "<hex>",
      "key_id": "mldsa65-xxxxxxxxxxxxxxxx",
      "active": true
    }
  ],
  "verification_docs": "https://www.stratalize.com/docs/gsr"
}

Public API: GET /api/trust/verify-unified/{synthesis_id}

Core response fields

For GSR-only verification, prefer POST /api/trust/verify-receipt with the _receipt object from your saved x402 response, or verify offline using the walkthrough below.

Public API: POST /api/trust/verify-receipt

POST https://www.stratalize.com/api/trust/verify-receipt
Content-Type: application/json

{ "receipt": { ... full _receipt from x402 200 response ... } }

Merkle inclusion proofs (synthesis artifacts)

Walkthrough: offline GSR signature verification (Node 20+)

Uses the published GSR-JCS-1 rules above. Install: npm install canonicalize @noble/post-quantum.

import canonicalize from "canonicalize";
import { createHash } from "node:crypto";
import { ml_dsa65 } from "@noble/post-quantum/ml-dsa.js";

const GSR_JCS_1 = "GSR-JCS-1";

function computeKeyId(publicKeyHex) {
  const bytes = Buffer.from(publicKeyHex, "hex");
  const fp = createHash("sha256").update(bytes).digest("hex").slice(0, 16);
  return `mldsa65-${fp}`;
}

/** Apply GSR-JCS-1 pre-canonicalization rules (see table above). */
function canonicalReceiptForm(receipt) {
  if ((receipt.canonicalization_profile ?? GSR_JCS_1) !== GSR_JCS_1) {
    throw new Error("unsupported profile");
  }
  const clone = structuredClone(receipt);
  delete clone.field_abac_decision;
  delete clone.passport_scope_decision;
  clone.signature.value = null;
  clone.signature.signed_at = null;
  clone.anchor.digest = "";
  clone.anchor.anchor_tx_hash = null;
  clone.anchor.anchor_status = "pending";
  const canonical = canonicalize(clone);
  if (canonical === undefined) throw new Error("JCS failed");
  return canonical;
}

async function verifyGsrReceipt(receipt) {
  const keyRes = await fetch("https://www.stratalize.com/api/trust/signing-key");
  if (!keyRes.ok) throw new Error(`signing-key HTTP ${keyRes.status}`);
  const keys = await keyRes.json();
  const entry = keys.keys?.find((k) => k.algorithm === "ML-DSA-65" && k.active);
  if (!entry?.key) throw new Error("no active ML-DSA-65 key");
  const keyId = computeKeyId(entry.key);
  if (receipt.signature.signer !== keyId) {
    return { valid: false, reason: "signer/key_id mismatch" };
  }
  const canonical = canonicalReceiptForm(receipt);
  const digestOk =
    createHash("sha256").update(Buffer.from(canonical, "utf8")).digest("hex") ===
    receipt.anchor.digest;
  const sigOk = ml_dsa65.verify(
    Buffer.from(receipt.signature.value, "base64url"),
    Buffer.from(canonical, "utf8"),
    Buffer.from(entry.key, "hex"),
  );
  return { valid: sigOk && digestOk, signature: sigOk, digest_binding: digestOk, key_id: keyId };
}

// Usage: const receipt = x402Response._receipt;
// const result = await verifyGsrReceipt(receipt);

Proof URLs on x402 responses

Related: _stratalize attestation, x402, trust.stratalize.com/verify.