AstroLune Roadmap

Dates are intentionally absent until maintainers publish resourced release targets. Milestones describe dependency order, not promises.

Baseline — in progress

• Rust 2024 workspace and strict lint policy.
• Core protocol, execution, storage, network, service, and tooling crate boundaries.
• Repository documentation, CI, dependency policy, and contribution templates.
• Initial pure invariant and integration tests.
• Review public interface naming, preserve compatibility aliases and distinguish demonstration/runtime trust boundaries; baseline.

M1 — canonical foundations

Canonical encodings, protocol domains, hashes, addresses, signatures, checked resource arithmetic, golden vectors, property tests, and decoder fuzzing.

• Strict primitive/current-transaction codecs and canonical-byte regression tests.
• Standard BLAKE2s-256, strict Ed25519, transaction signing/ID domains, and address derivation.
• Checked resource pricing and cryptographic conformance vectors.
• Bounded version-1 genesis, validated commitments, initial account/validator state, and CLI verification.
• Atomic daemon genesis activation, restart identity checks, and preserved initial account state.
• Version-1 signed transactions with expiry, explicit lanes, signed prices, and strict decoding.
• Version-1 signed votes and finality certificates, checked committee commitments, and independent Ed25519 quorum verification.
• Versioned reference-network envelopes and opt-in certified daemon finality.
• Canonical RFC 9381 VRF proofs, role-bound context, RFC vectors and malformed-proof rejection.
• Freeze supported genesis-v1/v2 histories in 50 binary compatibility fixtures, with authenticated replay and independent commitment/framing checks; details.
• Freeze eight separate PoTB producer-profile fixtures, with authenticated replay and independent framing/commitment checks; details.
• Qualify explicit governance envelopes, daemon activation and preserved legacy compatibility; rules and tests.
• Shared extension fuzz oracle, 99 structured seeds and deterministic one-million-input mutation campaign; qualification details.
• Long deterministic and coverage-guided fuzz campaigns over the protocol and contract surfaces; scope and measurements.
• Committed bounded registry advisory lookup and a recorded dependency/security review; evidence.
• Full-lockfile licence coverage over all 158 locked packages with a pinned baseline, closing the 121-package limit of the dependency-policy tool's own graph; cause and bound.
• Cross-platform suite qualification; per-leg suite reports are recorded as artifacts, both release legs now pass, and the two intermittent debug failures are reproduced and root-caused — a historical query that used a finalized payment as its precondition over an RPC that could not distinguish catch-up from evicted history, and a Windows accepted socket inheriting its listener's non-blocking mode. Both are fixed; what remains is an observed clean run across all four legs; observed runs.
• Upgrade qualification: current stable dependencies, legacy vault compatibility, strict Rust 1.99.0 checks and bounded registry advisory lookup; evidence.

M2 — transactions and state

Signed envelopes, validation order, account/state commitments, immutable snapshots, proofs, state diffs, atomic commit, recovery, pruning, and snapshot exchange.

Current progress: signed admission validates existing transaction fields against an account view. Merkle state commitments, membership and absence proofs, immutable snapshots, bounded transitions, atomic state/whole-chain archive recovery, and verified snapshot exchange are implemented with rollback tests. Proposal execution stays private until successful commit. Sequential signed payment overlays, balance/nonce transitions, fixed reference fees, execution revalidation, and daemon account/submission RPC are implemented. The versioned transaction envelope, expiry enforcement, and post-commit expiry eviction are implemented. Append-only block/delta logs now provide durable publication, disk history reads, linear replay and legacy compatibility for new network directories. Protected signing-journal rollover now continues after the former decision cap with constant file size and lock-preserving recovery. Bounded recent transaction indexing and certified receipt recovery are implemented. Quorum fee/capacity governance and bounded historical state indexing are implemented. Explicit bounded history export and pinned recovery are implemented; automated retention remains open. Encrypted consensus-key custody and an independent monotonic signing anchor are implemented with explicit daemon activation; hardware isolation and a coordinated two-store rewrite remain out of scope. Local daemon block/state restart integration is implemented; daemon signing-state integration and independent authentication of recovered history are implemented in the certified reference-network profile. See state and recovery and chain archives.

