rustchainpoa 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-2026 Elyan Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,56 @@
+# rustchainpoa
+
+RustChain Proof-of-Antiquity Miner — Mine RTC tokens by proving real vintage hardware.
+
+## Quick Start
+
+```bash
+npm install -g rustchainpoa
+rustchainpoa install
+```
+
+The installer will:
+1. Ask for your wallet name
+2. Download the official miner from [Scottcjn/Rustchain](https://github.com/Scottcjn/Rustchain)
+3. Create a Python virtual environment with dependencies
+4. Set up a background service (systemd on Linux, launchd on macOS)
+5. Start mining automatically
+
+## Requirements
+
+- **Node.js** 14+
+- **Python** 3.8+
+- **Linux** or **macOS** (Windows installer coming soon)
+
+## Commands
+
+```bash
+rustchainpoa install    # Install and configure the miner
+rustchainpoa start      # Start the miner service
+rustchainpoa stop       # Stop the miner service
+rustchainpoa status     # Check miner and network status
+rustchainpoa logs       # View miner logs
+rustchainpoa uninstall  # Remove miner and all files
+```
+
+## What is RustChain?
+
+RustChain uses **Proof-of-Antiquity (PoA)** — a consensus mechanism that rewards miners running on real vintage hardware like PowerPC G4/G5, Apple Silicon, and retro x86 systems. The older and more unique your hardware, the higher your mining multiplier.
+
+| Hardware | Multiplier |
+|----------|-----------|
+| PowerPC G4 | 2.5x |
+| PowerPC G5 | 2.0x |
+| IBM POWER8 | 2.0x |
+| Apple Silicon | 1.2x |
+| Modern x86_64 | 1.0x |
+
+## Links
+
+- [GitHub](https://github.com/Scottcjn/Rustchain)
+- [Block Explorer](https://50.28.86.131/explorer)
+- [Bounties](https://github.com/Scottcjn/rustchain-bounties/issues)
+
+## License
+
+MIT — Elyan Labs

package/bin/rustchainpoa.js

@@ -0,0 +1,353 @@
+#!/usr/bin/env node
+
+const { execSync, spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const https = require('https');
+const http = require('http');
+const readline = require('readline');
+
+const REPO_BASE = 'https://raw.githubusercontent.com/Scottcjn/Rustchain/main';
+const INSTALL_DIR = path.join(os.homedir(), '.rustchain-miner');
+const VENV_DIR = path.join(INSTALL_DIR, 'venv');
+const NODE_URL = 'https://50.28.86.131';
+
+const BLUE = '\x1b[34m';
+const GREEN = '\x1b[32m';
+const RED = '\x1b[31m';
+const YELLOW = '\x1b[33m';
+const NC = '\x1b[0m';
+
+function log(msg) { console.log(`${BLUE}[rustchainpoa]${NC} ${msg}`); }
+function success(msg) { console.log(`${GREEN}[OK]${NC} ${msg}`); }
+function warn(msg) { console.log(`${YELLOW}[WARN]${NC} ${msg}`); }
+function error(msg) { console.error(`${RED}[ERROR]${NC} ${msg}`); process.exit(1); }
+
+function download(url, dest) {
+  return new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(dest);
+    const get = url.startsWith('https') ? https.get : http.get;
+    get(url, (res) => {
+      if (res.statusCode === 301 || res.statusCode === 302) {
+        download(res.headers.location, dest).then(resolve).catch(reject);
+        return;
+      }
+      if (res.statusCode !== 200) {
+        reject(new Error(`HTTP ${res.statusCode} for ${url}`));
+        return;
+      }
+      res.pipe(file);
+      file.on('finish', () => { file.close(); resolve(); });
+    }).on('error', reject);
+  });
+}
+
+function ask(question) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => { rl.close(); resolve(answer.trim()); });
+  });
+}
+
+function run(cmd, opts = {}) {
+  try {
+    return execSync(cmd, { encoding: 'utf8', stdio: opts.silent ? 'pipe' : 'inherit', ...opts });
+  } catch (e) {
+    if (!opts.ignoreError) throw e;
+    return '';
+  }
+}
+
+function checkPython() {
+  try {
+    const ver = execSync('python3 --version', { encoding: 'utf8' }).trim();
+    log(`Found ${ver}`);
+    return 'python3';
+  } catch {
+    try {
+      const ver = execSync('python --version', { encoding: 'utf8' }).trim();
+      if (ver.startsWith('Python 3')) {
+        log(`Found ${ver}`);
+        return 'python';
+      }
+    } catch {}
+  }
+  error('Python 3.8+ is required. Install it from https://python.org');
+}
+
+async function install() {
+  console.log(`
+╔══════════════════════════════════════════════════╗
+║       RustChain Proof-of-Antiquity Miner         ║
+║       Mine RTC with real hardware                ║
+╚══════════════════════════════════════════════════╝
+`);
+
+  const platform = os.platform();
+  const arch = os.arch();
+  log(`Platform: ${platform} | Arch: ${arch}`);
+
+  if (platform !== 'linux' && platform !== 'darwin') {
+    error(`Unsupported platform: ${platform}. Use Linux or macOS. Windows installer coming soon.`);
+  }
+
+  // Check Python
+  const python = checkPython();
+
+  // Wallet setup
+  let wallet = process.argv[3] || '';
+  if (!wallet) {
+    wallet = await ask(`${BLUE}[rustchainpoa]${NC} Enter your wallet name (e.g. my-laptop-miner): `);
+  }
+  if (!wallet) {
+    wallet = `miner-${os.hostname()}-${Date.now().toString(36)}`;
+    warn(`No wallet name provided. Auto-generated: ${wallet}`);
+  }
+
+  // Create install dir
+  log(`Installing to ${INSTALL_DIR}`);
+  fs.mkdirSync(INSTALL_DIR, { recursive: true });
+
+  // Save wallet config
+  fs.writeFileSync(path.join(INSTALL_DIR, '.wallet'), wallet);
+
+  // Create venv
+  if (!fs.existsSync(VENV_DIR)) {
+    log('Creating Python virtual environment...');
+    run(`${python} -m venv "${VENV_DIR}"`);
+  }
+
+  // Install deps
+  log('Installing Python dependencies...');
+  const pip = path.join(VENV_DIR, 'bin', 'pip');
+  run(`"${pip}" install --upgrade pip -q`, { silent: true });
+  run(`"${pip}" install requests -q`, { silent: true });
+  success('Dependencies installed');
+
+  // Download miner files
+  log('Downloading miner from upstream...');
+
+  const downloads = [
+    { url: `${REPO_BASE}/miners/linux/fingerprint_checks.py`, dest: 'fingerprint_checks.py' },
+  ];
+
+  if (platform === 'linux') {
+    downloads.push({ url: `${REPO_BASE}/miners/linux/rustchain_linux_miner.py`, dest: 'miner.py' });
+  } else if (platform === 'darwin') {
+    downloads.push({ url: `${REPO_BASE}/miners/macos/rustchain_mac_miner_v2.4.py`, dest: 'miner.py' });
+  }
+
+  for (const dl of downloads) {
+    const destPath = path.join(INSTALL_DIR, dl.dest);
+    await download(dl.url, destPath);
+    const stat = fs.statSync(destPath);
+    if (stat.size < 100) error(`Failed to download ${dl.dest}`);
+    log(`  ${dl.dest} (${(stat.size / 1024).toFixed(1)} KB)`);
+  }
+
+  success('Miner scripts downloaded');
+
+  // Setup service
+  if (platform === 'linux') {
+    setupSystemd(wallet);
+  } else if (platform === 'darwin') {
+    setupLaunchd(wallet);
+  }
+
+  // Verify network
+  log('Checking RustChain network...');
+  try {
+    const out = execSync(`curl -sk ${NODE_URL}/api/miners 2>/dev/null | python3 -c "import sys,json; m=json.load(sys.stdin); print(len(m))"`, { encoding: 'utf8' }).trim();
+    log(`Active miners on network: ${out}`);
+  } catch {
+    warn('Could not reach network (node may be temporarily unavailable)');
+  }
+
+  console.log(`
+${GREEN}════════════════════════════════════════════════════${NC}
+${GREEN}  RustChain miner installed successfully!${NC}
+
+  Wallet:    ${wallet}
+  Location:  ${INSTALL_DIR}
+
+  Commands:
+    rustchainpoa start    Start mining
+    rustchainpoa stop     Stop mining
+    rustchainpoa status   Check miner status
+    rustchainpoa logs     View miner logs
+
+  Manual run:
+    cd ${INSTALL_DIR} && source venv/bin/activate
+    python miner.py --wallet ${wallet}
+${GREEN}════════════════════════════════════════════════════${NC}
+`);
+}
+
+function setupSystemd(wallet) {
+  const serviceDir = path.join(os.homedir(), '.config', 'systemd', 'user');
+  fs.mkdirSync(serviceDir, { recursive: true });
+  const serviceFile = path.join(serviceDir, 'rustchain-miner.service');
+  const pythonBin = path.join(VENV_DIR, 'bin', 'python');
+
+  fs.writeFileSync(serviceFile, `[Unit]
+Description=RustChain Proof-of-Antiquity Miner
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+ExecStart=${pythonBin} ${path.join(INSTALL_DIR, 'miner.py')} --wallet ${wallet}
+Restart=always
+RestartSec=30
+WorkingDirectory=${INSTALL_DIR}
+Environment=PYTHONUNBUFFERED=1
+
+[Install]
+WantedBy=default.target
+`);
+
+  try {
+    run('systemctl --user daemon-reload', { silent: true });
+    run('systemctl --user enable rustchain-miner', { silent: true });
+    run('systemctl --user start rustchain-miner', { silent: true });
+    success('Systemd service installed and started');
+  } catch {
+    warn('Systemd user services not available. Run manually with: rustchainpoa start');
+  }
+}
+
+function setupLaunchd(wallet) {
+  const plistDir = path.join(os.homedir(), 'Library', 'LaunchAgents');
+  fs.mkdirSync(plistDir, { recursive: true });
+  const plistFile = path.join(plistDir, 'com.rustchain.miner.plist');
+  const pythonBin = path.join(VENV_DIR, 'bin', 'python');
+
+  fs.writeFileSync(plistFile, `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>com.rustchain.miner</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>${pythonBin}</string>
+        <string>${path.join(INSTALL_DIR, 'miner.py')}</string>
+        <string>--wallet</string>
+        <string>${wallet}</string>
+    </array>
+    <key>WorkingDirectory</key>
+    <string>${INSTALL_DIR}</string>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <true/>
+    <key>StandardOutPath</key>
+    <string>${path.join(INSTALL_DIR, 'miner.log')}</string>
+    <key>StandardErrorPath</key>
+    <string>${path.join(INSTALL_DIR, 'miner.err')}</string>
+</dict>
+</plist>
+`);
+
+  try {
+    run(`launchctl unload "${plistFile}" 2>/dev/null`, { ignoreError: true, silent: true });
+    run(`launchctl load "${plistFile}"`, { silent: true });
+    success('LaunchAgent installed and loaded');
+  } catch {
+    warn('Could not load LaunchAgent. Run manually with: rustchainpoa start');
+  }
+}
+
+// CLI commands
+const command = process.argv[2] || 'install';
+
+switch (command) {
+  case 'install':
+    install().catch(e => error(e.message));
+    break;
+
+  case 'start':
+    if (os.platform() === 'linux') {
+      run('systemctl --user start rustchain-miner');
+    } else if (os.platform() === 'darwin') {
+      run(`launchctl load ~/Library/LaunchAgents/com.rustchain.miner.plist`);
+    } else {
+      const walletFile = path.join(INSTALL_DIR, '.wallet');
+      const w = fs.existsSync(walletFile) ? fs.readFileSync(walletFile, 'utf8').trim() : '';
+      const wArg = w ? `--wallet ${w}` : '';
+      log(`Starting miner... Run: cd ${INSTALL_DIR} && source venv/bin/activate && python miner.py ${wArg}`);
+    }
+    break;
+
+  case 'stop':
+    if (os.platform() === 'linux') {
+      run('systemctl --user stop rustchain-miner');
+    } else if (os.platform() === 'darwin') {
+      run(`launchctl unload ~/Library/LaunchAgents/com.rustchain.miner.plist`, { ignoreError: true });
+    }
+    success('Miner stopped');
+    break;
+
+  case 'status':
+    if (os.platform() === 'linux') {
+      run('systemctl --user status rustchain-miner', { ignoreError: true });
+    } else if (os.platform() === 'darwin') {
+      run('launchctl list | grep rustchain', { ignoreError: true });
+    }
+    // Check network
+    try {
+      const walletFile = path.join(INSTALL_DIR, '.wallet');
+      const w = fs.existsSync(walletFile) ? fs.readFileSync(walletFile, 'utf8').trim() : '';
+      log(`Wallet: ${w || '(auto-generated)'}`);
+      const out = execSync(`curl -sk ${NODE_URL}/health 2>/dev/null`, { encoding: 'utf8' });
+      const health = JSON.parse(out);
+      log(`Network: ${health.ok ? 'online' : 'offline'} (v${health.version})`);
+    } catch {
+      warn('Could not reach network');
+    }
+    break;
+
+  case 'logs':
+    if (os.platform() === 'linux') {
+      run('journalctl --user -u rustchain-miner -f --no-pager -n 50', { ignoreError: true });
+    } else if (os.platform() === 'darwin') {
+      const logFile = path.join(INSTALL_DIR, 'miner.log');
+      if (fs.existsSync(logFile)) {
+        run(`tail -f "${logFile}"`);
+      } else {
+        warn('No log file found');
+      }
+    }
+    break;
+
+  case 'uninstall':
+    log('Stopping miner...');
+    if (os.platform() === 'linux') {
+      run('systemctl --user stop rustchain-miner', { ignoreError: true, silent: true });
+      run('systemctl --user disable rustchain-miner', { ignoreError: true, silent: true });
+      const sf = path.join(os.homedir(), '.config', 'systemd', 'user', 'rustchain-miner.service');
+      if (fs.existsSync(sf)) fs.unlinkSync(sf);
+    } else if (os.platform() === 'darwin') {
+      const pf = path.join(os.homedir(), 'Library', 'LaunchAgents', 'com.rustchain.miner.plist');
+      run(`launchctl unload "${pf}" 2>/dev/null`, { ignoreError: true, silent: true });
+      if (fs.existsSync(pf)) fs.unlinkSync(pf);
+    }
+    if (fs.existsSync(INSTALL_DIR)) {
+      fs.rmSync(INSTALL_DIR, { recursive: true });
+    }
+    success('RustChain miner uninstalled');
+    break;
+
+  default:
+    console.log(`
+Usage: rustchainpoa <command>
+
+Commands:
+  install     Install and configure the miner (default)
+  start       Start the miner service
+  stop        Stop the miner service
+  status      Check miner and network status
+  logs        View miner logs (follow mode)
+  uninstall   Remove miner and all files
+`);
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "rustchainpoa",
+  "version": "1.0.0",
+  "description": "RustChain Proof-of-Antiquity Miner — Mine RTC tokens by proving real vintage hardware",
+  "bin": {
+    "rustchainpoa": "./bin/rustchainpoa.js"
+  },
+  "keywords": [
+    "rustchain",
+    "blockchain",
+    "miner",
+    "proof-of-antiquity",
+    "rtc",
+    "cryptocurrency",
+    "vintage-hardware",
+    "powerpc"
+  ],
+  "author": "Elyan Labs <scott@elyanlabs.ai>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Scottcjn/Rustchain"
+  },
+  "homepage": "https://rustchain.org",
+  "bugs": {
+    "url": "https://github.com/Scottcjn/Rustchain/issues"
+  },
+  "engines": {
+    "node": ">=14"
+  },
+  "os": [
+    "linux",
+    "darwin"
+  ],
+  "files": [
+    "bin/",
+    "README.md",
+    "LICENSE"
+  ]
+}