Phantom.Coin – an absolutely deterministic, rule-based L1 (DAG + aBFT, eUTXO). First building block of an open ecosystem.
Summary: Phantom-Coin is the starting point of a larger open-source ecosystem on GitHub. The L1 combines PoW solely for issuance with a leaderless DAG + aBFT engine (O(1) finality), no Unix time in the protocol/consensus path, uses eUTXO (open to smart-contract predicates), and ships QUIC-P2P plus Prometheus/Grafana observability. The architecture is causal, absolutely deterministic, and rule-based (same inputs ⇒ same outputs).
I am not a programmer; the coin belongs to the community — nobody controls this network.
Naming note: “Phantom-Coin” is just a working title I used for the project — I couldn’t think of a better name 😅. The name is not final and can be changed by the community.
⸻
What’s already in place
* Consensus & ordering: Leaderless DAG + aBFT with O(1) finality; total order e.g. via (consensus_time, event_id). No Unix time in the consensus path (time is UI/logs only).
* Issuance & monetary policy: PoW for issuance only, with a hard supply cap.
* State model: eUTXO (predicates v0), no EVM in the hot path → open to custom smart-contract logic on an eUTXO basis. The community will decide whether smart contracts are enabled on L1.
* Networking & ops: QUIC-P2P, Tokio async, Prometheus metrics, Grafana dashboards, Docker-Compose & scripts for localnet/observability.
* Determinism & rules: Fees/payouts and finality follow fixed, deterministic rules (including compact vote masks). The DAG’s causality enforces reproducible decisions.
⸻
Tests & benchmarks (public CI)
* CI/Actions: Workspace/unit tests, Criterion benches (short/nightly), bench aggregation & regression gate (p50/p95 tolerances), fuzz-smoke (codec/types/P2P) with seeds/corpora.
* Artifacts: Aggregated bench results (criterion_agg.) and raw data (criterion_raw.) are produced per run — transparent, reproducible, and baseline-comparable.
⸻
Minimum hardware requirement
* Runs on Raspberry Pi 5; recommended: 8 GB RAM (or more) and a 64-bit Linux.
* Asynchronous, multicore-friendly design (Tokio) — the project intentionally targets Pi-5-class hardware as a first-class platform.
⸻
How we work & governance
* Absolutely deterministic & rule-based: Same inputs ⇒ same outputs; no wall-clock heuristics in consensus.
* Fully decentralized: No one (not even me) controls the network. Decisions (e.g., enabling smart contracts on L1) are made by the community.
* Ecosystem start: This repo is the first building block; additional components (wallets, bridges, tools) will be built modularly alongside it. Code is on GitHub.
⸻
Looking for experts to harden the code & reach production readiness
Core & security
* DAG/aBFT researchers: safety/liveness proofs, adversarial models, finality rules.
* Formal methods: TLA+ / Coq / Isabelle — invariants and model-checking for consensus & eUTXO transitions.
* Cryptography: hash/sig primitives (e.g., BLAKE3/Ed25519), domain separation, Merkle payout root, constant-time audits.
Networking & performance
* QUIC/libp2p: transport tuning, congestion control, peer scoring, NAT traversal, latency/throughput optimization.
* Rust systems/async: zero-copy paths, locking strategies, backpressure, unsafe audits.
* Storage/DB: fsync/WAL strategies, LSM tuning (e.g., RocksDB backends), crash consistency & snapshots.
* Mempool/proposer: fairness under conflicts, spam/MEV resistance, deterministic ordering.
* Performance engineering: Criterion benches, regression gates, baseline comparisons.
* Fuzzing & differential testing: codec/types/P2P with seeds/dictionaries; sanitizer builds.
* Observability/SRE: Prometheus instrumentation, dashboards, alerting, SLOs.
⸻
Get involved
* Read the code, check CI runs/artifacts, open issues/PRs, run benches/fuzz locally, and propose parameters.
* Experts in the areas above are especially invited to harden the code and push toward production readiness.