M3 — deterministic Rust contracts

Pinned contract toolchain, canonical target selection, validator, interpreter, host ABI, metering, SDK, reproducible artifacts, source verification, and differential backends.

• Integer-only WebAssembly ABI v2 validator and interpreter with bounded memory, fuel, state access and staged writes/events.
• Pinned Rust 1.99.0 standalone contract builds, repeated-byte comparison, artifact validation, sandbox execution and code-hash verification CLI.
• Signed deployment/call transactions, nonce/fee transitions, explicit genesis activation and certified restart/catch-up tests.
• Allocation-free Rust SDK bindings, bundled builds and real wasm32 host-call tests.
• Restricted Cargo package/source manifests and offline published-source verification.
• Dedicated contract fuzz target with a differential validate/execute oracle and gated mutation campaigns; scope.
• Qualified alternate engine configurations across the backend seam, with a measured prohibition on lazy compilation whose deferred work is charged to the call's fuel; scope.
• Qualified AOT, JIT or SIMD backends; no native backend is implemented.

Implemented behavior and the remaining activation boundary are specified in document 29.

M4 — parallel execution

Access leasing, execution waves, multiple lanes, optimistic validation, deterministic conflict replay, locality, fusion, caches, prefetch, object pools, and signature batches.

• Parallel signed payment waves with checked actual access, private overlays and serial error replay.
• Node verification/replay integration and serial/parallel differential tests across worker counts.
• Mixed contract/payment waves, aggregate capacity enforcement and deterministic serial replay.
• Explicit rotating-producer system lane with reserved VRF resources, mixed application execution and atomic publication.
• Explicit genesis-v2 daemon activation of the VRF system lane.
• Consensus capacity/fee governance: more than 2/3 incumbent weight, next-epoch activation; details.
• Bounded verified VRF transition cache and single-pass evidence history verification, with equivalence tests and local measurements.
• Bounded execution-parent read cache and borrowed-key wave planning, with uncached/serial equivalence and deterministic read-count checks; scope.
• Reuse a bounded worker pool across each block's parallel waves, with thread-count and serial-equivalence checks; scope.
• Reference execution locality through borrowed-key planning and parent caching, consecutive singleton-wave fusion, bounded declared-key prefetch and reusable worker result buffers, with serial-equivalence checks; scope.
• Bounded parallel strict signature verification with deterministic failing-index reporting, routed through every quorum path, with serial-equivalence tests; scope.

M5 — PoTB and finality

PoTB state transitions and evidence, audited VRF provider, weighted sampler, partial rotation, producer selection, prevote/precommit state machine, certificates, anti-equivocation journal, formal models, and adversarial simulations.

• Registered-key ECVRF proof generation/verification and offline operator commands.
• Complete-roster weighted sampling without modulo bias, partial-rotation computation and producer-role sampling.
• Bounded full-roster collection, parent randomness, authenticated handoff, rotating execution/history replay and proof-verifier APIs; details.
• Activate VRF in the daemon: contribution gossip, complete-roster availability policy, standby signing participation, persisted handoff serving and RPC/CLI/DNS catch-up; profile and tests.
• Bounded historical committee commitments and portable offence bundles; format and selected quorum-admission policy.
• Candidate consent, protected incumbent approvals, weighted quorum certificates and offline operator CLI; details.
• Canonical evidence inclusion, active PoTB weights and quorum-authorized admission in an explicit producer profile, with atomic application execution and authenticated recovery; details.
• Activate the PoTB profile in daemon provisioning, gossip, persisted handoff serving and RPC/CLI/DNS catch-up; workflow and limits.
• Deterministic rotating-network delivery simulations with partitions, loss, delay, duplicates, invalid messages, durable restart and authenticated catch-up; scope.
• Validly signed Byzantine coalitions below the accountability threshold, membership churn crossed with delivery faults, and adverse weight concentration; scope.
• Bounded exhaustive model of agreement, lock safety, weighted accountability and bounded-round decision, conformance-tested against the production voter; bounds and limits.
• Unbounded formal safety/liveness and independent provider review.

