a new kind of blockchain core

A blockchain
with a mathematical
proof
.

Astrea's core agreement rules are checked by math. Its records come with proof they have not changed. Helper services cannot quietly decide what is true.

13
Proof files checked by Lean
23
Live status messages
4–10
Nodes on one laptop
LIVE · LOCAL CLUSTER
ws://127.0.0.1
A B C D COMMIT
+0msRoundAdvancednode A · round 42
+12msDagBlockAcceptednode B · 0x4a7c…
+18msLeaderElectednode B · round 42
+24msThresholdClockTickround 42 · 3/4 certified
+31msDagBlockAcceptednode C · 0x8b21…
+38msQueueDepthSampledconsensus · 12/1024
+45msThresholdClockTickround 42 · 4/4 certified
+52msCommitFinalizedcommit #18421 · 0x2f9a…
+58msAstProofIssuedbatch 1842 · root 0xc7d4…
+64msWalAppended+847 bytes
+71msDocumentWrittenDocuments · v18421
+78msRoundAdvancednode A · round 43
+0msRoundAdvancednode A · round 42
+12msDagBlockAcceptednode B · 0x4a7c…
+18msLeaderElectednode B · round 42
+24msThresholdClockTickround 42 · 3/4 certified
+31msDagBlockAcceptednode C · 0x8b21…
+38msQueueDepthSampledconsensus · 12/1024
+45msThresholdClockTickround 42 · 4/4 certified
+52msCommitFinalizedcommit #18421 · 0x2f9a…
+58msAstProofIssuedbatch 1842 · root 0xc7d4…
+64msWalAppended+847 bytes
+71msDocumentWrittenDocuments · v18421
+78msRoundAdvancednode A · round 43
01 · overview

Three things nothing else has all three of.

A non-engineer can hold these three ideas in their head. Everything below is detail.

Math-checked agreement

The rules that decide which transactions win are accompanied by a mathematical proof. A computer has checked the proof. Most chains say we tested it. Astrea says we proved it.

13
proof files · on disk · readable

Cryptographic data

Astrea is not just an order book. It's a full data layer. Every batch of writes produces a small cryptographic fingerprint of the whole state. A user can verify any record against that fingerprint without trusting anyone.

verifiable records · per batch

Live observable

One command starts four to ten local nodes and shows a live feed of important changes as they happen. Anyone — investor, partner, auditor — can watch the system run on their own laptop. No screenshots needed.

23
event types · documented

HONEST SCOPE

The math proof covers the consensus core — the core rule for choosing the winning block. The networking and data systems are engineered and tested, but they are not mathematically proved. Every document keeps that line clear.

02 · the proof

The proof is not a press release. It's on disk.

Every safety claim starts as a theorem in Lean — software that checks each step of the proof. No human shortcut, no "trust the paper".

MysticetiKernel.lean · line 24
PROVED
/-- Quorum intersection: any two quorums in a Byzantine-fault-tolerant
    committee of size n = 3f+1, each containing q = 2f+1 nodes, must
    share at least f+1 honest validators. This is the kernel arithmetic
    that makes single-leader commitment unique. -/
theorem quorum_intersection_cardinality
    (n f q cardA cardB cardInter : Nat)
    (hn : n = 3 * f + 1)
    (hq : q = 2 * f + 1)
    (hA : q ≤ cardA)
    (hB : q ≤ cardB)
    (hUnion : cardA + cardB ≤ n + cardInter) :
    f + 1 ≤ cardInter := by
  subst n
  subst q
  omega
PROTOCOL SPECIFICATION a frozen reference document SAFETY No two honest nodes commit conflicting blocks proved in Lean LIVENESS Honest nodes always eventually commit proved in Lean REFINEMENT The code preserves the spec's invariants proved in Lean CONSENSUS CORE — implementation in Rust a reconstruction OF the spec, with verified equivalence
03 · the data layer

Not a ledger. A data engine.

Astrea includes a built-in document database under the chain. It records changes safely, keeps searchable lists, stores file chunks, and creates one cryptographic fingerprint for the whole database after each batch of writes.

Documents collection-typed

Apps store versioned records, not mystery bytes. Astrea knows about documents, search lists, files, compute receipts, expiry records, and proof records — each with its own use.

Authenticated state tree per batch

