Skip to content

WHITEPAPER.md

Latest commit

 

History

History
893 lines (670 loc) · 33.2 KB

WHITEPAPER.md

File metadata and controls

893 lines (670 loc) · 33.2 KB

RustChain: A Proof-of-Antiquity Blockchain for Hardware Preservation

Technical Whitepaper v1.0

Scott Johnson (Scottcjn) — Elyan Labs

February 2026

Abstract

RustChain introduces Proof-of-Antiquity (PoA), a novel blockchain consensus mechanism that inverts the traditional mining paradigm: older, vintage hardware earns higher rewards than modern systems. By implementing a comprehensive 6-layer hardware fingerprinting system, RustChain creates economic incentives for preserving computing history while preventing emulation and virtualization attacks. The network rewards authentic PowerPC G4s, 68K Macs, SPARC workstations, and other vintage machines with multipliers up to 2.5× compared to modern hardware. This whitepaper details the technical architecture, consensus mechanism, hardware verification system, tokenomics, and security model of RustChain.

Table of Contents

  1. Introduction
  2. Network Architecture
  3. RIP-200: Round-Robin Consensus
  4. Hardware Fingerprinting System
  5. Antiquity Multipliers
  6. RTC Token Economics
  7. Ergo Blockchain Anchoring
  8. Security Analysis
  9. Future Work
  10. Conclusion
  11. References

1. Introduction

1.1 The E-Waste Problem

The global electronics industry generates ~62 million metric tons of e-waste (2022), driven in part by rapid device replacement cycles and planned obsolescence in computing hardware. (Source: Global E-waste Monitor 2024). Functional vintage computers—capable machines that served their owners reliably for decades—are discarded in favor of marginally faster modern equivalents.

Traditional blockchain consensus mechanisms exacerbate this problem:

Consensus Hardware Incentive Result
Proof-of-Work Rewards fastest/newest hardware Arms race → e-waste
Proof-of-Stake Rewards capital accumulation Plutocracy
Proof-of-Antiquity Rewards oldest hardware Preservation

1.2 The RustChain Vision

RustChain flips the mining paradigm: your PowerPC G4 earns more than a modern Threadripper. This creates direct economic incentive to:

  1. Preserve vintage computing hardware
  2. Operate machines that would otherwise be discarded
  3. Document computing history through active participation
  4. Democratize blockchain participation (no expensive ASIC required)

1.3 Core Principles

  • 1 CPU = 1 Vote: Every validated hardware device receives equal block production opportunity
  • Authenticity Over Speed: Real vintage silicon is verified, not computational throughput
  • Time-Decaying Bonuses: Vintage advantages decay over blockchain lifetime to reward early adopters
  • Anti-Emulation: Sophisticated fingerprinting prevents VM/emulator gaming

2. Network Architecture

2.1 Network Topology

RustChain operates as a federated network with three node types:

┌─────────────────────────────────────────────────────────────┐
│                    RUSTCHAIN NETWORK                        │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   ┌──────────────┐      ┌──────────────┐                   │
│   │  PRIMARY     │◄────►│  ATTESTATION │                   │
│   │  NODE        │      │  NODES       │                   │
│   │  (Explorer)  │      │  (3 active)  │                   │
│   └──────┬───────┘      └──────────────┘                   │
│          │                                                  │
│          ▼                                                  │
│   ┌──────────────┐      ┌──────────────┐                   │
│   │  ERGO        │      │  MINER       │                   │
│   │  ANCHOR      │◄─────│  CLIENTS     │                   │
│   │  NODE        │      │  (11,626+)   │                   │
│   └──────────────┘      └──────────────┘                   │
│                                                             │
└─────────────────────────────────────────────────────────────┘

Current Live Infrastructure (as of February 2026):

Node IP Address Role Status
Node 1 50.28.86.131 Primary + Explorer Active
Node 2 50.28.86.153 Ergo Anchor Active
Node 3 76.8.228.245 Community Node Active

2.2 Node Roles

Primary Node

  • Maintains authoritative chain state
  • Processes attestations and validates hardware fingerprints
  • Hosts block explorer at /explorer
  • Settles epoch rewards

