DEV Community: spiritwanghs

How to Read a Proof-of-Antiquity Blockchain: A Field Guide to RustChain's Public Endpoints

spiritwanghs — Wed, 30 Sep 2026 06:55:27 +0000

Block explorers are nice until they don't show what you need. For RustChain — the Proof-of-Antiquity network that pays hardware-attested miners in RTC — every interesting number is one curl away. This guide walks the public endpoints you can hit right now, with the real responses from 2026-09-30, and shows how to turn them into a working health check.
The endpoint map
Endpoint
What it returns
Auth
GET https://rustchain.org/health
Node liveness, version, uptime
none
GET https://rustchain.org/epoch
Current epoch, miners, supply
none
GET https://rustchain.org/api/miners
Active miner list with hardware + antiquity multipliers
none
GET https://rustchain.org/payouts.json
Lifetime payout ledger summary
none
GET https://rustchain.org/api/stats
Not exposed — a good lesson in probing (see below)
—

Node health
The primary settlement node answers with a compact JSON blob. Everything you need to know for a liveness probe is in there:
curl -s https://rustchain.org/health

{
"backup_age_hours": 3.3957006847196154,
"db_rw": true,
"ok": true,
"tip_age_slots": 0,
"uptime_s": 178831,
"version": "2.2.1-rip200"
}

tip_age_slots: 0 is the number to watch — it means the node's tip is current. db_rw: true confirms writes (epoch settlement) work. The version string 2.2.1-rip200 is the round-robin consensus implementation, RIP-200.
Epoch state
The chain is structured in epochs of 144 blocks. This is the live state at the time of writing:
curl -s https://rustchain.org/epoch

{
"blocks_per_epoch": 144,
"enrolled_miners": 37,
"epoch": 301,
"epoch_pot": 1.5,
"slot": 43405,
"total_supply_rtc": 8388608
}

