AI Agent A and Agent B both trigger a payment at the same time. Who was first?

OpenTTT answers this with cryptographic Proof of Time — synthesized from multiple independent time sources, verified through GRG integrity shards, and signed with Ed25519 for non-repudiation.

Quick Start

npm install @helm-protocol/ttt-mcp

// claude_desktop_config.json
{
  "mcpServers": {
    "ttt": {
      "command": "npx",
      "args": ["@helm-protocol/ttt-mcp"]
    }
  }
}

That's it. Your AI agent now has access to 5 Proof of Time tools.

Tools

Tool	Description
`pot_generate`	Generate a Proof of Time for a transaction
`pot_verify`	Verify a Proof of Time using its hash and GRG shards
`pot_query`	Query PoT history from local log and on-chain subgraph
`pot_stats`	Get turbo/full mode statistics for a time period
`pot_health`	Check system health: time sources, subgraph sync, uptime

Tool Parameters

pot_generate

Generate a Proof of Time for a transaction. Returns potHash, timestamp, stratum, and GRG integrity shards.

Parameter	Type	Required	Description
txHash	string	Yes	Transaction hash (hex with 0x prefix)
chainId	number	Yes	Chain ID (e.g. 8453 for Base, 84532 for Base Sepolia)
poolAddress	string	Yes	DEX pool contract address

pot_verify

Verify a Proof of Time using its hash and GRG shards. Returns validity, mode (turbo/full), and timestamp.

Parameter	Type	Required	Description
potHash	string	Yes	PoT hash to verify (hex with 0x prefix)
grgShards	string[]	Yes	Array of hex-encoded GRG integrity shards
chainId	number	Yes	EVM chain ID (e.g. 84532 for Base Sepolia)
poolAddress	string	Yes	Uniswap V4 pool address (0x-prefixed)

pot_query

Query Proof of Time history from local log and on-chain subgraph.

Parameter	Type	Required	Description
startTime	number	No	Start time (unix ms). Default: 24h ago
endTime	number	No	End time (unix ms). Default: now
limit	number	No	Max entries to return. Default: 100, max: 1000

pot_stats

Get PoT statistics: total swaps, turbo/full counts, and turbo ratio for a given period.

Parameter	Type	Required	Description
period	`"day"` \| `"week"` \| `"month"`	Yes	Time period for statistics

pot_health

Check PoT system health: time source status, subgraph sync, server uptime, and current mode.

Parameter	Type	Required	Description
(none)	—	—	This tool takes no parameters

Example: Generate and Verify a PoT

// In your AI agent's tool call:
const pot = await pot_generate({
  txHash: "0xabc123...",
  chainId: 84532,
  poolAddress: "0xdef456..."
});

// pot.potHash — unique Proof of Time hash
// pot.grgShards — GRG integrity shards for verification
// pot.timestamp — synthesized nanosecond timestamp
// pot.mode — "turbo" (honest) or "full" (requires full verification)

const verification = await pot_verify({
  potHash: pot.potHash,
  grgShards: pot.grgShards
});
// verification.valid — true if integrity shards reconstruct correctly

How It Works

Time Synthesis — Queries multiple independent time sources (NIST, Google, Cloudflare) via HTTPS/NTP and synthesizes a median timestamp with uncertainty bounds
GRG Pipeline — Encodes transaction data through a multi-layer integrity pipeline, producing verifiable shards
Ed25519 Signing — Signs the PoT hash for non-repudiation
Adaptive Mode — Honest builders get turbo mode (fast, profitable); tampered sequences get full mode (slow, costly) — natural economic selection

Claude Desktop Configuration

Add to your claude_desktop_config.json:

{
  "mcpServers": {
    "ttt": {
      "command": "npx",
      "args": ["@helm-protocol/ttt-mcp"]
    }
  }
}

Config file locations:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json
Linux: ~/.config/Claude/claude_desktop_config.json

Requirements

Node.js >= 18
Network access for time synthesis (HTTPS to time.nist.gov, time.google.com, time.cloudflare.com)

Use Cases

1. MEV Bot — Transaction Ordering Proof

Problem: You got front-run. You know it happened. You can't prove it — mempool timestamps are per-node, unsigned, and non-authoritative. No evidence, no recourse.

Solution: Call pot_generate before submitting every transaction. The PoT receipt is cryptographically signed by three independent time sources (NIST, Google, Cloudflare), hashed on-chain to Base Sepolia TTT ERC-1155. If front-running occurs, you have a timestamped, on-chain-anchored record of your original submission that predates the attacker's block inclusion.

// Before tx submission
const pot = await client.callTool({ name: "pot_generate", arguments: { txHash: pendingTxHash, chainId: 8453 } });
// Store pot.potHash alongside your trade log
// If front-run: pot.potHash is your evidence, timestamped by NIST+Google+Cloudflare

V2 path: When builder staking goes live, S(V) ≥ V − c₀ makes reordering economically irrational for any V. Not just evidence — prevention.

2. DEX Protocol — AdaptiveSwitch Sandwich Deterrence

Problem: Small-to-mid value sandwich attacks (V < ~$87) are constant background noise on any AMM. Each one is individually too small to litigate, collectively significant. No governance mechanism moves fast enough to respond.

Solution: Integrate TTTHookSimple (Uniswap V4 hook, Base Sepolia: 0x8C633b05b833a476925F7d9818da6E215760F2c7). Honest builders who preserve PoT-verified ordering get turbo mode (~50ms path). Builders who tamper are flagged to full mode (~127ms + exponential backoff up to 320 blocks). The 77ms throughput differential makes reordering cost exceed opportunity value for the V* range. No vote. No committee. Economics.

