1
Miner (off-chain)
Reference CUDA / OpenCL / CPU miner searches for four 32-byte values whose Keccak-256 hashes collide on the lowest N bits against the current challenge.
Architecture
The search is expensive. The proof is tiny.
EVMORE splits mining into two halves. Finding a KeccakCollision is bandwidth-heavy work done off-chain by GPUs and CPUs. Verifying it is four hash operations done on-chain by a 62-line Vyper contract. That asymmetry is what makes proof-of-work affordable to settle inside the EVM.
Data flow
┌──────────────┐ challenge, N ┌────────────────────┐
│ Ethereum │ ───────────────▶ │ Miner (GPU/CPU) │
│ contract │ │ KeccakCollision │
│ state │ ◀─────────────── │ search (off-chain)│
└──────┬───────┘ 4 sorted vals └────────────────────┘
│
▼
┌────────────────────────────┐
│ Verifier.vy (62 lines) │ re-hash × 4, mask low N bits,
│ ascending? unique? │ reject replays across epochs
└──────────────┬─────────────┘
│ valid
▼
┌────────────────────────────┐ supply < 21M ?
│ Token.vy (ERC-20 mint) │ ─────────────────▶ reward → miner
└──────────────┬─────────────┘
│ fees
▼
┌────────────────────────────┐ 1k / 10k / 100k thresholds
│ Treasury + Bridge stages │ ─────────────────▶ unlock roadmap
└────────────────────────────┘ The four layers
2
Verifier contract (on-chain)
62-line Vyper contract re-hashes the four submissions, masks the lowest N bits, and confirms ascending order + global uniqueness. Four Keccak ops and a handful of comparisons.
3
Token contract (on-chain)
On a valid proof, the mint function checks total supply against the 21M cap and issues the current block reward as a standard ERC-20 transfer.
4
Treasury + bridges (on-chain)
Mining fees accumulate in a transparent treasury. Bridge and federated-mining stages unlock deterministically at encoded thresholds (1k / 10k / 100k EVMORE).
Why the verifier is only 62 lines
All the computational work of mining happens in the search. By the time a miner has four values that collide, verifying them is trivial: re-hash each value against the challenge, mask off everything but the lowest N bits, and confirm they all match. Add a check that the four values are in ascending order (a canonical form that prevents trivial re-orderings) and a uniqueness check across epochs (to block replay), and you are done.
That is why the verifier fits in 62 lines of Vyper and costs a bounded amount of gas regardless of how hard the underlying search was. Difficulty scales by widening N — the number of colliding bits — not by making verification more expensive.
Difficulty and block time
EVMORE targets a ~10-minute block time and retargets difficulty every 2,016 blocks, mirroring Bitcoin's retarget window. As aggregate hashrate rises, the required collision width N increases, making valid collisions rarer and holding the block interval steady.
The 10-minute target is a deliberate choice for Ethereum: it keeps on-chain verification infrequent and cheap, rather than optimizing for raw throughput. EVMORE is built to make a verifiable, fair distribution affordable to settle on-chain, not to be a high-TPS payment rail.
Read the contracts. Run the miner.
Everything above is enforced in Vyper you can read and a miner you can run today.