OpenTTT

Reference implementation of draft-helmprotocol-tttps-00

OpenSSL for Transaction Ordering -- TLS-grade Proof of Time for DeFi.

OpenTTT brings cryptographic time verification to blockchain transaction ordering. Where TLS made HTTP trustworthy, OpenTTT makes transaction sequencing verifiable. No trust assumptions. No gentleman's agreements. Physics.

If this project is useful to you, please star it on GitHub — it helps others find it.

npm install openttt

Why OpenTTT

Current MEV protection relies on trust: builders promise fair ordering, protocols ask nicely, and everyone hopes for the best. Flashbots asks builders to behave. OpenTTT proves whether they did.

| | Flashbots | OpenTTT | |---|---|---| | Mechanism | Social contract (request) | Physical verification (proof) | | Enforcement | Reputation, exclusion | Economic natural selection | | Bad actors | Must be identified and removed | Naturally unprofitable, self-selecting out | | Time source | Block timestamp (miner-controlled) | Multi-source NTP synthesis (NIST, Google, Apple) |

The core insight: Rollups generate precise timestamps and deliver them to builders with a receipt. The Adaptive GRG pipeline then verifies whether the builder respected that ordering:

• Honest builder: Sequence matches -> Turbo mode (50ms verification) -> faster -> more profitable
• Dishonest builder: Sequence mismatch -> Full mode (127ms verification) -> slower -> less profitable -> leaves

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

Quick Start

Try it in 30 seconds — No ETH, No Wallet

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 blockchain. No wallet. No gas fees. Just verified time from 4 independent HTTPS sources (NIST, Apple, Google, Cloudflare). Start here, upgrade to on-chain when ready.

On-Chain Mode (Full Power)

import { TTTClient } from "openttt";

const ttt = await TTTClient.forBase({ privateKey: process.env.OPERATOR_PK! });
ttt.startAutoMint();

Connects to Base, synthesizes time from atomic clock sources, and mints Proof-of-Time tokens on-chain.

Progressive Disclosure

OpenTTT is designed around progressive disclosure. Start simple, add control as you need it.

Level 1 -- Just Works

import { TTTClient } from "openttt";

const ttt = await TTTClient.forBase({ privateKey: process.env.OPERATOR_PK! });
ttt.startAutoMint();

Level 2 -- Custom Network and Tier

const ttt = await TTTClient.forSepolia({
  privateKey: process.env.OPERATOR_PK!,
  rpcUrl: "https://my-rpc.example.com",
  tier: "T2_slot",
});
ttt.startAutoMint();

Level 3 -- Full Control

const ttt = await TTTClient.create({
  signer: {
    type: "turnkey",
    apiBaseUrl: "https://api.turnkey.com",
    organizationId: "org-...",
    privateKeyId: "pk-...",
    apiPublicKey: "...",
    apiPrivateKey: "...",
  },
  network: "base",
  tier: "T1_block",
  contractAddress: "0x...",
  poolAddress: "0x...",
  timeSources: ["nist", "google", "cloudflare", "apple"],
  protocolFeeRate: 0.05,
  enableGracefulShutdown: true,
});

ttt.startAutoMint();

Signer Options

OpenTTT abstracts away signer complexity. Use a raw private key for development, TEE-backed keys for production, or cloud HSMs for institutional deployments.

| Type | Use Case | Config | |---|---|---| | privateKey | Development, small operators | { type: "privateKey", key: "0x..." } or { type: "privateKey", envVar: "OPERATOR_PK" } | | turnkey | Production, TEE-backed institutional custody | { type: "turnkey", apiBaseUrl, organizationId, privateKeyId, apiPublicKey, apiPrivateKey } | | privy | Embedded wallets, consumer-facing apps (coming soon) | { type: "privy", appId, appSecret } | | kms | Cloud HSM (AWS KMS or GCP Cloud KMS) | { type: "kms", provider: "aws"\|"gcp", keyId, ... } |

AWS KMS requires @aws-sdk/client-kms. GCP KMS requires @google-cloud/kms. Both are optional peer dependencies -- install only what you use.

Tiers