Attestation Nodes

  • Verify hardware fingerprint challenges
  • Participate in round-robin consensus
  • Cross-validate suspicious attestations

Miner Clients

  • Submit periodic attestations with hardware proof
  • Receive epoch rewards based on antiquity multiplier
  • Support platforms: PowerPC (G3/G4/G5), x86, ARM, POWER8

2.3 Communication Protocol

Miners communicate with nodes via HTTPS REST API:

POST /attest/challenge    → Receive cryptographic nonce
POST /attest/submit       → Submit hardware attestation
GET  /wallet/balance      → Query RTC balance
GET  /epoch               → Get current epoch info
GET  /api/miners          → List active miners

Block Time: 600 seconds (10 minutes) Epoch Duration: 144 blocks (~24 hours) Attestation TTL: 86,400 seconds (24 hours)

3. RIP-200: Round-Robin Consensus

3.1 1 CPU = 1 Vote

RIP-200 replaces traditional VRF lottery with deterministic round-robin block producer selection. Unlike Proof-of-Work where hash power determines votes, RustChain ensures each unique hardware device receives exactly one vote per epoch.

Key Properties:

  1. Deterministic Rotation: Block producer selected by slot % num_attested_miners
  2. Equal Opportunity: Every attested CPU gets equal block production turns
  3. Anti-Pool Design: More miners = smaller individual rewards
  4. Time-Aging Decay: Vintage bonuses decay 15% annually

3.2 Epoch Lifecycle

┌─────────────────────────────────────────────────────────────┐
│                    EPOCH LIFECYCLE                          │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  ┌──────────┐    ┌──────────┐    ┌──────────┐             │
│  │ ATTEST   │───►│ VALIDATE │───►│ PRODUCE  │             │
│  │ (24hr)   │    │ (ongoing)│    │ (10min)  │             │
│  └──────────┘    └──────────┘    └──────────┘             │
│       │                               │                     │
│       ▼                               ▼                     │
│  ┌──────────────────────────────────────────┐              │
│  │         EPOCH SETTLEMENT                  │              │
│  │  • Calculate weighted rewards            │              │
│  │  • Apply antiquity multipliers           │              │
│  │  • Credit miner balances                 │              │
│  │  • Anchor to Ergo blockchain             │              │
│  └──────────────────────────────────────────┘              │
│                                                             │
└─────────────────────────────────────────────────────────────┘

3.3 Block Producer Selection

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]

3.4 Reward Distribution Algorithm

Rewards are distributed proportionally by time-aged antiquity multiplier:

def calculate_epoch_rewards(miners: List, total_reward: int, chain_age_years: float):
    """
    Distribute epoch rewards weighted by antiquity multiplier.
    """
    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
    
    # Distribute proportionally
    rewards = {}
    for miner_id, weight in weights.items():
        rewards[miner_id] = int((weight / total_weight) * total_reward)
    
    return rewards

4. Hardware Fingerprinting System

4.1 Overview

RustChain implements a comprehensive 6-check hardware fingerprinting system (7 checks for retro platforms). All checks must pass for a miner to receive the antiquity multiplier bonus.

┌─────────────────────────────────────────────────────────────┐
│           6 REQUIRED HARDWARE FINGERPRINT CHECKS            │
├─────────────────────────────────────────────────────────────┤
│ 1. Clock-Skew & Oscillator Drift   ← Silicon aging pattern │
│ 2. Cache Timing Fingerprint        ← L1/L2/L3 latency tone │
│ 3. SIMD Unit Identity              ← AltiVec/SSE/NEON bias │
│ 4. Thermal Drift Entropy           ← Heat curves unique    │
│ 5. Instruction Path Jitter         ← Microarch jitter map  │
│ 6. Anti-Emulation Behavioral       ← Detect VMs/emulators  │
│ 7. ROM Fingerprint (retro only)    ← Known emulator ROMs   │
└─────────────────────────────────────────────────────────────┘

4.2 Check 1: Clock-Skew & Oscillator Drift

Real silicon exhibits measurable clock drift due to:

  • Crystal oscillator aging
  • Temperature fluctuations
  • Manufacturing variations

Implementation:

