Protocol

How the chain works.

Equium is a single Solana program that runs a proof-of-work round every minute or so. Miners race to find an Equihash 96,5 solution whose hash falls under the current difficulty target. The first valid solution closes the round and mints 25 EQM to the winner.

Round lifecycle

Each round is identified by a monotonically increasing block_height. When a round opens, the protocol records a challenge (32 bytes) derived from the previous round's challenge, the last winner's pubkey, and the slot hash at the open slot. Miners take that challenge plus their own pubkey and the block height as the input to Equihash, then search nonces until they find a valid solution whose SHA-256 falls under the current target.

The first miner to land a valid mine transaction in the round wins it. The program verifies the Equihash solution, checks the hash against the target, transfers the reward from the program vault to the winner's associated token account, and opens the next round.

Empty rounds

If no valid solution is submitted in a reasonable window, anyone can call advance_empty_round to close the round without a winner. The reward for that round stays in the vault and is never minted. Empty rounds permanently reduce circulating supply below the 21M cap.

Equihash 96,5

Equihash is a memory-hard proof-of-work designed by Biryukov and Khovratovich. The (n, k) parameters are tunable; we use (96, 5) because it solves quickly on commodity CPUs (~50 MB working set, sub-second per attempt) while remaining hostile to GPU/ASIC speedups.

Each attempt asks the miner to find 2^(k+1) = 64 indices into a Blake2b-derived hash table that satisfy a tree of XOR cancellations. Verifying a solution is roughly O(k · 2^k)— fast enough to fit comfortably inside Solana's compute budget.

Why memory-hard?

Memory-bound PoW resists ASIC and GPU optimization because the bottleneck is RAM bandwidth, not arithmetic throughput. A 32-core workstation has a measurable but linear advantage over a laptop; a $40k GPU farm does not have an exponential one.

I-block layout

The 81-byte input to Equihash (called the I-block) is constructed deterministically from the round state and the miner's pubkey:

offset  len  field
0       9    b"Equium-v1"           personalization
9       32   current_challenge      from EquiumConfig
41      32   miner_pubkey
73      8    block_height (LE u64)

The Wagner search loop hashes I-block || nonce into the initial Blake2b state per attempt. Including the miner's pubkey in the input is what makes solutions non-transferable: a captured solution replayed by a different wallet produces a different I-block and fails verification.

Target & retargeting

The current target is a 32-byte big-endian unsigned integer stored in EquiumConfig.current_target. A solution wins if sha256(soln_indices || I-block) < target when both are interpreted as 256-bit big-endian numbers. Lower target means harder.

Every 60 blocks the protocol retargets. It compares the actual elapsed time since the last retarget against the target window (3,600 seconds, since 60 blocks at 60 seconds each is one hour) and scales the target:

new_target = old_target * actual_seconds / target_seconds

The ratio is clamped to [0.5x, 2x] per retarget — the same convention Bitcoin uses, with damping tuned for the smaller 60-block window. This keeps difficulty responsive to real hashrate changes without overshooting in either direction.

Emission schedule

Block reward starts at 25 EQM per block and halves every 378,000 blocks. At a one-minute target, that's roughly one halving every 8.6 months. The first four eras:

Era	Reward / block	Approx. start	Cumulative supply
`Era 1`	25 EQM	Genesis	0 → 9,450,000
`Era 2`	12.5 EQM	~Month 9	9,450,000 → 14,175,000
`Era 3`	6.25 EQM	~Year 1.7	14,175,000 → 16,537,500
`Era 4`	3.125 EQM	~Year 2.6	16,537,500 → 17,718,750

Roughly 99% of the mineable supply is produced within the first decade. The schedule asymptotes toward — but never reaches — the 21,000,000 cap. The premine is 10% (2.1M); the mineable portion is 18.9M.

On-chain accounts

The program manages two PDAs and a config-defined mint:

PDA	Seeds	Purpose
`EquiumConfig`	`["equium-config"]`	Round state, target, equihash params, halving counters, last winner.
`Mineable vault`	`["equium-vault"]`	Program-owned token account that custodies the 18.9M mineable supply. Funded once at launch via fund_vault.

The mint itself is pre-created off-chain by the deployer and referenced by the config. This separation means the program never needs mint authority — it only moves tokens out of the vault — which keeps the cap enforcement at the SPL Token level regardless of program upgrades.

Instructions

Name	Caller	Effect
`initialize`	Admin (once)	Creates the config PDA with the given Equihash params and initial target.
`fund_vault`	Admin (once)	Transfers the mineable supply into the vault PDA. Opens mining.
`mine`	Anyone	Submits a nonce + solution. On success, transfers reward to caller, advances height, and derives the next challenge.
`advance_empty_round`	Anyone	Closes a stalled round without minting. Caller pays the tx fee.
`retarget`	Anyone	Triggers difficulty adjustment if the 60-block window has elapsed.
`renounce_admin`	Admin (once)	Permanently drops admin powers. Called at launch.

Security properties

Front-running resistance. Solutions are bound to the miner's pubkey via the I-block. A mempool observer cannot replay a winning nonce from their own wallet.
Cap immutability. Mint authority is revoked before the public launch. The protocol can only move tokens out of its vault, never create new ones.
Round atomicity. Each round opens, mints once, and closes within a single Solana transaction. There is no multi-step state that can desync.
No admin backdoors after launch. Once renounce_admin runs, no further privileged operations are possible — including parameter changes.