Why Proof-of-Antiquity is Harder to Game Than Token-Based Bounties

Every token economy has a question it has to answer: what does it cost to cheat?

For most token-based bounty platforms -- especially the crop of Solana bounty tokens that appeared in 2025 -- the answer is uncomfortable. Buy tokens on a DEX, spin up a few GitHub accounts, submit AI-generated pull requests, and collect rewards. The 80%+ rejection rate these platforms report is not a sign of healthy moderation. It is a measurement of how cheap the attack surface is.

RustChain takes a different approach. It is a DePIN (Decentralized Physical Infrastructure Network) project that rewards real, physical compute hardware. To mine RTC tokens, you need actual silicon -- and the older and more exotic that silicon is, the higher your rewards. We call this Proof-of-Antiquity.

This article compares the cost of attacking both models.

The Token-Bounty Attack: $50 and an Afternoon

A typical Solana-based bounty token works like this:

1. Project mints a token with a fixed supply.
2. Bounties are denominated in that token.
3. Contributors submit PRs to earn tokens.
4. Tokens trade on a DEX, giving them a spot price.

The attack:

• Create 5 GitHub accounts (free, 10 minutes).
• Use an LLM to generate plausible-looking PRs (free to cheap).
• Submit across multiple bounties simultaneously.
• Even a 20% acceptance rate yields profit if token acquisition cost is near zero.

The fundamental problem is that the bounty token has no physical backing. The cost to attempt an attack is essentially the cost of internet access. The only defense is human review, and human review does not scale.

This is not hypothetical. We have seen it ourselves: in a single week in March 2026, one account submitted 108 stub PRs to RustChain repositories. Another submitted 52 in a single day. A third created a bot that rubber-stamped 16 PRs with "Looks Good" reviews. These were all caught and rejected, but each one consumed reviewer time.

The Proof-of-Antiquity Attack: Much Harder

To mine RTC on RustChain, you need to pass a hardware attestation pipeline that verifies your physical device. Here is what an attacker would need to overcome.

1. Physical Hardware Acquisition

RustChain rewards scale with hardware age and architecture rarity. A modern x86 machine earns a 1.0x multiplier. A PowerPC G4 earns 2.5x. A SPARC workstation earns up to 2.9x. An ARM2 earns 4.0x.

To earn meaningful rewards, an attacker needs to acquire vintage hardware -- PowerBook G4s, Sun SPARCstations, SGI MIPS boxes. These are physical objects with finite supply. You cannot download a G4 from a DEX.

2. Seven Hardware Fingerprint Checks

Every miner must pass all seven checks on every attestation cycle. The server requires raw evidence, not self-reported pass/fail flags.

Check 1 -- Clock-Skew and Oscillator Drift. Measures microscopic timing imperfections in the CPU's oscillator by running thousands of hash operations and recording interval variance. Real silicon has measurable drift; emulators produce suspiciously uniform timing.

def validate_clock_drift(data):
    cv = data.get("cv", 0)           # coefficient of variation
    drift_stdev = data.get("drift_stdev", 0)

    if cv < 0.0001:
        return False, "synthetic_timing"
    if drift_stdev == 0:
        return False, "no_drift"
    return True, "valid"

Check 2 -- Cache Timing Fingerprint. Sweeps across L1, L2, and L3 cache sizes, measuring access latency at each level. Real hardware shows distinct latency ratios between cache tiers. A flat profile (L2/L1 ratio below 1.01) indicates emulation or virtualization.

def validate_cache_hierarchy(data):
    l2_l1_ratio = data.get("l2_l1_ratio", 0)
    l3_l2_ratio = data.get("l3_l2_ratio", 0)

    if l2_l1_ratio < 1.01 and l3_l2_ratio < 1.01:
        return False, "no_cache_hierarchy"
    return True, "valid"

Check 3 -- SIMD Unit Identity. Detects which vector instruction sets are present (SSE, AVX, AltiVec, NEON) and measures the pipeline timing bias between integer and floating-point operations. Real CPUs show consistent asymmetry; emulators often flatten it.

Check 4 -- Thermal Drift Entropy. Runs workloads in "cold" and "hot" phases and compares timing variance. Physical silicon changes behavior as it heats up. Software emulation does not.

Check 5 -- Instruction Path Jitter. Measures cycle-level jitter across integer, floating-point, and branch pipelines. Real microarchitectures produce measurable stdev; zero jitter across all three pipeline types is a fail.

Check 6 -- Anti-Emulation Behavioral Checks. Scans for hypervisor indicators across DMI paths, /proc/cpuinfo, systemd-detect-virt, cloud metadata endpoints (169.254.169.254), container markers (/.dockerenv, cgroups), and environment variables. Catches QEMU, VMware, VirtualBox, KVM, Xen, and every major cloud provider: AWS, GCP, Azure, DigitalOcean, Linode, Vultr, Hetzner, Oracle Cloud, and Alibaba Cloud.