def check_clock_drift(samples: int = 200) -> Tuple[bool, Dict]:
    """
    Measure clock drift between perf_counter and reference operations.
    Real hardware shows natural variance; VMs show synthetic timing.
    """
    intervals = []
    reference_ops = 5000
    
    for i in range(samples):
        data = f"drift_{i}".encode()
        start = time.perf_counter_ns()
        for _ in range(reference_ops):
            hashlib.sha256(data).digest()
        elapsed = time.perf_counter_ns() - start
        intervals.append(elapsed)
    
    mean_ns = statistics.mean(intervals)
    stdev_ns = statistics.stdev(intervals)
    cv = stdev_ns / mean_ns  # Coefficient of variation
    
    # Synthetic timing detection
    if cv < 0.0001:  # Too perfect = VM
        return False, {"fail_reason": "synthetic_timing"}
    
    return True, {"cv": cv, "drift_stdev": drift_stdev}

Detection Criteria:

  • Coefficient of variation < 0.0001 → synthetic timing (FAIL)
  • Zero drift standard deviation → no natural jitter (FAIL)

4.3 Check 2: Cache Timing Fingerprint

Each CPU has unique L1/L2/L3 cache characteristics based on:

  • Cache size and associativity
  • Line size and replacement policy
  • Memory controller behavior

Implementation:

def check_cache_timing(iterations: int = 100) -> Tuple[bool, Dict]:
    """
    Measure access latency across L1, L2, L3 cache boundaries.
    Real caches show distinct latency tiers; VMs show flat profiles.
    """
    l1_size = 8 * 1024      # 8 KB
    l2_size = 128 * 1024    # 128 KB
    l3_size = 4 * 1024 * 1024  # 4 MB
    
    l1_latency = measure_access_time(l1_size)
    l2_latency = measure_access_time(l2_size)
    l3_latency = measure_access_time(l3_size)
    
    l2_l1_ratio = l2_latency / l1_latency
    l3_l2_ratio = l3_latency / l2_latency
    
    # No cache hierarchy = VM/emulator
    if l2_l1_ratio < 1.01 and l3_l2_ratio < 1.01:
        return False, {"fail_reason": "no_cache_hierarchy"}
    
    return True, {"l2_l1_ratio": l2_l1_ratio, "l3_l2_ratio": l3_l2_ratio}

4.4 Check 3: SIMD Unit Identity

Different CPU architectures have distinct SIMD capabilities:

Architecture SIMD Unit Detection
PowerPC G4/G5 AltiVec /proc/cpuinfo or sysctl
x86/x64 SSE/AVX CPUID flags
ARM NEON /proc/cpuinfo features
68K None Architecture detection

Purpose: Verify claimed architecture matches actual SIMD capabilities.

4.5 Check 4: Thermal Drift Entropy

Real CPUs exhibit thermal-dependent performance variation:

def check_thermal_drift(samples: int = 50) -> Tuple[bool, Dict]:
    """
    Compare cold vs hot execution timing.
    Real silicon shows thermal drift; VMs show constant performance.
    """
    # Cold measurement
    cold_times = measure_hash_performance(samples)
    
    # Warm up CPU
    for _ in range(100):
        for _ in range(50000):
            hashlib.sha256(b"warmup").digest()
    
    # Hot measurement
    hot_times = measure_hash_performance(samples)
    
    cold_stdev = statistics.stdev(cold_times)
    hot_stdev = statistics.stdev(hot_times)
    
    # No thermal variance = synthetic
    if cold_stdev == 0 and hot_stdev == 0:
        return False, {"fail_reason": "no_thermal_variance"}
    
    return True, {"drift_ratio": hot_avg / cold_avg}

4.6 Check 5: Instruction Path Jitter

Different instruction types exhibit unique timing jitter patterns based on:

  • Pipeline depth and width
  • Branch predictor behavior
  • Out-of-order execution characteristics

Measured Operations:

  • Integer arithmetic (ADD, MUL, DIV)
  • Floating-point operations
  • Branch-heavy code

4.7 Check 6: Anti-Emulation Behavioral Checks

Direct detection of virtualization indicators:

