Cypherpunk L2 Experiment

Starknet execution. Circle STARK proofs. Settled on Zcash.

Ztarknet explores a Starknet-inspired rollup that anchors to Zcash L1 via a Transparent Zcash Extension (TZE) verifier. Programmable, privacy-native, and battle-ready for zero-knowledge maximalists.

Join the discussion Read the thesis
Proof System
Circle STARKs (Stwo/Cairo)
L2 Runtime
Madara (Rust Starknet client)
L1 Settlement
Zcash TZE verifier
Anchor UTXO Chain

Each state root lives in a TZE output. Spend prev anchor, prove the transition, mint the next root. Minimal surface, maximum verifiability.

Privacy Native

Zcash shields what matters. Ztarknet adds programmable headroom without touching base-layer guarantees.

Rust-all-the-way

Zebra fork, Madara, and Stwo/Cairo glue together an end-to-end Rust pipeline for experimentation.

Why Ztarknet

Scaling programmable privacy without diluting trust

Keep Zcash minimal

Push general-purpose computation to a Cairo VM on L2. Zcash verifies the proof via TZE and keeps consensus surface area tight.

Proof-first integration

The draft ZIP introduces a Circle STARK verifier as a new TZE type. Full nodes validate proofs natively—no bespoke scripting, no hand-wavy trust assumptions.

Programmable freedom

Starknet tooling, account abstraction, and Cairo contracts become available to Zcash users while L1 privacy stays uncompromised.

How it fits together

The Circle STARK rollup loop

L2 Sequencing

  • Madara batches and executes Starknet-style transactions.
  • State updates emit a new L2 root per block.
  • Execution traces feed directly into prover workers.

Proof Generation

  • Stwo/Cairo produces Circle STARK proofs for each block.
  • Public inputs commit to root_k and root_{k+1}.
  • Optional aggregation once the PoC is stable.

Zcash Settlement

  • TZE transaction spends the previous anchor UTXO.
  • Witness carries the proof; precondition locks the next root.
  • Zebra fork validates the proof via the Circle STARK TZE.

It’s a clean UTXO chain of anchors: prove the state transition, hand the verifier the bytes, and let Zcash consensus seal the next root. No ceremony, no sidecar trust assumptions.

PoC stack

Minimal components, maximum signal

Verifier

Zebra + Circle STARK TZE

A forked Zebra node hosts the draft TZE verifier, aligning with ZIP-222/245 to ensure transactions anchor proofs in canonical digests.

Explore the fork
Sequencer

Madara (Rust)

Starknet-compatible client providing JSON-RPC, state commitments, and mempool logic. The devnet spins up with a single command.

Check the client
Prover

Stwo / Cairo

Circle STARK prover stack validating Cairo execution traces for each L2 block. JSON workflows first, native integrations next.

Dive into Stwo
Submitter

TZE Tx builder

Custom Rust glue to bundle proofs and state roots into witness bytes that a Zebra node validates before minting the next anchor.

Read the draft ZIP

Impact surface

What the PoC unlocks

01

Demonstrate native proof verification

Prove that a Zcash full node can verify Circle STARK proofs inside consensus rules, without exotic extensions or trusted relays.

02

Release a replayable devnet

Ship a Dockerized stack with Madara, Stwo/Cairo, and the Zebra fork so researchers can replay the entire loop locally.

03

Explore data availability options

Start minimal with state roots, then weigh on-chain DA, hybrid publishing, or validity rollup bridges for production hardening.

Deep dive

Resources & references

Ztarknet repository Circle STARK-enabled Zebra fork Circle STARK TZE draft ZIP Starknet protocol intro Stwo/Cairo proof stack Madara sequencer