TETRA — Layer-1 UTXO Blockchain
One Chain • Six Seconds • The Whole Planet
Proof of Stake at planetary scale, built from scratch. Tetra is an Ouroboros-lineage Layer-1 whose signature feature is a consensus-embedded adaptive block cadence: every block carries a re-verifiable, feedback-controlled slot coefficient targeting six-second blocks. Stake-weighted VRF leader election, an eUTXO multi-asset ledger with parallel local validation, JavaScript smart contracts in a deterministic sandbox, and Bitcoin-style 21M scarcity — verified live on a geo-distributed devnet with a dual Kotlin/Rust node architecture.
Block Time Is a Constant Nobody Chose
Proof-of-Stake chains inherit their pacing, their fork rules, and their contract languages from decisions frozen at genesis — and pay for it forever.
Hard-Coded Cadence
PoS protocols fix the active-slot coefficient at genesis. When network conditions drift, the one parameter that governs block frequency can never respond.
Nondeterminism in Consensus
Wall-clock reads inside consensus logic make honest nodes disagree. Tetra's own early devnet fractured into 10–14 competing tips from exactly this class of bug.
Global Mutable State
Account-model ledgers funnel every transaction through shared state, serializing validation and making outcomes depend on ordering.
Contract Languages That Gatekeep
Writing on-chain logic usually means learning a purpose-built DSL and its toolchain before writing a single rule.
A Chain That Paces Itself
Tetra embeds the cadence controller in consensus itself: a bounded feedback loop recomputes the active-slot coefficient per block from chain history, carries it in the header, and lets any node re-verify it.
Consensus-Embedded Cadence
A bounded feedback controller recomputes the active-slot coefficient every block from chain history alone. The value ships in the header — any node can re-derive and verify it. Target: six seconds.
Deterministic O(1) Fork Choice
A closed-form, height-dominant score with lexicographic hash tie-break. No clocks, no randomness — the fix that permanently ended the multi-tip forking bug.
eUTXO Multi-Asset Ledger
Extended UTXO with datums and arbitrary-precision amounts. Validation is local and parallel — no global mutable state to contend over.
JavaScript Smart Contracts
policy(context, redeemer, datum) in a deterministic GraalVM sandbox. If you can write a function, you can write a contract.
Four Layers, One Verifiable Chain
From hand-implemented cryptographic primitives to a live explorer, every layer is built from scratch and every claim is re-checkable — the Rust node is a byte-exact port verified check-by-check against a frozen Kotlin reference.
Ecosystem & Observability
A hexagonal explorer and indexer on Axum with a dual store — ScyllaDB for immutable history, Postgres for derived state, per-node "cell" indexing, reorgs marked orphaned and replayed — plus bench/eval telemetry, an htop-style Rust TUI, and the protocol website with the whitepaper.
Dual-Node Architecture
A frozen Kotlin 2.0 / Spring Boot reference node with per-node PostgreSQL serves as the correctness oracle; the active Rust node is a near-std-only port — hand-rolled HTTP server and JSON parser included — verified byte-exact per check.
Consensus Engine
Stake-weighted ECVRF leader election over 5-day epochs of 432,000 slots, the adaptive cadence controller, deterministic fork choice, and a 1,038-block settlement depth. A lottery anyone can check; a winner no one can predict.
Cryptography & Ledger Foundation
Hand-implemented primitives validated against golden vectors and RFC 8032 / FIPS 180-4: Ed25519, SHA-256/512, ECVRF, and edwards25519 field arithmetic on 5×51-bit limbs. Domain-separated Merkle hashing; the block hash is the Merkle root over a 13-element header.
Life of a Block
Every six seconds — by design, not decree — a block moves through four verifiable stages. Nothing in the pipeline consults a wall clock.
Elect
Per SlotWhat Happens
- Stake-weighted ECVRF lottery over each 432,000-slot epoch
- Proof generated with RFC 9381 ECVRF-EDWARDS25519-SHA512-Elligator2
- Any node re-verifies the proof — no one predicts the winner
- Validated against golden vectors, RFC 8032, FIPS 180-4
Pace
Per BlockWhat Happens
- Bounded feedback controller reads recent chain history
- Active-slot coefficient recomputed toward the 6-second target
- New coefficient carried in the 13-element header
- Every node re-derives it independently — consensus-embedded, not oracle-fed
Validate
ParallelWhat Happens
- eUTXO transactions validated locally, in parallel
- Multi-asset amounts with arbitrary precision
- policy(context, redeemer, datum) contracts run in the deterministic GraalVM sandbox
- 21M cap and halving schedule enforced by validation rules
Settle
1,038 BlocksWhat Happens
- O(1) closed-form fork choice scores competing tips
- Height dominates; lexicographic hash breaks ties
- Explorer marks orphaned blocks and replays reorgs
- Settlement reached at 1,038-block depth
Trust Is Earned Check by Check
A from-scratch blockchain earns credibility through discipline: a frozen oracle, golden vectors, live evidence — and stated limits.
Dual-Node Oracle
CorrectnessPractices
- Kotlin reference node frozen as the source of truth
- Rust port verified byte-exact, check by check
- Near-std-only Rust: crypto, JSON, HTTP all hand-rolled
- ~64k LOC Rust, ~42k Kotlin, ~40k TypeScript
Golden-Vector Testing
VerificationPractices
- 302 Rust node tests + 174 Kotlin tests
- ECVRF validated against RFC 9381 golden vectors
- Ed25519 and hashing checked against RFC 8032 / FIPS 180-4
- Domain-separated hashing prevents cross-context collisions
Live Verification
2026-07-10Evidence
- Geo-distributed devnet, 18 Kotlin validators
- Full sync: 2,510 of 2,510 blocks accepted, zero rejections
- Cadence p50 4.9s against the 6s target; p95 17s
- Prometheus + Grafana end to end
Stated Limits
Honest ScopeKnown Today
- 1,000+ validator scale not yet demonstrated
- Whitepaper is a v0.3 draft (July 2026)
- Praos-style security under the adaptive coefficient is a stated conjecture
- One known open defect: geo8 final convergence fails
From Devnet to Planetary Scale
The consensus core is live and verified on a geo devnet. Each phase widens the evidence without softening the determinism.
Live Geo Devnet
Running TodayDelivered
- Self-pacing consensus across 18 geo-distributed validators
- Full ecosystem: explorer, indexer, TUI, telemetry
- Whitepaper v0.3 and protocol site published
- Docker profiles with 5-node dev fleets
Rust Node Parity
In ProgressPlanned Deliverables
- Complete the byte-exact Rust port to full parity
- Extend the 302-test suite alongside the port
- Keep the frozen Kotlin node as permanent oracle
- Promote Rust as the primary node
Hardening & Analysis
In DesignPlanned Deliverables
- Fix geo8 final-convergence failure
- Formal security analysis of the adaptive coefficient
- Whitepaper beyond v0.3 draft
- Expanded adversarial test scenarios
Scale Validation
Not Yet DemonstratedPlanned Deliverables
- Simulation and testing toward 1,000+ validators
- Larger public devnet cohorts
- Cadence-controller behavior under stress
- Long-horizon settlement measurements
Who Tetra Is For
A research-grade protocol, an approachable developer platform, and a working demonstration of from-scratch engineering.
For Protocol Engineers
For dApp Developers
For Engineering Leaders
See a Chain That Paces Itself
Read the whitepaper, watch the cadence controller work on the live protocol site, or book a call to talk consensus design, from-scratch cryptography, and what it takes to verify a blockchain byte by byte.