openttt

OpenTTT

Reference implementation of draft-helmprotocol-tttps

Cryptographic Proof-of-Time for Distributed Systems — TLS-grade time verification without trust assumptions.

OpenTTT brings verifiable, Byzantine-fault-tolerant timestamping to any distributed system. Where TLS made HTTP trustworthy, OpenTTT makes ordering and sequencing verifiable. No trust assumptions. No gentleman's agreements. Physics.

npm install openttt

Why OpenTTT

Current distributed systems rely on trust for ordering: services promise fair sequencing, protocols ask nicely, and everyone hopes for the best. OpenTTT proves whether ordering was respected — cryptographically, without a trusted third party.

	Conventional NTP	OpenTTT
Mechanism	Single-source timestamp	Multi-source synthesized Proof-of-Time
Verification	Trust the server	Cryptographic multi-anchor proof
Attack detection	None	13 Byzantine attack types detected
Enforcement	Audit after the fact	Real-time rejection at ingestion
Time sources	One NTP server	NIST + Apple + Google + Cloudflare (parallel)

The core insight: Honest participants receive a Proof-of-Time receipt. A multi-layer data integrity pipeline then verifies whether ordering was respected:

• Honest node: Sequence matches → Turbo mode (fast verification path) → lower latency → more efficient
• Dishonest node: Sequence mismatch → Full mode (complete verification path) → higher overhead → naturally exits

No governance vote. No slashing committee. Cheating is simply bad engineering.

Product Suite

OpenTTT is the source-available (BSL-1.1) core of the Helm Protocol product family. The full suite:

Product	Description	Key Metric
OpenTTT / TTTPS	Byzantine Audit API — cryptographic Proof-of-Time with 13-attack detection	IETF Draft
HYDRA-KV	LLM inference KV cache accelerator — distributed prefill/decode separation	3.20× compression, 95.6% dedup
HYDRA-CDN	Edge delivery with GapVec5 routing and erasure-coded resilience	30% loss tolerance
HYDRA-AUDIT	Infrastructure audit with Prometheus, JSON-LD, and Grafana integration	TRAI/CERT-In compatible

Use Cases

LLM Inference Acceleration (HYDRA-KV)

KV cache transfer between prefill and decode nodes becomes a bottleneck at scale. HYDRA-KV uses TTTPS timestamps to sequence and audit cache chunks, combined with a multi-layer compression pipeline that achieves 3.20× reduction and 95.6% deduplication.

Resilient Edge Delivery (HYDRA-CDN)

High-loss network environments (satellite, mobile edge, cross-border) require delivery guarantees that standard CDN protocols cannot provide. HYDRA-CDN uses GapVec5 adaptive routing and erasure coding to tolerate 30% packet loss while maintaining per-chunk TTTPS audit seals.

Byzantine Audit (TTTPS)

Any distributed system that needs verifiable ordering — financial infrastructure, IoT sensor networks, compliance-regulated APIs — can embed TTTPS to produce tamper-evident Proof-of-Time receipts. 13 Byzantine attack patterns are detected and rejected in real time.

Quick Start

Proof-of-Time in 30 Seconds — HTTPS Only, No Setup

import { HttpOnlyClient } from "openttt";

const client = new HttpOnlyClient();
const pot = await client.generatePoT();
console.log(pot.timestamp, pot.confidence, pot.sources);

const valid = client.verifyPoT(pot);
console.log("Valid:", valid); // true

No infrastructure required. Four independent HTTPS time sources (NIST, Apple, Google, Cloudflare) are queried in parallel. The synthesized median produces a confidence-scored Proof-of-Time immediately.

Server Mode — Continuous PoT Stream

import { TTTClient } from "openttt";

const ttt = await TTTClient.create({
  timeSources: ["nist", "google", "cloudflare", "apple"],
  enableGracefulShutdown: true,
});

ttt.startAutoMint();

ttt.onAlert((alert) => {
  // Route to PagerDuty, Grafana, Telegram, etc.
  console.error(`[OpenTTT Alert] ${alert}`);
});

Health Monitoring

const health = await ttt.getHealth();
// {
//   healthy: true,
//   checks: { ntpSourcesOk: true, signerAvailable: true, ... },
//   metrics: { mintCount: 142, successRate: 1.0, avgMintLatencyMs: 1847 },
//   alerts: []
// }

Architecture

TTTClient (entry point)
|-- AutoMintEngine         Continuous PoT generation loop
|   |-- TimeSynthesis      Multi-source NTP median synthesis
|   |   |-- NIST           time.nist.gov  (US national standard)
|   |   |-- Google         time.google.com
|   |   |-- Apple          time.apple.com
|   |   '-- Cloudflare     time.cloudflare.com
|   '-- GRG Pipeline       Multi-layer data integrity (proprietary)
|-- AdaptiveSwitch         TURBO / FULL verification mode state machine
|-- ByzantineDetector      13-pattern attack classifier
'-- Signer Abstraction     PrivateKey | KMS (AWS / GCP)

