Most blockchains use randomness through oracles, commit-reveal schemes, or trusted committees. EntropyChain bakes verifiable, unbiasable entropy into the consensus layer itself. Every block contributes a public seed derived from its proof-of-work — usable directly by smart primitives like random NFT mints and on-chain lotteries.
CPU-mineable. Argon2id-based. Open and live on testnet.
EntropyChain is built for CPU mining. Argon2id makes GPUs and ASICs only marginally faster than commodity processors, so a regular machine at home contributes meaningfully to network security and randomness — not just heat.
Run the desktop miner, generate a wallet, and start earning real testnet ENTRO. Multi-account support, send/receive, and token creation all built in.
Most chains pick one of these. EntropyChain insists on all three because none of them works as well in isolation: trustless randomness needs decentralized hashrate, decentralized hashrate needs CPU-friendly mining, and CPU-friendly mining needs a memory-hard hash.
Mining uses Argon2id, the PHC competition winner.
ASIC and GPU acceleration give a much smaller advantage than against
SHA-256 — the bottleneck becomes DRAM bandwidth, not silicon.
A laptop can mine. That's the point.
Every block commits a seed e_i = H(prev_hash ‖ miner_nonce)
covered by the proof-of-work. Anyone can verify the derivation from
public block data alone. The chain itself is a public randomness
beacon — no separate VDF, no oracle, no committee.
Transactions like nft_random_mint and
lottery_draw consume the beacon directly. No smart
contracts. No oracle integrations. The protocol enforces fair
derivation; verification is a single hash recomputation.
The end-to-end path from block production to verifiable trait derivation on a minted NFT — every step is deterministic, every input is public.
Miner picks a 16-byte miner_nonce, computes
e_i = sha256(prev_hash || miner_nonce), then searches
for an Argon2id PoW solution. The seed is committed in the header.
Peers verify the proof-of-work, which simultaneously verifies
e_i was correctly derived. The seed becomes
permanently queryable at /rpc/entropy/{height}.
User specifies collection, token_id, and a past
entropy_height. The seed at that height is the source
of randomness for trait derivation.
For each trait j:
trait_j = f_j(sha256(e_i || collection || token_id || tag_j)).
Same inputs always produce the same traits. Anyone can recompute.
The NFT records its source block height. Future inspectors can verify nothing was cherry-picked: the source seed was committed before the mint transaction was even constructed.
Both fully on-chain. No oracles. No committees. No off-chain computation. Each is a single transaction type the protocol enforces directly.
Mint an NFT whose traits are deterministically derived from a referenced block's entropy. The minter cannot pick traits. The chain cannot lie about traits. Every property is reproducible from public data.
Create a lottery with a future draw_height. Tickets bought
until that block. Winner deterministically selected from the seed
at draw_height. Prize transferred natively, no escrow contract.
Free, public, no registration. Spin up a wallet in the browser, request testnet ENTRO from the faucet, mint a random NFT or run a lottery. Verify everything you do on the explorer.