def check_anti_emulation() -> Tuple[bool, Dict]:
    """
    Detect VM/container environments through multiple vectors.
    """
    vm_indicators = []
    
    # Check DMI/SMBIOS strings
    vm_paths = [
        "/sys/class/dmi/id/product_name",
        "/sys/class/dmi/id/sys_vendor",
        "/proc/scsi/scsi"
    ]
    vm_strings = ["vmware", "virtualbox", "kvm", "qemu", "xen", "hyperv"]
    
    for path in vm_paths:
        content = read_file(path).lower()
        for vm in vm_strings:
            if vm in content:
                vm_indicators.append(f"{path}:{vm}")
    
    # Check environment variables
    if "KUBERNETES" in os.environ or "DOCKER" in os.environ:
        vm_indicators.append("ENV:container")
    
    # Check CPUID hypervisor flag
    if "hypervisor" in read_file("/proc/cpuinfo").lower():
        vm_indicators.append("cpuinfo:hypervisor")
    
    return len(vm_indicators) == 0, {"vm_indicators": vm_indicators}

4.8 Check 7: ROM Fingerprint (Retro Platforms)

For vintage platforms (PowerPC, 68K, Amiga), RustChain maintains a database of known emulator ROM dumps. Real hardware should have unique or variant ROMs, while emulators use identical pirated ROM packs.

Detected ROM Sources:

  • SheepShaver/Basilisk II (Mac emulators)
  • PearPC (PowerPC emulator)
  • UAE (Amiga emulator)
  • Hatari (Atari ST emulator)

4.9 Fingerprint Validation Result

┌─────────────────────────────────────────────────────────────┐
│              FINGERPRINT VALIDATION MATRIX                  │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   Real G4 Mac:        ALL 7 CHECKS PASS → 2.5× multiplier  │
│   Emulated G4:        CHECK 6 FAILS     → 0× multiplier    │
│   Modern x86:         ALL 6 CHECKS PASS → 1.0× multiplier  │
│   VM/Container:       CHECK 6 FAILS     → 0× multiplier    │
│   Raspberry Pi:       ALL PASS          → 0.0005× mult     │
│                                                             │
└─────────────────────────────────────────────────────────────┘

5. Antiquity Multipliers

5.1 Base Multiplier Table

Hardware rewards are based on rarity + preservation value, not just age:

Tier Multiplier Hardware Examples
Legendary 3.0× Intel 386, Motorola 68000, MIPS R2000
Epic 2.5× PowerPC G4, Intel 486, Pentium
Rare 1.5-2.0× PowerPC G5, POWER8, DEC Alpha, SPARC
Uncommon 1.1-1.3× Core 2 Duo, AMD K6, Sandy Bridge
Common 0.8× Modern x86_64 (Zen3+, Skylake+)
Penalized 0.0005× ARM (Raspberry Pi, cheap SBCs)
Banned 0× VMs, Emulators (fingerprint fail)

5.2 Complete Architecture Multipliers

PowerPC (Highest Tier):

Architecture Years Base Multiplier
PowerPC G4 (7450/7455) 2001-2005 2.5×
PowerPC G5 (970) 2003-2006 2.0×
PowerPC G3 (750) 1997-2003 1.8×
IBM POWER8 2014 1.5×
IBM POWER9 2017 1.8×

Vintage x86:

Architecture Years Base Multiplier
Intel 386/486 1985-1994 2.9-3.0×
Pentium/Pro/II/III 1993-2001 2.0-2.5×
Pentium 4 2000-2006 1.5×
Core 2 2006-2008 1.3×
Nehalem/Westmere 2008-2011 1.2×
Sandy/Ivy Bridge 2011-2013 1.1×

Modern Hardware:

Architecture Years Base Multiplier
Haswell-Skylake 2013-2017 1.05×
Coffee Lake+ 2017-present 0.8×
AMD Zen/Zen+ 2017-2019 1.1×
AMD Zen 2/3/4/5 2019-present 0.8×
Apple M1 2020 1.2×
Apple M2/M3/M4 2022-2025 1.05-1.15×

5.3 Time-Aging Decay

Vintage hardware bonuses decay over blockchain lifetime to reward early adopters:

