@helm-protocol/ttt-mcp 0.2.2 → 0.3.1

package/dist/tools.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,24 +17,67 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var tools_exports = {};
 __export(tools_exports, {
+  potCheckpoint: () => potCheckpoint,
   potGenerate: () => potGenerate,
+  potGraph: () => potGraph,
   potHealth: () => potHealth,
   potQuery: () => potQuery,
   potStats: () => potStats,
-  potVerify: () => potVerify
+  potVerify: () => potVerify,
+  redis: () => redis,
+  restoreDagEntry: () => restoreDagEntry,
+  tttsFreshnessSeal: () => tttsFreshnessSeal,
+  updateLastPot: () => updateLastPot
 });
 module.exports = __toCommonJS(tools_exports);
 var import_openttt = require("openttt");
 var import_telemetry = require("./telemetry");
+var import_server = require("./server");
+var import_ioredis = __toESM(require("ioredis"));
+const GrgPipeline = (
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  require("openttt").GrgPipeline ?? null
+);
+function applyAdvisory(result, advisory) {
+  if (!advisory) return result;
+  if (result === null || typeof result !== "object") return result;
+  const notices = [];
+  if (advisory.warning) notices.push(advisory.warning);
+  if (advisory.overageActive) notices.push("Overage billing is active \u2014 usage above your plan limit will be charged.");
+  if (notices.length === 0) return result;
+  return { ...result, _quotaNotice: notices.join(" | ") };
+}
+function resolvePaidApiKey() {
+  return process.env.TTT_API_KEY?.trim() || void 0;
+}
+const redis = new import_ioredis.default(process.env.REDIS_URL ?? "redis://127.0.0.1:6379", {
+  lazyConnect: true,
+  enableOfflineQueue: false,
+  maxRetriesPerRequest: 1
+});
+redis.on("error", () => {
+});
 const timeSynth = new import_openttt.TimeSynthesis();
 const adaptiveSwitch = new import_openttt.AdaptiveSwitch();
 const potSigner = new import_openttt.PotSigner();
 const startedAt = Date.now();
 const POT_LOG_MAX = 1e4;
 const potLog = [];
+const potByEventId = /* @__PURE__ */ new Map();
+const potByPrevEventId = /* @__PURE__ */ new Map();
+const evictedEventIds = /* @__PURE__ */ new Set();
+const EVICTED_MAX = 1e3;
 function bigintReplacer(_key, value) {
   return typeof value === "bigint" ? value.toString() : value;
 }
@@ -40,26 +85,213 @@ function serialize(obj) {
   return JSON.parse(JSON.stringify(obj, bigintReplacer));
 }
 const SUBGRAPH_URL = "https://api.studio.thegraph.com/query/1744392/openttt-base-sepolia/v0.1.0";