Every batch of writes creates one cryptographic fingerprint of the whole database. Anyone can prove a specific record was in the database at a specific batch — without revealing anything else.

Secondary indexes row-counted

Search lists track exactly how many records were added and how many were removed. Apps can build search-style queries without re-reading the whole chain.

Computation receipts digest-bound

For a limited job, Astrea can issue a small receipt that ties the starting data to the result. The receipt says this input produced this output, and anyone can check it.

04 · what becomes possible

A shared truth layer for apps that need records people can check.

Astrea is broad infrastructure. Its breadth is what makes a lot of new things possible. Apps that used to need a chain, a database, a scheduler, a messaging system, and a proof service can now start from one shared foundation. Use cases that couldn't touch blockchain before — because the chains were too narrow, too expensive, too slow, or too closed — can move onto this.

NEWLY POSSIBLE

Private messaging with verifiable mailbox state communications

Messages stay encrypted, but users can still prove that a message arrived, when it arrived, and where it sits in the mailbox. Mailboxes and threads are built into the protocol, not bolted on by the app.

Subsidized civic and public services government · civic tech

The user pays nothing per action; a sponsor or operator covers the cost. Astrea measures the work separately from the bill — so free-to-user services work at scale without inviting abuse.

Auditable healthcare and identity records healthcare · identity

Each record is cryptographically tied to a known state of the world. Patients, regulators, and applications can verify a record without seeing other people's data. Every disclosure is explicit, not implicit.

Subscription apps with on-chain scheduling consumer · saas

"Charge me every month", "deliver this on Tuesday", "expire this after 90 days" — all native protocol features. Schedulers can propose due actions; the protocol still checks them. No off-chain server holds the authority.

Verifiable computation receipts scientific · enterprise

A computation runs once. The receipt records its inputs and outputs cryptographically. Any party can verify the receipt without re-running the computation or seeing internal data. Useful for ML model evaluation, scientific reproducibility, audited analytics.

Cross-chain reads without bridge risk infra · multi-chain

Accept a narrow, proven fact from Ethereum or another chain without trusting a bridge operator to invent the answer. Each imported claim is narrow, signed, and bounded.

Real database-style apps with cryptographic state app developers

Documents, collections, indexes, query receipts — all native. Apps stop needing a database next to the chain. Authenticated reads mean the user never has to trust the server.

Hybrid public-private workflows finance · enterprise · privacy

Sealed bids that reveal after the auction. Private votes with public totals. Confidential health records with public eligibility checks. Each private action says up front what it reveals and what it hides — so apps cannot pretend to be more private than they are.

None of these are exotic claims — they fall out of the protocol's structure. The full list is much longer; these are the categories that come up most.

05 · comparison

Astrea vs the field.

Six practical questions a builder asks when picking a chain. Each row shows the real shape, not just yes or no.

DISTINCTIVE

Machine-checked consensus proof

Lean checks that the core avoids conflicting winners, keeps making progress, and follows the written rules. The files are on disk and runnable.

vs. most chains: paper claims · vs. Algorand: partial Coq safety proof; Astrea ships runnable Lean for its own core · vs. Sui: Mysticeti paper, no machine proof
DISTINCTIVE

Cryptographic data layer

Per-batch root commitments over a full document store, not a key-value blob.

vs. typical chains: opaque key-value backed by Merkle tries; no native document model
DISTINCTIVE

Live-view as a first-class protocol

A documented live feed with 23 kinds of status messages — designed to show what happened without exposing private content.

vs. typical RPC: generic subscriptions and queries · Astrea has a dedicated protocol-level status feed
Capability Ethereum Solana Sui Aptos Cosmos Avalanche Polkadot Algorand Mina Cardano Astrea
Consensus proof checked by software paper-only none paper none paper paper paper Coq partial ZK proofs (different axis) papers Lean · 13 files
Written rules first, then code EIPs informal informal informal informal informal informal RFCs paper-led paper-led peer-reviewed frozen spec
Built-in document database KV (Merkle Patricia) KV (RocksDB) object-typed KV resource KV KV (IAVL) KV KV KV KV (Merkle) KV (UTXO+) document store
Fingerprint after each write batch Merkle Patricia Merkle Merkle Merkle IAVL Merkle Merkle Merkle recursive SNARKs Merkle authenticated state tree
Built-in live status feed RPC + WS subset RPC + WS subset RPC RPC RPC RPC RPC RPC RPC RPC dedicated WS · 23 events
Runs locally for demo devnet localnet localnet localnet localnet localnet localnet testnet testnet testnet 4–10 nodes · one command
Astrea distinctive full capability partial / informal none / different shape