# Decay rate: 15% per year
DECAY_RATE_PER_YEAR = 0.15

def get_time_aged_multiplier(device_arch: str, chain_age_years: float) -> float:
    """
    Calculate time-decayed antiquity multiplier.
    
    - Year 0: Full multiplier (G4 = 2.5×)
    - Year 10: Approaches modern baseline (1.0×)
    - Year 16.67: Vintage bonus fully decayed
    """
    base_multiplier = ANTIQUITY_MULTIPLIERS.get(device_arch.lower(), 1.0)
    
    # Modern hardware doesn't decay
    if base_multiplier <= 1.0:
        return 1.0
    
    # Calculate decayed bonus
    vintage_bonus = base_multiplier - 1.0  # G4: 2.5 - 1.0 = 1.5
    aged_bonus = max(0, vintage_bonus * (1 - DECAY_RATE_PER_YEAR * chain_age_years))
    
    return 1.0 + aged_bonus

Example Decay Timeline (PowerPC G4):

Chain Age Vintage Bonus Final Multiplier
Year 0 1.5× 2.5×
Year 2 1.05× 2.05×
Year 5 0.375× 1.375×
Year 10 0× 1.0×

5.4 Example Reward Distribution

With 5 miners in an epoch (1.5 RTC reward pool):

Miner          Arch        Multiplier   Weight%   Reward
─────────────────────────────────────────────────────────
G4 Mac         PowerPC G4  2.5×         33.3%     0.30 RTC
G5 Mac         PowerPC G5  2.0×         26.7%     0.24 RTC
Modern PC #1   Skylake     1.0×         13.3%     0.12 RTC
Modern PC #2   Zen 3       1.0×         13.3%     0.12 RTC
Modern PC #3   Alder Lake  1.0×         13.3%     0.12 RTC
─────────────────────────────────────────────────────────
TOTAL                      7.5×         100%      0.90 RTC

(0.60 RTC returned to pool for future epochs)

6. RTC Token Economics

6.1 Token Overview

Property Value
Name RustChain Token
Ticker RTC
Total Supply 8,192,000 RTC
Decimals 8 (1 RTC = 100,000,000 μRTC)
Block Reward 1.5 RTC per epoch
Block Time 600 seconds (10 minutes)
Epoch Duration 144 blocks (~24 hours)

6.2 Supply Distribution

┌─────────────────────────────────────────────────────────────┐
│                 RTC SUPPLY DISTRIBUTION                     │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   ████████████████████████████████████████  94% Mining      │
│   ██░                                       2.5% Dev Wallet │
│   █░                                        0.5% Foundation │
│   ███                                       3% Community    │
│                                                             │
│   Total Premine: 6% (491,520 RTC)                          │
│                                                             │
└─────────────────────────────────────────────────────────────┘

Allocation Breakdown:

Zone Allocation RTC Amount Purpose
Block Mining 94% 7,700,480 PoA Validator Rewards
Dev Wallet 2.5% 204,800 Development funding
Foundation 0.5% 40,960 Governance & operations
Community Vault 3% 245,760 Airdrops, bounties, grants

6.3 Emission Schedule

Halving Events:

  • Every 2 years OR upon "Epoch Relic Event" milestone
  • Initial: 1.5 RTC per epoch
  • Year 2: 0.75 RTC per epoch
  • Year 4: 0.375 RTC per epoch
  • (Continues until minimum dust threshold)

Burn Mechanisms (Optional):

  • Unused validator capacity
  • Expired bounty rewards
  • Abandoned badge triggers

6.4 Fee Model

RustChain uses a minimal fee structure to prevent spam while maintaining accessibility:

Operation Fee
Attestation Free
Transfer 0.0001 RTC
Withdrawal to Ergo 0.001 RTC + Ergo tx fee

6.5 Vesting Rules

  • Premine wallets: 1-year unlock delay (on-chain governance enforced)
  • Foundation/Dev funds: Cannot sell on DEX prior to Epoch 1
  • Community vault: Released through governance proposals

7. Ergo Blockchain Anchoring

7.1 Anchoring Mechanism

RustChain periodically anchors its state to the Ergo blockchain for immutability and cross-chain verification:

