HoloyZ is an open-source, developer-first toolkit for creating custom blockchain networks from templates.

This repository is organized as a Rust workspace:

• holoyz-core — typed config, cryptographic ledger, builder, and core module traits
• holoyz-cometbft — CometBFT-style BFT with rounds, nil votes, and vote-extension verification
• holoyz-evm — revm bytecode execution plus EIP-1559 account transfers
• holoyz-libp2p — rust-libp2p gossipsub + identify
• holoyz-cli — command-line interface

The first release focuses on a tight curated toolkit:

• holoyz-cometbft
• holoyz-evm
• holoyz-libp2p

That is enough to assemble a local EVM devnet end to end.

HoloyZ helps teams:

• scaffold a new chain project
• define chain behavior with typed config
• compose consensus, runtime, and networking modules
• run a local devnet
• build and deploy chain artifacts

HoloyZ uses a builder pattern rather than an open-ended plugin registry.

• ChainConfig defines the chain shape
• ChainBuilder assembles the final chain
• modules implement typed traits for consensus, runtime, and networking
• HoloyzChain runs genesis, mempool, BFT rounds, and block production

The local chain now runs production-shaped primitives instead of stub lifecycle hooks:

• Keccak-256 headers with RFC-6962 Merkle roots for transactions, receipts, application state, and a data-availability commitment
• CometBFT BFT with prevote/precommit, ed25519 validator signatures, round timeouts, nil votes, and instant finality at a strict +2/3 voting-power quorum
• ABCI++ vote extensions so each validator signs extra payload bytes alongside the precommit; signatures are verified before they are accepted
• Weighted round-robin proposers (Tendermint proposer priority); offline proposers skip the round instead of stalling an honest set
• Bonded proof-of-stake with double-sign / downtime slashing and jailing
• EIP-1559 base-fee adjustment, burned base fee, and proposer tips; the block builder ranks mempool transactions by effective priority fee
• revm executes contract create/call bytecode; native transfers stay on the account path
• Replay protection via chain ID, account nonces, and ed25519 signatures. Addresses are the last 20 bytes of keccak256(pubkey).
• libp2p gossipsub + identify for transaction gossip and bootnode dial. Consensus votes stay in-process on this node.

Faucet and validator keys are random seeds in holoyz.keys.toml (gitignored), not derived from network_id. decode_tx never auto-signs; the UI/dev operator path signs with that key file.

This is a localnet lab. The UI binds 127.0.0.1, rejects foreign Origin on mutations, and refuses 0.0.0.0 listen addresses. holoyz build and holoyz deploy are explicit stubs.

HoloyZ uses holoyz.toml at the repository root.

Example:

name = "holoyz"
network_id = "holoyz-localnet"
mode = "testnet"

[consensus]
engine = "cometbft"
block_time_seconds = 3
finality = "deterministic"
vote_extensions = true
timeout_propose_ms = 1000
max_rounds = 8

[runtime]
vm = "evm"
gas_enabled = true
chain_id = 2026
eip1559 = true
initial_base_fee = 1000000000

[network]
transport = "libp2p"
bootnodes = []
listen_addr = "127.0.0.1:30333"

[devnet]
enabled = true
validator_count = 4
full_node_count = 1

[staking]
enabled = true
min_bond = 1000
slash_double_sign_bps = 500
slash_downtime_bps = 100
jail_after_missed = 10

use holoyz_core::{ChainBuilder, ChainConfigBuilder, ChainMode, DevKeys};
use holoyz_cometbft::CometBftModule;
use holoyz_evm::EvmModule;
use holoyz_libp2p::Libp2pModule;

let config = ChainConfigBuilder::new()
    .name("holoyz")
    .network_id("holoyz-localnet")
    .mode(ChainMode::Testnet)
    .build();

let keys = DevKeys::load_or_create("holoyz.keys.toml", config.devnet.validator_count)?;
let chain = ChainBuilder::new(config)
    .keys(keys)
    .consensus(Box::new(CometBftModule::builder().build()))
    .runtime(Box::new(EvmModule::builder().build()))
    .network(Box::new(Libp2pModule::builder().build()))
    .build()?;

While the chain is running, Runtime execute accepts UTF-8 payloads or JSON transfers:

{"to":"0x…","value":1000}

cargo build
cargo test
cargo run -p holoyz-cli -- dev
cargo run -p holoyz-cli -- create my-chain
cargo run -p holoyz-cli -- ui

holoyz create my-chain writes my-chain/holoyz.toml and my-chain/holoyz.keys.toml.

holoyz dev reads holoyz.toml from the working directory, loads or creates holoyz.keys.toml, assembles the modules named in consensus.engine / runtime.vm / network.transport (cometbft, evm, libp2p), and runs HoloyzChain until Ctrl-C. Unsupported engine/vm/transport values fail instead of being ignored.

holoyz ui serves the graphical interface at http://127.0.0.1:2026 and reads/writes holoyz.toml. The same UI includes a chain explorer at /explorer and a live three.js chain space at /space.

holoyz build and holoyz deploy are stubs in v0.1.

MIT. See LICENSE.

• real multi-process devnet orchestration
• artifact build pipeline
• deploy target support