HONEST CALIBRATION

Several competitors have meaningful formal-methods work. Algorand has academic correctness arguments and a partial Coq safety proof from Runtime Verification — saying "no machine proof" elsewhere would be wrong. Cardano's Ouroboros has one of the strongest peer-reviewed consensus research lines. Mina ships proof-based execution at a level Astrea does not yet match — different architecture, different trade-offs. Sui uses the same Mysticeti family of consensus that Astrea anchors against. Astrea's claim is the combination: runnable Lean proofs for the consensus core, records users can verify, and strict limits that keep helper services from becoming the source of truth. Astrea is library-stage today; public-network deployment is honestly still ahead.

06 · the protocol in pieces

Astrea, piece by piece.

The main parts of Astrea, one at a time. Each piece has a plain-English summary up top. Tap any card for more detail on what the field does, where Astrea is distinct, and an honest caveat.

FOREIGN ROOTS Ethereum · IBC · others SERVICE CLUSTERS · NON-AUTHORITY query · index · scheduler · oracle · DA helpers · fanout AUTHENTICATED STATE documents · collections · indexes · patches messages · mailboxes · oracle facts · clocks + proof-backed query against snapshot roots DATA AVAILABILITY payload manifests retention domains retrieval proofs PIXELVM EXECUTION + PROVING SUBSTRATE capsules · coprocessors · proof IR · folds · CHARK / CHASM CONSENSUS CORE · MYSTICETI-C · MACHINE-CHECKED PROOF parallel proposers · finality ladder · proof-anchored ordering narrow claims
six layers · one state machine · service clusters cannot define truth
01 · consensus

How transactions become final

In plain English

Imagine four chefs in a kitchen, each writing down what dish to cook. They have a quick rule for which list is the real one, even though all four are writing at once. Astrea does that for transactions — many computers propose changes in parallel, and the network has a clear rule for which ones become final.

How it works

Astrea lets several nodes suggest transactions at once, then uses a proven core rule to choose one order. Users see fast confirmation first; later checkpoints make records ready for exports, cleanup, and audits.

V40 · consensus profile · finality model · soundness theorems
Astrea's move

The same Mysticeti-C family of consensus, anchored to a frozen specification, with the consensus-core safety and liveness proofs as Lean files on disk.

Field pattern

Sui uses Mysticeti as its DAG core. Cardano's Ouroboros has the most peer-reviewed cryptographic analysis. Algorand has Coq formalizations of parts of safety. Most other chains rely on academic papers without mechanized proofs.

Library-stage. Public-network deployment is honestly still ahead. The mechanized proof scope is the consensus core, not the whole system.
02 · concurrency

Safe parallel work, without conflicts

In plain English

Two cashiers at different registers can serve different customers at the same time because they aren't touching the same cash drawer. Astrea figures out which transactions are like that — totally independent — and runs them at the same time, safely.

How it works

Astrea has a shared meaning layer for every record and rule. Instead of guessing which transactions clash by looking at addresses, it tracks exactly what each one changes. Running things in parallel becomes a correctness question, not a scheduling guess.

V40 · CHL semantic constitution · formal algebraic foundation · partition laws
Astrea's move

Parallelism is admitted only when the registered laws say the effects commute. Sharding and capacity expansion are legal factorizations of the same state machine — not separate chains glued together.

Field pattern

Solana parallelizes by predeclared account locks. Aptos uses Block-STM optimistic execution with retries. Sui distinguishes owned vs shared objects.

Powerful only if extractors and laws are correct. Source-language tooling must preserve the semantic meaning exactly — that work continues.
03 · execution + proving

A proof engine, not a chip emulator

In plain English

Many zero-knowledge proof systems prove statements about low-level machine instructions ("did the chip do X?"). Astrea aims to prove statements closer to what the app means ("did the bank balance change correctly?"). Much closer to what humans care about.

How it works