The VRF and sampler specification distinguishes implemented selection from daemon activation.

Current progress: authenticated fixed-height vote collection separates rounds/phases/blocks, rejects equivocation and replays, and emits bounded canonical certificates. The producer can verify a trusted committee and certificate before atomic execution/state publication. Protocol details. Durable signing, monotonic decision recovery, process locking, and typed vote signing are implemented/tested. Local BFT voting, verified prevote proofs, timeout transitions, and atomic version-2 vote/lock recovery are implemented/tested, including payment execution and certified archive recovery. Signed proposals and a reference round-robin participant now coordinate authenticated proposal signing, execution, vote collection, timeout events, and atomic publication. Certified reference networking now adds daemon integration, monotonic timers, persisted available values, explicit provisioning, and certified catch-up. Verified weighted VRF selection, certified handoff and explicit rotating block execution/recovery are implemented. Genesis-v2 daemon activation, historical handoff serving and client catch-up are implemented. Formal distributed liveness and production network qualification remain open.

PoTB progress: double-vote evidence and a policy workbench now verify offences, retain durable bounded proofs and evaluate capped integer scores over finalized history. VRF collection, activation and committee handoff are implemented. Canonical evidence inclusion, active weight transitions and admission are implemented in the separate producer profile, with live daemon and client activation.

M6 — node and networking

Authenticated encrypted transport, peer discovery, rate limiting, compact blocks, finalized sync, bounded queues, stage pipelining, speculative work, external RPC, and adaptive-capacity governance.

• Prepare owned outgoing response snapshots and encode outside the daemon node lock, with byte-equivalence and snapshot-lifetime tests; scope.
• Decode incoming exchanges once in peer workers and pass owned messages through the bounded mailbox, with receive-path equivalence tests; scope.
• Integrate optional compact block propagation with owned transaction dictionaries, inline missing bodies and legacy fallback; format and scope.
• Integrate bounded detached execution, speculative candidate preparation and next-height fetch with sequential voting/publication checks; pipeline and limits.

Current progress: certified reference networking connects independent daemon processes with fixed genesis membership, signed proposals/votes, step timers, payment gossip, bounded mutually authenticated TLS 1.3 exchanges, protected journals, durable available-value recovery, and sequential certified catch-up. Local devnet generation and explicit signer provisioning are implemented. Real process tests cover quorum operation, RPC payments, restart, and late join. TLS identity validation and provisioning are implemented with independent transport keys and deadline tests. Non-voting full nodes now independently authenticate history, execute imported blocks, relay payments, serve RPC, and recover without signing authority. Scoped private-network discovery, bounded TLS sessions, local metrics and authenticated observer recovery are implemented/tested. Explicit pinned history retention is implemented. Public-network hardening and automated retention remain open. Explicit genesis-v2 rotating consensus is implemented.

M7 — ecosystem

Wallet integration and DNS registry and resolver.

Current progress: the native-payment CLI wallet derives real public identities, signs payments offline to non-overwritable files, checks signatures and policy, reads finalized accounts/status, and submits saved transactions with explicit ambiguous-outcome handling. The typed RPC client has bounded frames, strict response checks and whole-call deadlines. Encrypted wallet custody is implemented with fixed-cost Argon2id and authenticated encryption; see SDK and vaults. Certified state membership/absence queries and the on-chain DNS registry with an authenticated resolver are implemented; see state proofs and DNS. Certified receipt queries, bounded recent transaction lookup and authenticated finality waiting are implemented; see receipts.

M8 — public testnet and production gates

Distributed calibration, interoperability, long fuzz campaigns, reproducible releases, dependency review, external cryptography/consensus/runtime/security audits, key ceremonies, monitoring, incident response, and operator runbooks.

