The onchain virtual miner

01Introduction

Decentralized compute networks (DePIN) already let anyone rent out a GPU and earn tokens for running AI jobs. What they treat as an afterthought is the miner itself — usually a row in an off-chain database, a key in a config file, a worker that comes and goes. Chromau inverts that: the miner is a first-class, on-chain object with its own money, its own rules, and its own economic reflex.

Concretely, a Chromau miner is a program-derived account (PDA) governed by the chromau_miner program on Solana. It holds a stake vault, claims inference tasks, is paid on verified completion, compounds automatically, and — once its vault crosses a threshold — spawns a child miner. The physical GPU that does the arithmetic is rented on demand and thrown away; it never is the miner. This is the whole thesis in one line:

1.1 Why on-chain

Putting the miner on-chain buys three things a database row can't: custody — the vault is owned by program logic, not an operator who can rug it; composability — a miner is an address other contracts can pay, stake into, or fractionalize; and autonomy — compounding and spawning are instructions anyone can crank, so the flywheel turns without a trusted server in the loop.

1.2 Contributions

• A fully on-chain miner-as-PDA model: stake, compute-credit, lineage and slashing state all live in one account (§2).
• A self-compounding flywheel that reinvests verified rewards and spawns new miners geometrically (§3).
• A set of load-bearing seed functions — determinism, commit-reveal, and VRF dispatch — that make verification and anti-Sybil actually hold (§4).
• A burn-mint work-token anchored to external paid demand, not emissions (§6).

02The Virtual Miner

Each miner is one PDA, seeded by its owner's key. The account is small, deterministic, and entirely describes the miner's economic state — there is nothing off-chain to trust about who the miner is or what it holds.

// PDA seeds: ["miner", authority]
pub struct MinerNode {
  authority:   Pubkey,   // owner
  vault:       Pubkey,   // stake token account (program-owned)
  stake:       u64,      // locked $CHROMAU
  credit:      u64,      // compute credit = ⌊√stake⌋
  generation:  u8,       // lineage depth (0 = root)
  parent:      Pubkey,   // spawner
  tasks_done:  u64,
  slashed:     bool,
  last_slot:   u64,
}

Compute credit is the miner's economic weight — the size of task it may claim and the number of replicas it may serve. It is deliberately concave in stake, credit = ⌊√stake⌋, so that doubling stake does not double influence. This blunts winner-take-all dynamics and makes Sybil-splitting stake into many nodes economically neutral rather than advantageous.

03The Flywheel

The reflex that makes a Chromau miner interesting is that it compounds itself. Every verified settlement mints a reward net of a burned requester fee; the net is auto-restaked into the vault; stake up means credit up (√stake) means it can claim bigger jobs — and so on. When the vault crosses a spawn threshold θ, the miner splits off a child seeded with half its stake, and θ grows ×1.6 per generation. The colony expands geometrically.

3.1 Compounding & spawning

// per settled task, for miner m
gross   = m.credit * task_reward            // credit = ⌊√stake⌋
burn    = gross * fee_bps                    // requester demand → burned
net     = gross - burn
m.stake = m.stake + net                      // auto-compound
m.credit = isqrt(m.stake)

if m.stake >= theta:                          // spawn threshold
    child = spawn(seed = derive(m.key, m.spawn_nonce),
                  stake = m.stake / 2)
    theta = theta * 1.6                       // geometric ladder

04Seeds & Determinism

Verification is only meaningful if the same job produces the same bytes on every honest machine. AI inference is not deterministic by default — floating point, sampling, and GPU kernel scheduling all drift. Three seed functions turn that chaos into something a contract can check. These are load-bearing, not decoration: remove any one and verification or Sybil-resistance collapses.

4.1 · determinism seed

A per-task seed pins every source of nondeterminism so all replicas emit byte-identical output. Their result hashes can then be compared directly.

seed = keccak256( task_id ‖ input_hash ‖ model_id ‖ epoch )

// seed fixes: weights hash · dtype/quant · sampler RNG · deterministic kernels
result      = infer(input, seed)
result_hash = keccak256(result)      // this is what consensus compares