PixelVM turns limited app work into proof steps that stay close to the app's meaning. Instead of proving a huge list of low-level machine instructions, it proves statements that match what the app is actually trying to do.

V40 · PixelVM as execution + proof substrate · custom ISA · capsules · coprocessors
Astrea's move

Semantic-first proving — the meaning of the work is fixed first, then the proving backend is chosen. Public and private memory zones; coprocessor extension ABI for crypto, signatures, hash functions.

Field pattern

RISC Zero and SP1 are general zkVMs proving RISC-V or Rust execution traces. Polygon zkEVM proves Ethereum-equivalent execution. Most zkVMs are instruction-level, not semantic-first.

PixelVM is not a finished universal zkVM product. Full Ethereum proving is not complete.
04 · proof family

Proofs that split, fold, and combine

In plain English

Imagine reading a book aloud in chunks, with each chunk sealed in an envelope. You can prove you read the whole book by stacking the envelopes. Astrea proves computations the same way — in chunks that fold together into a final receipt.

How it works

Large proof jobs can be split into ordered chunks, checked piece by piece, and folded into one final receipt — without changing what is being proved.

V40 · CHARK family · CHASM streaming · ordered interval reduction · root artifact
Astrea's move

The proof stack is tied to semantic leaves and ordered interval reduction — not generic transaction proving. A development backend and a production proving backend share the same statement shape.

Field pattern

Mina uses recursive zero-knowledge proofs to keep the chain succinct. Starknet uses STARK proving with aggregation. Most proof systems are designed around generic transaction or program traces.

Production proving stack is the V40 architecture, not a deployed public proving network.
05 · authenticated state

Answers that come with proof

In plain English

When you ask a server "what's my account balance?", normally you just trust the answer. Astrea servers send the answer AND a tiny cryptographic receipt. You check the receipt yourself — a fake answer will not check out against the chosen fingerprint.

How it works

Astrea's data is organized into a few authenticated sections, each with its own fingerprint. When a server answers a query, it can include proof that the answer matches the known fingerprint. A fake answer will not check out.

V40 · authenticated state, MPT semantics, proof-backed query · RPC methods · query receipts
Astrea's move

Proof-backed query is first-class across documents, messages, manifests, and state domains. The protocol exposes canonical methods that return both the answer and the proof.

Field pattern

Ethereum uses Merkle Patricia tries for authenticated state, and Cosmos IBC verifies counterpart state via light-client-style proofs. But proof-backed query as a uniform application surface is uncommon outside of bespoke integrations.

Authenticated state roots are not unique. The stronger claim is the breadth of first-class integration across the protocol's data surfaces.
06 · data layer

A built-in document database

In plain English

Most chains let apps store little blobs of data. Astrea stores actual documents — collections, indexes, versions — like a real database, but every record is cryptographically tied to the state. Apps stop needing a separate database next to the chain.

How it works

Astrea treats documents, versions, search lists, and query receipts as built-in record types. Large bodies live in storage lanes; the chain keeps small authenticated headers. Apps get a real cryptographic database — not a generic blob store.

V40 · document storage, Mongo-style state, zkDB · canonical storage model · basic indexing
Astrea's move

Document semantics, patch history, and proof-backed reads are elevated into the protocol model. Indexes are declared and counted; queries return receipts.

Field pattern

Ethereum storage is account- and contract-oriented. Sui exposes an object-centric state model. Most ecosystems handle indexing and search via off-chain indexers, not the base protocol.

This is not full MongoDB on-chain. Ad-hoc search and analytics remain service-plane work unless explicitly made canonical.
07 · messaging

Native messaging at chain level

In plain English

Most chains have no idea what "a message from Alice to Bob" means. Astrea does — it understands mailboxes, threads, encrypted bodies, broadcasts. Like Signal, but participants or auditors can verify that a message arrived without ever seeing the encrypted contents.

How it works

Astrea can track mailboxes, threads, encrypted message bodies, broadcasts, and replay protection as chain records. Participants or auditors can verify that a message arrived and where it sits — without seeing the encrypted contents.

V40 · global messaging as native protocol · messaging partition law · world-scale messaging
Astrea's move

Authenticated messaging state. Consensus certifies the message state; service clusters handle push delivery. Fanout is explicitly non-authoritative — it cannot rewrite history.

