RIP-200: The Round-Robin Consensus That Lets Every CPU Vote Once

No hash race, no staking lottery. RustChain's block producer is just a modulo operation — and that's the point.
When a network's whole gimmick is "old hardware outearns new," its consensus can't be a hash-power race — a 2003 PowerBook would lose to any modern GPU within seconds, and the entire economic design collapses. So RustChain doesn't race. Its consensus, RIP-200, replaces the usual VRF lottery with a deterministic round-robin: each attested CPU gets exactly one turn per rotation cycle, regardless of how fast or slow it is.
1 CPU = 1 Vote
The core rule is deliberately boring:
Deterministic rotation — the block producer for a given slot is chosen by slot % num_attested_miners
Equal opportunity — every attested CPU gets the same number of production turns
Anti-pool design — more miners means smaller individual rewards, so there's no incentive to spin up farms
Time-aging decay — vintage multipliers decay 15% per year, rewarding early participants
Hash power doesn't buy you anything. Owning one attested machine gets you exactly one vote in the rotation.
The epoch lifecycle
Every epoch runs through four phases:
ATTEST (24h) -> VALIDATE (ongoing) -> PRODUCE (10min) -> SETTLEMENT

Attest — miners prove their hardware identity through the fingerprinting system.
Validate — attested miners continuously validate blocks.
Produce — the round-robin schedule picks producers in deterministic order.
Settlement — rewards are weighted by time-aged antiquity multipliers, credited to balances, and the ledger is anchored to Ergo.
Block producer selection, in code
def get_round_robin_producer(slot: int, attested_miners: List) -> str:
"""
Deterministic round-robin block producer selection.
Each attested CPU gets exactly 1 turn per rotation cycle.
"""
if not attested_miners:
return None

# Deterministic rotation: slot modulo number of miners
producer_index = slot % len(attested_miners)
return attested_miners[producer_index]

That's the entire election. No randomness, no lottery tickets, no "lucky miner" — a schedule any node can verify. If there are 100 attested miners, miner #0 produces slot 0, 100, 200…; miner #42 produces 42, 142, 242… Everyone knows who's next, which makes the consensus auditable by construction.
Rewards are weighted, not equal
Equal turns, but unequal payouts — that's where the vintage economics kick in. Settlement distributes the epoch reward proportionally to each miner's time-aged antiquity multiplier:
def calculate_epoch_rewards(miners, total_reward, chain_age_years):
weights, total_weight = {}, 0.0

for miner_id, device_arch, fingerprint_passed in miners:
    if not fingerprint_passed:
        weight = 0.0          # VMs/emulators get ZERO
    else:
        weight = get_time_aged_multiplier(device_arch, chain_age_years)

    weights[miner_id] = weight
    total_weight += weight

return {
    miner_id: int((weight / total_weight) * total_reward)
    for miner_id, weight in weights.items()
}

Two things stand out:
Failed fingerprint = zero. A VM or emulator gets no share at all — the anti-farm guarantee is enforced in the payout math, not in policy.
Multipliers carry over into rewards. The same 2.5× a G4 gets in the multiplier table becomes 2.5× the weight in settlement. So a G4's turn in the rotation is worth 2.5× a modern chip's turn.
How it compares to the alternatives
Consensus
Who gets to produce
Farming countermeasure
Hardware incentive
Proof-of-Work
Hash-power race
None (more hashrate = more power)
Newest/fastest wins
Proof-of-Stake
Stake-weighted lottery
Stake slashing
Richest wins
RIP-200
Deterministic rotation
1 CPU = 1 vote + fingerprint gate
Oldest authentic wins

PoW's countermeasure to centralization is more computation — which is the problem, not the fix. RIP-200's countermeasure is attestation: the network only admits devices that pass the 6-layer fingerprint, and among those, each gets one vote in the rotation. To dominate the schedule you'd have to acquire thousands of physically distinct vintage machines and pass fingerprinting on each — the most expensive attack in crypto, aimed at the least profitable reward.
The 24-hour attestation matters
The ATTEST (24h) phase isn't ceremony. Every epoch, miners re-prove hardware identity — oscillator drift patterns, cache timing, thermal entropy, instruction jitter — so a device that was real last week but got replaced by a VM this week is caught at the next attestation boundary and weight-zeroed. Continuous re-attestation is what makes the "banned tier" a state, not a one-time check.
Why this design is coherent
RustChain isn't trying to be faster than PoW or fairer than PoS — it's trying to make preservation economically rational. A round-robin schedule means your machine's income is a function of what it is (its attested identity and antiquity tier), not how much electricity you feed it. A 486 in a closet can earn more per turn than a Threadripper in a data center, and the network doesn't need to out-mine anyone to stay secure — it just needs honest attestation, which the 6-layer fingerprinting provides.
Bottom line
RIP-200 is the quiet engine underneath RustChain's loud premise. It's a modulo operation, a weighting function, and a settlement schedule — none of it clever, all of it auditable. That's exactly what you want from money: boring to run, impossible to game. The consensus doesn't fight Sybil attacks with raw compute; it prices identity honestly and lets physics do the policing.
Whitepaper: Proof-of-Antiquity (DOI 10.5281/zenodo.19442753) · Network: rustchain.org · Code: github.com/Scottcjn/Rustchain