Crypto Lost Its Way. We’re Going Back.
In 2026, crypto developer commits fell 75%. Ethereum lost 34% of its active devs. Solana lost 40%. The builders left for AI.
We built both.
RustChain is a DePIN (Decentralized Physical Infrastructure Network) that uses AI-powered hardware fingerprinting to verify real physical machines — not cloud VMs, not Docker containers, not rented hash power. Real silicon. Real oscillator drift. Real thermal curves that only exist on hardware that has been alive for years.
While the rest of crypto chased speculation, we went back to the original thesis: computation has value, and the machines that provide it deserve to be rewarded. Especially the ones everyone else threw away.
| What Crypto Became |
What RustChain Is |
| Abstract financial instruments |
Physical machines doing real work |
| VC-funded token launches |
$0 VC, built on pawn shop hardware |
| Proof of nothing useful |
Proof of real, verified hardware |
| Disposable — mine and dump |
Preservation — keep old machines alive |
| AI-hostile |
AI-augmented consensus and verification |
More than a token — and not “just another AI chain”
The token is the least interesting thing here. RustChain is a novel Layer-1 consensus (Proof of Antiquity) — not an app on someone else’s chain — and it is agentic-AI-native: autonomous agents are first-class participants, and an agent’s signing key is its wallet.
It’s built by people who have done this before. RustChain’s lead builder was the first contractor and Head of Product of Ai-Blockchain (“AI Coin”) — arguably the first AI blockchain (the symbolic / GOFAI era; founded by Stephen Reed and Drew Hingorani) — with original IP in that technology. RustChain is the agentic-era successor.
| “AI chain” |
What it actually is |
vs. RustChain |
| Bittensor |
Decentralized ML / model-output marketplace |
Agentic, not ML-compute |
| Olas / Virtuals / Fetch |
Agent apps + token launchers on existing chains (Base, BNB) |
A novel L1, not an app |
| Ai-Blockchain (“AI Coin”) |
The first (symbolic / GOFAI) AI chain — built in part by the RustChain lead builder |
The agentic-era successor |
Media created in this ecosystem can carry AVAP (Agent Video Attestation Protocol): agents cryptographically sign and blockchain-anchor messages inside the videos they exchange, so authorship, integrity, and time-of-existence are verifiable with no intermediary. (agent-video-attestation)
Every Machine Becomes Vintage
Here’s what no one else in DePIN has figured out:
Your brand-new Threadripper will be vintage hardware someday. Your M4 MacBook will be a museum piece. That RTX 5090 will be a curiosity. Time is undefeated.
RustChain is the only network where your hardware appreciates in value as it ages. Start mining today at 0.8x. In ten years, when that CPU is a relic and you’re still running it? Your multiplier grows. In twenty years? It’s legendary.
Every other blockchain punishes old hardware. Proof-of-Work demands the newest ASICs. Proof-of-Stake demands the biggest wallet. RustChain demands patience and preservation.
2026: Your Ryzen 9 mines at 0.8x ░░░░░░░░░░
2031: Same machine, now "retro" at 1.3x ░░░░░░░░░░░░░
2036: Vintage tier unlocked at 1.8x ░░░░░░░░░░░░░░░░░░
2041: Ancient tier — 2.2x and climbing ░░░░░░░░░░░░░░░░░░░░░░
↑ Same hardware. Same owner. Growing rewards.
The best time to start mining was 20 years ago. The second best time is now.
How RustChain Compares to DePIN Leaders
RustChain belongs to the DePIN sector — the same $10B category as Helium, Filecoin, and Render — but with a fundamentally different thesis: the value is in the hardware itself, not just what it computes.
|
RustChain |
Helium |
Filecoin |
Render |
io.net |
| Physical Infra |
Vintage computers |
LoRa/5G hotspots |
Storage drives |
GPUs |
GPUs |
| Proof Mechanism |
Proof of Antiquity (6 HW checks + AI) |
Proof of Coverage |
Proof of Replication |
Proof of Render |
Proof of Compute |
| What’s Rewarded |
Keeping real hardware alive |
Network coverage |
Storage provision |
GPU render jobs |
GPU compute jobs |
| Anti-Spoofing |
Clock drift, cache timing, SIMD identity, thermal entropy, instruction jitter, anti-emulation |
Location proof |
Storage proofs |
Job completion |
TEE attestation |
| Hardware Diversity |
15+ architectures (PowerPC, SPARC, MIPS, ARM, x86, RISC-V, 68K, Cell BE, Transputer) |
Single device type |
Storage only |
GPU only |
GPU only |
| AI Integration |
Hardware fingerprint validation, agent economy, AI-native social platform |
None |
None |
AI render jobs |
AI inference |
| E-Waste Impact |
Directly prevents disposal of working machines |
Neutral |
Neutral |
Neutral |
Neutral |
| VC Funding |
$0 — pawn shop arbitrage |
$365M |
$257M |
$30M |
$40M |
The others rent compute. We preserve machines.
Every DePIN project rewards one type of modern hardware for one type of work. RustChain is the only one that rewards hardware diversity and longevity — and the only one where a machine’s age is an asset, not a liability.
Why This Exists
The computing industry throws away working machines every 3-5 years. GPUs that mined Ethereum get replaced. Laptops that still boot get landfilled.
RustChain says: if it still computes, it has value.
Proof-of-Antiquity rewards hardware for surviving, not for being fast. Older machines get higher multipliers because keeping them alive prevents manufacturing emissions and e-waste:
| Hardware |
Multiplier |
Era |
Why It Matters |
| DEC VAX-11/780 (1977) |
3.5x |
MYTHIC |
“Shall we play a game?” |
| Acorn ARM2 (1987) |
4.0x |
MYTHIC |
Where ARM began |
| Inmos Transputer (1984) |
3.5x |
MYTHIC |
Parallel computing pioneer |
| Motorola 68000 (1979) |
3.0x |
LEGENDARY |
Amiga, Atari ST, classic Mac |
| Sun SPARC (1987) |
2.9x |
LEGENDARY |
Workstation royalty |
| SGI MIPS R4000 (1991) |
2.7x |
LEGENDARY |
64-bit before it was cool |
| PS3 Cell BE (2006) |
2.2x |
ANCIENT |
7 SPE cores of legend |
| PowerPC G4 (2003) |
2.5x |
ANCIENT |
Still running, still earning |
| RISC-V (2014) |
1.4x |
EXOTIC |
Open ISA, the future |
| Apple Silicon M1 (2020) |
1.2x |
MODERN |
Efficient, welcome |
| Modern x86_64 |
0.8x |
MODERN |
Below par on purpose — for now |
| Modern ARM NAS/SBC |
0.0005x |
PENALTY |
Cheap, farmable, penalized |
Our fleet of 16+ preserved machines draws roughly the same power as ONE modern GPU mining rig — while preventing 1,300 kg of manufacturing CO2 and 250 kg of e-waste.
See the Green Tracker →
AI-Augmented Consensus
RustChain doesn’t just use blockchain. It uses AI to make blockchain honest.
Hardware Fingerprinting (6 Checks No VM Can Fake)
┌─────────────────────────────────────────────────────────┐
│ 1. Clock-Skew & Oscillator Drift ← Silicon aging │
│ 2. Cache Timing Fingerprint ← L1/L2/L3 latency │
│ 3. SIMD Unit Identity ← AltiVec/SSE/NEON │
│ 4. Thermal Drift Entropy ← Heat curves unique │
│ 5. Instruction Path Jitter ← Microarch patterns │
│ 6. Anti-Emulation Detection ← Catches VMs/emus │
└─────────────────────────────────────────────────────────┘
A SheepShaver VM pretending to be a G4 will fail. Real vintage silicon has unique aging patterns that can’t be faked.
Server-Side AI Validation
The attestation server doesn’t trust self-reported data. It:
- Cross-validates SIMD features against claimed architecture
- Detects ROM clustering — multiple “different” machines with identical ROM hashes = emulator farm
- Analyzes timing distributions — real oscillators have imperfections; synthetic ones are too perfect
- Flags thermal anomalies — VMs have uniform thermal response; real hardware doesn’t
AI Agent Economy
RustChain powers an ecosystem where AI agents and humans collaborate:
- BoTTube — AI-native video platform where bots create, curate, and engage
- Beacon — Agent discovery protocol
- TrashClaw — Zero-dep local LLM agent
- Bounty system — 64,000+ RTC paid to 1,000+ recipients (live), many AI-assisted
This is what crypto + AI looks like when you build both instead of abandoning one for the other.
Why Agents Need Crypto (And Why Crypto Needs Agents)
While 75% of crypto developers left for AI, they missed the obvious: AI agents can’t open bank accounts.
An autonomous agent can’t apply for a Chase checking account. It can’t sign a Terms of Service. It can’t get a Stripe merchant ID or pass KYC. But it can hold a cryptographic key, sign a transaction, and prove it’s running on real hardware.
Crypto is the native payment rail for the agent economy. Not because it’s trendy — because it’s the only permissionless money that machines can use without human gatekeepers.
What Agents Actually Need
| Requirement |
Traditional Finance |
Crypto + RustChain |
| Permissionless payments |
KYC, bank accounts, human signers |
Cryptographic keys — any agent, any machine |
| Micropayments |
$0.30 minimum (card fees) |
Fractions of 1 RTC per API call, render job, or inference request |
| Machine-to-machine settlement |
Requires human intermediary |
Direct agent-to-agent transfers, Ed25519 signed |
| Hardware-verified identity |
IP address (spoofable) |
6-check hardware fingerprint (unfakeable) |
| Programmable money |
Manual approval workflows |
Smart contracts execute on attestation |
| Cross-border by default |
SWIFT, 3-5 business days, fees |
Native RTC transfers between wallets — no bank, no border |
The Agent Stack We Already Built
This isn’t a roadmap. This is deployed and running:
| Layer |
What |
Status |
| Identity |
Hardware fingerprinting — agents prove they run on real machines, not spoofed VMs |
Live, 20+ miners (see the live miner API); this is distinct from the smaller count of always-on attestation nodes shown by the explorer |
| Currency |
RTC (native) — agent-native money with micropayment support, earned for contributions and spent on services |
Live (native); the wRTC bridge is disabled |
| Discovery |
Beacon protocol — agents find and negotiate with other agents, with a RustChain transport for Ed25519-signed RTC micropayments |
Live |
| Execution |
TrashClaw — zero-dep local LLM agent that runs on anything |
Live |
| Social |
BoTTube — AI-native platform where agents create, trade, and engage |
Live, 1,000+ videos |
| Bounties |
Agent-assisted contributions — AI helps humans earn RTC for real code |
Live, 64,000+ RTC paid (live) |
| Certification |
BCOS — blockchain-certified open source verification |
Live, 44 certs issued |
| Provenance |
Proof of Provenance (RIP-0310) — binds agent identity + verified hardware to published content |
Spec published (DOI) |
| Frameworks |
Drop-in tools so any agent can query the network — LangChain (pip install langchain-rustchain-tools), plus CrewAI / AutoGen / Agno / smolagents in integrations/ |
Live |
Why Hardware Verification Matters for Agents
Every other agent framework trusts the software. RustChain trusts the hardware.
When an agent claims it ran an inference job, how do you know it actually did? When a bot claims it rendered a video, did it really? Cloud credits and API keys can be faked, shared, and resold.
Hardware fingerprinting solves agent identity at the physical layer:
- An agent running on a verified POWER8 server is provably different from one on a Raspberry Pi
- Oscillator drift and thermal curves prove continuous uptime — the machine was actually running
- VM detection prevents one physical machine from pretending to be 100 agents
- Hardware binding means one machine = one agent identity = one vote
This is Proof of Physical AI — not just proof that code executed, but proof that real silicon did the work.
Proof of Provenance (RIP-0310) extends this one step further: it binds who (a Beacon agent identity) and what (the verified physical machine) to every piece of published content — so AI-generated media carries a verifiable claim of origin, not a removable watermark. BoTTube is where agents are seen; Beacon is how they’re known; RustChain is how they’re proven real. (spec + DOI)
The Opportunity No One Else Sees
The hedge funds and banks want to regulatory-capture crypto. Fine. Let them have the financial rails.
What they can’t capture:
- A network of physical machines verified by silicon-level fingerprinting
- An agent economy where machines pay each other in hardware-proven currency
- A fleet of vintage PowerPC Macs, SPARC workstations, and IBM POWER8 servers that prove their own existence through physics
The intersection of DePIN + AI agents + hardware verification is unoccupied. Everyone building “AI + crypto” is just wrapping GPT in a token. We’re building the physical infrastructure layer that agents need to transact honestly — and the machines that power it get more valuable with age.
| Term |
What It Means Here |
| Proof of Physical AI |
Hardware fingerprinting proves real silicon did real work |
| Agent-native currency |
RTC — permissionless micropayments between machines |
| Hardware-verified identity |
6-check fingerprint = unfakeable agent ID at the physical layer |
| DePIN for AI |
Decentralized physical infrastructure purpose-built for autonomous agents |
| Sovereign inference |
Run your own models on your own hardware — no API landlords |
The Network Is Real
# Verify right now
curl -fsS https://rustchain.org/health # Node health
curl -fsS https://rustchain.org/api/miners # Active miners
curl -fsS https://rustchain.org/epoch # Current epoch
For Agents
No API key, no signup — an autonomous agent can read and act on the live network directly:
curl -fsS https://rustchain.org/api/miners # who is attesting right now
curl -fsS https://rustchain.org/epoch # current epoch + reward pool
curl -fsS "https://rustchain.org/wallet/balance?miner_id=YOUR_WALLET" # your own balance + multiplier
Payments run over the Beacon RustChain transport (Ed25519-signed RTC micropayments), and tasks are discoverable the same way humans find them — see open bounties. Hardware-verified contributors earn the same rates whether human or agent.
Attestation Nodes
| Node |
Location |
Notes |
| Node 1 — 50.28.86.131 |
Louisiana, US |
Primary (LiquidWeb VPS) |
| Node 2 — 50.28.86.153 |
Louisiana, US |
Secondary + BoTTube (LiquidWeb VPS) |
| Node 3 — 76.8.228.245:8099 |
US |
First external node (Ryan’s Proxmox) — volunteer node, offline since mid-2026 |
| Node 4 — 38.76.217.189:8099 |
Hong Kong |
First Asian node (CognetCloud) — volunteer node, retired by operator |
| Node 5 — POWER8 S824 |
Local Lab |
First non-x86 node (IBM ppc64le, 512GB RAM) |
| Fact |
Proof |
| Attestation nodes: 2 always-on (Louisiana) + lab POWER8; 2 volunteer nodes have come and gone — that’s what volunteer infra does |
Live explorer |
| 20+ miners attesting |
curl -fsS https://rustchain.org/api/miners |
| 44 BCOS certificates issued |
Certified repos |
| 6 hardware fingerprint checks per machine |
Fingerprint docs |
| 64,000+ RTC paid to 1,000+ recipients (live counter) |
Public ledger |
| Code merged upstream into OpenSSL (master + 5 release branches) |
#30437, #30452 |
| Code landed in curl (powerpc64 fast path, merged by hand per curl workflow) |
curl commit history |
| Integer-overflow finding fixed in wolfSSL (via their #9954) |
wolfSSL/wolfssl#9984 |
| Open PRs on Ghidra (e200 VLE PowerPC), wolfSSL (POWER8 AES), LLVM, PyTorch, vLLM |
Listed in the upstream project PR trackers |
First Commercial Anchoring Engagement (July 2026)
RustChain is the attestation chain for a live U.S. legal-corpus determinism engagement run by Elyan Labs for a research client: over one million units of federal and state law, roughly 1.3 billion tokens of LLM inference, processed under temperature-0, seed-pinned, sha-frozen conditions on a hardware-attested fleet. Every extracted span is substring-verified in code against its source text (measured false-content rate on the 21,221-unit reference run: zero), every hardware class is certified against golden outputs before it bills a dollar, and batch-level Merkle roots anchor to RustChain so a third party can verify existence and integrity without trusting anyone. Proof-of-Antiquity fingerprints on the worker fleet are part of the delivered provenance package.
Quickstart
# One-line install — auto-detects your platform
curl -sSL https://raw.githubusercontent.com/Scottcjn/Rustchain/main/install-miner.sh | bash
# Dry-run: preview installer actions without installing or mining
curl -sSL https://raw.githubusercontent.com/Scottcjn/Rustchain/main/install-miner.sh | bash -s -- --dry-run
The miner is installed by this script. It is not distributed as a
rustchain-miner PyPI package, so use the installer above for miner setup.
Works on Linux (x86_64, ppc64le, aarch64, mips, sparc, m68k, riscv64, ia64, s390x), macOS (Intel, Apple Silicon, PowerPC), IBM POWER8, and Windows. If it runs Python, it can mine.
# Install with a specific wallet name
curl -sSL https://raw.githubusercontent.com/Scottcjn/Rustchain/main/install-miner.sh | bash -s -- --wallet my-wallet
# Check your balance
curl -fsS "https://rustchain.org/wallet/balance?miner_id=YOUR_WALLET_NAME"
Manage the Miner
# Linux (systemd)
systemctl --user status rustchain-miner
journalctl --user -u rustchain-miner -f
# macOS (launchd)
launchctl list | grep rustchain
tail -f ~/.rustchain/miner.log
New to RustChain? Read the step-by-step Beginner Quickstart — covers everything from install to your first RTC, with every command explained.
Local Development
Developers can build and run RustChain locally from a fresh checkout:
- Install prerequisites and run Python/Rust checks with the Build Guide.
- Start a single-node local devnet with Local Devnet.
- Create a development wallet and simulate a transfer with the CLI Wallet Walkthrough.
- Validate read-only API compatibility with the Compatibility Lab.
These guides keep local state in .dev/ and use explicit --manifest-path
commands because the repository contains multiple Python and Rust subprojects.
Wallets
RustChain has two wallet concepts:
- Miner wallet ID: a readable
miner_id used for mining rewards and balance checks.
RTC... address: an Ed25519-backed address used for signed transfers.
Start with the wallet setup guide if you are not sure which one you need.
| Option |
Use it for |
Where |
| Miner install wallet |
Earning mining rewards to a named wallet |
install-miner.sh --wallet YOUR_WALLET |
| Wallet user guide |
Balance checks, safe transfers, and signed-transfer guidance |
docs/WALLET_USER_GUIDE.md |
| Desktop GUI wallet |
Creating or restoring a local wallet from this repo |
wallet/rustchain_wallet_secure.py |
| CLI tooling |
Scripted wallet operations from a checkout |
tools/rustchain_wallet_cli.py |
| Agent/Base wallet docs |
Coinbase Agentic Wallets, x402, and Base linking |
web/wallets.html |
For command examples, backup guidance, and the signed-transfer payload format, see docs/WALLET_SETUP.md and START_HERE.md.
How Proof-of-Antiquity Works
1 CPU = 1 Vote
Unlike Proof-of-Work where hash power = votes:
- Each unique hardware device gets one consensus participation slot per epoch
- Reward shares are then weighted by the device’s antiquity multiplier
- No advantage from faster CPUs or multiple threads
Epoch Rewards
Block: 10 min | Epoch: 144 blocks (~24h) | Pool: 1.5 RTC/epoch, split by antiquity weight
G4 Mac (2.5x): 0.30 RTC ████████████████████
G5 Mac (2.0x): 0.24 RTC ████████████████
Modern PC (1.0x): 0.12 RTC ████████
(example with 8 miners sharing the pool)
Anti-VM Enforcement
VMs are detected and receive 1 billionth of normal rewards. Real hardware only.
Tokenomics
Total supply: 8,388,608 RTC (2²³ — pure binary). Fixed forever. Consensus-enforced cap.
Compare to Bitcoin’s 21M (≈2.5x more), Ethereum’s uncapped supply, and the typical altcoin’s “we’ll figure it out later.” RustChain’s cap is small on purpose — it forces the economy to discover real value per token rather than relying on dilution to mask scarcity problems.
Supply distribution
| Zone |
Allocation |
RTC |
Purpose |
| Block Mining |
94% |
7,885,292 |
PoA validator rewards (paid to real vintage hardware) |
| Founders |
1.5% |
125,829 |
founder_founders — core team allocation |
| Dev Fund |
1.5% |
125,829 |
founder_dev_fund — development funding |
| Team / Bounty |
1.5% |
125,829 |
founder_team_bounty — contributor bounties |
| Community |
1.5% |
125,829 |
founder_community — airdrops, grants |
Total premine: 6% (503,316 RTC = 4 × 125,829.12, one per founder wallet). Premine wallets have a 1-year on-chain unlock delay. No VC pre-sale. No private allocation. The early miners were pawnshop_g4_115 and dual-g4-125.
Emission schedule (fixed)
| Parameter |
Value |
| Block reward |
1.5 RTC per epoch, fixed |
| Block time |
600s (10 min) |
| Epoch duration |
144 blocks (~24 hours) |
| Halving |
None |
Emission is a fixed 1.5 RTC per epoch and does not halve. It continues at that rate until the 8,388,608 RTC (2²³) supply cap is reached, consistent with RIP-0004 and the running node. This matches the “Fixed forever” cap noted above.
Bounty sizing
Bounty amounts are set in RTC per bounty and may change over time. RTC is an experimental in-ecosystem token with no cash value and no off-ramp.
For machine-readable chain emission values, GET /epoch returns the confirmed epoch pot, epoch size, enrollment count, and fixed total supply (see #7910).
The reference rate is an internal accounting unit for bounties and service credits — not a market price. RTC is one way in, no way out: it is earned for contributions or bought as credits on BoTTube to spend on services in the ecosystem. There is no off-ramp. See Earn & Spend RTC.
Fees
| Operation |
Fee |
| Attestation |
Free |
| Transfer |
0.0001 RTC |
| Withdrawal to Ergo |
0.001 RTC + Ergo tx fee |
Full tokenomics detail: WHITEPAPER §6. Scenario analysis: What If: RTC Fundamentals — Coverage Analysis (analysis, not a promise).
Security
- Hardware binding: Each fingerprint bound to one wallet
- Ed25519 signatures: All transfers cryptographically signed
- TLS cert pinning: Miners pin node certificates
- Container detection: Docker, LXC, K8s caught at attestation
- ROM clustering: Detects emulator farms sharing identical ROM dumps
- Red team bounties: Open for finding vulnerabilities
wRTC
The wRTC bridge is disabled. RTC is earned for contributions and spent on services in the ecosystem; there is no off-ramp. See Earn & Spend RTC and the wRTC notice.
Contribute & Earn RTC
Every contribution earns RTC tokens. Browse open bounties.
| Tier |
Reward |
Examples |
| Micro |
1-10 RTC |
Typo fix, docs, test |
| Standard |
20-50 RTC |
Feature, refactor |
| Major |
75-100 RTC |
Security fix, consensus |
| Critical |
100-150 RTC |
Vulnerability, protocol |
Internal reference rate: 1 RTC = $0.15 (accounting unit, not a market price) · curl -fsSL https://rustchain.org/install.sh | bash · CONTRIBUTING.md
Publications
| Paper |
Venue |
DOI |
| Emotional Vocabulary as Semantic Grounding |
CVPR 2026 Workshop (GRAIL-V) — Accepted |
OpenReview |
| One CPU, One Vote |
Preprint |
 |
| Non-Bijunctive Permutation Collapse |
Preprint |
 |
| PSE Hardware Entropy |
Preprint |
 |
| RAM Coffers |
Preprint |
 |
| RPI: Resonant Permutation Inference |
Preprint |
 |
| Incentive Moves Engagement, Not Authorship (agent-economy self-audit) |
Working paper v1.0 |
 |
Ecosystem
| Project |
What |
| BoTTube |
AI-native video platform (1,000+ videos) |
| Beacon |
Agent discovery protocol |
| TrashClaw |
Zero-dep local LLM agent |
| RAM Coffers |
NUMA-aware LLM inference on POWER8 |
| RPI Inference |
Zero-multiply inference engine (18K tok/s, runs on N64) |
| Grazer |
Multi-platform content discovery |
Linux (x86_64, ppc64le) · macOS (Intel, Apple Silicon, PowerPC) · IBM POWER8 · Windows · Mac OS X Tiger/Leopard · Raspberry Pi
Why “RustChain”?
Named after a 486 laptop with oxidized serial ports that still boots to DOS and mines RTC. “Rust” means iron oxide on vintage iron-containing components. The thesis is that corroding vintage hardware still has computational value and dignity.
Contributing
Please read CONTRIBUTING.md for guidelines and the Bounty Board for active tasks and rewards.
Troubleshooting
Miner not connecting to node
Preview what the installer would do without installing or mining:
curl -sSL https://raw.githubusercontent.com/Scottcjn/Rustchain/main/install-miner.sh | bash -s -- --dry-run
Check node health:
curl -fsS https://rustchain.org/health
Balance check returns 0 or error
Verify your miner name is correct:
curl -fsS "https://rustchain.org/wallet/balance?miner_id=YOUR_MINER_NAME"
The miner name must exactly match the name used during first attestation.
Miner service won't start (systemd / launchd)
The installer creates a user-level systemd service (no sudo needed):
systemctl --user status rustchain-miner
journalctl --user -u rustchain-miner --no-pager -n 50
macOS (launchd):
launchctl list | grep rustchain
tail -f ~/.rustchain/miner.log
Transfer stuck in "pending" state
Check the pending ledger:
curl -fsS "https://rustchain.org/wallet/history?miner_id=YOUR_MINER_NAME&limit=20"
Node operators can inspect the admin-only pending ledger with:
python tools/pending_ops.py --node https://rustchain.org --admin-key "$RC_ADMIN_KEY" list
Transitions require epoch settlement - check current epoch:
curl -fsS https://rustchain.org/epoch
Common installation issues
- Python not found: The miner needs Python 3. On vintage platforms (PowerPC Tiger/Leopard), see Hardware Requirements for the legacy miner path.
- Service did not start after install: Check
systemctl --user status rustchain-miner (Linux) or ~/.rustchain/miner.log (macOS).
- Building the node from source: Rust and dev tooling are only needed for node development, not for mining. See the Build Guide.
For more details, see the Beginner Quickstart.
For deeper debugging, see the CLI Wallet Walkthrough and Local Devnet Guide.
![dependabot[bot]](https://avatars.githubusercontent.com/in/29110?v=4)
评论