// Query current switch state for a pool
const status = await client.callTool({ name: "pot_stats", arguments: { poolAddress: "0x..." } });
// status.adaptiveMode: "turbo" | "full"
// status.currentV_star: estimated MEV threshold being deterred

Outcome: ~80% reduction in sub-threshold sandwich attacks. Provable per-block audit trail.

3. Hedge Fund / Prop Desk — MiFIR Art.22c Compliance

Problem: MiFIR Article 22c / RTS 25 requires microsecond-precision UTC-synchronized timestamps for every trade on regulated venues. The standard hardware solution (PTP/IEEE 1588 appliances) costs $50K–$500K and requires dedicated ops. Most DeFi-adjacent funds run manual reconciliation between two separate timestamp systems.

Solution: pot_generate produces an Ed25519-signed timestamp with uncertainty bound, confidence score, and multi-source attestation. The output is structurally compatible with RTS 25 audit record requirements. No hardware appliance. No dedicated ops. One API call per trade.

const audit = await client.callTool({
  name: "pot_generate",
  arguments: { txHash: tradeHash, chainId: 8453, metadata: { desk: "MACRO-1", trader: "algo-07" } }
});
// audit.timestamp: nanosecond precision
// audit.uncertainty: +/- ms bound (required field in RTS 25 record)
// audit.confidence: fraction of sources that agreed
// audit.ed25519_sig: non-repudiation signature
// Export to your compliance system — same format, every trade

Outcome: MiFIR-grade audit trail at ~$0.04/1K calls (DEX tier). Replaces $50K+ hardware setup. IETF standardized via draft-helmprotocol-tttps-00.

4. Liquidity Provider — Position Timeline for Dispute Resolution

Problem: LP enters and exits positions based on market conditions. When impermanent loss occurs due to a suspected protocol exploit or ordering manipulation, proving the sequence of events (position entry → exploit event → position exit) requires timestamped evidence that the current stack doesn't provide.

Solution: Stamp every LP action (add liquidity, remove liquidity, fee harvest) with a PoT receipt. The receipt chain creates an unforgeable causal timeline: each action's potHash references the previous, anchored on Base Sepolia. Legally defensible for tax documentation, insurance claims, and protocol dispute resolution.

// On liquidity add
const entryPot = await client.callTool({ name: "pot_generate", arguments: { txHash: addLiqTx, chainId: 8453 } });

// On liquidity remove
const exitPot = await client.callTool({ name: "pot_generate", arguments: { txHash: removeLiqTx, chainId: 8453 } });

// Verify the causal chain
const chain = await client.callTool({ name: "pot_verify", arguments: { potHash: exitPot.potHash, precedingHash: entryPot.potHash } });
// chain.valid: true means exit cryptographically followed entry

5. AI Agent Coordination — Multi-Agent Causal Ordering

Problem: When multiple AI agents interact in a pipeline (Agent A signals → Agent B acts → Agent C settles), the causal order matters for debugging, auditing, and liability. Agent logs are unverifiable—any agent can claim any timestamp.

Solution: Each agent calls pot_generate before acting. The resulting potHash chain is independently verifiable: "Agent A's signal at T₁ preceded Agent B's action at T₂" can be proven without trusting either agent's self-reported logs. The on-chain anchor makes the ordering dispute-proof.

// Agent A (signal generator)
const signalPot = await client.callTool({ name: "pot_generate", arguments: { txHash: signalId } });

// Agent B (executor) — references Agent A's pot
const execPot = await client.callTool({
  name: "pot_generate",
  arguments: { txHash: execId, precedingPotHash: signalPot.potHash }
});

// Any third party can verify the causal chain
const verified = await client.callTool({ name: "pot_verify", arguments: { potHash: execPot.potHash, precedingHash: signalPot.potHash } });

Outcome: Unforgeable causal chain across autonomous agents. Useful for multi-agent DeFi strategies, audit compliance, and cross-agent dispute resolution.

TypeScript: MEV Bot Integration

import { McpClient } from "@modelcontextprotocol/sdk/client/mcp.js";

// Generate a Proof of Time for a transaction
const result = await client.callTool({
  name: "pot_generate",
  arguments: {
    txHash: "0xabc123...",
    chainId: 8453,
    poolAddress: "0xdef456..."
  }
});
// Returns: { potHash, timestamp, stratum, grg_shards }

Python: Hedge Fund Audit

import subprocess, json

result = subprocess.run(
    ["npx", "-y", "@helm-protocol/ttt-mcp"],
    input=json.dumps({
        "tool": "pot_verify",
        "potHash": "0x...",
        "expectedChainId": 8453
    }),
    capture_output=True, text=True
)

Rate Limits & Pricing

Free Tier:   100 calls/day per IP — no API key needed
Paid Tier:   Set TTT_API_KEY env var — unlimited
Commercial:  peter@kenosian.com (hedge funds, DEX protocols, OTC desks)

Learn More

OpenTTT SDK — The underlying SDK
IETF Draft: draft-helmprotocol-tttps-00 — TTTPS Protocol Specification
Helm Protocol — GitHub

License

BSL-1.1 — free for non-commercial use.

Commercial use (production bots, hedge funds, prop desks) requires a license.
→ kenosian.com/pricing

Change Date: 2029-05-28 → Apache 2.0

Keywords

mcp

model-context-protocol

FAQs

What is @helm-protocol/ttt-mcp?

Is @helm-protocol/ttt-mcp popular?

Is @helm-protocol/ttt-mcp well maintained?

Package last updated on 28 May 2026

@helm-protocol/ttt-mcp