Mining EVMORE on a consumer GPU: a practical setup guide

This is the post I wish I had when I tried to set up an EVMORE miner for the first time. It assumes you have read the KeccakCollision explainer — you know roughly what the algorithm asks you to do — and you want to actually run it on hardware you own.

I will use a single RTX 4070 as the reference machine throughout. Other GPUs work; I will call out the deltas.

Hardware sizing

The performance profile of KeccakCollision is bandwidth-bound on random memory access. That means:

• GPU memory bandwidth matters more than shader count. A 4070 (504 GB/s) and a 4080 (716 GB/s) differ by roughly the bandwidth ratio at the same difficulty, not by the shader-count ratio.
• GPU memory capacity matters more than core count. You want the collision table to fit in VRAM. At 16-bit difficulty, a few hundred MB suffices.
• PCIe bandwidth almost does not matter. The miner is GPU-resident after initial load.

What works comfortably as of writing:

Tier	GPU class	Notes
Entry	RTX 3060 / RX 6600	Find first solution in ~5-15 min at launch difficulty
Mid	RTX 4070 / RX 7800 XT	Comfortable headroom, table fits easily
High	RTX 4090 / Radeon Pro	Multi-instance per GPU possible
CPU-only	Modern Ryzen with DDR5	Surprisingly competitive at low difficulty

You do not need datacentre hardware. You probably do not even need a second card. A single consumer GPU is the design point.

Software installation

The reference miner builds for CUDA and OpenCL live in the evmore repository. On a fresh Ubuntu 24.04 box:

# Prerequisites
sudo apt update
sudo apt install -y build-essential git cmake pkg-config libssl-dev
# NVIDIA: install CUDA 12.4 from NVIDIA's apt repo
# AMD: install ROCm 6.x from AMD's apt repo

# Clone
git clone https://github.com/cryptuon/evmore
cd evmore/mining

# Build (CUDA path; OpenCL path is `make opencl`)
make cuda

# Sanity check
./build/evmore-miner --benchmark

The --benchmark flag runs a short self-test against a fixed challenge and reports hashes-per-second and expected time-to-solution at the current network difficulty. On a 4070 you should see roughly 180-220 MH/s of Keccak throughput plus the collision-table lookups. The exact number does not matter; what matters is whether the time-to-solution estimate looks sane.

Miner configuration

A minimal config.toml:

[wallet]
# The Ethereum address that will receive rewards
address = "0xYourEthereumAddressHere"

[rpc]
# Any Ethereum RPC will do. Public RPCs work for low volume;
# paid RPCs (Alchemy, Infura, QuickNode) are recommended at scale.
endpoint = "https://eth-mainnet.example/v1/YOUR_KEY"

[mining]
# Number of GPU threads. Default = device count.
threads = 1
# Collision table size in MB. Increase if you have headroom.
table_mb = 256
# Resubmit interval -- how often to refresh the challenge.
refresh_seconds = 10

[submit]
# Gas price ceiling. Solutions that would cost more in gas
# than the reward is worth are dropped.
max_gwei = 30

Three settings deserve special attention:

max_gwei. Submitting a solution costs gas. At very high gas prices on Ethereum mainnet, a single solution submission can cost more than the reward it returns. The miner will drop solutions when the gas price exceeds this ceiling. Set it to something that matches your willingness to pay for opportunity cost.

refresh_seconds. When a new block is mined, the network challenge changes, and your in-progress collision table becomes stale. A short refresh interval costs you in-flight work but ensures you are always mining against the current challenge.

table_mb. Bigger tables mean more in-flight candidates, which means slightly higher probability of finding a 4-collision per unit time. Diminishing returns kick in quickly; 256 MB is usually plenty.

Running it

./build/evmore-miner --config config.toml

You should see output like:

[2026-04-04T13:21:09Z INFO  evmore_miner] device=0 (NVIDIA GeForce RTX 4070)
[2026-04-04T13:21:09Z INFO  evmore_miner] challenge=0x4f3a... difficulty=16 epoch=128
[2026-04-04T13:21:09Z INFO  evmore_miner] mining at 198.4 MH/s; ETA to solution: ~6m13s
[2026-04-04T13:27:42Z INFO  evmore_miner] SOLUTION FOUND: 0xae21... pattern=0x9c41
[2026-04-04T13:27:42Z INFO  evmore_miner] submitting tx: gasPrice=22 gwei estCost=$0.71
[2026-04-04T13:27:51Z INFO  evmore_miner] submission accepted: block=21934002 epoch=128

When you see “submission accepted,” the verifier accepted your proof and recorded you in the current epoch.

Claiming rewards

EVMORE uses an epoch-based claim model. When you find a solution, you are recorded in the current epoch. After the epoch closes (every 144 blocks at the 10-minute target — roughly daily), you call claimReward() to mint the EVMORE tokens you earned.

The reference miner does this automatically:

./build/evmore-miner --config config.toml --auto-claim

--auto-claim polls the contract for epochs in which you have recorded solutions and submits the claim transaction when the epoch closes. Each claim costs gas. The miner batches multiple epochs into a single claim transaction when possible to amortise the gas overhead.

Alternatively, you can claim manually:

# From the repo root, using ape
uv run ape console
# In the console:
>>> token = EvmoreToken.at("0x...")
>>> token.claimReward(epoch=128, sender=accounts.load("miner"))

What if I do not find a solution

At the launch difficulty (N=16), the expected time-to-solution on a 4070 is on the order of minutes. If your miner has been running for hours without a solution:

• Check the challenge is current. A stale challenge means you are mining against a snapshot the network has already moved past.
• Check refresh_seconds. If it is set too long, you may be working on an out-of-date challenge.
• Check the RPC endpoint. A flaky RPC produces stale challenge data.
• Check difficulty. If the network difficulty has risen significantly since launch (more miners online), the expected time stretches accordingly.
• Check thermals. A throttled GPU does much less work per second. nvidia-smi or rocm-smi will tell you.

The benchmark mode is the diagnostic. Run --benchmark periodically. If the reported throughput is roughly half of what your card should be doing, the problem is usually thermal or driver.

What if my proof gets reverted

If you see:

[ERROR] proof rejected: revert: solution already submitted in earlier epoch

This is the global uniqueness check firing. Some other miner found the same 4-collision before you. This is rare at low difficulties because the search space is enormous, but it does happen when many miners are working on the same challenge. There is no recovery — the solution is burned. Move on.

If you see:

[ERROR] proof rejected: revert: ascending order violated

This is a bug in your miner. The four values must be sorted in strictly ascending order as uint256. The reference miner does this correctly; if you have modified it, check your sort.

What if I want to pool

The reference miner is solo by default. Pool mining requires a pool contract — a smart contract that escrows the reward, accepts proofs from multiple miners, and pays out by proof attribution. Several community pool contracts exist; consult the Discord for the current list. The pool contract abstraction is one of the things that becomes natural because EVMORE mining is verified on-chain: pools can verify proof shares from members directly.

What about taxes

Self-mined assets create a tax event in most jurisdictions at the moment of receipt (when claimReward mints to your address), at the fair market value at that moment. Future disposal is a separate capital-gains event from that basis. The reference miner logs every successful submission and claim with timestamp and tx hash; this log is useful for tax accounting. Talk to an accountant familiar with crypto self-mining for your jurisdiction.

The bottom line

Mining EVMORE on a single consumer GPU is meant to be a weekend project, not a capital expenditure. The hardware is what you already own. The software is one make away. The first solution comes in minutes, not hours.

If you do nothing else, run the benchmark. It tells you whether your hardware is going to be competitive without committing you to anything. Then decide.