Field pattern

Ethereum applications often use event logs as message-like signals. Chainlink CCIP and LayerZero focus on chain-to-chain messaging. User-level mailboxes as a protocol concept are rare.

Consensus doesn't deliver mobile push notifications. It certifies message state; specialized service clusters handle the actual push.
08 · data availability

Where large data lives, with rules

In plain English

Big files (photos, documents, archives) shouldn't be on the main chain — too expensive. Astrea has a separate place for them, but ties everything together so the main chain can prove a file exists without storing it.

How it works

The chain keeps the small facts it must verify; large files (photos, archives, document bodies) live in storage lanes with rules for keeping, repairing, and retrieving them. The main chain can prove a file exists without storing the file itself.

V40 · DA layer, payload manifests, universal cost · what belongs in DA
Astrea's move

Message bodies, document bodies, proof bundles, archives, and imported evidence all declare their DA profiles. DA integrates with the data and proof semantics, not as a sidecar.

Field pattern

Celestia specializes in data availability sampling as a standalone network. Ethereum already has proto-danksharding blobs for rollup data; full danksharding remains roadmap work. Most chains do not have a native cross-cutting data-availability semantics.

Not claiming to out-Celestia Celestia at pure DA. The point is integration with state, proofs, and application semantics.
09 · oracles + scheduling

Time and outside facts as records

In plain English

Apps often need outside data ("what's the temperature in Tokyo?") or to do things later ("run this on Tuesday"). Astrea treats both as protocol features. The services providing the data can't secretly change history — the protocol always checks them.

How it works

Time and outside facts ("the temperature in Tokyo", "the price of a stock") only enter Astrea as authenticated records. Helper services may suggest that something is due, but the normal rules still decide whether it runs. No hidden "server says so" authority.

V40 · oracles, clock domains, scheduling, subscriptions · timed continuations · ZK subscriptions
Astrea's move

Clock facts, oracle facts, timed continuations, and subscriptions are protocol-shaped. Scheduler service clusters never become authority — they propose, the protocol admits.

Field pattern

Chainlink and Pyth provide oracle feeds and services to smart contracts. Most chains expose block time or oracle contracts, but scheduling is typically app or service logic — not a protocol object.

Oracles do not make external truth automatic. The trust and evidence model still depends on the registered oracle law.
10 · cross-chain

Reading other chains without bridges

In plain English

Imagine borrowing a fact from Ethereum without trusting a bridge operator to tell the truth. Astrea reads a finalized checkpoint from Ethereum and accepts only the specific proven claims against it — nothing more.

How it works

Astrea first records a finalized checkpoint from another chain, then accepts only the specific facts proven from that checkpoint. Cross-chain influence is limited to those proven facts — bridge-style trust expansion is structurally avoided.

V40 · foreign-state import + rollup-style local · the Ethereum story
Astrea's move

Deliberately narrow: finalized root, registered import law, proven claim, local projection. Bridge-style trust expansion is structurally avoided.

Field pattern

IBC verifies counterpart state through light-client-style proofs. Chainlink CCIP and LayerZero provide general cross-chain message layers. zkEVM projects prove full Ethereum execution directly.

Not "full zkEVM". The accurate framing is "trust-minimized Ethereum query and narrow state-transition proof path".
11 · sharding

Adding capacity without breaking the meaning

In plain English

When a city grows, you add more neighborhoods — but they're still one city, one government. Astrea adds capacity by splitting work along clear lines, but it's still one verifiable system, not many systems pretending to be one.

How it works

Astrea adds capacity only when the split keeps the same answer you would get from one unsplit system. Throughput gains are only counted as real when they preserve the same meaning.

V40 · automatic sharding, partition law · safe refinement theorem · capacity growth modes
Astrea's move

Sharding is a semantic claim, not just operational: partitions are legal factorizations of one state machine. Refinement preserves equivalence with the unsharded view.

Field pattern

Polkadot scales through parachains under shared security. NEAR uses sharding and resharding under Nightshade (which frames itself as one chain). Avalanche supports custom L1/subnet deployments. They scale by adding shards or chains with their own execution boundaries; Astrea's claim is that splits are allowed only when they preserve the same application meaning.

Sharding helps only where workloads are actually independent. Cross-partition work still pays coordination cost.
12 · service plane

