push0: Proof Orchestration for Zero-Knowledge Rollups

A scalable, fault-tolerant, and prover-agnostic orchestration framework for managing zero-knowledge proof generation workflows.

Overview

push0 decouples proving logic from scheduling infrastructure, enabling:

• Event-driven dispatcher--collector architecture over persistent priority queues
• Block-sequential proving with intra-block parallelism
• Automatic task recovery via message persistence and at-least-once delivery
• Seamless integration of heterogeneous zkVMs through a standard executor interface
• Horizontal scaling with sub-10ms orchestration overhead

For details, see our paper: push0: Scalable and Fault-Tolerant Orchestration for Zero-Knowledge Proof Generation.

Repository Structure

push0-orchestrator/
├── prover-traits/               # Trait definitions for prover integration
│   └── src/
│       ├── prover.rs            # Prover, Witness, Operation traits
│       ├── composer.rs          # Composer trait
│       ├── serialize.rs         # Serialization utilities
│       └── error.rs             # Error types
│
├── orchestrator/                # Core orchestrator library (11 crates)
│   ├── collector/               # Aggregation logic and collection strategies
│   ├── config/                  # Configuration (env vars, CLI args)
│   ├── collection_strategy/     # Pluggable collection strategies (Match, Sequential, Custom)
│   ├── db_utils/                # Database connection helpers
│   ├── dispatcher/              # Task dispatch core
│   ├── executor/                # Executor interface (JSON, Composer)
│   ├── message_policy/          # Message bus backends (NATS, S3, filesystem)
│   ├── metrics/                 # Prometheus metrics exporter
│   ├── storage/                 # Task storage backends (memory, filesystem, DB, NATS)
│   ├── traces/                  # OpenTelemetry tracing
│   └── traits/                  # Core trait definitions
│
└── experiments/                 # Reproducible experiments from the paper
    ├── orchestrator/            # Experiment binary (echo executor mode)
    ├── scripts/                 # Python experiment runners
    ├── k8s/                     # Kubernetes deployment configs
    └── results/                 # Experiment results (JSON)

Getting Started

Prerequisites

• Rust (stable toolchain)
• Docker & Docker Compose (for experiments)
• NATS server (for message bus)

Build

git clone https://github.com/zircuit-labs/push0-orchestrator.git
cd push0-orchestrator/orchestrator
cargo build --release

Running Experiments

See experiments/README.md for instructions on reproducing the paper's evaluation.

Architecture

The orchestrator consists of three core components:

• Message Bus: Persistent priority queues with at-least-once delivery (NATS JetStream).
• Dispatcher: Pulls tasks, invokes prover binaries via a standard interface, publishes results.
• Collector: Aggregates results from one or more queues using pluggable collection strategies.

Provers are treated as opaque executables. Integration requires implementing the Prover and Composer traits from prover-traits/, or using the JSON executor which invokes any binary via stdin/stdout.

Extending

To integrate a new prover:

1. Implement the Prover trait from prover-traits/
2. Configure a dispatcher with the prover binary path and queue identifiers
3. Define collection strategies for your proving pipeline