Time Synthesis

OpenTTT queries multiple atomic clock-synchronized sources in parallel and produces a median-synthesized timestamp with confidence scoring. All readings must fall within a stratum-dependent tolerance of the synthesized median, or the Proof of Time is rejected. Single-source operation triggers a degraded-confidence warning.

GRG Pipeline

GRG is a multi-layer data integrity pipeline that protects PoT payloads — analogous to how the TLS record protocol protects HTTP payloads. It provides compression, erasure coding, and error correction in a single pass, producing verifiable shards that can be independently validated and reconstructed.

Implementation details are proprietary. See the IETF Draft for the abstract specification.

Adaptive Mode Switching

The enforcement mechanism uses a sliding-window match rate with hysteresis:

• Entry to Turbo: high ordering match rate over a sustained window
• Integrity failure in Turbo: exponential backoff penalty
• Design intent: hard to earn trust, easy to lose it

IETF Draft

OpenTTT implements draft-helmprotocol-tttps (TTTPS — TLS-grade Time Token Protocol Stack).

Abstract: This document specifies TTTPS, a protocol for generating and verifying cryptographic Proof-of-Time (PoT) tokens using multiple independent time sources. TTTPS provides Byzantine fault tolerance against timestamp manipulation, supports 13 categories of time-based attacks, and is designed for integration into existing transport-layer security stacks without requiring changes to application protocols.

Full draft: datatracker.ietf.org/doc/draft-helmprotocol-tttps/

API Reference

TTTClient

Method	Description
TTTClient.create(config)	Create and initialize a client
ttt.startAutoMint()	Start continuous PoT generation
ttt.stopAutoMint()	Stop the generation loop
ttt.getHealth()	Returns HealthStatus with source connectivity and performance
ttt.onAlert(callback)	Register a callback for health alerts
ttt.destroy()	Graceful shutdown

TimeSynthesis

Method	Description
synthesize()	Query all sources, return median-synthesized timestamp
generateProofOfTime()	Generate a verifiable PoT with source signatures
verifyProofOfTime(pot)	Verify all readings are within tolerance of the median

GrgPipeline

Method	Description
GrgPipeline.processForward(data)	Encode through the multi-layer integrity pipeline
GrgPipeline.processInverse(shards, length)	Decode with integrity verification

Error Handling

All SDK errors extend TTTBaseError with three actionable fields:

import { TTTTimeSynthesisError } from "openttt";

try {
  const pot = await client.generatePoT();
} catch (e) {
  if (e instanceof TTTTimeSynthesisError) {
    console.error(e.message);  // What happened
    console.error(e.reason);   // Why it happened
    console.error(e.fix);      // How to fix it
  }
}

Error Class	Scope
TTTConfigError	SDK configuration
TTTSignerError	Signer acquisition or usage
TTTNetworkError	Connectivity, source availability
TTTTimeSynthesisError	NTP time synthesis failures

Requirements

• Node.js >= 18
• TypeScript >= 5.3 (for development)
• Network access to NTP sources (UDP 123 outbound or HTTPS fallback)

Optional peer dependencies:

Package	Required for
@aws-sdk/client-kms	AWS KMS signer
@google-cloud/kms	GCP Cloud KMS signer

Pricing

Tier	Price	Quota	Use Case
FREE	$0	100 calls/day	Non-commercial, research, personal bots (revenue < $10K/yr)
BOT	$199/mo	5M calls · 1K req/s	MEV bots, arbitrage bots
DEX/LP	$499/mo	20M calls + overage	DEX protocols, liquidity providers
FUND	$2,000+/mo	Unlimited + MiFIR Art.22c audit log	Hedge funds, OTC desks, prop trading

API key & commercial licensing: [e-mail]

License

BSL-1.1 — free for non-commercial use.

Commercial use (production bots, hedge funds, prop desks) requires a license.
→ Pricing

Change Date: 2029-05-28 → Apache 2.0

Full license text: LICENSE — Copyright 2026 Helm Protocol.

Links

• IETF Draft: draft-helmprotocol-tttps — Protocol specification
• Helm Protocol GitHub — Organization and repositories

Contributing

Bug reports, feature requests, and pull requests are welcome.

• Bug reports: Open an issue with a minimal reproduction case.
• Feature requests: Open an issue describing the use case and expected behavior.
• Pull requests: Fork, make changes, ensure all tests pass (npm test), open a PR against main.

For significant changes, open an issue first to discuss the approach.