@helm-protocol/ttt-mcp 0.3.1 → 0.3.3

package/README.md

@@ -2,7 +2,19 @@
 
 > Reference implementation of [draft-helmprotocol-tttps](https://datatracker.ietf.org/doc/draft-helmprotocol-tttps/) (IETF Experimental)
 
-**MCP Server for OpenTTT — Proof of Time tools for AI agents**
+**Proof-of-Time attestation — Ed25519-signed timestamps with multi-source corroboration and explicit error bounds. IETF draft-helmprotocol-tttps**
+
+---
+
+## EU AI Act Art. 50 — AI-Generated Content Transparency
+
+TTTPS provides cryptographic time-provenance for AI-generated content at the moment of creation. A `pot_generate` call anchors a tamper-evident timestamp to a cryptographic hash of the content record — independently of any embedded metadata.
+
+**C2PA complementarity**: C2PA metadata is stripped during recapture, transcoding, and format conversion. TTTPS survives as an external anchor independently verifiable without metadata chain continuity — allowing forensic reconstruction of content provenance even when embedded markers are absent.
+
+**GDPR-compatible by design**: PoT records contain no content and no personal identifiers. Each record binds a cryptographic hash (SHA-256 + HMAC-SHA256) to a multi-source time attestation. No plaintext content transits or is stored on Helm servers.
+
+IETF specification: [`draft-helmprotocol-tttps`](https://datatracker.ietf.org/doc/draft-helmprotocol-tttps/) (ISE track). Contact: peter@kenosian.com.
 
 ---
 
@@ -43,12 +55,12 @@ Claude workflow → [context compressed] → agents call pot_query(eventId)
 ### Claude Code
 
 ```bash
-claude mcp add ttt -- npx -y @helm-protocol/ttt-mcp@0.3.0
+claude mcp add ttt -- npx -y @helm-protocol/ttt-mcp@0.3.2
 ```
 
 With an API key (raises the free limit to your plan's monthly quota):
 ```bash
-claude mcp add ttt -e TTT_API_KEY=your-key -- npx -y @helm-protocol/ttt-mcp@0.3.0
+claude mcp add ttt -e TTT_API_KEY=your-key -- npx -y @helm-protocol/ttt-mcp@0.3.2
 ```
 
 ### Claude Desktop
@@ -60,7 +72,7 @@ Add to `claude_desktop_config.json`:
   "mcpServers": {
     "ttt": {
       "command": "npx",
-      "args": ["-y", "@helm-protocol/ttt-mcp@0.3.0"],
+      "args": ["-y", "@helm-protocol/ttt-mcp@0.3.2"],
       "env": { "TTT_API_KEY": "your-key" }
     }
   }
@@ -69,7 +81,7 @@ Add to `claude_desktop_config.json`:
 
 ### Cursor
 
-[![Add to Cursor](https://img.shields.io/badge/Add%20to%20Cursor-1a1a1a?style=flat&logo=cursor&logoColor=white)](https://cursor.com/install-mcp?name=ttt&config=eyJjb21tYW5kIjoibnB4IiwiYXJncyI6WyIteSIsIkBoZWxtLXByb3RvY29sL3R0dC1tY3BAMC4zLjAiXX0=)
+[![Add to Cursor](https://img.shields.io/badge/Add%20to%20Cursor-1a1a1a?style=flat&logo=cursor&logoColor=white)](https://cursor.com/install-mcp?name=ttt&config=eyJjb21tYW5kIjoibnB4IiwiYXJncyI6WyIteSIsIkBoZWxtLXByb3RvY29sL3R0dC1tY3BAMC4zLjIiXX0=)
 
 One-click install, or add the same `mcpServers` block above to `.cursor/mcp.json`.
 
@@ -115,12 +127,13 @@ pot_graph(eventId: "step-2", depth: 5)
 
 ---
 
-## 7 Tools
+## 8 Tools
 
 | Tool | Purpose |
 |------|---------|
 | `pot_generate` | Stamp a workflow step with a cryptographic timestamp |
 | `pot_verify` | Verify a PoT signature |
+| `pot_verify_v08` | Verify a draft-08 §3 Payload Digest record |
 | `pot_query` | O(1) exact lookup by eventId — core amnesia recovery |
 | `pot_graph` | Traverse causal DAG (backward + forward chain) |
 | `pot_checkpoint` | Roll up events into a compressed summary — use every ~100 events or before long tasks |
@@ -133,7 +146,7 @@ pot_graph(eventId: "step-2", depth: 5)
 
 ### pot_generate
 
-Stamp a workflow step with a cryptographic timestamp. For Claude Code: use `eventId` + `prevEventId`. For DeFi: use `txHash` + `chainId` + `poolAddress`. One of `eventId` or `txHash` is required.
+Stamp a workflow step with a cryptographic timestamp. For Claude Code: use `eventId` + `prevEventId`. For DeFi: use `txHash` + `chainId` + `poolAddress`. To bind the attestation to a specific piece of content (draft-08 §3 Payload Digest), also supply `contentDigest`. One of `eventId`, `txHash`, or `contentDigest` is required.
 
 | Parameter | Type | Required | Description |
 |-----------|------|----------|-------------|
@@ -142,6 +155,19 @@ Stamp a workflow step with a cryptographic timestamp. For Claude Code: use `even
 | txHash | string | Either/or | Transaction hash (DeFi, hex with 0x prefix) |
 | chainId | number | No | EVM chain ID (DeFi) |
 | poolAddress | string | No | DEX pool contract address (DeFi) |
+| contentDigest | string | Either/or | SHA-256 digest (lowercase hex, 64 chars) of the content this record attests to. Computed by the caller — the server never sees the content. When the local time synthesis meets draft-08's own requirements (≥3 independent sources, a representable error bound), the response includes a spec-conformant `potRecordV08` binary record (hex); otherwise `potRecordV08Error` explains why not. |
+| ctxId | string | No | draft-08 §3.3 context identifier (Commitment domain separator, max 255 octets). Defaults to a fixed server value; MAY be public. |
+
+### pot_verify_v08
+
+Verify a draft-08 §3 record produced by `pot_generate`'s `potRecordV08` field: recomputes the Commitment, checks the Ed25519 signature, and — if `content` is supplied — checks it against the record's Payload Digest.
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| potRecordV08 | string | Yes | Hex-encoded 184 or 216-octet record |
+| ctxId | string | No | Must match what `pot_generate` used, or verification fails |
+| issuerPubKey | string | No | Hex-encoded 32-byte raw Ed25519 public key. Defaults to this server's own key. |
+| content | string | No | Payload to check against the record's Payload Digest field |
 
 ### pot_query
 

package/dist/index.js

@@ -101,16 +101,20 @@ function toolSuccess(result) {
   return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
 }
 function buildMcpServer() {
-  const s = new import_mcp.McpServer({ name: "ttt-mcp", version: "0.3.1" });
+  const s = new import_mcp.McpServer({ name: "ttt-mcp", version: "0.3.2" });
   s.tool(
     "pot_generate",
-    "Generate a cryptographic Proof of Time timestamp (draft-helmprotocol-tttps, https://datatracker.ietf.org/doc/draft-helmprotocol-tttps/). For Claude Code workflows: use eventId + prevEventId to build a causal chain. For DeFi: use txHash + chainId + poolAddress. Either eventId or txHash is required.",
+    "Generate a cryptographic Proof of Time timestamp (draft-helmprotocol-tttps, https://datatracker.ietf.org/doc/draft-helmprotocol-tttps/). For Claude Code workflows: use eventId + prevEventId to build a causal chain. For DeFi: use txHash + chainId + poolAddress. For a spec-conformant draft-08 \xA73 record binding this attestation to a specific piece of content, also supply contentDigest. One of eventId, txHash, or contentDigest is required.",
     {
       eventId: import_zod.z.string().optional().describe("Workflow step identifier (Claude Code). E.g. 'refactor_auth_step1'"),
       prevEventId: import_zod.z.string().optional().describe("Previous step's eventId \u2014 links steps into a causal chain"),
       txHash: import_zod.z.string().optional().describe("Transaction hash (DeFi, hex with 0x prefix)"),
       chainId: import_zod.z.number().optional().describe("EVM chain ID (DeFi, e.g. 8453 for Base)"),
-      poolAddress: import_zod.z.string().optional().describe("DEX pool contract address (DeFi)")
+      poolAddress: import_zod.z.string().optional().describe("DEX pool contract address (DeFi)"),
+      contentDigest: import_zod.z.string().regex(/^[0-9a-f]{64}$/).optional().describe(
+        "SHA-256 digest (lowercase hex, 64 characters) of the content this record attests to. Computed by the caller \u2014 the server never sees the content itself. When supplied, and the local time synthesis meets draft-08's own requirements (>=3 independent sources, a representable error bound), the response includes a spec-conformant potRecordV08 binary record (hex-encoded) in addition to the usual potHash fields; otherwise potRecordV08Error explains why it could not be produced."
+      ),
+      ctxId: import_zod.z.string().max(255).optional().describe("draft-08 \xA73.3 context identifier (domain separator for the Commitment). Defaults to a fixed server value if omitted; MAY be public.")
     },
     { title: "Generate Proof of Time", readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
     async (args) => {
@@ -141,6 +145,25 @@ function buildMcpServer() {
       }
     }
   );
+  s.tool(
+    "pot_verify_v08",
+    "Verify a draft-helmprotocol-tttps-08 \xA73 Proof-of-Time record (as produced by pot_generate's potRecordV08 field): recomputes the Commitment and checks the Ed25519 signature, and \u2014 if content is supplied \u2014 recomputes SHA-256(content) and checks it against the record's Payload Digest field.",
+    {
+      potRecordV08: import_zod.z.string().describe("Hex-encoded 184 or 216-octet record from pot_generate's potRecordV08 field"),
+      ctxId: import_zod.z.string().max(255).optional().describe("Context identifier the record was generated under. Must match what pot_generate used, or verification fails."),
+      issuerPubKey: import_zod.z.string().optional().describe("Hex-encoded 32-byte raw Ed25519 issuer public key. Defaults to this server's own key."),
+      content: import_zod.z.string().optional().describe("The payload (utf8) to check against the record's Payload Digest field, if available")
+    },
+    { title: "Verify draft-08 Proof-of-Time Record", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    async (args) => {
+      try {
+        const result = await (0, import_tools.potVerifyV08)(args);
+        return toolSuccess(result);
+      } catch (err) {
+        return toolError(err);
+      }
+    }
+  );
   s.tool(
     "pot_query",
     "Query Proof of Time records. Use eventId for exact O(1) lookup of a specific workflow step (collision probability 2^-256). Use startTime/endTime for time-range queries.",
@@ -234,7 +257,7 @@ async function main() {
     const httpServer = (0, import_http.createServer)(async (req, res) => {
       if (req.method === "GET" && (req.url === "/health" || req.url === "/ping")) {
         res.writeHead(200, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ status: "ok", server: "ttt-mcp", version: "0.3.1" }));
+        res.end(JSON.stringify({ status: "ok", server: "ttt-mcp", version: "0.3.2" }));
         return;
       }
       if (req.method === "POST") {

package/dist/pot_record_v08.js

@@ -0,0 +1,212 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var pot_record_v08_exports = {};
+__export(pot_record_v08_exports, {
+  MTI_INTEGRITY_ALG_SHA256: () => MTI_INTEGRITY_ALG_SHA256,
+  RECORD_SIZE_HOLDER: () => RECORD_SIZE_HOLDER,
+  RECORD_SIZE_NO_HOLDER: () => RECORD_SIZE_NO_HOLDER,
+  RESERVED_ERROR_BOUND: () => RESERVED_ERROR_BOUND,
+  assemblePotRecordV08: () => assemblePotRecordV08,
+  computeCommitmentSha256: () => computeCommitmentSha256,
+  decodePotRecordV08: () => decodePotRecordV08,
+  ed25519KeyFromSeed: () => ed25519KeyFromSeed,
+  ed25519PublicKeyFromRaw: () => ed25519PublicKeyFromRaw,
+  generatePotRecordV08: () => generatePotRecordV08,
+  rawPublicKeyOf: () => rawPublicKeyOf,
+  verifyPotRecordV08: () => verifyPotRecordV08
+});
+module.exports = __toCommonJS(pot_record_v08_exports);
+var import_crypto = require("crypto");
+const ED25519_PKCS8_PREFIX = Buffer.from("302e020100300506032b657004220420", "hex");
+const ED25519_SPKI_PREFIX = Buffer.from("302a300506032b6570032100", "hex");
+function ed25519KeyFromSeed(seed) {
+  if (seed.length !== 32) throw new Error("Ed25519 seed must be 32 bytes");
+  const der = Buffer.concat([ED25519_PKCS8_PREFIX, seed]);
+  return (0, import_crypto.createPrivateKey)({ key: der, format: "der", type: "pkcs8" });
+}
+function ed25519PublicKeyFromRaw(pub) {
+  if (pub.length !== 32) throw new Error("Ed25519 public key must be 32 bytes");
+  const der = Buffer.concat([ED25519_SPKI_PREFIX, pub]);
+  return (0, import_crypto.createPublicKey)({ key: der, format: "der", type: "spki" });
+}
+function rawPublicKeyOf(key) {
+  return key.export({ type: "spki", format: "der" }).subarray(-32);
+}
+const PRE_OFFSET = {
+  HEADER: 0,
+  // Version(4)|Tier(4), Flags(8), Integrity Alg(16) — 4 bytes
+  SRC_ERR: 4,
+  // Src Cnt(8), Error Bound(24) — 4 bytes
+  TIMESTAMP: 8,
+  // 8 bytes
+  ISSUER_KEY_ID: 16,
+  // 8 bytes
+  NONCE: 24,
+  // 32 bytes
+  PAYLOAD_DIGEST: 56,
+  // 32 bytes
+  HOLDER_KEY: 88
+  // 32 bytes, iff Flags bit 0 = 1
+};
+const PRE_LEN_NO_HOLDER = 88;
+const PRE_LEN_HOLDER = 120;
+const COMMITMENT_LEN = 32;
+const SIGNATURE_LEN = 64;
+const RECORD_SIZE_NO_HOLDER = PRE_LEN_NO_HOLDER + COMMITMENT_LEN + SIGNATURE_LEN;
+const RECORD_SIZE_HOLDER = PRE_LEN_HOLDER + COMMITMENT_LEN + SIGNATURE_LEN;
+const MTI_INTEGRITY_ALG_SHA256 = 1;
+const RESERVED_ERROR_BOUND = 16777215;
+function encodeFieldsPre(f) {
+  if (f.version < 0 || f.version > 15) throw new Error("version must fit in 4 bits");
+  if (f.tier < 0 || f.tier > 15) throw new Error("tier must fit in 4 bits");
+  if (f.integrityAlg < 0 || f.integrityAlg > 65535) throw new Error("integrityAlg must fit in 16 bits");
+  if (f.srcCnt < 3) throw new Error("Src Cnt MUST be at least 3 (draft-08 Section 3.2)");
+  if (f.srcCnt > 255) throw new Error("srcCnt must fit in 8 bits");
+  if (f.errorBoundUs === RESERVED_ERROR_BOUND) {
+    throw new Error("Error Bound 0xFFFFFF is reserved and MUST NOT be emitted (draft-08 Section 3.2)");
+  }
+  if (f.errorBoundUs < 0 || f.errorBoundUs > 16777215) throw new Error("errorBoundUs must fit in 24 bits");
+  if (f.issuerKeyId.length !== 8) throw new Error("issuerKeyId must be 8 bytes");
+  if (f.nonce.length !== 32) throw new Error("nonce must be 32 bytes");
+  if (f.payloadDigest.length !== 32) throw new Error("payloadDigest must be 32 bytes (SHA-256)");
+  if (f.holderKey !== void 0 && f.holderKey.length !== 32) {
+    throw new Error("holderKey must be 32 bytes");
+  }
+  const hasHolder = f.holderKey !== void 0;
+  const buf = Buffer.alloc(hasHolder ? PRE_LEN_HOLDER : PRE_LEN_NO_HOLDER);
+  buf.writeUInt8(f.version << 4 | f.tier, PRE_OFFSET.HEADER);
+  buf.writeUInt8(hasHolder ? 128 : 0, PRE_OFFSET.HEADER + 1);
+  buf.writeUInt16BE(f.integrityAlg, PRE_OFFSET.HEADER + 2);
+  buf.writeUInt8(f.srcCnt, PRE_OFFSET.SRC_ERR);
+  buf.writeUIntBE(f.errorBoundUs, PRE_OFFSET.SRC_ERR + 1, 3);
+  buf.writeBigUInt64BE(f.timestampNs, PRE_OFFSET.TIMESTAMP);
+  f.issuerKeyId.copy(buf, PRE_OFFSET.ISSUER_KEY_ID);
+  f.nonce.copy(buf, PRE_OFFSET.NONCE);
+  f.payloadDigest.copy(buf, PRE_OFFSET.PAYLOAD_DIGEST);
+  if (hasHolder) f.holderKey.copy(buf, PRE_OFFSET.HOLDER_KEY);
+  return buf;
+}
+function computeCommitmentSha256(fieldsPre, ctxId) {
+  const ctxBytes = Buffer.from(ctxId, "utf8");
+  if (ctxBytes.length > 255) {
+    throw new Error("ctx_id exceeds 255 octets \u2014 not usable with integrity algorithm 0x0001");
+  }
+  return (0, import_crypto.createHash)("sha256").update(Buffer.concat([Buffer.from([ctxBytes.length]), ctxBytes, Buffer.from([0]), fieldsPre])).digest();
+}
+function assemblePotRecordV08(fields, ctxId, issuerPrivateKey) {
+  const fieldsPre = encodeFieldsPre(fields);
+  const commitment = computeCommitmentSha256(fieldsPre, ctxId);
+  const p = Buffer.concat([fieldsPre, commitment]);
+  const signature = (0, import_crypto.sign)(null, p, issuerPrivateKey);
+  return Buffer.concat([p, signature]);
+}
+function generatePotRecordV08(fields, ctxId, issuerPrivateKeySeed) {
+  return assemblePotRecordV08(fields, ctxId, ed25519KeyFromSeed(issuerPrivateKeySeed));
+}
+function decodePotRecordV08(record) {
+  if (record.length < 2) throw new Error("record too short to read Flags");
+  const flags = record.readUInt8(PRE_OFFSET.HEADER + 1);
+  const hasHolder = (flags & 128) !== 0;
+  const expectedLen = hasHolder ? RECORD_SIZE_HOLDER : RECORD_SIZE_NO_HOLDER;
+  if (record.length !== expectedLen) {
+    throw new Error(`expected ${expectedLen} octets for Flags bit0=${hasHolder ? 1 : 0}, got ${record.length}`);
+  }
+  const versionTier = record.readUInt8(PRE_OFFSET.HEADER);
+  const version = versionTier >> 4 & 15;
+  const tier = versionTier & 15;
+  const integrityAlg = record.readUInt16BE(PRE_OFFSET.HEADER + 2);
+  const srcCnt = record.readUInt8(PRE_OFFSET.SRC_ERR);
+  const errorBoundUs = record.readUIntBE(PRE_OFFSET.SRC_ERR + 1, 3);
+  const timestampNs = record.readBigUInt64BE(PRE_OFFSET.TIMESTAMP);
+  const issuerKeyId = Buffer.from(record.subarray(PRE_OFFSET.ISSUER_KEY_ID, PRE_OFFSET.ISSUER_KEY_ID + 8));
+  const nonce = Buffer.from(record.subarray(PRE_OFFSET.NONCE, PRE_OFFSET.NONCE + 32));
+  const payloadDigest = Buffer.from(record.subarray(PRE_OFFSET.PAYLOAD_DIGEST, PRE_OFFSET.PAYLOAD_DIGEST + 32));
+  const preLen = hasHolder ? PRE_LEN_HOLDER : PRE_LEN_NO_HOLDER;
+  const holderKey = hasHolder ? Buffer.from(record.subarray(PRE_OFFSET.HOLDER_KEY, PRE_OFFSET.HOLDER_KEY + 32)) : void 0;
+  const fieldsPre = Buffer.from(record.subarray(0, preLen));
+  const commitment = Buffer.from(record.subarray(preLen, preLen + COMMITMENT_LEN));
+  const signature = Buffer.from(record.subarray(preLen + COMMITMENT_LEN, preLen + COMMITMENT_LEN + SIGNATURE_LEN));
+  const p = Buffer.from(record.subarray(0, preLen + COMMITMENT_LEN));
+  return {
+    version,
+    tier,
+    flags,
+    integrityAlg,
+    srcCnt,
+    errorBoundUs,
+    timestampNs,
+    issuerKeyId,
+    nonce,
+    payloadDigest,
+    holderKey,
+    commitment,
+    signature,
+    fieldsPre,
+    p
+  };
+}
+function verifyPotRecordV08(record, ctxId, issuerPublicKeyRaw, content) {
+  let decoded;
+  try {
+    decoded = decodePotRecordV08(record);
+  } catch (e) {
+    return { verdict: "rejected", reason: e instanceof Error ? e.message : String(e) };
+  }
+  if (decoded.version !== 1) {
+    return { verdict: "rejected", reason: `unknown version ${decoded.version}, expected 1` };
+  }
+  if (decoded.integrityAlg !== MTI_INTEGRITY_ALG_SHA256) {
+    return { verdict: "rejected", reason: `unimplemented integrity algorithm 0x${decoded.integrityAlg.toString(16)}` };
+  }
+  if (decoded.errorBoundUs === RESERVED_ERROR_BOUND) {
+    return { verdict: "rejected", reason: "Error Bound carries the reserved value 0xFFFFFF" };
+  }
+  const expectedCommitment = computeCommitmentSha256(decoded.fieldsPre, ctxId);
+  if (!expectedCommitment.equals(decoded.commitment)) {
+    return { verdict: "rejected", reason: "commitment mismatch" };
+  }
+  const publicKey = ed25519PublicKeyFromRaw(issuerPublicKeyRaw);
+  if (!(0, import_crypto.verify)(null, decoded.p, publicKey, decoded.signature)) {
+    return { verdict: "rejected", reason: "Ed25519 signature invalid" };
+  }
+  let payloadDigestMatchesContent;
+  if (content !== void 0) {
+    const recomputed = (0, import_crypto.createHash)("sha256").update(content).digest();
+    payloadDigestMatchesContent = recomputed.equals(decoded.payloadDigest);
+    if (!payloadDigestMatchesContent) {
+      return { verdict: "rejected", reason: "Payload Digest does not match supplied content", payloadDigestMatchesContent };
+    }
+  }
+  return { verdict: "intact", payloadDigestMatchesContent };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MTI_INTEGRITY_ALG_SHA256,
+  RECORD_SIZE_HOLDER,
+  RECORD_SIZE_NO_HOLDER,
+  RESERVED_ERROR_BOUND,
+  assemblePotRecordV08,
+  computeCommitmentSha256,
+  decodePotRecordV08,
+  ed25519KeyFromSeed,
+  ed25519PublicKeyFromRaw,
+  generatePotRecordV08,
+  rawPublicKeyOf,
+  verifyPotRecordV08
+});

package/dist/tools.js

@@ -35,6 +35,7 @@ __export(tools_exports, {
   potQuery: () => potQuery,
   potStats: () => potStats,
   potVerify: () => potVerify,
+  potVerifyV08: () => potVerifyV08,
   redis: () => redis,
   restoreDagEntry: () => restoreDagEntry,
   tttsFreshnessSeal: () => tttsFreshnessSeal,
@@ -44,6 +45,8 @@ module.exports = __toCommonJS(tools_exports);
 var import_openttt = require("openttt");
 var import_telemetry = require("./telemetry");
 var import_server = require("./server");
+var import_crypto = require("crypto");
+var import_pot_record_v08 = require("./pot_record_v08");
 var import_ioredis = __toESM(require("ioredis"));
 const GrgPipeline = (
   // eslint-disable-next-line @typescript-eslint/no-require-imports
@@ -72,6 +75,16 @@ const timeSynth = new import_openttt.TimeSynthesis();
 const adaptiveSwitch = new import_openttt.AdaptiveSwitch();
 const potSigner = new import_openttt.PotSigner();
 const startedAt = Date.now();
+const potSignerPrivateKeyV08 = (0, import_crypto.createPrivateKey)({
+  key: Buffer.from(potSigner.getPrivateKeyHex(), "hex"),
+  format: "der",
+  type: "pkcs8"
+});
+const potSignerPublicKeyRawV08 = Buffer.from(potSigner.getPubKeyHex(), "hex").subarray(-32);
+const potSignerIssuerKeyIdV08 = (0, import_crypto.createHash)("sha256").update(potSignerPublicKeyRawV08).digest().subarray(0, 8);
+const DEFAULT_CTX_ID_V08 = "openttt-mcp/pot_generate";
+const DEFAULT_TIER_V08 = 3;
+const CONTENT_DIGEST_HEX_RE = /^[0-9a-f]{64}$/;
 const POT_LOG_MAX = 1e4;
 const potLog = [];
 const potByEventId = /* @__PURE__ */ new Map();
@@ -172,12 +185,15 @@ function restoreDagEntry(entry) {
   }
 }
 async function potGenerate(args) {
-  if (!args.eventId && !args.txHash) {
-    throw new Error("Either eventId (Claude Code) or txHash (DeFi) is required");
+  if (!args.eventId && !args.txHash && !args.contentDigest) {
+    throw new Error("One of eventId (Claude Code), txHash (DeFi), or contentDigest is required");
+  }
+  if (args.contentDigest !== void 0 && !CONTENT_DIGEST_HEX_RE.test(args.contentDigest)) {
+    throw new Error("contentDigest must be a 64-character lowercase hex SHA-256 digest");
   }
   (0, import_telemetry.telemetryIncrement)("pot_generate");
   const apiKey = resolvePaidApiKey();
-  if (apiKey && args.eventId) {
+  if (apiKey && args.eventId && !args.contentDigest) {
     const { data, advisory } = await (0, import_server.delegateToServer)({
       apiKey,
       method: "POST",
@@ -288,6 +304,33 @@ async function potGenerate(args) {
     });
   }
   updateLastPot(pot.timestamp, pot.stratum, pot.sources);
+  let potRecordV08;
+  let potRecordV08CtxId;
+  let potRecordV08Error;
+  if (args.contentDigest !== void 0) {
+    const ctxId = args.ctxId ?? DEFAULT_CTX_ID_V08;
+    const errorBoundUs = Math.round(pot.uncertainty * 1e3);
+    if (isOfflineFallback || pot.sources < 3) {
+      potRecordV08Error = `Src Cnt is ${pot.sources}, but draft-08 \xA73.2 requires at least 3 independent time sources`;
+    } else if (errorBoundUs < 0 || errorBoundUs >= import_pot_record_v08.RESERVED_ERROR_BOUND) {
+      potRecordV08Error = `Error Bound ${errorBoundUs}us is not representable in the 24-bit field (or hits the reserved value)`;
+    } else {
+      const fields = {
+        version: 1,
+        tier: DEFAULT_TIER_V08,
+        integrityAlg: import_pot_record_v08.MTI_INTEGRITY_ALG_SHA256,
+        srcCnt: pot.sources,
+        errorBoundUs,
+        timestampNs: pot.timestamp,
+        issuerKeyId: potSignerIssuerKeyIdV08,
+        nonce: (0, import_crypto.randomBytes)(32),
+        payloadDigest: Buffer.from(args.contentDigest, "hex")
+      };
+      const record = (0, import_pot_record_v08.assemblePotRecordV08)(fields, ctxId, potSignerPrivateKeyV08);
+      potRecordV08 = record.toString("hex");
+      potRecordV08CtxId = ctxId;
+    }
+  }
   return serialize({
     potHash,
     eventId: args.eventId ?? null,
@@ -305,7 +348,9 @@ async function potGenerate(args) {
       issuerPubKey: signature.issuerPubKey,
       signature: signature.signature,
       issuedAt: signature.issuedAt.toString()
-    }
+    },
+    ...potRecordV08 !== void 0 && { potRecordV08, potRecordV08CtxId, potRecordV08IssuerPubKey: potSignerPublicKeyRawV08.toString("hex") },
+    ...potRecordV08Error !== void 0 && { potRecordV08Error }
   });
 }
 async function potVerify(args) {
@@ -329,6 +374,21 @@ async function potVerify(args) {
     verifiedAt: Date.now()
   });
 }
+async function potVerifyV08(args) {
+  (0, import_telemetry.telemetryIncrement)("pot_verify_v08");
+  const record = Buffer.from(args.potRecordV08, "hex");
+  const ctxId = args.ctxId ?? DEFAULT_CTX_ID_V08;
+  const issuerPubKey = args.issuerPubKey !== void 0 ? Buffer.from(args.issuerPubKey, "hex") : potSignerPublicKeyRawV08;
+  const content = args.content !== void 0 ? Buffer.from(args.content, "utf8") : void 0;
+  const result = (0, import_pot_record_v08.verifyPotRecordV08)(record, ctxId, issuerPubKey, content);
+  return serialize({
+    verdict: result.verdict,
+    reason: result.reason ?? null,
+    payloadDigestMatchesContent: result.payloadDigestMatchesContent ?? null,
+    ctxId,
+    verifiedAt: Date.now()
+  });
+}
 async function potQuery(args) {
   (0, import_telemetry.telemetryIncrement)("pot_query");
   const apiKey = resolvePaidApiKey();
@@ -590,6 +650,7 @@ async function potCheckpoint(args) {
   potQuery,
   potStats,
   potVerify,
+  potVerifyV08,
   redis,
   restoreDagEntry,
   tttsFreshnessSeal,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@helm-protocol/ttt-mcp",
-  "version": "0.3.1",
-  "description": "MCP Server for OpenTTT — Proof of Time tools for AI agents",
+  "version": "0.3.3",
+  "description": "Proof-of-Time attestation \u2014 Ed25519-signed timestamps with multi-source corroboration and explicit error bounds. IETF draft-helmprotocol-tttps",
   "main": "dist/index.js",
   "bin": {
     "ttt-mcp": "./dist/index.js"
@@ -11,7 +11,7 @@
     "README.md"
   ],
   "scripts": {
-    "build": "esbuild index.ts tools.ts telemetry.ts auth.ts server.ts --platform=node --target=node18 --format=cjs --outdir=dist",
+    "build": "esbuild index.ts tools.ts telemetry.ts auth.ts server.ts pot_record_v08.ts --platform=node --target=node18 --format=cjs --outdir=dist",
     "start": "node dist/index.js",
     "dev": "npx ts-node index.ts",
     "test": "jest --forceExit",
@@ -20,16 +20,21 @@
   "jest": {
     "preset": "ts-jest",
     "testEnvironment": "node",
-    "testMatch": ["**/__tests__/**/*.test.ts"],
+    "testMatch": [
+      "**/__tests__/**/*.test.ts"
+    ],
     "moduleNameMapper": {
       "^openttt$": "<rootDir>/node_modules/openttt/dist/index.js"
     },
     "transform": {
-      "^.+\\.tsx?$": ["ts-jest", {
-        "tsconfig": {
-          "module": "CommonJS"
+      "^.+\\.tsx?$": [
+        "ts-jest",
+        {
+          "tsconfig": {
+            "module": "CommonJS"
+          }
         }
-      }]
+      ]
     }
   },
   "keywords": [