4.2 · commit-reveal seed

If a replica could see another's answer before submitting, it would simply copy it. Each node commits a hash of (result ‖ nonce) first; only after all commits land does it reveal. Nobody can plagiarize what they can't see.

4.3 · VRF dispatch seed

A miner must not choose which tasks — or which co-replicas — it serves, or it could surround a task with its own Sybils and self-attest. Assignment is drawn from a verifiable random function seeded by an unpredictable recent slot hash.

replica_set = VRF( recent_slothash ‖ task_id )   // unpredictable, yet verifiable

4.4 · spawn seed

Lineage is deterministic and auditable: a child's address derives from its parent plus a spawn counter, so the whole colony tree can be reconstructed from chain state alone.

child_pda = PDA([ "miner", parent_pubkey, spawn_nonce ])

05Verification

Chromau ships the cheapest guarantee that works today and treats stronger ones as a staged upgrade — the interface (a result_hash plus a proof) stays the same as the proof system underneath it hardens.

1  claim_task    bid accepted, stake bonded, escrow locked
2  infer         GPU limb runs infer(input, seed)  → keccak256
3  consensus     N replicas commit-reveal; hashes must agree (e.g. 3/3)
4  settle        agree → mint reward, burn fee, release escrow
                 disagree → slash minority, re-dispatch via VRF
5  compound      net auto-restaked; credit recomputed

5.1 Today: redundant consensus

N independent replicas run the deterministic job and commit-reveal their result hashes. Agreement finalizes and pays; a dissenting minority is slashed and the task is re-dispatched. Simple, cheap, and robust as long as an honest majority of a VRF-drawn replica set is likely — which the concave credit curve and staking cost are designed to ensure.

5.2 Roadmap: zkML

Redundancy pays for verification with duplicated compute. The end state replaces step 3 with a succinct zkML validity proof: the miner proves the published hash is the correct output of model_id on input_hash under the pinned seed, and a single verifier check replaces the replica quorum — no re-execution, no trusted majority. Proving cost is why this is a research track and not the default today.

06Tokenomics

$CHROMAU is a work-token, not an emissions faucet. It is the unit compute is priced, paid, and bonded in — its value is meant to track real demand for verified inference, not the pace of inflation.

6.1 Fair launch

$CHROMAU launches as a fair launch on pump.fun — permissionless, with no presale, no team pre-mine, and no insider allocation set aside. Everyone enters on the same terms, and that property is verifiable on-chain. The launch is a rallying point for people who share the thesis, not a fundraise: the work-token mechanics above (§6) describe the direction the network is being built toward, not a utility the freshly launched token already carries.

07Architecture & Specs

08Security

• Sybil / self-collusion. VRF dispatch (§4.3) stops a miner from surrounding its own task; concave √stake credit makes splitting stake across fake nodes economically neutral.
• Answer-copying. Commit-reveal (§4.2) hides results until all replicas are committed, so consensus can't be gamed by plagiarism.
• Fake work. Determinism (§4.1) makes "did you actually run it" objectively checkable; mismatches slash. zkML (§5.2) makes it provable outright.
• Reflexive collapse. The burn-mint / stake design ties token value to external demand, not emissions — the only real defense against a death spiral.

09Roadmap

• Phase 1 — localnet loop (now). chromau_miner PDA, escrow & settlement, redundant-consensus verification, auto-compound and spawn. Prove the closed loop: submit result → on-chain pay → restake → spawn.
• Phase 2 — real limbs & devnet. Swap the sim for real deterministic inference on GPUs; add stake/slash and VRF dispatch; deploy to devnet.
• Phase 3 — verifiable compute. Replace the replica quorum with zkML validity proofs for the hot task classes.

10Disclaimers

Chromau is a research prototype under active development. Nothing here is financial, investment, or legal advice, nor an offer to sell or solicitation to buy any token. $CHROMAU is a fair-launch community token on pump.fun — not a security, not equity, and not a promise of return; the protocol mechanics described here are a research direction, not a utility the token already carries. Forward-looking statements about the protocol's direction are subject to change.