ZenoDEX is a high-assurance, production-candidate decentralized autonomous exchange for Tau Network. It uses a hybrid model: deterministic Python computes operational state, while Tau Language specs, ESSO kernels, Lean proofs, and replayable certificates check the safety boundaries around settlement.
This README is the front door. Detailed assurance evidence lives in the linked docs, proof files, kernels, and replay scripts.
- Install And Load The Current Testnet
- Why The Name ZenoDEX?
- Current Status
- Assurance Snapshot
- Design Principles
- Core Features
- Features
- Quick Start
- ZenoLedger Node Operations
- Public Testnet Direction
- Repository Layout
- Documentation
- License
Use the latest operator bundle when you want to run ZenoDEX locally without cloning the full repository. It starts the DEX UI, ZenoLedger local nodes, a local Tau test node, Zeno Oracle, and the stdlib API on your machine.
Prerequisites: Docker Desktop or Docker Engine with compose v2, Python 3.11+, and Chrome or Chromium if you want browser smoke checks.
Download, verify, and extract the current release:
ZENODEX_VERSION=0.1.22
curl -L -o "zenodex-operator-${ZENODEX_VERSION}.tar.gz" \
"https://github.com/TheDarkLightX/ZenoDEX/releases/download/v${ZENODEX_VERSION}/zenodex-operator-${ZENODEX_VERSION}.tar.gz"
curl -L -o SHA256SUMS \
"https://github.com/TheDarkLightX/ZenoDEX/releases/download/v${ZENODEX_VERSION}/SHA256SUMS"
sha256sum -c --ignore-missing SHA256SUMS
tar -xzf "zenodex-operator-${ZENODEX_VERSION}.tar.gz"
cd "zenodex-operator-${ZENODEX_VERSION}"Clone the Tau local-testnet dependency. Tau is fetched by the tester and is not redistributed inside the ZenoDEX operator bundle.
mkdir -p external
git clone https://github.com/IDNI/tau-testnet.git external/tau-testnetStart and load the local testnet:
python3 tools/zenoctl.py testnet local up \
--out-dir ./local-testnet \
--engine docker \
--ui-port 18081 \
--health-timeout 240Open the UI:
http://127.0.0.1:18081
Run the live feature check:
python3 tools/zenoctl.py testnet local smoke \
--out-dir ./local-testnet \
--engine docker \
--browser autoStop the stack while preserving local state:
python3 tools/zenoctl.py testnet local down \
--out-dir ./local-testnet \
--engine dockerThe local stack exposes only a loopback nginx port by default. The browser uses
relative /api/* calls; nginx injects backend tokens server-side.
Native launcher track: release builds now include a Linux zenodex launcher,
and CI builds Linux, macOS, and Windows launcher artifacts. The launcher is the
future one-command path:
zenodex local-testnet upIt supplies a default local state directory, checks prerequisites, can fetch the
pinned Tau local-testnet dependency, and delegates to the existing checked
zenoctl.py orchestration. See
docs/NATIVE_INSTALLER_PLAN.md.
Latest release page: github.com/TheDarkLightX/ZenoDEX/releases/tag/v0.1.22. Full local-testnet details: docs/LOCAL_TESTNET_QUICKSTART.md.
Zeno of Elea posed paradoxes about motion and division. In the Dichotomy paradox, reaching a goal requires first going halfway, then halfway through the remaining distance, then halfway again. Modern mathematics resolves this with limits; a countably infinite sequence of shrinking steps sums to a finite total.
The analogy applies directly to tokenomics and protocol accounting. A supply schedule can approach a floor forever without crossing it:
S_{n+1} = F + r(S_n - F)
Where:
S_n = total supply after step n
F = supply floor
r = remaining fraction per step, with 0 < r < 1
The closed form is:
S_n = F + r^n(S_0 - F)
For every finite n, S_n > F, while S_n approaches F as n grows. The
total burn remains bounded:
S_0 - S_n = (1 - r^n)(S_0 - F) <= S_0 - F
Steps can be unbounded while the cumulative burn stays finite. That is the core Zeno analogy.
Real ledgers add an integer constraint. A token may be displayed with decimals; committed balances are integer base units. Once an ideal real-valued change falls below one base unit, the protocol must define a deterministic dust policy.
ZenoDEX therefore uses:
- integer base units
- explicit supply floors
- deterministic rounding
- explicit dust accounting
- bounded arithmetic proofs
For protocol tokens and LP shares, the practical target is 18 base-unit
decimals plus explicit dust accounting. If an ideal transfer is T* and the
ledger rounds down to t base units at decimal scale d, the rounding error is
bounded by one base unit:
0 <= T* - t / 10^d < 10^(-d)
Convergent tokenomics stay deterministic on real ledgers. The protocol approaches a floor without floating point arithmetic, implicit precision upgrades, or ambiguous rounding.
public-testnet candidate
high-assurance functional core
Tau Net handoff adapter available
production mainnet readiness gated by validator-network hardening and live-value deployment
The pinned release replay for the release tree dated 2026-04-06 was green:
- acceptance TCB:
385 passed,98.8%branch coverage - critical gate:
1424 passed,99%branch coverage - release gate:
passed end to end - mutation gate:
5 killed, 2 inconclusive - fuzz gate:
58 passed - snapshot recovery:
17 passed - Tau syntax:
60/60 - Tau traces:
1/1
This is historical release evidence for the pinned release tree. It is not a live statement about the current checkout.
For live status on the current checkout, run python3 tools/permissionless_assurance.py status.
Important derivatives note:
- The published v1.1 funding-rate formal claim is now the decomposed one:
funding_rate_market_v1for phase/state transitions plusfunding_rate_settlement_witness_v1_1for settlement arithmetic, both in the release-backed assurance lane. - The monolithic
funding_rate_market_v1_1kernel remains useful as a parity/reference artifact, but it is not part of the published formal release claim. funding_rate_market_v1andcurve_selection_market_v1remaindisputedin the claims registry for settlement authorization semantics and should not be treated as authorization-complete public settlement guarantees.- The bounded TLC/TLA+ claim surface is summarized in docs/TLA_CLAIM_SUMMARY.md and release-checked via
python3 tools/render_tla_claim_summary.py --check.
Release vocabulary:
release-backed: included in the current published formal/public assurance claimpublic replay: reproducible from a clean checkout plus the documented external toolchains via the shipped replay/checker surfaceauthorization-complete: safe to treat as a public settlement-authorizing guarantee without extra trusted environment inputsdisputed: intentionally excluded from stronger public authorization claims until the witness/auth lane is trust-complete
More detail:
- docs/ASSURANCE_RELEASE_SNAPSHOT.md
- docs/PUBLIC_ASSURANCE_REPLAY.md
- docs/TLA_CLAIM_SUMMARY.md
- docs/ASSURANCE_GLOSSARY.md
- docs/claims_registry.yaml
Invalid states must be unrepresentable. Correct-by-construction design eliminates bad states at the type level; tests confirm the behavior that remains.
ZenoDEX keeps consensus-critical logic small, deterministic, and replayable. The core avoids floating point arithmetic, uses canonical serialization, and commits state through reproducible roots. Complementary evidence includes Lean proofs, Tau specs, ESSO kernels, property tests, replay receipts, fuzzing, and adversarial simulations. ZenoLedger v0 provides the replayable testnet layer that makes this evidence independently verifiable across machines.
Proof-backed and evidence-backed areas include:
- CPMM integer arithmetic and invariant checks
- canonical ordering and candidate selection surfaces
- settlement replay validation
- Zeno Oracle: freshness checks, reporter lifecycle replay, token-settlement replay, and fail-closed malformed-input handling
- zUSD collateral and redemption math
- perps funding and margin boundaries
- ZenoProof: evidence registry and verifier checks
- FIRE settlement receipts, verifier rules, and budget-safety claims
- Certified Financial Math Object payoff, collateral, and fixed-point bridges
- ZenoLedger: headers, checkpoints, watcher attestations, mirror roots, and Tau handoff packets
This is a high-assurance public-testnet candidate. It exceeds conventional prototype rigor. Production value deployment still requires operational hardening and fresh release evidence.
Continuous markets force a latency race over ordering, observation time, and inclusion. ZenoDEX moves key surfaces to deterministic batch mechanisms.
Uniform Price Batch Auction (UPBA) is the target clearing architecture for reducing intra-batch ordering games. Under true uniform clearing, execution depends on the admitted order multiset and the clearing certificate, instead of an arbitrary sequence of individual swaps.
The current UPBA work is scoped:
aggregate orders
compute or propose a uniform clearing result
verify certificate conditions deterministically
commit accepted result through ZenoLedger feature suites
UPBA reduces intra-batch ordering MEV. By itself it does not address inclusion/exclusion games, batch-boundary timing, oracle timing, censorship, or cross-domain latency; those surfaces are modeled separately.
The solver incentive model has a checked local payoff theorem. When the bounty exceeds compute cost, the slash penalty is positive, and the verifier always catches invalid submissions, honest solving strictly dominates idling or submitting a bad solution. The bound is conditional on those assumptions and does not claim that every production actor game is solved.
ZenoEnergy is an isolated research scorer for UPBA v2 candidate search. A small energy/ranking model orders candidate settlements before deterministic verification. The verifier remains the settlement authority:
Model proposes; verifier decides.
Headline result on bounded synthetic data. The preferred 97-parameter gap-weighted ranker reaches 100% top-10 recall on committed holdout and cross-seed synthetic receipts, reduces mean verifier-winner position versus hand energy, and records zero invalid accepts. Learned and hybrid orderings average 1.008 verifier calls on the bounded synthetic run and 1.013 verifier calls across a 3-seed by 3-candidate-count stress grid. The multi-family adversarial suffix stress extends this to 944 verifier-invalid cases across 8 invalidity families with zero invalid accepts.
Recent surfaces. A runtime dominance-cover certificate prototype and a WES bridge rank dominance-cover checker work while deterministic UPBA verification remains authoritative. A dominance-prefix audit shows current learned and hybrid rankers reaching a finite-list dominance-cover certificate after the first checked candidate on the committed bounded run. The suffix-bound early-stop certificate adds a deterministic unchecked-suffix objective bound; declared-output-only bounds fail on injected high-output invalid suffixes, while deterministic disqualifiers preserve the certificate.
Curriculum and data. A Julia negative-curriculum lane converts hard negatives into sampling weights and a bounded epiplexity proxy so training can prioritize rare deterministic disqualifiers while preserving verifier authority. The first bounded rare-disqualifier curriculum ranker did not beat the gap-weighted default, so the default stays promoted for research. The data-scaling probe shows raw same-generator synthetic volume helps from small budgets but saturates below the current checkpoint. The quality-selection probe sharpens this: winner-bearing hard-batch selection beats raw winner-bearing sampling at medium budgets, while tiny hard-only budgets can overfocus on rare current-model misses. The ensemble probe adds six-member advisory energy ensembles and Borda-style rank disagreement; it preserves top-10 recall and zero invalid accepts but does not beat the current checkpoint on mean verifier calls, so ensemble disagreement stays diagnostic rather than a promoted default. The best-model registry pins the preferred UPBA checkpoint and the three deterministically regenerated AutoTrader hard synthetic models with sha256 hashes, so future experiments have stable advisory baselines.
Honest boundaries.
- Production ranking remains gated by real or production-shadow replay.
- Ranking by low energy alone is not an optimality certificate (formal Lean counterexample at docs/ZENO_ENERGY_ENERGY_ORDER_ALONE_FORMAL.md).
- The epiplexity proxy can guide data selection only after heldout ranking metrics prove it helps.
- All of the above is bounded synthetic evidence. The replay tooling below cannot authorize settlement, change policy predicates, or turn synthetic fixtures into production evidence.
Replay and promotion tooling. The replay secret scanner catches obvious key material before packaging. The source manifest builder packages real replay reports with canonical hashes and secret-scan attestations. The replay coverage profile checker rejects narrow real replay evidence before promotion. The production evidence bundle then assembles source-manifested, coverage-profiled UPBA and AutoTrader real replay reports and runs the fail-closed advisory ranking promotion gate.
References.
- Model and results: V0 spec, results, paper
- Suffix bound: main, cross-seed, adversarial, family stress
- Dominance: cover, WES search, prefix audit
- Curriculum and data: negative curriculum, curriculum ranker, data scaling, quality selection, ensemble, best models
- Formal and theoretical: energy-order-alone Lean counterexample, epiplexity literature note
- Production gate and replay: gate, secret scan, source manifest, coverage profile, evidence bundle
ZenoProof is the internal evidence registry and verifier layer. Its public role is to connect checked evidence to replayable claims and verifier gates. Mechanism details are intentionally kept out of the public README until the release scope is finalized.
FIRE is the internal framework for turning financial mechanisms into checked object packages: templates, instances, certificates, verifier receipts, replay receipts, and settlement-authority predicates. FIRE proposals are non-authoritative until they compile into accepted artifacts and pass the FIRE verifier.
Certified Financial Math Objects are the financial instruments that FIRE is meant to package. A live object should specify:
formula + units + bounds + state transition + oracle policy
+ collateral rule + proof/certificate
The point is bounded liability, replayable settlement, and clear evidence labels. A certified object may still be economically unwise or unprofitable; the certification claim is about mechanical invariants such as payoff bounds, collateral sufficiency, fixed-point rounding buffers, conservation, and settlement replay.
- Spot DEX: deterministic CPMM execution, LP accounting, settlement replay, and state-root commitments.
- UPBA: uniform-clearing research with testnet feature-suite coverage for aggregate batch-auction verification.
- ZUSD: overcollateralized stablecoin mechanics, redemption, and collateral-ratio analysis.
- Perpetuals: epoch-based funding, margin checks, insurance boundaries, and liquidation research.
- ZenoOracle: freshness checks, reporter lifecycle replay, token-settlement replay, and fail-closed handling of malformed input.
- ZenoProof: evidence registry and verifier layer for replayable assurance claims. Mechanism details are intentionally withheld from the public README until release.
- FIRE: internal object pipeline with verifier receipts, proof-tree certificates, budget-safety checks, and replay gates for promoted financial mechanisms.
- Certified Financial Math Objects: formula-bound financial instruments with explicit units, payoff bounds, collateral rules, oracle policy, and proof or certificate bundles.
- Confidential Extensions: TEE-first confidential admission with experimental FHE sealed-bid verification surfaces.
- Autotrader Policy Surface: local deterministic controller checks over quote receipts, cadence, budgets, and rejected actions.
- ZenoLedger: replayable public-testnet candidate with watcher attestations, mirror roots, status roots, and Tau handoff.
This is the recommended path for testers who want to exercise ZenoDEX locally against live local nodes. It starts a Docker compose stack with ZenoLedger writer/forwarder/read-only nodes, a local Tau test node, Zeno Oracle, the stdlib API, nginx, and the DEX UI.
Prerequisites:
- Docker Desktop or Docker Engine with compose v2.
- Python 3.11+.
- Chrome or Chromium only if you want browser smoke checks.
Download, verify, and extract the current operator bundle:
ZENODEX_VERSION=0.1.22
curl -L -o "zenodex-operator-${ZENODEX_VERSION}.tar.gz" \
"https://github.com/TheDarkLightX/ZenoDEX/releases/download/v${ZENODEX_VERSION}/zenodex-operator-${ZENODEX_VERSION}.tar.gz"
curl -L -o SHA256SUMS \
"https://github.com/TheDarkLightX/ZenoDEX/releases/download/v${ZENODEX_VERSION}/SHA256SUMS"
sha256sum -c --ignore-missing SHA256SUMS
tar -xzf "zenodex-operator-${ZENODEX_VERSION}.tar.gz"
cd "zenodex-operator-${ZENODEX_VERSION}"Clone the Tau local-testnet dependency. Tau is fetched by the tester and is not redistributed inside the ZenoDEX bundle:
mkdir -p external
git clone https://github.com/IDNI/tau-testnet.git external/tau-testnetStart the local multi-node testnet:
python3 tools/zenoctl.py testnet local up \
--out-dir ./local-testnet \
--engine docker \
--ui-port 18081 \
--health-timeout 240Open the UI:
http://127.0.0.1:18081
Run live feature checks:
python3 tools/zenoctl.py testnet local smoke \
--out-dir ./local-testnet \
--engine docker \
--browser autoStop the stack while preserving state:
python3 tools/zenoctl.py testnet local down \
--out-dir ./local-testnet \
--engine dockerFully reset the local chain, fixtures, and volumes:
python3 tools/zenoctl.py testnet local reset \
--out-dir ./local-testnet \
--engine docker \
--forceDetails and troubleshooting: docs/LOCAL_TESTNET_QUICKSTART.md.
Install Python dependencies:
python3 -m pip install --require-hashes -r requirements-dev.lock.txtProduction/container runtime installs use the smaller runtime lock:
python3 -m pip install --require-hashes -r requirements-core.lock.txtClone optional Tau dependencies under external/:
mkdir -p external
cd external
git clone https://github.com/IDNI/tau-lang.git
git clone https://github.com/IDNI/tau-testnet.git
cd ..Run the local API and UI:
DEX_API_ENABLED=true ZENODEX_API_BEARER_TOKEN=sekret \
python3 -m src.integration.api_server
cd tools/dex-ui
npm install
VITE_DEMO_MODE=false VITE_API_TOKEN=sekret \
npm run dev -- --host 127.0.0.1 --port 5173When a zenoctl testnet local up stack is running, the Vite dev server
auto-detects its loopback nginx port for /api/*. Set API_PROXY_TARGET
explicitly when you are wiring the UI to a manually started API server.
Run the broad Python test suite:
pytest tests/Run Lean proofs:
cd lean-mathlib
lake buildRun the ZenoLedger public-testnet candidate builder:
python3 tools/zeno_ledger_make_public_testnet_bundle.py \
--out-dir /tmp/zeno-ledger-public-testnet \
--network-id zeno-ledger-devnet-0 \
--chain-id zeno-ledger-devnet-0Before starting a node, run the lightweight local preflight. These commands do not need external network access and catch the common setup mistakes before an operator opens ports or mirrors a bundle:
python3 tools/zeno_ledger_node.py --help
python3 tools/permissionless_assurance.py status
python3 tools/check_tau_supported_runtime_subset.py
pytest -q tests/tau/test_tau_spec_assurance.pyFor a same-machine network rehearsal, run:
python3 tools/zeno_ledger_public_network_smoke.py \
--out-dir /tmp/zeno-ledger-public-network-smoke \
--network-id zeno-ledger-devnet-0 \
--chain-id zeno-ledger-devnet-0The node entrypoint wraps the same bundle and replay logic. Use it to build a bootstrap bundle, run a follower/watcher node, and optionally serve node status over HTTP:
python3 tools/zeno_ledger_node.py bootstrap \
--out-dir /tmp/zeno-ledger-public-testnet \
--network-id zeno-ledger-devnet-0 \
--chain-id zeno-ledger-devnet-0 \
--token-symbol tZENO
python3 tools/zeno_ledger_node.py sync \
--base-url https://example.test/zeno-ledger-public-testnet/ \
--out-dir /tmp/zeno-ledger-public-testnet-synced
python3 tools/zeno_ledger_node.py write-network-config \
--bundle-root /tmp/zeno-ledger-public-testnet \
--mirror-base-url https://example.test/zeno-ledger-public-testnet/ \
--writer-url https://example.test:8787 \
--out /tmp/zeno-ledger-public-testnet/public_network_config.json
python3 tools/zeno_ledger_node.py join-network \
--config-url https://example.test/zeno-ledger-public-testnet/public_network_config.json \
--node-id operator-b \
--bundle-root /tmp/zeno-ledger-public-testnet-synced \
--data-dir /tmp/zeno-ledger-node-b \
--serveThe same public-testnet publish and join paths are available through the operator wrapper:
python3 tools/zenoctl.py testnet publish-config \
--bundle-root /tmp/zeno-ledger-public-testnet \
--mirror-base-url https://example.test/zeno-ledger-public-testnet/ \
--writer-url https://example.test:8787 \
--out /tmp/zeno-ledger-public-testnet/public_network_config.json
python3 tools/zenoctl.py testnet join \
--config-url https://example.test/zeno-ledger-public-testnet/public_network_config.json \
--node-id operator-b \
--serveFor a remote operator, use a join config to combine sync, replay, peer checking, and serving when a public network config has not been published:
cat > /tmp/zeno-ledger-node-b.json <<'JSON'
{
"schema": "zenodex.zeno_ledger.node_join_config.v0",
"base_url": "https://example.test/zeno-ledger-public-testnet/",
"bundle_root": "/tmp/zeno-ledger-public-testnet-synced",
"node_id": "operator-b",
"data_dir": "/tmp/zeno-ledger-node-b",
"peer_urls": ["http://127.0.0.1:8787"],
"serve": true,
"host": "0.0.0.0",
"port": 8788,
"poll_seconds": 5,
"enable_testnet_intake": true,
"enable_testnet_faucet": true,
"submit_peer_url": "http://127.0.0.1:8787"
}
JSON
python3 tools/zeno_ledger_node.py join \
--config /tmp/zeno-ledger-node-b.jsonThe lower-level run command is still available when an operator wants to manage each step manually:
python3 tools/zeno_ledger_node.py run \
--bundle-root /tmp/zeno-ledger-public-testnet-synced \
--node-id operator-a \
--data-dir /tmp/zeno-ledger-node-a \
--peer-watcher-attestation \
/tmp/zeno-ledger-public-testnet-synced/bootstrap/watcher_attestations/bootstrap_range_1_5.json \
--serve \
--host 127.0.0.1 \
--port 8787ZenoLedger also has opt-in Risc0 proof-of-execution coverage for the current
ZenoDEX spot v1 guest subset. The real-proof smoke builds the guest with
RISC0_FORCE_BUILD=1, generates non-empty receipts, and verifies them through
the host CLI for an empty transition, faucet mint, create-pool, and
swap-exact-in. The receipt journal binds the state hash, transaction
commitment, pre-app hash, post-app hash, and block timestamp.
This is current local evidence for the restricted guest path. It does not yet prove the full Python ZenoDEX runtime, multi-intent batches, exact-out, multi-hop routing, production prover performance, or validator-network readiness.
After the node has verified its bootstrap bundle, a local operator can append testnet DEX transactions into the node-local live ledger:
python3 tools/zeno_ledger_node.py append \
--data-dir /tmp/zeno-ledger-node-a \
--tx /path/to/testnet_tx.json \
--time-ms 1778731000000
python3 tools/zeno_ledger_node.py pull-live \
--data-dir /tmp/zeno-ledger-node-b \
--peer-url http://127.0.0.1:8787
python3 tools/zeno_ledger_node.py check-peers \
--data-dir /tmp/zeno-ledger-node-b \
--peer-url http://127.0.0.1:8787
python3 tools/zeno_ledger_node.py serve \
--data-dir /tmp/zeno-ledger-node-b \
--host 127.0.0.1 \
--port 8788 \
--peer-url http://127.0.0.1:8787 \
--poll-seconds 5 \
--submit-peer-url http://127.0.0.1:8787 \
--enable-testnet-intake \
--enable-testnet-faucet
python3 tools/zeno_ledger_node.py faucet \
--data-dir /tmp/zeno-ledger-node-a \
--to-pubkey 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \
--asset 0x1111111111111111111111111111111111111111111111111111111111111111 \
--amount 100000This is the first public-node layer for ZenoLedger. The node bootstraps from a
bundle, verifies the ledger, emits a watcher attestation, and serves
/health, /status, /features, /tokens, /network, /live,
/attestation, and /testnet-status.
The sync command downloads only indexed JSON artifacts from a public HTTP
mirror and verifies every mirror hash before the node runs.
The public bundle ships a deterministic test-token catalog (tZENO, tASSET0,
and tASSET1) plus testnet-only faucet behavior for feature testing. The
faucet accepts canonical 32-byte test asset IDs, so operators can mint
throwaway assets for live test pools without touching release token policy.
Latest local shipment metadata is in
docs/LATEST_TESTNET_CHECKPOINT.md. The
current checkpoint builds the static DEX UI, executes the public-testnet
feature-suite bundle, and verifies the operator archive manifest before
sharing.
The append command writes post-bootstrap testnet DEX blocks under the node
data directory. The pull-live command fetches live block bodies from a peer
and accepts them only after local deterministic replay produces the same
header. A served node can also poll peer URLs with --peer-url and
--poll-seconds.
Testnet HTTP intake is disabled by default. --enable-testnet-intake opens
POST /tx, and --enable-testnet-faucet opens POST /faucet for bounded
fake-token minting. A follower can expose POST /tx and POST /faucet while
forwarding submissions to a designated writer with --submit-peer-url, then
follow the resulting live blocks by deterministic replay.
The join command wraps sync, replay, watcher attestation, optional peer
check, and optional serving into one JSON-configured operator flow. The
check-peers command compares network ID, chain ID, feature-suite hash, peer
height, and the common header hash before an operator trusts a peer. The
write-network-config and join-network commands let any operator join from
one published URL.
Live P2P block gossip and validator scheduling remain future network work.
The next release target is a public-testnet v0 where the 3-node multi-machine rehearsal graduates into an operator-facing network:
seed operator publishes public_network_config.json
-> outside operators join from one URL
-> followers verify and replay before serving status or forwarding testnet txs
-> phones and browsers connect as clients or verify checkpoint bundles
The target is documented in docs/PUBLIC_TESTNET_V0_1_16_PLAN.md. The first public testnet can keep one designated writer while opening node launch and deterministic replay to outside operators. Rotating validators, open P2P gossip, and production value remain later milestones.
Run the same-machine dual-operator rehearsal before copying to another
computer. The two-machine operator runbook is
docs/ZENO_LEDGER_TWO_MACHINE_TESTNET.md.
python3 tools/zeno_ledger_public_network_smoke.py \
--out-dir /tmp/zeno-ledger-public-network-smoke \
--network-id zeno-ledger-devnet-0 \
--chain-id zeno-ledger-devnet-0
python3 tools/zeno_ledger_dual_operator_rehearsal.py \
--out-dir /tmp/zeno-ledger-dual-operator \
--network-id zeno-ledger-devnet-0 \
--chain-id zeno-ledger-devnet-0This builds two independent public-testnet bundles, checks their hashes match, copies one bundle into a second operator directory, replays it, and emits a combined two-watcher status report.
Run the copied-bundle rehearsal on a second machine:
python3 tools/zeno_ledger_operator_rehearsal.py \
--bundle-root /path/to/copied/zeno-ledger-public-testnet \
--operator-id operator-b \
--out-dir /tmp/zeno-ledger-operator-b \
--peer-watcher-attestation \
/path/to/copied/zeno-ledger-public-testnet/bootstrap/watcher_attestations/bootstrap_range_1_5.jsonThe rehearsal succeeds when the second machine emits ok=true, an
operator_attestation_hash, and a combined_testnet_status_hash with
combined_watcher_count=2.
src/core/: deterministic DEX, AMM, zUSD, perps, oracle, and confidential extension logicsrc/state/: state tables, state-root helpers, and canonical commitmentssrc/integration/: API server, ZenoLedger, Tau handoff, snapshots, and verification adapterssrc/kernels/: generated/reference kernels and verified state machinessrc/tau_specs/: Tau Language policy specslean-mathlib/Proofs/: Lean proof artifactszk/zrpf_risc0/: bounded ZRPF structural proof and retained-replay profiletools/: operational scripts, replay helpers, feature-suite builders, and UIdocs/: public specs, architecture notes, and release evidencetests/: unit, integration, replay, and assurance testsexperimental/andknowledge/: discovery artifacts, simulations, and negative-knowledge records
docs/SPECIFICATION.mddocs/ALGORITHMS.mddocs/FIRE_MANIFESTO.mddocs/derivatives/CERTIFIED_FINANCIAL_MATH_OBJECTS.mddocs/TAU_ARCHITECTURE.mddocs/TAU_LANGUAGE_CONSTRAINTS.mddocs/ASSURANCE_RELEASE_SNAPSHOT.mddocs/DISASTER_HARDNESS_ASSURANCE_METRIC.mddocs/research/ZRPF_V3_CORRECT_BY_CONSTRUCTION_SPEC_20260710.mdzk/zrpf_risc0/README.md
TBD