+function compressEntry(entry, depth, depthThreshold) {
+  const t = depthThreshold ?? { compact: 5, minimal: 20, rollup: 50 };
+  if (depth <= t.compact) return entry;
+  if (depth <= t.minimal) return {
+    // compact
+    eventId: entry.eventId,
+    potHash: entry.potHash,
+    timestamp: entry.timestamp,
+    prevEventId: entry.prevEventId
+  };
+  if (depth <= t.rollup) return {
+    // minimal
+    eventId: entry.eventId,
+    timestamp: entry.timestamp
+  };
+  return `${entry.eventId ?? "?"}@${entry.timestamp}`;
+}
+function depthThresholdFromTokens(maxTokens, entryCount) {
+  const charBudget = maxTokens * 4;
+  const fullBudget = charBudget * 0.6;
+  const compactBudget = charBudget * 0.25;
+  const minimalBudget = charBudget * 0.1;
+  const fullDepth = Math.max(1, Math.floor(fullBudget / 300));
+  const compactDepth = fullDepth + Math.max(0, Math.floor(compactBudget / 120));
+  const minimalDepth = compactDepth + Math.max(0, Math.floor(minimalBudget / 60));
+  return {
+    compact: Math.min(fullDepth, entryCount),
+    minimal: Math.min(compactDepth, entryCount),
+    rollup: Math.min(minimalDepth, entryCount)
+  };
+}
+let _lastPotTimestampNs = null;
+let _lastPotStratum = 16;
+let _lastPotSources = 0;
+function updateLastPot(timestampNs, stratum, sources) {
+  _lastPotTimestampNs = timestampNs;
+  _lastPotStratum = stratum;
+  _lastPotSources = sources;
+}
+function tttsFreshnessSeal() {
+  if (_lastPotTimestampNs === null) return null;
+  const nowNs = BigInt(Date.now()) * 1000000n;
+  const age_ms = Number((nowNs - _lastPotTimestampNs) / 1000000n);
+  const ttlMs = _lastPotStratum <= 3 ? 100 : _lastPotStratum <= 8 ? 1e3 : _lastPotStratum <= 15 ? 5e3 : 0;
+  return { age_ms, stratum: _lastPotStratum, sources: _lastPotSources, ttlMs };
+}
+function restoreDagEntry(entry) {
+  if (potByEventId.has(entry.eventId)) return;
+  const e = {
+    potHash: entry.potHash,
+    timestamp: entry.timestamp,
+    stratum: entry.stratum,
+    mode: entry.mode,
+    chainId: entry.chainId ?? void 0,
+    poolAddress: entry.poolAddress ?? void 0,
+    eventId: entry.eventId,
+    prevEventId: entry.prevEventId ?? void 0,
+    createdAt: entry.createdAt
+  };
+  if (potLog.length >= POT_LOG_MAX) {
+    const evicted = potLog.shift();
+    if (evicted.eventId) {
+      potByEventId.delete(evicted.eventId);
+      evictedEventIds.add(evicted.eventId);
+      if (evictedEventIds.size > EVICTED_MAX) {
+        const first = evictedEventIds.values().next().value;
+        if (first !== void 0) evictedEventIds.delete(first);
+      }
+    }
+    if (evicted.prevEventId) {
+      const siblings = potByPrevEventId.get(evicted.prevEventId);
+      if (siblings) {
+        const filtered = siblings.filter((s) => s !== evicted);
+        if (filtered.length === 0) potByPrevEventId.delete(evicted.prevEventId);
+        else potByPrevEventId.set(evicted.prevEventId, filtered);
+      }
+    }
+  }
+  potLog.push(e);
+  potByEventId.set(entry.eventId, e);
+  if (entry.prevEventId) {
+    const bucket = potByPrevEventId.get(entry.prevEventId) ?? [];
+    bucket.push(e);
+    potByPrevEventId.set(entry.prevEventId, bucket);
+  }
+}
 async function potGenerate(args) {
+  if (!args.eventId && !args.txHash) {
+    throw new Error("Either eventId (Claude Code) or txHash (DeFi) is required");
+  }
   (0, import_telemetry.telemetryIncrement)("pot_generate");
-  const pot = await timeSynth.generateProofOfTime();
+  const apiKey = resolvePaidApiKey();
+  if (apiKey && args.eventId) {
+    const { data, advisory } = await (0, import_server.delegateToServer)({
+      apiKey,
+      method: "POST",
+      path: "/pot/generate",
+      body: { eventId: args.eventId, prevEventId: args.prevEventId }
+    });
+    if (data && typeof data === "object") {
+      const d = data;
+      if (typeof d.stratum === "number" && typeof d.sources === "number" && typeof d.timestamp === "string") {
+        updateLastPot(BigInt(d.timestamp), d.stratum, d.sources);
+      }
+    }
+    return applyAdvisory(data, advisory);
+  }
+  let pot;
+  let isOfflineFallback = false;
+  try {
+    pot = await timeSynth.generateProofOfTime();
+  } catch {
+    isOfflineFallback = true;
+    const nowMs = BigInt(Date.now());
+    pot = {
+      timestamp: nowMs * 1000000n,
+      stratum: 16,
+      uncertainty: 999999999,
+      confidence: 0,
+      sources: 0,
+      nonce: Buffer.from(crypto.getRandomValues(new Uint8Array(16))).toString("hex"),
+      expiresAt: (nowMs + 300000n) * 1000000n,
+      sourceReadings: []
+    };
+  }
   const potHash = import_openttt.TimeSynthesis.getOnChainHash(pot);
-  const txData = new TextEncoder().encode(args.txHash);
-  const grgShards = import_openttt.GrgPipeline.processForward(txData, args.chainId, args.poolAddress);
+  let grgShards = [];
+  let currentMode;
+  if (args.txHash && args.chainId != null && args.poolAddress) {
+    const txData = new TextEncoder().encode(args.txHash);
+    grgShards = GrgPipeline.processForward(txData, args.chainId, args.poolAddress).map((s) => Buffer.from(s).toString("hex"));
+    const syntheticBlock = {
+      timestamp: Number(pot.timestamp / 1000000n),
+      // ns → ms
+      txs: [args.txHash],
+      data: new TextEncoder().encode(args.txHash)
+    };
+    const syntheticTTTRecord = {
+      time: Number(pot.timestamp / 1000000n),
+      txOrder: [args.txHash],
+      grgPayload: []
+    };
+    currentMode = adaptiveSwitch.verifyBlock(syntheticBlock, syntheticTTTRecord, args.chainId, args.poolAddress);
+  } else {
+    currentMode = adaptiveSwitch.getCurrentMode();
+  }
   const signature = potSigner.signPot(potHash);
   const entry = {
     potHash,
     timestamp: pot.timestamp.toString(),
     stratum: pot.stratum,
-    mode: adaptiveSwitch.getCurrentMode(),
+    mode: currentMode,
     chainId: args.chainId,
     poolAddress: args.poolAddress,
+    eventId: args.eventId,
+    prevEventId: args.prevEventId,
     createdAt: Date.now()
   };
+  if (potLog.length >= POT_LOG_MAX) {
+    const evicted = potLog.shift();
+    if (evicted.eventId) {
+      potByEventId.delete(evicted.eventId);
+      evictedEventIds.add(evicted.eventId);
+      if (evictedEventIds.size > EVICTED_MAX) {
+        const first = evictedEventIds.values().next().value;
+        if (first !== void 0) evictedEventIds.delete(first);
+      }
+    }
+    if (evicted.prevEventId) {
+      const siblings = potByPrevEventId.get(evicted.prevEventId);
+      if (siblings) {
+        const filtered = siblings.filter((e) => e !== evicted);
+        if (filtered.length === 0) potByPrevEventId.delete(evicted.prevEventId);
+        else potByPrevEventId.set(evicted.prevEventId, filtered);
+      }
+    }
+  }
   potLog.push(entry);
-  if (potLog.length > POT_LOG_MAX) potLog.shift();
+  if (args.eventId) potByEventId.set(args.eventId, entry);
+  if (args.prevEventId) {
+    const bucket = potByPrevEventId.get(args.prevEventId) ?? [];
+    bucket.push(entry);
+    potByPrevEventId.set(args.prevEventId, bucket);
+  }
+  if (args.eventId) {
+    redis.setex(
+      `dag:${args.eventId}`,
+      90 * 86400,
+      JSON.stringify({
+        eventId: args.eventId,
+        prevEventId: args.prevEventId ?? null,
+        potHash,
+        timestamp: pot.timestamp.toString(),
+        stratum: pot.stratum,
+        mode: currentMode,
+        createdAt: entry.createdAt,
+        chainId: args.chainId ?? null,
+        poolAddress: args.poolAddress ?? null
+      })
+    ).catch(() => {
+    });
+  }
+  updateLastPot(pot.timestamp, pot.stratum, pot.sources);
   return serialize({
     potHash,
+    eventId: args.eventId ?? null,
+    prevEventId: args.prevEventId ?? null,
     timestamp: pot.timestamp.toString(),
     stratum: pot.stratum,
     uncertainty: pot.uncertainty,
@@ -67,7 +299,8 @@ async function potGenerate(args) {
     sources: pot.sources,
     nonce: pot.nonce,
     expiresAt: pot.expiresAt.toString(),
-    grgShards: grgShards.map((s) => Buffer.from(s).toString("hex")),
+    ...isOfflineFallback && { mode: "local" },
+    ...grgShards.length > 0 && { grgShards },
     signature: {
       issuerPubKey: signature.issuerPubKey,
       signature: signature.signature,
@@ -81,7 +314,7 @@ async function potVerify(args) {
   let valid = false;
   let reconstructedSize = 0;
   try {
-    const recovered = import_openttt.GrgPipeline.processInverse(shards, 0, args.chainId, args.poolAddress);
+    const recovered = GrgPipeline.processInverse(shards, 0, args.chainId, args.poolAddress);
     valid = recovered.length > 0;
     reconstructedSize = recovered.length;
   } catch {
@@ -98,6 +331,31 @@ async function potVerify(args) {
 }
 async function potQuery(args) {
   (0, import_telemetry.telemetryIncrement)("pot_query");
+  const apiKey = resolvePaidApiKey();
+  if (apiKey) {
+    const { data, advisory } = await (0, import_server.delegateToServer)({
+      apiKey,
+      method: "GET",
+      path: "/pot/query",
+      query: {
+        eventId: args.eventId,
+        startTimeNs: args.startTime != null ? args.startTime * 1e6 : void 0,
+        endTimeNs: args.endTime != null ? args.endTime * 1e6 : void 0,
+        limit: args.limit
+      }
+    });
+    return applyAdvisory(data, advisory);
+  }
+  if (args.eventId) {
+    const entry = potByEventId.get(args.eventId);
+    return serialize({
+      local: entry ? [entry] : [],
+      subgraph: [],
+      found: !!entry,
+      totalLocal: potLog.length,
+      query: { eventId: args.eventId }
+    });
+  }
   const limit = Math.min(args.limit ?? 100, 1e3);
   const now = Date.now();
   const startTime = args.startTime ?? now - 864e5;
@@ -140,8 +398,56 @@ async function potQuery(args) {
     query: { startTime, endTime, limit }
   });
 }
+async function potGraph(args) {
+  (0, import_telemetry.telemetryIncrement)("pot_graph");
+  const apiKey = resolvePaidApiKey();
+  if (apiKey) {
+    const { data, advisory } = await (0, import_server.delegateToServer)({
+      apiKey,
+      method: "GET",
+      path: "/pot/graph",
+      query: { eventId: args.eventId, depth: args.depth }
+    });
+    return applyAdvisory(data, advisory);
+  }
+  const maxDepth = Math.min(args.depth ?? 10, 100);
+  const backwardChain = [];
+  let cursor = potByEventId.get(args.eventId);
+  let d = 0;
+  while (cursor && d < maxDepth) {
+    backwardChain.unshift(cursor);
+    cursor = cursor.prevEventId ? potByEventId.get(cursor.prevEventId) : void 0;
+    d++;
+  }
+  const forwardChain = potByPrevEventId.get(args.eventId) ?? [];
+  const found = potByEventId.has(args.eventId);
+  const chainBroken = backwardChain.some((e) => e.eventId && evictedEventIds.has(e.eventId)) || cursor?.prevEventId != null && potByEventId.get(cursor.prevEventId) == null;
+  const chainRoot = backwardChain.length > 0 ? backwardChain[0] : null;
+  const isServerRestart = chainBroken && chainRoot !== null && chainRoot.prevEventId != null && !potByEventId.has(chainRoot.prevEventId) && !evictedEventIds.has(chainRoot.prevEventId);
+  const brokenAt = chainBroken ? isServerRestart ? "server_restart" : backwardChain[0]?.eventId ?? null : null;
+  const compressedBackward = backwardChain.map((e, i) => compressEntry(e, i + 1));
+  return serialize({
+    eventId: args.eventId,
+    found,
+    backwardChain: compressedBackward,
+    forwardChain,
+    chainLength: backwardChain.length + forwardChain.length,
+    reachableDepth: backwardChain.length,
+    chainBroken,
+    brokenAt
+  });
+}
 async function potStats(args) {
   (0, import_telemetry.telemetryIncrement)("pot_stats");
+  const apiKey = resolvePaidApiKey();
+  if (apiKey) {
+    const { data, advisory } = await (0, import_server.delegateToServer)({
+      apiKey,
+      method: "GET",
+      path: "/pot/stats"
+    });
+    return applyAdvisory(data, advisory);
+  }
   const now = Date.now();
   const periodMs = {
     day: 864e5,
@@ -220,11 +526,72 @@ async function potHealth() {
     }
   });
 }
+async function potCheckpoint(args) {
+  (0, import_telemetry.telemetryIncrement)("pot_checkpoint");
+  const apiKey = resolvePaidApiKey();
+  if (apiKey) {
+    const { data, advisory } = await (0, import_server.delegateToServer)({
+      apiKey,
+      method: "GET",
+      path: "/pot/checkpoint",
+      query: {
+        fromEventId: args.fromEventId,
+        toEventId: args.toEventId,
+        startTime: args.startTime,
+        endTime: args.endTime,
+        maxTokens: args.maxTokens
+      }
+    });
+    return applyAdvisory(data, advisory);
+  }
+  const now = Date.now();
+  const startTime = args.startTime ?? now - 36e5;
+  const endTime = args.endTime ?? now;
+  let entries;
+  if (args.fromEventId && args.toEventId) {
+    entries = [];
+    let cursor = potByEventId.get(args.fromEventId);
+    const maxDepth = 1e3;
+    let d = 0;
+    while (cursor && d < maxDepth) {
+      entries.push(cursor);
+      if (cursor.eventId === args.toEventId) break;
+      const nexts = potByPrevEventId.get(cursor.eventId ?? "") ?? [];
+      cursor = nexts[0];
+      d++;
+    }
+  } else {
+    entries = potLog.filter((e) => e.createdAt >= startTime && e.createdAt <= endTime);
+  }
+  const eventCount = entries.length;
+  const depthThreshold = args.maxTokens ? depthThresholdFromTokens(args.maxTokens, entries.length) : void 0;
+  const compressed = entries.map((e, i) => compressEntry(e, i + 1, depthThreshold));
+  const chainIntact = !entries.some((e) => e.eventId && evictedEventIds.has(e.eventId));
+  const nextCheckpointHint = Math.max(10, 240 - eventCount % 240);
+  const checkpointId = `ckpt_${now}_${eventCount}`;
+  const firstTs = entries[0]?.timestamp ?? null;
+  const lastTs = entries[entries.length - 1]?.timestamp ?? null;
+  return serialize({
+    checkpointId,
+    eventCount,
+    chainIntact,
+    nextCheckpointHint,
+    rollup: compressed,
+    summary: `${eventCount} events from ${firstTs ?? "?"} to ${lastTs ?? "?"}`,
+    generatedAt: now
+  });
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  potCheckpoint,
   potGenerate,
+  potGraph,
   potHealth,
   potQuery,
   potStats,
-  potVerify
+  potVerify,
+  redis,
+  restoreDagEntry,
+  tttsFreshnessSeal,
+  updateLastPot
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@helm-protocol/ttt-mcp",
-  "version": "0.2.2",
+  "version": "0.3.1",
   "description": "MCP Server for OpenTTT — Proof of Time tools for AI agents",
   "main": "dist/index.js",
   "bin": {
@@ -11,9 +11,26 @@
     "README.md"
   ],
   "scripts": {
-    "build": "esbuild index.ts tools.ts telemetry.ts auth.ts --platform=node --target=node18 --format=cjs --outdir=dist",
+    "build": "esbuild index.ts tools.ts telemetry.ts auth.ts server.ts --platform=node --target=node18 --format=cjs --outdir=dist",
     "start": "node dist/index.js",
-    "dev": "npx ts-node index.ts"
+    "dev": "npx ts-node index.ts",
+    "test": "jest --forceExit",
+    "typecheck": "NODE_OPTIONS='--max-old-space-size=4096' tsc --noEmit"
+  },
+  "jest": {
+    "preset": "ts-jest",
+    "testEnvironment": "node",
+    "testMatch": ["**/__tests__/**/*.test.ts"],
+    "moduleNameMapper": {
+      "^openttt$": "<rootDir>/node_modules/openttt/dist/index.js"
+    },
+    "transform": {
+      "^.+\\.tsx?$": ["ts-jest", {
+        "tsconfig": {
+          "module": "CommonJS"
+        }
+      }]
+    }
   },
   "keywords": [
     "mcp",
@@ -35,13 +52,17 @@
     "node": ">=18"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.12.1",
-    "openttt": "^0.2.6",
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "ioredis": "^5.11.0",
+    "openttt": "^0.2.13",
     "zod": "^3.25.0"
   },
   "devDependencies": {
+    "@types/jest": "^30.0.0",
     "@types/node": "^20.11.19",
     "esbuild": "^0.27.4",
+    "jest": "^30.4.2",
+    "ts-jest": "^29.4.11",
     "typescript": "^5.3.3"
   },
   "mcpName": "io.github.Helm-Protocol/openttt-pot"