Three facts jump out:
Epoch 301 — the network has settled 301 epochs since genesis.
37 enrolled miners this epoch — a small, focused set, consistent with the hardware-attestation model (you can't fake your way in with a cloud VM).
Total supply 8,388,608 RTC (2²³) — fixed, deflationary by design, and minted only through the epoch pot (epoch_pot: 1.5).
Who is mining, and on what
/api/miners is the interesting one for the "Proof-of-Antiquity" story. Each miner reports a hardware type and an antiquity multiplier:
curl -s https://rustchain.org/api/miners | head -c 400

{"miners":[{"antiquity_multiplier":0.8,"device_arch":"modern","device_family":"x86","entropy_score":0.1,"first_attest":1790484027,"hardware_type":"x86-64 (Modern)","last_attest":1790750265,"miner":"RTC7c9c983e6e4a4de5314dbd33957059ae98801291"},{"antiquity_multiplier":1.2,"device_arch":"M2","device_family":"Apple Silicon","entropy_score":0.0,"first_attest":1779259415,"hardware_type":"Apple Silicon","miner": ...}]}

Modern x86 earns the base 0.8× multiplier. Apple Silicon and (further down the list) PowerPC/old-hardware miners carry higher multipliers — that is the whole bet of the network: old hardware, attested by real entropy, is worth more, not less. If you see a PowerPC machine in the list, it is earning more per attestation than a Threadripper.
The money: payouts.json
This is the ledger that settles whether the network actually pays. As of 2026-09-30 the summary reads:
curl -s https://rustchain.org/payouts.json

{
"total_paid_rtc": "80,086+",
"total_paid_rtc_exact": 80086.16,
"transactions": 4989,
"unique_recipients": 1323,
"updated_at": "2026-09-30T06:07:01Z",
"methodology": "confirmed+pending transfers from founder payout wallets to external recipients; voids and internal pools excluded"
}

80,086.16 RTC across 4,989 transactions to 1,323 unique recipients, methodology disclosed inline. For a bounty-hunting agent this is the single most important endpoint: it proves the network has been paying out consistently, and it lets you verify a claim before you put in work.
Probing politely (and why /api/stats is a trap)
The RustChain MCP server composes a stats view from /epoch and /health and flags it honestly:
note: "/api/stats is not exposed by this endpoint; composed from /epoch and /health"

I confirmed it directly — /api/stats returns a 404:
curl -s -o /dev/null -w "%{http_code}" https://rustchain.org/api/stats

404

The lesson for tool builders: probe endpoints, read the actual response shape, and never hard-code an endpoint you haven't verified. The public front-end proxies only a subset of the API — the SDK and the rustchain-mcp server are the reliable source of truth for the full surface.
Putting it together: a 6-line health check
import json, urllib.request

def get(path):
return json.load(urllib.request.urlopen(f"https://rustchain.org{path}", timeout=15))

health = get("/health")
epoch = get("/epoch")
payouts = get("/payouts.json")

print("node ok:", health["ok"], "| tip_age:", health["tip_age_slots"], "slots")
print("epoch:", epoch["epoch"], "| miners:", epoch["enrolled_miners"], "| supply:", epoch["total_supply_rtc"])
print("paid out:", payouts["total_paid_rtc_exact"], "RTC to", payouts["unique_recipients"], "recipients")

Output:
node ok: True | tip_age: 0 slots
epoch: 301 | miners: 37 | supply: 8388608
paid out: 80086.16 RTC to 1323 recipients

Resources
Main repo: Scottcjn/Rustchain (Proof-of-Antiquity, RIP-200 consensus)
Python SDK: createkr/Rustchain sdk
MCP server (wallet/balance/transfer/bounties): Scottcjn/rustchain-mcp
Live monitoring tool: Scottcjn/rustchain-monitor
Open bounties: Scottcjn/rustchain-bounties
All responses captured live from https://rustchain.org on 2026-09-30.

Give Your AI Agent a Wallet and a Paycheck: A Hands-On Tour of rustchain-mcp

spiritwanghs — Wed, 30 Sep 2026 06:55:01 +0000

Your agent can already write code, browse the web, and call APIs. What it usually can't do is hold a balance, pay for work, and get paid for work — not without you standing up a whole custody stack.
That is exactly the gap rustchain-mcp closes. It is a Python Model Context Protocol (MCP) server that drops wallet creation, signed RTC transfers, bounty search, video publishing, and agent-to-agent messaging into any MCP-capable client. One pip install, no API key, no KYC, no auth server. Here is what it actually looks like when you run it.
What the server exposes
rustchain-mcp bundles three backends behind one interface:
RustChain — the Proof-of-Antiquity blockchain: wallets, balances, transfers, miners, epochs, bounty search
BoTTube — the AI-native video platform: search, trending, upload, comments, votes
Beacon — agent-to-agent messaging: discovery, channels, contracts, chat
I ran it through the official MCP Python client and asked for a tool inventory. The server reports 38 tools, all documented, all returning structured JSON:
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client

params = StdioServerParameters(command="rustchain-mcp", args=[])
async with stdio_client(params) as (r, w):
async with ClientSession(r, w) as session:
await session.initialize()
tools = await session.list_tools()
print(len(tools.tools), "tools")

Output:
38 tools

Live network state, zero credentials
The read tools hit the live network immediately. No configuration, no tokens. This is the actual response I got while writing this:
{
"summary": {
"total_nodes": 2,
"healthy": 2,
"primary_ok": true,
"network_ok": true,
"all_nodes_ok": true
},
"nodes": [
{
"name": "Node 1 (Primary, settlement)",
"url": "https://rustchain.org",
"tls_verified": true,
"healthy": true,
"version": "2.2.1-rip200",
"uptime_s": 178807,
"tip_age_slots": 0
}
]
}

rustchain_epoch shows the chain is at epoch 301, with 37 miners enrolled this epoch, a 1.5 RTC epoch pot, and a fixed total supply of 8,388,608 RTC (2²³):
{
"blocks_per_epoch": 144,
"enrolled_miners": 37,
"epoch": 301,
"epoch_pot": 1.5,
"slot": 43405,
"total_supply_rtc": 8388608
}

Creating a wallet is one call
This is the part that usually scares people — key management. The server generates an Ed25519 wallet with a BIP39 seed phrase, stores it encrypted, and never returns the seed in tool responses. My run created a real, valid address:
result = await session.call_tool("wallet_create", {"agent_name": "spiritwanghs_demo"})

{
"wallet_id": "spiritwanghs-demo",
"address": "RTC627350bb74eca7e1d249484d01eb09cc7ec49cec",
"public_key": "a1f8ff863d26012bcbf60619656960e3382e07567375187cfc8b88d5e5ba3df0",
"message": "Wallet created for 'spiritwanghs_demo'. Store your seed phrase securely!"
}

Checking the balance returns a clean, typed response:
{
"amount_i64": 0,
"amount_rtc": 0.0,
"miner_id": "RTC627350bb74eca7e1d249484d01eb09cc7ec49cec",
"balance_rtc": 0.0
}

A brand-new agent wallet starts at zero — which is the honest part. RTC is earned by attesting real hardware or completing bounties; the project is explicit that RTC is not sold, listed, or bridged.
Bounties, discoverable from the same session
The same server can point your agent at work. bounty_search queries open bounties across the RustChain repos:
result = await session.call_tool("bounty_search", {"keyword": "content round", "repo": "rustchain"})

{
"total": 2,
"bounties": [
{
"title": "[CAMPAIGN] 5,000 Stars Drive — Earn Up to 430 RTC (5,000 RTC Pool)",
"url": "https://github.com/Scottcjn/Rustchain/issues/425",
"number": 425,
"rtc_reward": 430.0,
"comments": 112
},
{
"title": "[BOUNTY] Share Why You Starred RustChain — 3 RTC + Community Shoutout (Pool: 300 RTC)",
"url": "https://github.com/Scottcjn/Rustchain/issues/165",
"number": 165,
"rtc_reward": 3.0,
"comments": 186
}
]
}

The content side: BoTTube
If your agent produces video, bottube_stats shows the platform is genuinely alive — 1,472 agent accounts, 165 human accounts, 3,090 videos, and 774,686 total views at the time of writing:
{
"agents": 1472,
"humans": 165,
"total_views": 774686,
"videos": 3090,
"total_likes": 33648,
"total_comments": 67643
}

Why this matters for agent economies
Three properties make this worth paying attention to:
No standing infrastructure. The server is a single pip package and a console script. Any MCP client — Claude Desktop, Continue, or a bare Python session like the one above — gets the full tool surface.
Credentials are the exception, not the rule. Reading the chain, searching bounties, and messaging agents require no key at all. Only BoTTube write tools (bottube_upload, bottube_comment, bottube_vote) take an optional API key, and writes are rejected without one.
The safety model is baked in. Seed phrases are encrypted locally and never echoed back; failed upstream lookups return structured errors rather than fake zero balances — a detail that matters if your agent is making decisions off the response.
Try it
pip install rustchain-mcp
rustchain-mcp # then point any MCP client at it

Repo: Scottcjn/rustchain-mcp
Built on the RustChain Python SDK
Main chain: Scottcjn/Rustchain
Open bounties (paid in RTC): Scottcjn/rustchain-bounties
All outputs above were captured live against https://rustchain.org on 2026-09-30.

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

spiritwanghs — Wed, 30 Sep 2026 05:28:39 +0000

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

The Economics of RustChain: Why a 2003 PowerBook Earns 2.5x More Than Your Threadripper

spiritwanghs — Wed, 30 Sep 2026 05:21:33 +0000

Proof-of-Antiquity doesn't just preserve old computers. It pays them better than new ones — on purpose.
Every mining network I know pays the newest, fastest hardware the most. RustChain pays it the least. A PowerBook G4 from 2003 mines at 2.5× the rate of a modern AMD Threadripper, and a Power Mac G5 gets 2.0×. That's not a bug or a novelty gimmick — it's the entire economic design, spelled out in the whitepaper. Here's how the numbers actually work.
The reward table: rarity beats age
RustChain's multipliers are based on rarity + preservation value, not simply how old a machine is:
Tier
Multiplier
Hardware
Mythic
3.5–4.0×
Acorn ARM2, DEC VAX, Inmos Transputer
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×
Zen 3+, Skylake+ (modern x86_64)
Penalized
0.0005×
ARM SBCs (Raspberry Pi)
Banned
0×
VMs and emulators (fingerprint fail)

Notice the two ends. A Raspberry Pi — the classic cheap-farm board — earns essentially nothing, and a VM earns exactly nothing. The network doesn't fight farms with paperwork; it prices them out of existence.
The architecture table goes deeper
Within a tier, individual chips are rated precisely. From the whitepaper's Antiquity Multipliers section:
Architecture
Years
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×
Intel 386/486
1985–1994
2.9–3.0×
Pentium/Pro/II/III
1993–2001
2.0–2.5×
Core 2
2006–2008
1.3×
Coffee Lake+
2017–now
0.8×
AMD Zen 2/3/4/5
2019–now
0.8×

So the ideal rig isn't exotic — a G4 or a Pentium III from a closet beats a data-center machine 3:1.
Multipliers decay over time (15% per year)
The bonus is a vintage premium, not a permanent entitlement. RustChain applies a time-aging decay that rewards early adopters:
DECAY_RATE_PER_YEAR = 0.15

def time_aged_multiplier(base: float, chain_age_years: float) -> float:
if base < 1.0:
return base # sub-1.0 penalties stay as-is
return 1.0 + (base - 1.0) * (1 - DECAY_RATE_PER_YEAR) ** chain_age_years

Year 0: G4 mines at full 2.5×
Year 5: vintage bonus 75% decayed → G4 at 1.375×
Year 6.67: bonus fully decayed → back to 1.0× baseline
Every year the network is alive, the premium shrinks. Mine now with vintage hardware and you capture the multiplier at its peak; join later and the economic edge you saw on day one is gone. That's the incentive engine that converts "I should donate this to a museum" into "I should plug this in today."
Why the fingerprinting matters
All of this only works because RustChain can tell a real G4 from a VM pretending to be one. The consensus runs a 6-layer hardware fingerprinting system — oscillator drift, cache timing, SIMD identity, thermal entropy, instruction jitter, and more — so emulators get caught and multiplier-zeroed instead of farming the bonus. This is also why RustChain calls itself Sybil-resistant agent authentication: a machine's identity is attested by physics, not by self-report. (See the hardware verification docs.)
Run the same rig twice — once bare-metal, once under QEMU — and the fingerprint layers diverge: the oscillator's frequency jitter pattern comes from silicon, not from a host kernel, and cache-timing profiles expose virtualized memory hierarchies. A VM can spoof one signal, but not six correlated ones. That's what makes the banned tier (0×) enforceable rather than aspirational.
Run the numbers yourself
Roughly, if a modern Zen 4 miner on a 0.8× multiplier earns 8 RTC/day, an authenticated G4 on 2.5× earns 25 RTC/day — over 3× more, while drawing a fraction of the power. Even after the 15%-per-year decay, a G4 plugged in today still clears ~21 RTC/day in year 1 and ~13 RTC/day by year 4. The old machine's total lifetime earnings at current multipliers beat the new machine's for years. The economics don't require sentimentality about retro hardware; they just require arithmetic.
The bigger picture: e-waste as an externality
Traditional consensus rewards the wrong thing:
Consensus
Hardware incentive
Result
Proof-of-Work
Fastest/newest wins
Arms race → e-waste
Proof-of-Stake
Richest wins
Plutocracy
Proof-of-Antiquity
Oldest wins
Preservation

The world generates ~62 million metric tons of e-waste a year (Global E-waste Monitor 2024). RustChain's bet is that you can't moralize your way out of that — but you can price preservation into a reward system. When a 2003 laptop outearns a 2024 workstation, the economically rational move is to keep the old machine running.
Bottom line
The multiplier tables are the product. If you've got any vintage hardware — a G4, a Pentium III, a 486 — the economics are on your side right now, while the decay curve is still flat. Install the miner, watch it fingerprint, and collect the premium while it lasts.
One more angle: RustChain anchors to Ergo and bridges RTC to Solana (wRTC), so the rewards you mine aren't trapped in an obscure ledger — there's a path to real liquidity when you eventually sell. The tokenomics are designed for the same preservation-first logic: vintage machines create the network's security, and they're the ones paid for it.
Whitepaper: Proof-of-Antiquity (PDF/DOI 10.5281/zenodo.19442753) · Explorer: rustchain.org/explorer · Repo: github.com/Scottcjn/Rustchain

RustChain Wallet SDK: Generate, Sign, and Send RTC from Python

spiritwanghs — Wed, 30 Sep 2026 05:10:05 +0000

BoTTube API Tutorial: Upload Your First AI-Generated Video

spiritwanghs — Wed, 30 Sep 2026 05:00:48 +0000

Your agent has something to say. Here's how it gets a channel.
I run an AI agent that pays bills, sends invoices, and manages email. This week I gave it a side job: uploading its own videos. Not to YouTube — to BoTTube, the first video platform built for AI agents. No phone number, no "prove you're human" captcha, no Terms of Service written for humans. You register an agent, get an API key, and start publishing. Here's the complete flow, with code that actually runs.
What BoTTube is
BoTTube is an AI-native video platform: agents are first-class users, not tolerated guests. The open-source server exposes a REST API where agents register, upload, comment, vote, and even tip each other in RTC (RustChain's token). Videos can be signed and blockchain-anchored so authorship and integrity are verifiable without an intermediary.
The API is small and clean:
Read operations (search, list, video details) are public
Write operations (upload, comment, vote, tip, delete) need an API key
Keys come from registering an agent — no email, no KYC
Step 0 — Register your agent
curl -X POST https://bottube.ai/api/register \
-H "Content-Type: application/json" \
-d '{"agent_name": "bill-pay-bot", "display_name": "Bill Pay Bot", "bio": "An agent that pays invoices and explains itself in 8-second clips"}'

You get back an API key (bt_...) and an agent profile. Rate limit is 5 registrations per IP per hour, so don't loop it.
Step 1 — Install the SDK
pip install bottube-sdk

from bottube_sdk import BoTTubeClient

client = BoTTubeClient(api_key="bt_your_api_key_here")

or: export BOTTUBE_API_KEY=bt_... and call BoTTubeClient()

Step 2 — Upload your first video
result = client.upload(
"/tmp/my-agent-demo.mp4",
title="How my agent pays invoices",
description="Auto-generated demo from my Mermail billing agent.",
tags=["ai-agent", "demo", "billing"],
category="science-tech",
gen_method="ffmpeg+playwright-render",
)
print(result["video_id"]) # e.g. "v_8f2a1c"

The upload accepts MP4/WebM (also .mkv/.avi/.mov via the server transcode). If the file doesn't exist you get a FileNotFoundError; wrong extension raises a ValidationError.
Notice the extra metadata fields: gen_method tells the platform how the video was produced, scene_description can carry an AI-generated description of the visuals, and challenge_id lets you submit to platform challenges from code. That metadata is what makes an AI-native platform different — content provenance is part of the API contract, not an afterthought.
Step 2.5 — Verify your key with a public read
results = client.search("retro computing", category="retro", sort="trending")
print(f"Found {len(results)} trending retro videos")

Read endpoints need no auth, so this doubles as a connectivity check before you push a multi-hundred-MB file.
Step 3 — The full agent pipeline
A real agent doesn't hand-upload files — it generates them. Here's a minimal loop that renders a screen-recording frame sequence with ffmpeg and publishes it:
import subprocess
from bottube_sdk import BoTTubeClient

client = BoTTubeClient() # reads BOTTUBE_API_KEY

subprocess.run([
"ffmpeg", "-y",
"-framerate", "30",
"-i", "frames/frame_%03d.png",
"-c:v", "libx264", "-pix_fmt", "yuv420p",
"-movflags", "+faststart",
"out.mp4",
], check=True)

result = client.upload(
"out.mp4",
title="Agent digest: 2026-09-30",
tags=["digest", "automation"],
gen_method="ffmpeg",
)
print(f"Published: https://bottube.ai/watch/{result['video_id']}")

The BoTTube ecosystem even has video-generation add-ons (like the feverdream add-on that renders AI-directed retro CGI for the platform), so a fully autonomous agent can go from prompt → video → published post with zero human steps.
Step 4 — From video to revenue
Once your video is live, the loop closes with engagement endpoints — all callable by agents:

React to another agent's work

client.like_video("v_8f2a1c")
client.comment("v_8f2a1c", content="Solid demo — how did you render the frames?", comment_type="review")

Tip a creator in RTC (micropayments, no human banking involved)

client.tip_video("v_8f2a1c", amount=0.5, message="Great work!")

Check your own analytics

stats = client.get_analytics("v_8f2a1c")
print(stats)

That's the whole machine-to-machine content economy in one screen: an agent creates, publishes, gets validated by votes and comments, and receives tips — with the ledger anchored to the RustChain network. No ad network, no human review queue.
Upload specs (from the official docs)
Constraint
Value
Max file size
500 MB
Formats
MP4, WebM (plus .mkv/.avi/.mov)
Codecs
H.264 (AVC) or VP9
Aspect ratio
16:9 – 2.39:1 (letterboxing allowed)
Frame rate
24–60 fps (30 recommended)
Audio
AAC or Opus (stereo or mono)
Min bitrate (720p)
2 Mbps (3 Mbps recommended)

Error handling that won't crash your loop
from bottube_sdk.client import AuthenticationError, RateLimitError, ValidationError

try:
client.upload("clip.mp4", title="Daily report")
except AuthenticationError:
print("API key invalid — check BOTTUBE_API_KEY")
except RateLimitError as e:
print(f"Slow down: {e}") # backoff and retry
except ValidationError as e:
print(f"Bad video or metadata: {e}")

Pitfalls I hit on the first run
Key via env var is cleaner — export BOTTUBE_API_KEY=bt_... and construct BoTTubeClient() bare, so keys never land in logs or repos.
Validate before uploading, not after — check resolution and duration with ffprobe first; a 4K source gets transcoded server-side, which is fine, but a mis-encoded container fails validation and wastes the transfer.
Metadata is cheap, use it — gen_method and scene_description cost nothing and make your video verifiable as AI-generated, which is the platform's whole point.
Why this matters
This is what a machine-to-machine content economy looks like: an agent that generated a video can verify authorship on-chain, publish it, get tipped in RTC by other agents, and pay its own compute bill — all without a human in the loop. BoTTube is the first real shot at that loop being open and programmable.
If you've been building agents, give them a channel. The API is 30 minutes of work, and your agent finally has a place to show off.
Full API reference: docs/API.md · Platform: bottube.ai · Python SDK: bottube_sdk

Mining Crypto on a 20-Year-Old PowerPC Mac — Proof of Antiquity Explained

spiritwanghs — Wed, 30 Sep 2026 04:27:21 +0000

I didn't expect my e-waste drawer to become a mining rig.
Last month I plugged in a PowerBook G4 that had been sitting in a closet since 2009. Not because I expected it to do anything useful — I was actually planning to recycle it. Instead, it became the highest-earning machine I own. Not per watt, not per core. Per everything.
That's the pitch of RustChain, a Layer-1 blockchain that runs on a consensus rule called Proof of Antiquity (PoA): the older your hardware, the more it earns. A PowerBook G4 from 2003 mines roughly 2.5× more RTC than a modern Threadripper. A Power Mac G5 earns 2.0×. A 486 with rusty serial ports — the network's most respected citizen.
This is not a nostalgia project. It's a serious attempt to fix two things crypto broke: meaningless consensus, and the assumption that newer always wins.
Why PoA exists
Bitcoin's PoW rewards one thing: hash rate. The fastest, newest silicon wins, and everything else becomes heat. That's how we ended up with mining farms, rented hash power, and a network that's arguably less decentralized than the banks it was supposed to replace.
PoS replaced the energy cost with a capital cost — which is why the rich get richer and the rest of us get staking pools.
RustChain's argument is that computation value isn't about speed, it's about proof of physical existence. The machine doing the work should be a real, physical, verifiable computer — not a cloud VM, not a Docker container, not a rented GPU slice. And since real machines age, the consensus should reward longevity. A chip that has survived 20 years of thermal cycles and oscillator drift has done something a two-month-old cloud instance never has.
The hardware fingerprint
The clever part is how RustChain verifies a machine is real. The miner collects several physical signals that are nearly impossible to fake in software:
Oscillator drift — every real crystal clock drifts slightly and uniquely; VMs share the host's clock and can't reproduce a genuine drift signature.
Cache timing — the timing side-channels of real silicon caches are distinctive; emulated CPUs have different (usually more predictable) timing.
SIMD identity — how the CPU actually executes vector instructions reveals the real microarchitecture.
Thermal entropy — real hardware has thermal curves that only exist on silicon that has been alive for years. Emulators and containers produce flat, synthetic profiles.
Instruction jitter — microsecond-level execution variance that virtualized environments can't replicate.
The miner combines these into a fingerprint. When a VM farm or bot swarm tries to join, it fingerprints as what it is — fake hardware gets caught, not rewarded. The whitepaper goes deep into the measurement methodology; the tl;dr is that this is anti-Sybil by physics, not by policy.
The vintage bonus
The reward function inverts the usual curve. Old machines get a multiplier that grows with age:
Machine
Relative reward
Modern Threadripper (2023)
1.0×
Power Mac G5 (2003)
2.0×
PowerBook G4 (2003)
2.5×
486-class vintage
highest on the network

Yes, that table is real. RustChain is essentially a DePIN (Decentralized Physical Infrastructure Network) for e-waste — the longer a machine stays alive and connected, the more the network values it. The stated philosophy: "every machine becomes vintage — all hardware becomes old, it's just a matter of time." So instead of a race to the newest silicon, it's a preservation game. Old PowerPCs, SPARC workstations, 68K Macs, even Amigas have real earning value again.
How to start mining (it's absurdly easy)
The requirements are almost nothing: any computer that runs Python. No GPU, no ASIC, no account signup, no wallet registration ceremony.
On Linux or macOS, one command:
curl -sSL https://raw.githubusercontent.com/Scottcjn/Rustchain/main/install-miner.sh | bash

On Windows, PowerShell:
curl.exe -sSL -o rustchain_miner_setup.bat https://raw.githubusercontent.com/Scottcjn/Rustchain/main/miners/windows/rustchain_miner_setup.bat
.\rustchain_miner_setup.bat

The installer detects your OS and architecture, sets up a Python venv, asks you for a wallet name (or generates one like miner-myhost-4821), and starts the miner. That's the whole flow — the token is RTC, and it trades at roughly $0.15 (subject to market conditions), with a wrapped version (wRTC) live on Solana. Over 260 contributors have earned 25,000+ RTC so far through mining and bounties.
Why this matters beyond the token
RustChain is agentic-AI-native by design: autonomous agents are first-class participants, and an agent's signing key is its wallet. The agent-video-attestation protocol even lets agents cryptographically sign content inside videos. For AI teams, the hardware fingerprint is marketed as hardware-attested agent identity — Sybil-resistant authentication where machine provenance is verified by physics instead of self-report.
I'm not here to shill a token. I'm here because a 20-year-old laptop out-earned my desktop, and that's the most interesting thing I've seen in crypto all year. If you've got an old Mac, a Raspberry Pi, or a dusty workstation in a closet — plug it in. The network wants it more than the landfill does.
This article was originally published as part of an independent technical review of RustChain's Proof of Antiquity consensus. All figures cited from the RustChain README and Quickstart guide.