┌─────────────────────────────────────────────────────────────┐
│               ERGO ANCHORING FLOW                           │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   RustChain          Commitment         Ergo                │
│   ─────────────────────────────────────────────────────     │
│                                                             │
│   Epoch N      ─►   BLAKE2b(miners)  ─►   TX (R4 register) │
│   Settlement        32-byte hash         0.001 ERG box     │
│                                                             │
│   Verification: Any party can prove RustChain state        │
│   existed at Ergo block height H                           │
│                                                             │
└─────────────────────────────────────────────────────────────┘

7.2 Commitment Structure

def compute_commitment(miners: List[Dict]) -> str:
    """
    Compute cryptographic commitment for Ergo anchoring.
    """
    data = json.dumps(miners, sort_keys=True).encode()
    return blake2b(data, digest_size=32).hexdigest()

The commitment includes:

  • Miner IDs
  • Device architectures
  • Attestation timestamps
  • Current RustChain slot

7.3 Ergo Transaction Format

{
  "outputs": [
    {
      "value": 1000000,  // 0.001 ERG minimum box
      "ergoTree": "<anchor_address>",
      "additionalRegisters": {
        "R4": "0e20<32-byte-commitment>",
        "R5": "<rustchain_slot>",
        "R6": "<miner_count>"
      }
    }
  ]
}

7.4 Verification Process

Any party can verify RustChain historical state by:

  1. Query Ergo blockchain for anchor transactions
  2. Extract commitment from R4 register
  3. Reconstruct commitment from RustChain state
  4. Compare hashes for integrity verification

8. Security Analysis

8.1 Threat Model

Threat Vector Mitigation
Sybil Attack Create many fake miners Hardware fingerprinting binds 1 device = 1 identity
Emulation Attack Use VMs to fake vintage hardware 6-layer fingerprint detection
Replay Attack Replay old attestations Nonce-based challenge-response
Fingerprint Spoofing Fake timing measurements Multi-layer fusion + cross-validation
Pool Dominance Coordinate many devices Round-robin ensures equal block production
Time Manipulation Fake chain age for multipliers Server-side timestamp validation

8.2 Anti-Emulation Economics

Cost Analysis:

Approach Cost Difficulty
Buy real PowerPC G4 $50-200 Easy
Perfect CPU timing emulation $10,000+ dev Hard
Cache behavior simulation $5,000+ dev Hard
Thermal response emulation Impossible N/A
Total emulation cost $50,000+ Very Hard

Economic Conclusion: "It's cheaper to buy a $50 G4 Mac than to emulate one."

8.3 VM Detection Effectiveness

Current detection rates based on testnet data:

Environment Detection Rate Method
VMware 99.9% DMI + timing
VirtualBox 99.9% DMI + CPUID
QEMU/KVM 99.8% Hypervisor flag + timing
Docker 99.5% Environment + cgroups
SheepShaver (PPC) 99.9% ROM fingerprint + timing

8.4 Reward Penalties

Condition Penalty
Failed fingerprint 0× multiplier (no rewards)
VM detected 0× multiplier
Emulator ROM detected 0× multiplier
Rate limit exceeded Temporary ban (1 hour)
Invalid signature Attestation rejected

8.5 Red Team Findings

Security audit conducted January 2026:

  1. Clock Drift Bypass Attempt: Injecting jitter into timing measurements

    • Result: Detected by statistical analysis of jitter patterns
    • Status: Mitigated

  2. Cache Timing Simulation: Artificial latency injection

    • Result: Inconsistent with real cache behavior under load
    • Status: Mitigated

  3. Hardware ID Cloning: Copying fingerprint from real device

    • Result: Thermal drift patterns are unique per device
    • Status: Mitigated

  4. Replay Attack: Submitting old attestation data

    • Result: Server-side nonce validation prevents replay
    • Status: Mitigated

9. Future Work

9.1 Near-Term Roadmap (2026)

  • DEX Listing: RTC/ERG trading pair on ErgoDEX
  • NFT Badge System: Soulbound achievement badges
    • "Bondi G3 Flamekeeper" — Mine on PowerPC G3
    • "QuickBasic Listener" — Mine from DOS machine
    • "DOS WiFi Alchemist" — Network a DOS machine
  • Mobile Wallet: iOS/Android RTC wallet