• Deterministic native archive generation, complete binary/document payloads and per-file checksums.
• Two independent native builds with byte-identity checks; Windows verified locally, Linux/Windows gates configured in CI.
• Run pinned Rust-to-WASM SDK and source-package tests in the release CI matrix.
• Provide routine operations and a bounded read-only calibration sampler with raw reports; runbook and measurement limits.
• Detached release-manifest signing over every packaged file hash, with offline verification and no invented signing identity; workflow.
• Dependency-free bounded benchmark harness and per-crate micro-benchmarks, measuring the hash, signature, VRF, codec, state, storage, execution and consensus paths whose cost was previously asserted only functionally, run on both platforms as a required CI check that verifies execution rather than any duration; method, figures and limits.
• Observe Linux and independent-machine reproducibility, and complete the release authority identity and key ceremony.

Detailed status and unresolved decisions are tracked in docs/08-implementation-status.md.

Remaining software for a closed network

Private membership does not remove the following unimplemented software work. External audits, public-testnet calibration and key ceremonies are separate release activities.

• Activate VRF and committee transitions, including restart, complete-roster unavailable-proof policy and catch-up.
• Activate the tested PoTB producer profile across daemon networking, operator provisioning and client verification.
• Connect signed deploy/call transactions to the WebAssembly runtime.
• Complete the Rust SDK host adapter.
• Complete bounded source-package tooling and exact artifact reconstruction.
• Complete mixed-lane execution, capacity/fee governance and reference execution optimizations with deterministic equivalence checks; scope.
• Qualify bounded parallel strict signature verification across every quorum path; scope.
• Add bounded state/transaction indexes and exact-height certified state proofs; details.
• Add explicit bounded history export and independently pinned recovery; operator workflow and limits.
• Add encrypted wallet custody, OS-generated wallet keys and direct vault signing.
• Add certified state membership/absence proofs and offline verification.
• Add receipt queries and transaction finality waiting.
• Implement the authenticated on-chain DNS registry and operational resolver.
• Complete scoped private-network peer discovery, bounded sessions, operational telemetry and authenticated observer recovery tooling.
• Complete fixed/rotating protocol compatibility fixtures and deterministic mutation qualification.
• Complete coverage-guided fuzzing of the protocol and contract surfaces on the local platform; measurements.
• Add an independent monotonic anchor and encrypted consensus-key custody with daemon activation; threat boundary.
• Complete remaining platform and reproducible-release qualification; the independent-machine comparator is committed and refuses same-machine reports, so what remains is a second physical machine rather than a second hosted run.

Remaining work by scope

The reference execution optimizations above do not complete the whole roadmap.

• Security-related work now has local evidence: bounded parallel strict signature verification, long deterministic and coverage-guided protocol/contract fuzz campaigns, validly signed Byzantine and churn simulations, a bounded formal model of fixed-height voting, a committed dependency/security review, anchored consensus key custody and detached release-manifest signing. What remains is work this repository cannot perform for itself: external cryptography, consensus, runtime and security audits, independent provider review of the VRF and signature backends, an unbounded formal safety/liveness argument, a release authority identity and key ceremony, and reproducibility observed on independent machines. Alternate runtime backends and automated history retention also remain unimplemented; they require runtime/metering qualification and checkpoint/signing-state recovery design respectively.
• Platform and release evidence remains external to the local Windows checks: Linux suite execution, cross-platform contract artifacts and reproducibility on independent machines. Configured CI gates do not establish observed results.
• M6 reference compact propagation and bounded stage overlap are implemented: peer fetch/decode, detached execution, node-thread voting and sequential commit. Speculation covers local candidate preparation and bounded next-height fetch; execution/voting on uncommitted descendant state is outside this reference profile. Exact behavior and bounds.
• Routine operations and calibration tooling are implemented. Actual distributed calibration, deployment-specific production acceptance and independent-machine reproducibility remain release activities. Local micro-benchmarks now measure the per-operation cost of the cryptographic, codec, state, storage, execution and consensus paths on one machine; they do not establish end-to-end throughput, operation-latency percentiles, or any figure comparable to another host. Functional equivalence and deterministic read/thread/allocation checks remain separate evidence from either; measurement limits.