Introduction

Introduction to ROKO Network

You ship Solidity. Your tooling is MetaMask, Hardhat, ethers.js. ROKO hands that exact toolchain one new power: consensus-grade time — nanosecond-resolution timestamps the network itself measures, agrees on, and enforces, instead of a number the block producer suggests.

The mechanism is Proof of Accurate Time (PoAT) — a physics-anchored consensus modifier in which validators measure time against each other in a live mesh. PoAT is designed so that measured time quality influences block-production eligibility and rewards; today the mesh measures and records per-validator time quality on-chain, while consensus-consequence enforcement is being enabled in stages.

What ROKO actually is

ROKO is an EVM-compatible blockchain built on Polkadot SDK (release-polkadot-v1.13.0) with the Frontier Ethereum layer, so MetaMask, Hardhat, ethers.js, and your existing Solidity contracts work unmodified.

On top of that familiar base, three things are different:

  • A validator time mesh. Validators run a native peer-to-peer time-sync layer ("PTP Squared") over the `/roko/timesync/1` libp2p protocol — measuring clock offsets between peers, scoring reputation statistically, and converging on a single mesh consensus time.
  • Temporal receipts on every transaction. Each transaction gets an ECDSA-signed receipt when it enters the pool, and block import rejects blocks that omit a receipted transaction past its inclusion deadline (default 15 seconds). The chain can prove your transaction wasn't silently dropped.
  • Deterministic, fee-priority ordering. Canonical nanosecond timestamps are assigned at pool receipt; higher-fee transactions get earlier canonical timestamps under a transparent protocol rule, and per-block temporal ordering is enforced by the runtime. Order is fixed at receipt by a deterministic, tamper-evident rule — no private builder reordering auction.

Timestamps are nanosecond-resolution `u128` values (NanoMoment), exposed to contracts through a temporal precompile and to everything else through a `temporal_*` JSON-RPC namespace — a consensus-backed time oracle with no third party to trust.

Validators self-classify their time source — Timebeat PTP daemon, chrony, or GNSS/PPS hardware — into Anchor, Standard, or Minimal tiers, with a measured root-distance-to-UTC in nanoseconds. The meshheads anchored to physics carry the highest tier.

Honest status (read this)

ROKO is at the gated-testnet stage. Builders should know:

  • The testnet currently runs 2-second blocks; the production-testnet target is 6 seconds (tracked in-code as M-19), and the mainnet runtime is compiled at 3 seconds.
  • The testnet EVM Chain ID is 442. A mainnet chain ID is not yet assigned — mainnet does not exist yet.
  • Time-quality offences are detected and recorded on-chain, but slashing enforcement is currently disabled in both compiled runtimes while the mesh matures.
  • A sudo key (full root) is present in both runtimes — standard for this stage, and a centralization fact you should weigh.

We would rather show you the real state of the chain than sell you a finished one.

Who this is for

If you build anything where when matters — auctions, trading and settlement, time-sensitive contracts, timestamping services, coordination between autonomous agents — ROKO gives you consensus-grade time as a native primitive instead of a trusted oracle.

Map of these docs

  • What is Temporal Blockchain? — the concept: why time as a consensus input matters, and how PoAT works (mesh, time quality, receipts).
  • Nanosecond Precision: Resolution vs. Accuracy — what nanosecond-resolution timestamps do and don't guarantee. We draw this line explicitly.
  • Join the Testnet — MetaMask config (Chain ID 442), how to request testnet ROKO, where the explorer will live, deploying a contract, and running a node.
  • What You Can Build — applications where consensus-grade time is the unlock.
  • Core Technology — deeper pages on consensus, temporal transactions, and network architecture.

Background reading: Of Time and Stamps — the story of why blockchains never had a trustworthy clock, told from the build.