Helpers cannot quietly become authority

In plain English

Lots of helpers run Astrea — indexers, schedulers, oracles, dashboards. But none of them can secretly become "the source of truth." If a helper goes down, things slow down. If it lies about a checkable answer, the proof fails.

How it works

Helpers can answer queries, deliver messages, schedule work, store files, or mirror data, but they cannot change the official record unless they submit a normal action the chain accepts. If a helper lies about a checkable answer, the proof fails.

V40 · formal service cluster model · non-authority axiom · service-plane interaction
Astrea's move

Non-authority is a protocol axiom: useful services may be stale or unavailable, but they do not define truth. Service clusters becoming authority is a defined fault, not a quiet drift.

Field pattern

Most ecosystems depend heavily on RPC providers, indexers, sequencers, relayers, and oracle networks for usability. These are often operationally critical even when not consensus authority — but the boundary is not always explicit.

Non-authority does not mean non-essential. Poor service availability can still hurt user experience.
13 · privacy

Privacy that says what it leaks

In plain English

Some apps need to be public (votes). Some need to be private (medical records). Some need both (a sealed bid that reveals after the auction). Astrea handles all three, and every transaction explicitly says what it leaks — so privacy and verifiability can compose honestly.

How it works

Astrea separates public work, private work, and mixed work. Hidden policies, hidden approvals, and private schedules are supported — and every action says up front exactly what it reveals and what it hides. Privacy is not bolted on; it is part of every call.

V40 · privacy modes P0-P3 · Prism-style edge privacy · protocol auth policies
Astrea's move

Privacy modes integrate with protocol authorization, documents, messages, and proof-visible execution boundaries. The leak manifest is part of the call, not an afterthought.

Field pattern

Zcash focuses on shielded transfers. Aztec focuses on private smart contracts. Aleo focuses on private applications via zero knowledge. Each handles privacy as a primary specialty.

The most aggressive privacy mode is experimental. Astrea should not be positioned as a finished privacy chain.
14 · economics

Measuring work separately from who pays

In plain English

Ethereum charges users gas in ETH. Astrea separates "how much work was done" from "who pays for it." Apps can subsidize users, charge in different tokens, give free service, or run civic apps with zero price to the end user — without changing the underlying protocol.

How it works

Astrea measures work separately from payment. The same meter can settle as native fees, sponsor debits, service quotas, operator absorption, or zero price to the end user. Public finance, enterprise apps, civic apps, messaging, and subsidized workflows all fit — without pretending every one is DeFi gas.

V40 · native call metering · settlement profiles · tokens · sponsored credit · concurrent RC lanes
Astrea's move

Metering, authorization, tickets, quotas, sponsor permits, replay storage, and multisig policy are part of one protocol model. The meter is semantic; settlement profiles are pluggable.

Field pattern

Ethereum uses gas paid in ETH. Many chains have native fee assets, sponsored transactions, or app-level paymasters — but rarely a general semantic settlement layer that handles civic, subsidized, and enterprise patterns natively.

The public economic model is not deployed. Free-to-user does not mean free-to-attack — abuse resistance stays visible.
07 · the path

Where things actually stand.

A horizontal status line. Done means it landed and was independently audited. Now means active work. Ahead means designed but not yet built.

DONE

Consensus core

Core agreement rule checked against the written spec — mathematical proofs that the core avoids conflicting winners, keeps making progress, and follows the spec.

DONE

Data layer

Built-in document database with safe write logs, search lists, file chunks, and state fingerprints. Full adversarial review of the data layer.

DONE

Actor runtime

The internal task runner has bounded queues and capped mailboxes — all five lifecycle status messages emit real, bounded data.

DONE

Live-view protocol

Documented live status feed with 23 message types. Twenty-threat adversarial audit complete. A four-to-ten-node local cluster ships with the codebase.

NOW

Scheduling-lag audit

Adversarial review of the new scheduling-lag measurement. Finishes the task-runner work.

AHEAD

Concurrency model check

Testing every possible timing order in the consensus core under simulated threading.

AHEAD

Network simulation

Many-node tests with bad behavior, dropped messages, network splits, and clock drift — at simulation speed.

AHEAD

Real-network testbed

Controlled-network many-node testing on real wires. Required before any public launch.