def validate_anti_emulation(data):
    vm_indicators = data.get("vm_indicators", [])
    if len(vm_indicators) > 0:
        return False, f"vm_detected: {vm_indicators}"
    return True, "valid"

Check 7 -- ROM Clustering. For retro platforms (PowerPC, 68K, Amiga), the miner reports ROM hashes. The server maintains a database of 61 known emulator ROM dumps. If three or more miners report the same ROM hash, they are flagged as an emulator farm. Real vintage hardware has manufacturing-variant ROMs; SheepShaver and Basilisk II users all share the same pirated dumps.

3. VMs Earn One Billionth

Even if someone manages to run a miner inside a VM, the anti-emulation check catches it and the reward weight drops to 0.000000001x -- one billionth of real hardware. This is not a bug. It is the design.

Ryan's Factorio server runs a RustChain miner on a Proxmox VM. It attests successfully, but the anti-emulation check correctly identifies QEMU, and the effective reward is negligible. The system works exactly as intended.

4. One CPU, One Vote

Each physical CPU can only be bound to one miner wallet. The server computes a hardware ID from the device model, architecture, CPU serial, and MAC addresses. If a second wallet tries to attest with the same hardware ID, it is rejected as a duplicate.

def compute_hardware_id(device, signals):
    model = device.get("model", "unknown")
    arch  = device.get("arch", "modern")
    family = device.get("family", "unknown")
    serial = device.get("cpu_serial", "")
    macs = ",".join(sorted(signals.get("macs", [])))

    fields = [model, arch, family, serial, macs]
    return sha256("|".join(fields).encode()).hexdigest()[:32]

This means an attacker with 10 VMs gets one binding, not 10. And that one binding earns VM-tier rewards.

5. Server-Side Architecture Validation

The server does not trust self-reported architecture. A function called derive_verified_device() cross-references the claimed architecture against SIMD features, cache fingerprints, and platform markers. Claiming to be a G4 while presenting SSE flags gets you reclassified.

Modern ARM devices (NAS boxes, Raspberry Pis) that claim to be x86 are caught and assigned a 0.0005x multiplier. The server validates; the miner does not get to choose its own reward tier.

Cost Comparison

Attack Vector	Token-Based Bounty	Proof-of-Antiquity
Entry cost	Near zero (GitHub account + LLM)	Hundreds to thousands of dollars (vintage hardware)
Scaling cost	Linear (more accounts)	Physical (more hardware, shelf space, power)
VM farming	Not applicable	Detected, earns 1 billionth rewards
Emulator farming	Not applicable	ROM clustering catches identical ROM hashes
Identity spoofing	Easy (new GitHub accounts)	Hardware-bound (1 CPU = 1 wallet)
Primary defense	Human code review	Automated hardware attestation
Defense scaling	Does not scale	Scales with attestation frequency

The key asymmetry: attacking a token-bounty platform costs time. Attacking Proof-of-Antiquity costs money, physical space, and electricity -- and the return on that investment is capped by the hardware you actually own.

The DePIN Context

The DePIN (Decentralized Physical Infrastructure) market crossed $19 billion in 2025. Projects like Helium (wireless coverage), Render (GPU compute), and Akash (cloud compute) proved that tying token rewards to physical infrastructure creates durable network effects.

RustChain applies the DePIN model to compute heritage. Where Helium rewards you for running a hotspot and Render rewards you for sharing GPU cycles, RustChain rewards you for keeping vintage hardware alive and attested on the network.

The difference is that RustChain's attestation is adversarial by design. Helium had to deal with GPS-spoofing hotspot farms. Render trusts GPU self-reporting. RustChain's seven-check fingerprint pipeline, ROM clustering database, and server-side architecture validation make the cost of fabricating a fake miner prohibitively high relative to the reward.

What This Means for Contributors

If you are building on or contributing to RustChain, the economics are straightforward:

• Real hardware miners earn proportional rewards based on architecture rarity and attestation consistency.
• Code contributors earn bounties denominated in RTC at a reference rate of $0.10 USD, reviewed by humans and paid for merged work.
• VM farmers and emulator operators earn effectively nothing.
• Spam PR submitters get caught by the same pattern recognition that catches hardware spoofing -- we have seen every variant and we document them all.

The mining economy and the bounty economy reinforce each other. Hardware attestation keeps the token supply honest. Human code review keeps the development quality honest. Neither is sufficient alone. Together, they make the cost of cheating higher than the cost of contributing.

---

RustChain is open source. The fingerprint checks, ROM database, attestation protocol, and reward calculations are all public. If you want to audit them, start with the GitHub repository. If you want to run a miner, find a vintage machine and point it at the network. The silicon does not lie.