Tiers control the minting interval. Choose based on your protocol's ordering resolution requirements.

| Tier | Interval | Use Case | |---|---|---| | T0_epoch | 6.4 minutes | Epoch-level ordering (validator sets, beacon chain) | | T1_block | 2 seconds | Block-level ordering on Base L2 (default) | | T2_slot | 12 seconds | Slot-level ordering on Ethereum L1 | | T3_micro | 100 milliseconds | High-frequency ordering (IoT, sub-block) |

const ttt = await TTTClient.forBase({
  signer: { type: "privateKey", envVar: "OPERATOR_PK" },
  tier: "T2_slot",
});

Health Monitoring

Production deployments need observability. getHealth() returns a comprehensive status object covering connectivity, balance, and mint performance.

const health = await ttt.getHealth();

console.log(health);
// {
//   healthy: true,
//   checks: {
//     initialized: true,
//     rpcConnected: true,
//     signerAvailable: true,
//     balanceSufficient: true,
//     ntpSourcesOk: true
//   },
//   metrics: {
//     mintCount: 142,
//     mintFailures: 0,
//     successRate: 1.0,
//     totalFeesPaid: "71000000000000",
//     avgMintLatencyMs: 1847,
//     lastMintAt: "2026-03-14T10:30:00.000Z",
//     uptimeMs: 86400000
//   },
//   alerts: []
// }

Alerts are emitted automatically when:

• RPC connection is lost
• ETH balance drops below threshold (default: 0.01 ETH)
• Mint success rate falls below 80%

Register a callback for real-time alerting:

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

ttt.setMinBalance(ethers.parseEther("0.05")); // Custom threshold

Networks

| Network | Chain ID | Factory Method | |---|---|---| | Base Mainnet | 8453 | TTTClient.forBase(config) | | Base Sepolia | 84532 | TTTClient.forSepolia(config) |

Custom networks can be provided via the network field in TTTClient.create():

const ttt = await TTTClient.create({
  signer: { type: "privateKey", envVar: "OPERATOR_PK" },
  network: {
    chainId: 8453,
    rpcUrl: "https://my-custom-rpc.example.com",
    tttAddress: "0x...",
    protocolFeeAddress: "0x...",
    usdcAddress: "0x...",
  },
});

API Reference

TTTClient

| Method | Description | |---|---| | TTTClient.create(config) | Create and initialize a client with full configuration | | TTTClient.forBase(config) | Factory for Base Mainnet (chain ID 8453) | | TTTClient.forSepolia(config) | Factory for Base Sepolia testnet (chain ID 84532) | | ttt.startAutoMint() | Start automatic TimeToken minting at the configured tier interval | | ttt.stopAutoMint() | Stop the auto-mint loop | | ttt.getHealth() | Returns HealthStatus with connectivity, balance, and performance checks | | ttt.getStatus() | Returns current tier, mint count, fees paid, and token balances | | ttt.listPools() | List all registered pool addresses | | ttt.getPoolStats(address) | Get mint/burn statistics for a specific pool | | ttt.onAlert(callback) | Register a callback for health alerts | | ttt.setMinBalance(wei) | Set minimum ETH balance threshold for alerts | | ttt.destroy() | Gracefully shut down: stops minting, unsubscribes events, clears state |

TimeSynthesis

| Method | Description | |---|---| | synthesize() | Query all configured NTP sources and return a median-synthesized timestamp | | generateProofOfTime() | Generate a verifiable Proof of Time with source signatures | | verifyProofOfTime(pot) | Verify that all source readings are within tolerance of the median | | TimeSynthesis.getOnChainHash(pot) | Keccak256 hash of a PoT for on-chain submission | | TimeSynthesis.serializeToBinary(pot) | Compact binary serialization for network transport | | TimeSynthesis.deserializeFromBinary(buf) | Deserialize from binary format |

GrgPipeline

| Method | Description | |---|---| | GrgPipeline.processForward(data) | Encode data through the multi-layer integrity pipeline, producing verifiable shards | | GrgPipeline.processInverse(shards, length) | Decode shards back to original data with integrity verification |

