How exfer mining works

Exfer uses Argon2id as its proof-of-work function. Unlike SHA-256 (Bitcoin) which is fast and cheap to ASIC, Argon2id is memory-hard — each hash attempt requires reading and mutating a large block of RAM, which makes custom hardware much less of a runaway advantage.

The high-level shape: you pick a nonce, compute Argon2id over the block header, and check whether the result meets the current difficulty target. If not, increment the nonce and try again. The miner that finds a valid hash first publishes the block and claims the coinbase reward.

Parameters at a glance

Hash rate expectations

Argon2id is memory-bandwidth bound, not CPU-bound. Two things determine your throughput:

1. Cache-line throughput / memory bandwidth — DDR4-3200 dual channel is meaningfully faster than single-channel DDR3.
2. Resident memory available — each concurrent attempt needs 64 MiB. A box with 1 GB of RAM can run roughly 8–10 concurrent attempts before thrashing.

Realistic rough numbers per machine (single thread, very rough order of magnitude):

Multi-threading multiplies linearly until memory bandwidth saturates.

What you actually earn

For now, every mined block pays the full coinbase reward (currently ~100 EXFER per block, halving every ~2 years) plus the sum of transaction fees in the block. The probability of any single attempt finding a block is roughly (your_hash_rate) / (network_hash_rate).

Network hash rate fluctuates. To check what's plausible right now:

1. Look at recent blocks via get_block in the RPC explorer — note the timestamps and difficulty.
2. Compare your local attempts/sec against the implied network rate.
3. Solo mining at < 0.1 % of network hash rate means months between blocks on average. Consider pool mining for steady smaller payouts.

Why CPU, not GPU?

GPUs are good at parallel computations with little memory per worker. Argon2id flips that — it wants lots of memory per worker, with random access patterns. GPUs do exist for Argon2id but the speedup over commodity DDR4 CPUs is far smaller than for SHA-256 (where it's ~10⁴×).

ASICs for Argon2id are theoretically possible but economically unattractive at Exfer's scale today.

Reward schedule

Block rewards follow exponential decay rather than the Bitcoin-style step halving:

reward(h) = max(MIN_REWARD, INITIAL_REWARD * exp(-ln(2) * h / HALF_LIFE))

with INITIAL_REWARD = 100 EXFER, MIN_REWARD = 1 EXFER, HALF_LIFE = 6 307 200 blocks.

In practice the reward halves every ~2 years and asymptotes at 1 EXFER per block. For the precise emission formula see Protocol specification §11.

Next

• Solo mine — the exact command, plus running it as a service.
• Pool mining — when solo doesn't make sense.