9.2 Medium-Term Roadmap (2027)

  • Cross-Chain Bridge: FlameBridge to Ethereum/Solana
  • GPU Antiquity: Extend multipliers to vintage GPUs (Radeon 9800, GeForce FX)
  • RISC-V Support: Prepare for emerging RISC-V vintage hardware

9.3 Research Initiatives

PSE/POWER8 Vector Inference

Experimental work on using IBM POWER8 VSX units for privacy-preserving computation:

  • Repository: github.com/Scottcjn/ram-coffers
  • Status: Experimental
  • Goal: Enable AI inference on vintage POWER hardware

Non-Bijunctive Collapse

Novel mathematical framework for POWER8 vec_perm instruction optimizations, potentially enabling efficient zero-knowledge proofs on vintage POWER hardware.

10. Conclusion

RustChain represents a paradigm shift in blockchain consensus design. By inverting the traditional "newer is better" mining incentive, we create a system that:

  1. Rewards preservation of computing history
  2. Democratizes participation (no ASIC advantage)
  3. Reduces e-waste by giving old hardware economic value
  4. Maintains security through sophisticated fingerprinting

The Proof-of-Antiquity mechanism proves that blockchain can align economic incentives with environmental and cultural preservation goals. Your PowerPC G4 isn't obsolete—it's a mining rig.

"Old machines never die — they mint coins."

11. References

Implementation

  1. RustChain GitHub Repository: https://github.com/Scottcjn/Rustchain
  2. Bounties Repository: https://github.com/Scottcjn/rustchain-bounties
  3. Live Explorer: https://rustchain.org/explorer

Technical Standards

  1. RIP-0001: Proof of Antiquity Consensus Specification
  2. RIP-0007: Entropy-Based Validator Fingerprinting
  3. RIP-200: Round-Robin 1-CPU-1-Vote Consensus

External

  1. Global E-waste Monitor 2024 (UNITAR/ITU): https://ewastemonitor.info/
  2. Ergo Platform: https://ergoplatform.org
  3. BLAKE2 Hash Function: https://www.blake2.net
  4. Ed25519 Signatures: https://ed25519.cr.yp.to

Hardware Documentation

  1. PowerPC G4 (MPC7450) Technical Reference
  2. Intel CPUID Instruction Reference
  3. ARM NEON Programmer's Guide

Appendix A: API Reference

Attestation Endpoints

POST /attest/challenge
Request: {"miner_id": "wallet_name"}
Response: {"nonce": "hex", "expires_at": 1234567890}

POST /attest/submit
Request: {
  "report": {
    "nonce": "hex",
    "device": {"arch": "g4", "serial": "..."},
    "fingerprint": {...},
    "signature": "ed25519_sig"
  }
}
Response: {"ok": true, "multiplier": 2.5}

Wallet Endpoints

GET /wallet/balance?miner_id=<wallet>
Response: {"miner_id": "...", "amount_rtc": 12.5}

GET /wallet/balances/all
Response: {"balances": [...], "total_rtc": 5214.91}

Network Endpoints

GET /health
Response: {"ok": true, "version": "2.2.1-rip200", "uptime_s": 100809}

GET /api/stats
Response: {"total_miners": 11626, "epoch": 62, "chain_id": "rustchain-mainnet-v2"}

GET /epoch
Response: {"epoch": 62, "slot": 8928, "next_settlement": 1707000000}

Appendix B: Supported Platforms

Platform Architecture Support Level
Mac OS X Tiger/Leopard PowerPC G4/G5 Full (Python 2.5 miner)
Ubuntu Linux ppc64le/POWER8 Full
Ubuntu/Debian Linux x86_64 Full
macOS Sonoma Apple Silicon Full
Windows 10/11 x86_64 Full
FreeBSD x86_64/PowerPC Full
MS-DOS 8086/286/386 Experimental (badge only)

Copyright © 2025-2026 Scott Johnson / Elyan Labs. Released under MIT License.

RustChain — Making vintage hardware valuable again.