AdaptiveSwitch

| Method | Description | |---|---| | verifyBlock(block, tttRecord) | Verify block ordering against TTT record; returns TURBO or FULL mode | | getCurrentMode() | Current adaptive mode | | getFeeDiscount() | Fee discount for current mode (20% in TURBO, 0% in FULL) |

Architecture

TTTClient (entry point)
|-- AutoMintEngine         Periodic minting loop
|   |-- TimeSynthesis      NTP multi-source median synthesis (NIST, Google, Apple)
|   |-- DynamicFeeEngine   Oracle-based pricing
|   |-- EVMConnector       On-chain mint/burn/events (ethers v6)
|   '-- ProtocolFee        EIP-712 signed fee collection
|-- AdaptiveSwitch         TURBO/FULL mode state machine
|-- GRG Pipeline           Multi-layer data integrity (proprietary)
|-- PoolRegistry           Multi-pool statistics tracking
'-- Signer Abstraction     PrivateKey | Turnkey | Privy | KMS

Data Integrity: 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.

The pipeline produces verifiable shards that can be independently validated and reconstructed, ensuring PoT integrity even under partial data loss.

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

Adaptive Mode Switching

The economic enforcement mechanism uses a sliding window (20 blocks) with hysteresis:

• Entry to Turbo: 95% ordering match rate over 20+ blocks
• Maintain Turbo: 85% match rate (relaxed to prevent flapping)
• Integrity failure in Turbo: Exponential backoff penalty (20, 40, 80, 160, 320 blocks)

This asymmetry is deliberate: it is hard to earn trust and easy to lose it.

Time Synthesis

OpenTTT queries multiple atomic clock-synchronized NTP sources in parallel and produces a median-synthesized timestamp with confidence scoring:

• NIST (time.nist.gov) -- US national standard
• Apple (time.apple.com) -- Apple global time service
• Google (time.google.com) -- Leap-smeared public NTP

All readings must fall within a stratum-dependent tolerance of the synthesized median (10ms for stratum 1, 25ms for stratum 2, 50ms for stratum 3+), or the Proof of Time is rejected. Single-source operation triggers a degraded-confidence warning.

Error Handling

All SDK errors extend TTTBaseError and include three fields for actionable diagnostics:

import { TTTSignerError } from "openttt";

try {
  const ttt = await TTTClient.forBase({
    signer: { type: "privateKey", envVar: "MISSING_VAR" },
  });
} catch (e) {
  if (e instanceof TTTSignerError) {
    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 or engine configuration | | TTTSignerError | Signer acquisition or usage | | TTTNetworkError | RPC, chain ID, connectivity | | TTTContractError | Smart contract interaction | | TTTTimeSynthesisError | NTP time synthesis failures | | TTTFeeError | Dynamic fee or protocol fee collection |

Graceful Shutdown

For long-running services, enable graceful shutdown to cleanly stop minting and release resources on SIGINT:

const ttt = await TTTClient.create({
  signer: { type: "privateKey", envVar: "OPERATOR_PK" },
  network: "base",
  enableGracefulShutdown: true,
});
ttt.startAutoMint();

// Or shut down manually at any time:
await ttt.destroy();

Requirements

• Node.js >= 18
• TypeScript >= 5.3 (for development)
• Network access to NTP servers (UDP port 123 outbound)

Optional peer dependencies (install only what you use):

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

License

Business Source License 1.1

Copyright 2026 Helm Protocol.

Learn More

• IETF Draft: draft-helmprotocol-tttps-00 — TTTPS Protocol Specification
• Yellow Paper — Technical Deep Dive
• MCP Server — AI Agent Integration (@helm-protocol/ttt-mcp)
• Subgraph (The Graph) — On-chain PoT Data
• Base Sepolia Contracts — TTT ERC-1155
• Helm Protocol — GitHub Organization

GitHub | Built by Helm Protocol

Contributing

Contributions are welcome. If you find a bug, have a feature request, or want to improve the documentation, please open an issue or submit a pull request on GitHub.

• 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 the repo, make your changes, ensure all tests pass (npm test), and open a PR against main.

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